Fundamentos prácticos

1

Aplica Platzidoro en este curso y asegura el éxito de tu aprendizaje

2

Los fundamentos de machine learning que aprenderás

3

Introducción a Numpy

4

Introducción y manipulación de datos con Pandas

5

Introducción a ScikitLearn

6

Comandos básicos de las librerías usadas en el curso (Numpy, Pandas y ScikitLearn)

Regresión Lineal y Logística

7

¿Qué es la predicción de datos?

8

Sobreajuste y subajuste en los datos

9

Regresión lineal simple y regresión lineal múltiple

10

Regresión lineal simple con Scikit-Learn: división de los datos

11

Regresión lineal simple con Scikit-Learn: creación del modelo

12

Regresión logística con Scikit-Learn: definición y división de datos

13

Regresión logística con Scikit-Learn: evaluación del modelo

14

Matriz de confusión

15

PlatziDoro Cápsula 1

Árboles de decisión

16

¿Qué es un árbol de decisión y cómo se divide?

17

Comprendiendo nuestro data set para la creación de un árbol de decisión

18

Creando un clasificador con Scikit-Learn

19

Entrenamiento del modelo de clasificación

20

Visualización del árbol de decisión

K-Means

21

¿Qué es K-Means?

22

Cargando el data set de Iris

23

Construcción y evaluación del modelo con K-Means

24

Graficación del modelo

25

PlatziDoro Cápsula 2

Aprendizaje profundo

26

Introducción al aprendizaje profundo

27

Conceptos básicos de Tensor Flow

28

Red neuronal convolucional

29

Conociendo el set de datos para la creación de la red neuronal

30

Crea y entrena tu primera red neuronal convolucional con Tensor Flow

31

Evaluación de la red convolucional

32

PlatziDoro Cápsula 3

Despedida

33

Recomendaciones para analizar correctamente tu problema

34

Siguientes pasos para continuar aprendendiendo de Machine Learning

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Evaluación de la red convolucional

31/34
Recursos

Aportes 16

Preguntas 1

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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()