Ejemplo básico de Machine Learning con Tensor Flow

Para dar tus primeros pasos en el aprendizaje de TensorFlow, te recomendaría comenzar con un ejemplo simple de creación y entrenamiento de un modelo de aprendizaje automático básico. Manos a la obra…

Vamos a darle un sentido metafórico a este ejemplo con imaginación.

Datos de Entrada (x_train, y_train): Imagina que estás entrenando a un niño llamado TensorFlow para que aprenda a reconocer diferentes tipos de frutas. En este caso:

x_train: Serían las imágenes de las frutas que le muestras a TensorFlow. Cada imagen es una foto de una fruta diferente, y estas fotos muestran características como el color, la forma y el tamaño de las frutas.
- Por ejemplo, podrías tener una foto de una manzana, otra de una naranja y otra de una banana. Estas fotos son como los datos de entrada x_train.
y_train: Serían las etiquetas que le das a TensorFlow para que sepa qué fruta está viendo en cada imagen. En otras palabras, es la respuesta a la pregunta «¿Qué fruta es esta?». Puedes etiquetar las fotos de manzanas como 1, las de naranjas como 2 y las de bananas como 3.
- Por lo tanto, si le estás mostrando una foto de una manzana, la etiqueta correspondiente (y_train) sería 1. Estas etiquetas son la información que le proporcionas a TensorFlow para que aprenda qué características de las frutas se asocian con cada tipo.

Datos de Salida (Predicciones): Después de que TensorFlow ha sido entrenado, ahora puedes mostrarle una nueva foto de fruta que nunca ha visto antes, y él debería poder decirte qué tipo de fruta es.

Entonces, las predicciones que obtienes después del entrenamiento serían como si le mostraras a TensorFlow una foto de una fruta misteriosa, y él te dice: «¡Oh, esto parece una manzana!» o «Creo que es una naranja».

En resumen, el proceso de entrenamiento es como enseñarle a un niño a reconocer frutas. Le muestras muchas fotos de diferentes frutas (datos de entrada), le dices qué fruta es cada una (etiquetas), y después de un buen entrenamiento, esperas que pueda decirte qué fruta es cuando le muestras una nueva foto (predicciones).

Vamos a verlo…

Entrenamiento de un Modelo en TensorFlow

Instalación de TensorFlow:

Si aún no tienes TensorFlow instalado, puedes hacerlo utilizando el siguiente comando en tu entorno de Python

pip install tensorflow

Importar TensorFlow y NumPy:

En tu script de Python, importa TensorFlow y NumPy:

import tensorflow as tf
import numpy as np

Crear Datos de Entrada y Salida:

Genera algunos datos de entrada y salida para tu modelo. Por ejemplo, puedes crear un conjunto de datos linealmente relacionados:

x_train = np.array([1, 2, 3, 4, 5], dtype=np.float32)
y_train = np.array([2, 4, 6, 8, 10], dtype=np.float32)

Definir el Modelo:

Crea un modelo simple utilizando la API de alto nivel Sequential de TensorFlow:

model = tf.keras.Sequential([tf.keras.layers.Dense(units=1, input_shape=[1])])

Compilar el Modelo:

Antes de entrenar el modelo, compílalo especificando la función de pérdida y el optimizador:

model.compile(optimizer='sgd', loss='mean_squared_error')

Entrenar el Modelo:

Entrena el modelo utilizando los datos de entrada y salida que has creado:

model.fit(x_train, y_train, epochs=100)

Realizar Predicciones:

Una vez que el modelo ha sido entrenado, puedes utilizarlo para realizar predicciones en nuevos datos:

x_test = np.array([6, 7, 8], dtype=np.float32)
predictions = model.predict(x_test)
print(predictions)

Este es un ejemplo básico para familiarizarte con el flujo de trabajo de TensorFlow. A medida que avances, podrás explorar modelos más complejos, técnicas de regularización, y otros aspectos del aprendizaje profundo. La documentación oficial de TensorFlow y los tutoriales en línea pueden ser recursos útiles a medida que profundizas en tus estudios. ¡Buena suerte en tu viaje de aprendizaje!

Aquí te dejo el código completo.

import tensorflow as tf
import numpy as np

# Step 3: Create Input and Output Data
x_train = np.array([1, 2, 3, 4, 5], dtype=np.float32)
y_train = np.array([2, 4, 6, 8, 10], dtype=np.float32)

