Evaluación de la red convolucional

Al parecer en este curso de FUNDAMENTOS prácticos de ML, no saben que es una red neuronal convolucional, en definitiva, se pueden conseguir mejores tutoriales gratuitos en la web. En este curso no profundizan nada acerca de las diferentes opciones de las librerías que usa, a pesar de que se hace llamar práctico. En fin, ya sea omitiendo los errores, simplemente es demasiado superficial, incluso si se hace llamar un curso básico. No se como serán las otras carreras o rutas de aprendizaje, hay buenos profesores, pero otros no tanto, en definitiva, lo que mejor sabe hacer platzi son campañas publicitarias.

Cuando di este curso hace ya unos 15 días, no había entendido casi nada y estaba un poco frustrado. Al volver a verlos con un poco mas de conocimientos en ML logré entender el proyecto a la perfección. Muchísimas gracias.

Me encontre este video Computer Vision es esto mismo, pero desde mi punto de vista mucho mejor explicado.

Esto no es una red neuronal convolucional, solo estamos pasando los pixeles como features.Averiguen un poco mas porque estos cursos tienen varios errores.

No entiendo porque no puede explicar bien lo que hace
predicted_label = np.argmax(predictions[i]), en este caso en predictions[i] nos retorna un array con las probabilidades de pertenecer a cada uno de los labels, es decir, la probabilidad de que sea cada prenda(bastaria que lo multipliques por 100 para sacar el porcentaje), por lo que la prediccion viene a ser la probabilidad maxima en ese array lo cual lo obtenemos con np.argmax que nos dara el index del valor maximo del array, entonces ya tendriamos el indice de la prediccion y bastaria con obtener el nombre de la prenda usando ese index en la lista de los nombres:(class_names[predicted_label])

no entiendo mucho este curso solo ponen el código pero no explican el porqué lo estan haciendo así, ni tampoco hacen interpretación de los resultados. Eso considero que es lo más importante, ya que el código lo puedo sólo copiar y pegar 😕 Si alguien me puede recomendar porfa donde podría aprender mejor

Si quieren saber sobre la teoría detrás de la convolución de imágenes entren a éste enlace. Si desean un tutorial que demuestre la capacitación de una simple red neuronal convolucional (CNN) para clasificar imágenes CIFAR entren a éste enlace. Ambas fuentes son de la página de TensoFlow.

El código no tiene las características de una red convolucional. En este video del canal de youtube de TensorFlow sí las explican con más detalle

Les adjunto la copia de mí código tiene una variante que hace más legible el código.

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

from tensorflow import keras

fashion_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

train_images.shape

class_name = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

plt.figure()
plt.imshow(train_images[100])
plt.grid(True)

train_images = train_images / 255.0
test_images = test_images / 255.0

%matplotlib inline

plt.figure(figsize=(10, 10))
for i in range(25):
  plt.subplot(5, 5, i + 1)
  plt.xticks([])
  plt.yticks([])

  plt.grid(False)

  plt.imshow(train_images[i], cmap=plt.cm.binary)
  plt.xlabel(class_name[train_labels[i]])

model = keras.Sequential([
                          keras.layers.Flatten(input_shape=(28, 28)),
                          keras.layers.Dense(128, activation=tf.nn.relu),
                          keras.layers.Dense(10, activation=tf.nn.softmax)
])

model.compile(
    optimizer=tf.train.AdamOptimizer(), 
    loss = 'sparse_categorical_crossentropy',
    metrics = ['accuracy']
)

model.fit(train_images, train_labels, epochs=5)

test_loss, test_acc = model.evaluate(test_images, test_labels)

print('')
print('Loss:', test_loss)
print('Accuracy:', test_acc)

predictions = model.predict(test_images)

%matplotlib inline

plt.figure(figsize=(10, 10))
for i in range(25):
  plt.subplot(5, 5, i + 1)
  plt.xticks([])
  plt.yticks([])

  plt.grid(False)

  plt.imshow(test_images[i], cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions[i])
  true_label = test_labels[i]
  
  if predicted_label == true_label:
    color = 'yellow'
  else:
    color = 'red' 

  etiqueta = class_name[predicted_label] + '(' + class_name[true_label] + ')'
  plt.xlabel(etiqueta).set_color(color)

Hola, quiero aprender más sobre tensorflow, algo más especializado o específico, porque no entendí todo lo que hicimos para definir el modelo. Qué curso recomiendan de deep learning con tensorflow?

La clasificación fue del 87% yesi-days

Siendo humano no podría clasificar con tanto detalle y con solo un par de errores.

En esa red “convolucional” no hay ninguna capa convolucional… Está aplanando las imágenes y metiéndoselas a una red tradicional. Ni deep, ni convolucional, ni nada de nada.

import tensorflow as tf
from tensorflow import keras

import numpy as np
import matplotlib.pyplot as plt

fashion_mnist = keras.datasets.fashion_mnist
(train_image, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

class_names = ['T-shirt/top','Trouser','Pullover','Dress','Coat','Sandal','Shirt','Sneaker','Bag','Ankle boot']
print("train_image.shape",train_image.shape)

plt.figure()
plt.imshow(train_image[100])
plt.grid(True)
plt.show()

train_images = train_image / 255.0
test_images = test_images / 255.0
plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5, 5, i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid('off')
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

#Crear modelo secuencial:
model = keras.Sequential([keras.layers.Flatten(input_shape = (28, 28)), keras.layers.Dense(128, activation = tf.nn.relu), keras.layers.Dense(10, activation = tf.nn.softmax)])

#Compilación del modelo:
model.compile(optimizer = tf.optimizers.Adam(), loss = 'binary_crossentropy', metrics = ['accuracy'])

#Entrenamiento:
model.fit(train_images, train_labels, epochs = 5)

test_loss, test_acc = model.evaluate(test_images, test_labels)
print("Accuracy:",test_acc)

#Predicción del modelo:
predictions = model.predict(test_images)

plt.figure(figsize=(10,10))

for i in range(25):
    plt.subplot(5, 5, i + 1)
    plt.xticks([])
    plt.yticks([])
    plt.grid('off')
    plt.imshow(test_images[i], cmap=plt.cm.binary)
    predicted_label = np.argmax(predictions[i])
    true_label = test_labels[i]
    if predicted_label == true_label:
        colorText = 'blue'
    else:
        colorText = 'red'
    plt.xlabel('{} ({})'.format(class_names[predicted_label], class_names[true_label]), color=colorText)

plt.show()