para los que trabajan con jupyter note hay que cambiar tf.train.AdamOptimizer() por tf.optimizers.Adam()
Fundamentos prácticos
Aplica Platzidoro en este curso y asegura el éxito de tu aprendizaje
Los fundamentos de machine learning que aprenderás
Introducción a Numpy
Introducción y manipulación de datos con Pandas
Introducción a ScikitLearn
Comandos básicos de las librerías usadas en el curso (Numpy, Pandas y ScikitLearn)
Regresión Lineal y Logística
¿Qué es la predicción de datos?
Sobreajuste y subajuste en los datos
Regresión lineal simple y regresión lineal múltiple
Regresión lineal simple con Scikit-Learn: división de los datos
Regresión lineal simple con Scikit-Learn: creación del modelo
Regresión logística con Scikit-Learn: definición y división de datos
Regresión logística con Scikit-Learn: evaluación del modelo
Matriz de confusión
PlatziDoro Cápsula 1
Árboles de decisión
¿Qué es un árbol de decisión y cómo se divide?
Comprendiendo nuestro data set para la creación de un árbol de decisión
Creando un clasificador con Scikit-Learn
Entrenamiento del modelo de clasificación
Visualización del árbol de decisión
K-Means
¿Qué es K-Means?
Cargando el data set de Iris
Construcción y evaluación del modelo con K-Means
Graficación del modelo
PlatziDoro Cápsula 2
Aprendizaje profundo
Introducción al aprendizaje profundo
Conceptos básicos de Tensor Flow
Red neuronal convolucional
Conociendo el set de datos para la creación de la red neuronal
Crea y entrena tu primera red neuronal convolucional con Tensor Flow
Evaluación de la red convolucional
PlatziDoro Cápsula 3
Despedida
Recomendaciones para analizar correctamente tu problema
Siguientes pasos para continuar aprendendiendo de Machine Learning
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 33
Preguntas 9
para los que trabajan con jupyter note hay que cambiar tf.train.AdamOptimizer() por tf.optimizers.Adam()
Explicacion del funcionamiento de las capas que usamos.
La primera capa de esta red, tf.keras.layers.Flatten, transforma el formato de las imagenes de un arreglo bi-dimensional (de 28 por 28 pixeles) a un arreglo uni dimensional (de 28*28 pixeles = 784 pixeles). Observe esta capa como una capa no apilada de filas de pixeles en la misma imagen y alineandolo. Esta capa no tiene parametros que aprender; solo reformatea el set de datos.
Despues de que los pixeles estan “aplanados”, la secuencia consiste de dos capastf.keras.layers.Dense. Estas estan densamente conectadas, o completamente conectadas. La primera capa Dense tiene 128 nodos (o neuronas). La segunda (y ultima) capa es una capa de 10 nodos softmax que devuelve un arreglo de 10 probabilidades que suman a 1. Cada nodo contiene una calificacion que indica la probabilidad que la actual imagen pertenece a una de las 10 clases.
Estoy un poco decepcionado de este curso debido a que ya conozco un poco del tema y no estamos trabajando con una red neuronal convolucional, en la clase introductoria del módulo la profesora explicó algo sobre cómo realmente funciona una red convolucional y después en esta clase práctica implementa una red neuronal fully conected aún cunado el tema de la clase no sugiere eso, además la profesora no explica correctamente partes complejas y claves si queremos entender realmente el machine learning como los optimizadores (adam en este caso), cuando lo implementa dice (no recuerdo bien) q es debido a la complejidad de la red porque habían varias neuronas en la capa de salida (10 si no me equivoco ) me parece q es bastante pobre el curso sinceramente. Sin ánimos de ofender y con el mayor respeto expreso mi sentir. Gracias
La arquitectura de red mostrada en clase no corresponde a una red neuronal convolucional, solo se muestran tres capas, la primera aplica el flatten necesario para las dos siguiente capas que realizan la siguiente operación:
output = activation(dot(input, kernel) + bias)
Que es la multiplicación de matrices típica de las capas lineales de una red neuronal.
Pensaba que en la siguiente clase irían a corregir lo dicho en esta o implementar la convolución con el fin de generar conclusiones a modo de comparativa, pero no. Por lo tanto no entiendo el motivo de explicar esto como redes neuronales convolucionales.
Por si quedan dudas de los conceptos:
“Loss function —Esto mide que tan exacto es el modelo durante el entrenamiento. Quiere minimizar esta funcion para dirigir el modelo en la direccion adecuada.
Optimizer — Esto es como el modelo se actualiza basado en el set de datos que ve y la funcion de perdida.
Metrics — Se usan para monitorear los pasos de entrenamiento y de pruebas. El siguiente ejemplo usa accuracy (exactitud) , la fraccion de la imagenes que son correctamente clasificadas.”(TensorFlow)
https://www.tensorflow.org/tutorials/keras/classification
A mi en el model.fit me hace el calculo sobre 1875 no sobre los 60000
cuando escribí la línea 11,obtenía un error. El error decía que no existía AdamOptimizer(). Entonces cambié
tf.train.AdamOptimizer()
por
tf.compat.v1.train.AdamOptimizer()
y ya funcionó
Para los que pasen por aqui y no funcione la parte del compiler, está deprecado AdamOptimizer, usen este código:
model.compile(optimizer = tf.keras.optimizers.Adam(),
loss = 'sparse_categorical_crossentropy',
metrics=['accuracy'])
Por si tienen problemas con errores al llamar a las funciones, esto es debido a que en las actualizaciones de TensorFlow pudieron reubicar dichas funciones en otras secciones de la libreria.
Les comparto mi código, basado en la version 2.2.0 de TensorFlow
import tensorflow as tf
from tensorflow.keras.datasets import fashion_mnist
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.nn import relu, softmax
fashion = fashion_mnist
(train_set, train_labels), (test_set, test_labels) = fashion.load_data()
layers = [Flatten(input_shape=(28,28)),
Dense(128, activation=relu),
Dense(10, activation=softmax)]
model = Sequential(layers)
model.compile(optimizer=Adam(),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x=train_set, y=train_labels, epochs=5)
model.evaluate(x=test_set, y=test_labels)
model.predict(test_set)
Comparto un ejemplo de una verdadera red neuronal convolucional para la clasificación de imágenes: https://www.tensorflow.org/tutorials/images/cnn
El ejemplo de esta clase es un red neuronal tradicional, donde todas las neuronas de las capas de entrada y salida están conectadas con la capa oculta (tipo “dense”) de 128 neuronas.
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('Accuracy ', test_acc)
Me hace el entrenamiento con 1875, elementos, y el test con 313, no entiendo porque toma números tan pequeños
Para los que les da error en la linea siguiente:
model.compile(optimizer=tf.AdamOptimizer(), loss = 'sparse_categorical_crossentropy', metrics=['accuracy'])
Deben cambiar lo siguiente, así funciona:
model.compile(optimizer = tf.keras.optimizers.Adam(), loss = 'sparse_categorical_crossentropy', metrics=['accuracy'])
Desde la creación del curso, el optimizador Adam, ha ido cambiando sintaxis, dejo ésta que es la que me funcionó en nov/2020:
model.compile(optimizer = tf.optimizers.Adam(), loss = ‘sparse_categorical_crossentropy’, metrics = [‘accuracy’])
La funcion de activacion Relu, hace que cuando se le mete un valor menor a 0, devuelve 0 y cuando se le mete un valor mayor a 0, actua como una funcion lineal normal.
La funcion de activacion Softmax transforma los numeros reales, en una distribucion de probabilidad,por ejemplo, 0.3 T-Shirt, 0.5 Sandal y 0.9 Goat, ya que goat es la que tiene mayor probabilidad es la que va a quedar
Me salió este error al momento de calcular la precisión
ValueError Traceback (most recent call last)
<ipython-input-181-65aaef7d17de> in <module>()
----> 1 test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
2 # print('Precisión: ', test_acc)
3 frames
/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/data_adapter.py in __init__(self, x, y, sample_weights, sample_weight_modes, batch_size, epochs, steps, shuffle, **kwargs)
280 label, ", ".join(str(i.shape[0]) for i in nest.flatten(data)))
281 msg += "Please provide data which shares the same first dimension."
--> 282 raise ValueError(msg)
283 num_samples = num_samples.pop()
284
ValueError: Data cardinality is ambiguous:
x sizes: 60000
y sizes: 10000
Please provide data which shares the same first dimension.
Me salía el error:
NameError: name 'keras' is not defined
lo solucione asi
pip install keras-unet-collection==0.1.13
pENSABA QUE aROESTI ERA EL PEOR MAESTRO
Si quieren aprender el porque esta red no es convolucional y que si es una red convolucional les dejo este video que lo explica:
Redes Neuronales Convolucionales - Clasificación avanzada de imágenes con IA / ML (CNN)
model.compile(optimizer = tf.keras.optimizers.Adam(), loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])
tf.train.AdamOptimizer() = tf.optimizers.Adam() por si acaso
tf.optimizers.Adam()
Con cada ejecución el Accuracy cambia.
Le di epochs=100
model.fit(train_images, train_labels, epochs = 100)
Y obtuve un accuracy de entrenamiento al 97%
Probé en el dataset de prueba, y obtuve una mejoría solo del 2%
10000/10000 [==============================] - 0s 35us/sample - loss: 0.8131 - acc: 0.8867
Accuracy 0.8867
Por otro lado, creo que epochs, es la cantidad de veces que entrenas al modelo
Quedo atentos a sus comentarios y conclusiones
Para los que luchan todavía con los conceptos de las redes neuronales como Loss function, optimizer, backpropagation, etc… les dejo el primer video de una serie donde se explica muy brevemente y con ejemplos didacticos. Link del video
Tensorflow se actualizó y muchos métodos cambiaron de nombre. La verdad es un complique que haya pasado eso. El caso es que buscan el error en gogole y casi siempre muestran como solucionarlo. Otro aporte que hago, es que también se puede escoger con cual versión de TF se va a trabajar en el notebook. así: %tensorflow_version 1.x
así los códigos anteriores corren.
Y esta es la nueva sintaxis para el optimizador: tf.optimizers.Adam()
**Dos dudas:
**
Epoch es proporcionan al Accuracy ¿A mayor nùmero de Epoch el Accuracy tendera a uno?
¿Existe un número óptimo de epochs o algún algoritmo para dar con este?
Quiza les sirve, quizas no.
Pero solucione lo del optimizer asi:
optimizer=tf.optimizers.Adam()```
Alguien sabe porque mi accuracy es menor (0.6) si el codigo es exactamente el mismo?
De antemano gracias
Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.