<jupyter_start><jupyter_text>Redes Neuronales Convolucionales**Instalar Theano*** pip install --upgrade --no-deps git+git://github.com/Theano/Theano.git**Instalar Tensorflow y Keras*** conda install -c conda-forge keras  Parte 1 - Construir el modelo de CNN<jupyter_code># Importar las liobrerías y paquetes
from keras.models import Sequential #para incializar la RN con pesos aleatorios
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
# Inicializar la CNN
classifier = Sequential() #arrancamos la RN<jupyter_output><empty_output><jupyter_text>--- Paso 1 - Convolución<jupyter_code>#- filtres=32 detectores de características(filtros) 
#- kernel_size= (3,3) son filtros de 3x3
#- input_shape es el tamaño de las imagenes (filas, columnas, canales de color)
#- activation es poner la función de activación para despertar las neuronas una vez aplicada al convolución
classifier.add(Conv2D(filters = 32,kernel_size = (3, 3), 
                      input_shape = (64, 64, 3), activation = "relu"))<jupyter_output><empty_output><jupyter_text>--- Paso 2 - Max Pooling<jupyter_code>#-pool_size es la matriz 2x2 del Max Pooling
classifier.add(MaxPooling2D(pool_size = (2,2)))
# Una segunda capa de convolución y max pooling

classifier.add(Conv2D(filters = 32,kernel_size = (3, 3), activation = "relu"))

classifier.add(MaxPooling2D(pool_size = (2,2)))<jupyter_output><empty_output><jupyter_text>--- Paso 3 - Flattening<jupyter_code>classifier.add(Flatten())<jupyter_output><empty_output><jupyter_text>--- Paso 4 - Full Connection<jupyter_code># -units es el numero de nodos que añadimos a la capa oculta(se suele poner la media entre las entradas y el nodo de salida)
# -Kernel_initializer para elegir la funcion que usaran los pesos
# -activation es la funcion de activacion para activar en la capa oculta (relu=rectificador lineal unitario)
classifier.add(Dense(units = 128, activation = "relu"))
classifier.add(Dense(units = 1, activation = "sigmoid"))
# Compilar la CNN

# -optimizer se encarga de buscar el conjunto optimo de pesos, usamos el algortimo adam
# -loss es la funcion de perdidas, la que minimiza el error
# -metrics es la metrica (la binaria de cross entropy en este caso ya que es perro o gato)

classifier.compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["accuracy"])<jupyter_output><empty_output><jupyter_text>Parte 2 - Ajustar la CNN a las imágenes para entrenar<jupyter_code>from keras.preprocessing.image import ImageDataGenerator

#lo de abajo es copiado-pegado de https://keras.io/preprocessing/image/. Con esto realizamos cambios
#aleatorios a nuestras imagenes de training para que busquen patrones, en definitva realizamos 
#transofrmaciones a nuestras imagenes. Asi la NN tendrá mas info para aprender.

train_datagen = ImageDataGenerator(
        rescale=1./255, #transforma los px's en vez de 0 a 255 de 0 a 1
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True) #volteo horizontal

test_datagen = ImageDataGenerator(rescale=1./255)

training_dataset = train_datagen.flow_from_directory('dataset/training_set',
                                                    target_size=(64, 64),
                                                    batch_size=32, #cantidad de imagenes que pasaran por la NN antes de volver a cargar los pesos
                                                    class_mode='binary') #perros o gatos por eso binario

testing_dataset = test_datagen.flow_from_directory('dataset/test_set',
                                                target_size=(64, 64),
                                                batch_size=32,
                                                class_mode='binary')

classifier.fit_generator(training_dataset,
                        steps_per_epoch=100,
                        epochs=3,
                        validation_data=testing_dataset,
                        validation_steps=2000)<jupyter_output>Found 8000 images belonging to 2 classes.
Found 2000 images belonging to 2 classes.
Epoch 1/3
100/100 [==============================] - 272s 3s/step - loss: 0.6006 - accuracy: 0.6744 - val_loss: 0.5569 - val_accuracy: 0.6480
Epoch 2/3
100/100 [==============================] - 279s 3s/step - loss: 0.5823 - accuracy: 0.6856 - val_loss: 0.5279 - val_accuracy: 0.6902
Epoch 3/3
100/100 [==============================] - 242s 2s/step - loss: 0.5559 - accuracy: 0.7194 - val_loss: 0.4313 - val_accuracy: 0.7371<jupyter_text>Parte 3 - Cómo hacer nuevas predicciones<jupyter_code>import numpy as np
from keras.preprocessing import image
test_image = image.load_img('dataset/single_prediction/nauka.jpg', target_size = (64, 64))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis = 0)
result = classifier.predict(test_image)
training_dataset.class_indices
if result[0][0] == 1:
    prediction = 'perro'
else:
    prediction = 'gato'

print("El animal de la foto es un " + prediction)<jupyter_output>El animal de la foto es un perro
{'fraction_non_alphanumeric': 0.10504532912889239, 'fraction_numerical': 0.03823413480488766, 'mean_word_length': 3.4674295774647885, 'pattern_counts': {'":': 0, '<': 27, '<?xml version=': 0, '>': 27, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 12, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '215506', 'license': 'CC0-1.0', 'n_tokens_mistral': 1760, 'n_tokens_neox': 1601, 'n_words': 469, 'path': 'datasets/Part_2_Convolutional_Neural_Networks_CNN/cnn.ipynb', 'repo_name': 'dasafo/deeplearning-az', 'size': '5074'}