<jupyter_start><jupyter_text><jupyter_code>!pip install fastai --upgrade<jupyter_output><empty_output><jupyter_text>Clasificador de animales<jupyter_code>import fastai.vision.all as fv
import torch 
from pathlib import Path
import pandas as pd 
from sklearn.model_selection import train_test_split
import shutil
import os<jupyter_output><empty_output><jupyter_text>Manejo de archivos>Para comenzar con el entrenamiento de la red primero he de cargar los datos (imagenes y csv), el archivo csv contiene las etiquetas a las que pertenece cada imagen.<jupyter_code>labels = pd.DataFrame(pd.read_csv('/content/train.csv'))
labels<jupyter_output><empty_output><jupyter_text>Separacion de datos>Ahora voy a asignar a los datos aleatoriamente "train" o "valid" para despues pasarlos a sus respectivas carpetas<jupyter_code>train, valid = train_test_split(labels, test_size = 0.33, random_state = 42) 
train.shape, valid.shape
pics = Path("/content/drive/MyDrive/AnimalsSmall/AnimalsSmall/images")
(pics).ls()<jupyter_output><empty_output><jupyter_text>>Ahora que ya estan asignadas las imagenes las mandare a sus respectivas carpetas, para esto, dentro de "train" y "valid" creare nuevas subcarpetas con el nombre de la etiqueta que tienen. Es decir, si no existe una carpeta con la etiqueta de la imagen que lee, supongamos "wolf", la creara y de alli en adelante metera todas las imagenes de "wolf" -Carpeta "train"<jupyter_code>tmp_train = [] 
for index, element in train.iterrows():
        tmp_train.append((f"/content/drive/MyDrive/AnimalsSmall/AnimalsSmall/images/{element[0]}", element[1]))

print(tmp_train)
for path in range(len(img)):
    tmp_path = str(img[path])
    for element in tmp_train: 
        if tmp_path == element[0]:
            try:
                os.mkdir(f"/content/drive/MyDrive/AnimalsSmall/AnimalsSmall/train/{element[1]}") # Creamos la subcarpeta
                shutil.copy(img[path], f"/content/drive/MyDrive/AnimalsSmall/AnimalsSmall/train/{element[1]}/") #movemos 
            except:
                shutil.copy(img[path], f"/content/drive/MyDrive/AnimalsSmall/AnimalsSmall/train/{element[1]}/") #movemos<jupyter_output><empty_output><jupyter_text>-Carpeta "valid"<jupyter_code>tmp_valid = [] 
for index, element in valid.iterrows():
        tmp_valid.append((f"/content/images/{element[0]}", element[1]))
print(tmp_valid)
for path in range(len(img)):
    tmp_path = str(img[path])
    for element in tmp_valid: 
        if tmp_path == element[0]:
            try:
                os.mkdir(f"/content/valid/{element[1]}") # Creamos la subcarpeta
                shutil.copy(img[path], f"/content/valid/{element[1]}/") #movemos 
            except:
                shutil.copy(img[path], f"/content/valid/{element[1]}/") #movemos<jupyter_output><empty_output><jupyter_text>**Entrenamiento** > * Ahora realizare los procedimientos como los que se muestran en el video>* Aplicare algunas transformaciones a las imagenes y algunos otros paramentros para comparar entre modelos<jupyter_code>animalitos = Path("/content/animalitos");!ls "/content/animalitos"
files = fv.get_image_files(animalitos);files #Obtencion de archivos dentro de la carpeta y subcarpetas de "animalitos"

def load(folder, size, batch_size):
  tfms = fv.aug_transforms(max_rotate= 180, 
                           max_lighting=0.80, 
                           max_zoom=1.2, 
                           max_warp=0.2)
  
  data = fv.DataBlock(blocks = (fv.ImageBlock, fv.CategoryBlock), 
                      get_items=fv.get_image_files, 
                      get_y=fv.parent_label, 
                      splitter=fv.GrandparentSplitter(),
                      item_tfms=fv.Resize(size), 
                      batch_tfms=tfms,)
  return data.dataloaders(folder, bs=batch_size)
data = load(animalitos, size=128, batch_size=28) #Cargamos los archivos todos de tamaño 128x128 y el tamaño de nuestro batch es de 64
data.show_batch() #Listo, ahora si se muestran jaja
x,y = data.one_batch() #x tiene al tamaño de nuestro batch, los canales de color y las dimensiones de nuestras imagenes, y tiene el tamaño de nuestro batch
x.shape, y.shape<jupyter_output><empty_output><jupyter_text>Modelo1 Ahora utilizare un modelo preentrenado para el entrenamiento de las ultimas capas>*Nuestro modelo sera el "resnet18".Learner sera nuestro primer intento el cual toma los datos, el modelo preentrenado y nuestra metrica sera "accuracy"<jupyter_code>learner = fv.cnn_learner(data, fv.resnet18, metrics=fv.accuracy) #Descargara los archivos del modelo preentrenado
learner.lr_find() #Buscamos el learning rate
learner.fit_one_cycle(2, lr_max=1e-2) #Lo manejare a 5 epocas
learner.recorder.plot_sched()
learner.save('stage1') #Guardare el modelo
#learner.load('stage1') Lo dejo aqui por si acaso<jupyter_output><empty_output><jupyter_text>Ahora hay que entrenar todas las capas<jupyter_code>learner.unfreeze() #vamos a descongelar toda la red 
learner.lr_find()
learner.fit_one_cycle(4, lr_max=slice(1e-6, 2e-4)) #Ahora le learnig rate variara entre el rango que estoy poniendo
learner.save('stage2')
learner.show_results(ds_idx=3, dl=data.train, shuffle=True)<jupyter_output><empty_output><jupyter_text>Resultados del modelo 1<jupyter_code>interp = fv.ClassificationInterpretation.from_learner(learner)
interp.plot_top_losses(9)<jupyter_output><empty_output><jupyter_text>Modelo2<jupyter_code>def load2(folder, size, batch_size):
  tfms = fv.aug_transforms(max_rotate= 360,
                           flip_vert=True, 
                           max_lighting=0.25, 
                           max_zoom=2.2, 
                           min_zoom=0.6,
                           max_warp=0.7,
                           do_flip=False
                           )
  
  data = fv.DataBlock(blocks = (fv.ImageBlock, fv.CategoryBlock), 
                      get_items=fv.get_image_files, 
                      get_y=fv.parent_label, 
                      splitter=fv.GrandparentSplitter(),
                      item_tfms=fv.Resize(size), 
                      batch_tfms=tfms,)
  return data.dataloaders(folder, bs=batch_size)