# Step 4: Define the Model
model = tf.keras.Sequential([tf.keras.layers.Dense(units=1, input_shape=[1])])

# Step 5: Compile the Model
model.compile(optimizer='sgd', loss='mean_squared_error')

# Step 6: Train the Model
model.fit(x_train, y_train, epochs=100)

# Step 7: Make Predictions
x_test = np.array([6, 7, 8], dtype=np.float32)
predictions = model.predict(x_test)
print(predictions)

Esta es la salida resultante a la ejecución.

Epoch 1/100
1/1 [==============================] - 1s 1s/step - loss: 99.4561
Epoch 2/100
1/1 [==============================] - 0s 8ms/step - loss: 58.0028
Epoch 3/100
1/1 [==============================] - 0s 8ms/step - loss: 33.8456
Epoch 4/100
1/1 [==============================] - 0s 7ms/step - loss: 19.7676
Epoch 5/100
1/1 [==============================] - 0s 7ms/step - loss: 11.5634
Epoch 6/100
1/1 [==============================] - 0s 7ms/step - loss: 6.7821
Epoch 7/100
1/1 [==============================] - 0s 8ms/step - loss: 3.9955
Epoch 8/100
1/1 [==============================] - 0s 8ms/step - loss: 2.3713
Epoch 9/100
1/1 [==============================] - 0s 8ms/step - loss: 1.4245
Epoch 10/100
1/1 [==============================] - 0s 9ms/step - loss: 0.8725
Epoch 11/100
1/1 [==============================] - 0s 8ms/step - loss: 0.5505
Epoch 12/100
1/1 [==============================] - 0s 8ms/step - loss: 0.3626
Epoch 13/100
1/1 [==============================] - 0s 8ms/step - loss: 0.2528
Epoch 14/100
1/1 [==============================] - 0s 8ms/step - loss: 0.1885
Epoch 15/100
1/1 [==============================] - 0s 9ms/step - loss: 0.1508
Epoch 16/100
1/1 [==============================] - 0s 8ms/step - loss: 0.1285
Epoch 17/100
1/1 [==============================] - 0s 8ms/step - loss: 0.1153
Epoch 18/100
1/1 [==============================] - 0s 8ms/step - loss: 0.1073
Epoch 19/100
1/1 [==============================] - 0s 8ms/step - loss: 0.1024
Epoch 20/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0992
Epoch 21/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0971
Epoch 22/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0956
Epoch 23/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0945
Epoch 24/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0936
Epoch 25/100
1/1 [==============================] - 0s 9ms/step - loss: 0.0928
Epoch 26/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0921
Epoch 27/100
1/1 [==============================] - 0s 10ms/step - loss: 0.0914
Epoch 28/100
1/1 [==============================] - 0s 10ms/step - loss: 0.0908
Epoch 29/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0901
Epoch 30/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0895
Epoch 31/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0889
Epoch 32/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0883
Epoch 33/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0877
Epoch 34/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0871
Epoch 35/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0865
Epoch 36/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0859
Epoch 37/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0853
Epoch 38/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0848
Epoch 39/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0842
Epoch 40/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0836
Epoch 41/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0831
Epoch 42/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0825
Epoch 43/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0819
Epoch 44/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0814
Epoch 45/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0808
Epoch 46/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0803
Epoch 47/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0798
Epoch 48/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0792
Epoch 49/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0787
Epoch 50/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0781
Epoch 51/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0776
Epoch 52/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0771
Epoch 53/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0766
Epoch 54/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0761
Epoch 55/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0755
Epoch 56/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0750
Epoch 57/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0745
Epoch 58/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0740
Epoch 59/100
1/1 [==============================] - 0s 9ms/step - loss: 0.0735
Epoch 60/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0730
Epoch 61/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0725
Epoch 62/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0720
Epoch 63/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0716
Epoch 64/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0711
Epoch 65/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0706
Epoch 66/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0701
Epoch 67/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0696
Epoch 68/100
1/1 [==============================] - 0s 10ms/step - loss: 0.0692
Epoch 69/100
1/1 [==============================] - 0s 9ms/step - loss: 0.0687
Epoch 70/100
1/1 [==============================] - 0s 9ms/step - loss: 0.0682
Epoch 71/100
1/1 [==============================] - 0s 9ms/step - loss: 0.0678
Epoch 72/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0673
Epoch 73/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0669
Epoch 74/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0664
Epoch 75/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0660
Epoch 76/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0655
Epoch 77/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0651
Epoch 78/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0646
Epoch 79/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0642
Epoch 80/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0638
Epoch 81/100
1/1 [==============================] - 0s 9ms/step - loss: 0.0633
Epoch 82/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0629
Epoch 83/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0625
Epoch 84/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0621
Epoch 85/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0617
Epoch 86/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0612
Epoch 87/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0608
Epoch 88/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0604
Epoch 89/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0600
Epoch 90/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0596
Epoch 91/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0592
Epoch 92/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0588
Epoch 93/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0584
Epoch 94/100
1/1 [==============================] - 0s 9ms/step - loss: 0.0580
Epoch 95/100
1/1 [==============================] - 0s 10ms/step - loss: 0.0576
Epoch 96/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0572
Epoch 97/100
1/1 [==============================] - 0s 8ms/step - loss: 0.0568
Epoch 98/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0565
Epoch 99/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0561
Epoch 100/100
1/1 [==============================] - 0s 7ms/step - loss: 0.0557
1/1 [==============================] - 0s 177ms/step
[[11.635091]
 [13.482389]
 [15.329688]]