data2 = load2(animalitos, size=128, batch_size=100)
x2,y2 = data2.one_batch()<jupyter_output><empty_output><jupyter_text>Entrenamiento de las ultimas capas del modelo 2<jupyter_code>learner2 = fv.cnn_learner(data2, fv.resnet18, metrics=fv.accuracy)
learner2.lr_find()
learner2.fit_one_cycle(20, lr_max=0.0012022644514217973)
learner2.recorder.plot_sched()
learner2.save('stage1_model2')<jupyter_output><empty_output><jupyter_text>Entrenamiento de todas las capas del modelo 2<jupyter_code>learner2.unfreeze() # Ahora debdemos de tener cuidado 
learner2.lr_find()
learner2.fit_one_cycle(4, lr_max=slice(1e-06, 2e-4)) #Entrenamos con varias learning rates
learner2.save('stage2_model2')
learner2.show_results(ds_idx=3, dl=data2.train, shuffle=True)<jupyter_output><empty_output><jupyter_text>Modelo 3<jupyter_code>def load3(folder, size, batch_size):
  tfms = fv.aug_transforms(max_rotate= 45,
                           flip_vert=True, 
                           max_lighting=0.40, 
                           max_zoom=1.2, 
                           min_zoom=0.2,
                           max_warp=0.2,
                           do_flip=True
                           )
  
  data = fv.DataBlock(blocks = (fv.ImageBlock, fv.CategoryBlock), 
                      get_items=fv.get_image_files, 
                      get_y=fv.parent_label, 
                      splitter=fv.GrandparentSplitter(),
                      item_tfms=fv.Resize(size), 
                      batch_tfms=tfms,)
  return data.dataloaders(folder, bs=batch_size)
data3 = load3(animalitos, size=128, batch_size=128)
x3,y3 = data3.one_batch()<jupyter_output><empty_output><jupyter_text>Entrenamiento de las ultimas capas del modelo 3<jupyter_code>learner3 = fv.cnn_learner(data3, fv.resnet101, metrics=fv.accuracy)
learner3.lr_find()
learner3.fit_one_cycle(3, wd=0.1, div=1, div_final=100, pct_start=0.6, lr_max=slice(0.0005754399462603033, 1e-2)) 
learner3.recorder.plot_sched()
learner3.save('stage1_model3')
learner3.show_results(ds_idx=3, dl=data3.train, shuffle=True)<jupyter_output><empty_output><jupyter_text>Entrenamiento de las ultimas capas de modelo 3<jupyter_code>learner3 = fv.cnn_learner(data3, fv.resnet18, metrics=fv.accuracy)
learner3.lr_find()
learner3.fit_one_cycle(3, lr_max=1e-3) 
learner3.recorder.plot_sched()
learner3.save('stage1_model3')<jupyter_output><empty_output><jupyter_text>Resultados del entrenamiento sin todas las capas<jupyter_code>learner3.show_results(ds_idx=3, dl=data3.train, shuffle=True)
interp = fv.ClassificationInterpretation.from_learner(learner3)
interp.plot_top_losses(9)<jupyter_output><empty_output><jupyter_text>Notas<jupyter_code>interp.plot_confusion_matrix(dpi = 90,figsize = (6,6))<jupyter_output><empty_output><jupyter_text>Modelo 4Con otro resnet<jupyter_code><jupyter_output><empty_output><jupyter_text>Modelo 5Muchas epocas<jupyter_code><jupyter_output><empty_output><jupyter_text>Modelo FinalHigh accuracy 20 epocas, resnet 1 y parametros del moche<jupyter_code><jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10340299813984025, 'fraction_numerical': 0.02538570959623591, 'mean_word_length': 3.838538909475913, 'pattern_counts': {'":': 0, '<': 85, '<?xml version=': 0, '>': 91, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '21', 'dir': 'jupyter-structured-clean-dedup', 'id': '608336', 'license': 'MIT', 'n_tokens_mistral': 3412, 'n_tokens_neox': 3196, 'n_words': 605, 'path': 'AnimalClassifier.ipynb', 'repo_name': 'GalvanLuis/NeuralNetClass', 'size': '9139'}