Esta salida está relacionada con el entrenamiento de una red neuronal simple usando TensorFlow. Desglosemos esto paso a paso:

Épocas: El proceso de entrenamiento se divide en épocas. Una época es un pase completo a través de todo el conjunto de datos de entrenamiento. En tu salida, entrenaste el modelo durante 100 épocas, como indica las líneas:

Epoch 1/100
...
Epoch 100/100

Pérdida (Loss): La pérdida es una medida de qué tan bien está funcionando la red neuronal. Representa el error entre la salida predicha y la salida real para los datos de entrenamiento. El objetivo durante el entrenamiento es minimizar esta pérdida. En cada época, ves una línea como:

1/1 [==============================] - 0s 177ms/step

Esta línea indica el progreso de un paso de entrenamiento para esa época. El valor asociado con esta línea es la pérdida actual. Por ejemplo:

Epoch 1/100
1/1 [==============================] - 1s 1s/step - loss: 99.4561

1/1 significa que se procesó un lote de un lote en total.
1s 1s/step indica el tiempo tomado para cada paso (en este caso, 1 segundo por paso).
loss: 99.4561 es el valor de la pérdida después de este paso.

Predicción: Después de entrenar el modelo, realizas predicciones utilizando el modelo entrenado en algunos datos de entrada. La salida:

[[11.635091]
 [13.482389]
 [15.329688]]

Representa las predicciones del modelo para tres instancias. Cada fila corresponde a una instancia diferente, y la columna representa la salida predicha.

Para la primera instancia, el modelo predice un valor de aproximadamente 11.64.
Para la segunda instancia, la predicción es aproximadamente 13.48.
Para la tercera instancia, la predicción es alrededor de 15.33.

La disminución gradual en la pérdida a lo largo de las épocas indica que el modelo está aprendiendo y ajustando sus parámetros para ajustarse mejor a los datos de entrenamiento. Valores de pérdida más bajos generalmente indican un mejor ajuste a los datos. En un escenario del mundo real, típicamente evaluarías el modelo en un conjunto de datos de validación o prueba separado para asegurarte de que se generalice bien a nuevos datos no vistos.

Volviendo al inicial sentido metafórico..

En el contexto de la detección de frutas, los valores de salida representarían la «confianza» de TensorFlow en que la fruta desconocida pertenece a cada una de las categorías conocidas. Cada número en la salida corresponde a la puntuación o probabilidad de que la fruta sea de una categoría específica.

Tomando el ejemplo de salida:

[[11.635091]
 [13.482389]
 [15.329688]]

Podríamos interpretarlo así:

La primera cifra (11.635091) podría representar la puntuación de que la fruta es una manzana.
La segunda cifra (13.482389) podría representar la puntuación de que la fruta es una naranja.
La tercera cifra (15.329688) podría representar la puntuación de que la fruta es una banana.

En este caso, la fruta se clasificaría como la categoría con la puntuación más alta. Por lo tanto, la salida indica que TensorFlow tiene más confianza en que la fruta desconocida es una banana, seguida por una naranja y luego una manzana.

Podemos imaginar esto como si TensorFlow dijera: «Basado en las características que he aprendido de las frutas durante mi entrenamiento, estoy bastante seguro de que esta fruta es una banana, menos seguro de que sea una naranja y aún menos seguro de que sea una manzana».

Deja una respuesta Cancelar respuesta