top of page

MACHINE LEARNING

TENSORFLOW



TensorFlow es una biblioteca de código abierto para aprendizaje automático a través de un rango de tareas, y desarrollado por Google para satisfacer sus necesidades de sistemas capaces de construir y entrenar redes neuronales para detectar y descifrar patrones y correlaciones, análogos al aprendizaje y razonamiento usados por los humanos.

El nombre TensorFlow deriva de las operaciones que tales redes neuronales realizan sobre arrays multidimensionales de datos. Estos arrays multidimensionales son referidos como "tensores". En una primera versión los cálculos de TensorFlow se expresaban como gráficos de flujo de datos con estado, sin embargo, con la evolución de la biblioteca la forma de codificar estas redes se ha vuelto más imperativa


TensorFlow es una de las bibliotecas más populares para el aprendizaje automático y la inteligencia artificial en Python. Tiene varias ventajas significativas sobre otras bibliotecas de machine learning:

  1. Flexibilidad y escalabilidad: TensorFlow está diseñado para ser altamente flexible, permitiendo la creación y entrenamiento de una amplia gama de modelos de aprendizaje automático, desde redes neuronales simples hasta complejas arquitecturas de deep learning. Además, ofrece escalabilidad para ejecutar modelos en dispositivos de diferentes tamaños, desde dispositivos móviles hasta grandes clusters de servidores.

  2. Gráficos computacionales: TensorFlow opera utilizando un grafo computacional, lo que significa que primero se define el grafo de cálculo y luego se ejecuta. Esto permite la optimización de operaciones y la posibilidad de realizar cálculos en paralelo, lo que mejora el rendimiento, especialmente en tareas intensivas en cómputo.

  3. Implementación de modelos de deep learning: TensorFlow proporciona una amplia variedad de herramientas y capas predefinidas para la implementación de modelos de deep learning, lo que facilita la construcción y el entrenamiento de redes neuronales convolucionales, recurrentes, y otros tipos de modelos complejos.

  4. Disponibilidad de recursos: Al ser una de las bibliotecas más populares, TensorFlow cuenta con una gran cantidad de documentación, tutoriales, y una comunidad activa que comparte código, modelos preentrenados y soluciones a problemas comunes en aprendizaje automático.

  5. TensorFlow Extended (TFX): TensorFlow no solo se centra en la etapa de desarrollo de modelos, sino que también ofrece TensorFlow Extended (TFX), una plataforma que permite construir pipelines completos de machine learning, desde la preparación de datos hasta el despliegue y monitoreo en producción.

  6. Compatibilidad y portabilidad: TensorFlow es compatible con múltiples plataformas, lo que permite el despliegue de modelos en dispositivos móviles, servidores o en la nube con relativa facilidad. Además, ofrece APIs en varios lenguajes de programación, no solo en Python, como TensorFlow.js para JavaScript o TensorFlow Lite para aplicaciones móviles.

USO DE LA LIBERIA EN LA PRACTICA

Ejemplo 1: "Breve introducción de sus funciones paso a paso"


import tensorflow as tf


1.- Carga el conjunto de datos MNIST y lo divide en conjuntos de entrenamiento y prueba.

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()


2.-Normaliza los valores de píxeles de las imágenes al rango [0, 1].

x_train, x_test = x_train / 255.0, x_test / 255.0


3.- Define un modelo de red neuronal secuencial con capas de aplanamiento, capas densas (totalmente conectadas), capa de dropout para regularización y una capa de salida con activación softmax para clasificación multiclase.

model = tf.keras.models.Sequential([

tf.keras.layers.Flatten(input_shape=(28, 28)),

tf.keras.layers.Dense(128, activation='relu'),

tf.keras.layers.Dropout(0.2),

tf.keras.layers.Dense(10, activation='softmax')

])


4.- Compila el modelo con un optimizador, una función de pérdida y métricas para monitorear durante el entrenamiento.

model.compile(optimizer='adam',

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])


5.- Entrenar el modelo con los datos de entrenamiento

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


6.- Evalúa la precisión del modelo utilizando el conjunto de prueba

test_loss, test_acc = model.evaluate(x_test, y_test)

print(f"Precisión del modelo: {test_acc}")


EJEMPLO 2 : "Aplicacion detallada"


import tensorflow as tf import tensorflow_datasets as tfds datos, metadatos = tfds.load('fashion_mnist', as_supervised=True, with_info=True) datos_entrenamiento, datos_pruebas = datos['train'], datos['test'] nombres_clases = metadatos.features['label'].names nombres_clases #Funcion de normalizacion para los datos def normalizar(imagenes, etiquetas): imagenes = tf.cast(imagenes, tf.float32) imagenes /= 255 #Aqui lo pasa de 0-255 a 0-1 return imagenes, etiquetas #Normalizamos los datos de entrenamiento y pruebas con la funcion que hicimos datos_entrenamiento = datos_entrenamiento.map(normalizar) datos_pruebas = datos_pruebas.map(normalizar) #Agregamos a cache (usamos la memoria para un entrenamiento mas rapido) datos_entrenamiento = datos_entrenamiento.cache() datos_pruebas = datos_pruebas.cache() import matplotlib.pyplot as plt #Dibujamos plt.figure(figsize=(10,10)) for i, (imagen, etiqueta) in enumerate(datos_entrenamiento.take(25)): imagen = imagen.numpy().reshape((28,28)) plt.subplot(5,5,i+1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(imagen, cmap=plt.cm.binary) plt.xlabel(nombres_clases[etiqueta]) plt.show() #Creamos el modelo modelo = tf.keras.Sequential([ tf.keras.layers.Flatten(input_shape=(28,28,1)), tf.keras.layers.Dense(50, activation=tf.nn.relu), tf.keras.layers.Dense(50, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax) ]) #Compilamos el modelo modelo.compile( optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(), metrics=['accuracy'] ) #Trabajamos por lotes para una mayor eficiencia en el entrenamiento TAMANO_LOTE = 32 num_ej_entrenamiento = metadatos.splits["train"].num_examples num_ej_pruebas = metadatos.splits["test"].num_examples datos_entrenamiento = datos_entrenamiento.repeat().shuffle(num_ej_entrenamiento).batch(TAMANO_LOTE) datos_pruebas = datos_pruebas.batch(TAMANO_LOTE) import math #Entrenamos historial = modelo.fit(datos_entrenamiento, epochs=5, steps_per_epoch= math.ceil(num_ej_entrenamiento/TAMANO_LOTE)) #Vemos la funcion de perdida plt.xlabel("# Epoca") plt.ylabel("Magnitud de pérdida") plt.plot(historial.history["loss"]) #Pintamos una cuadricula con varias predicciones, y marcamos si fue correcta (azul) o incorrecta (roja) import numpy as np for imagenes_prueba, etiquetas_prueba in datos_pruebas.take(1): imagenes_prueba = imagenes_prueba.numpy() etiquetas_prueba = etiquetas_prueba.numpy() predicciones = modelo.predict(imagenes_prueba) def graficar_imagen(i, arr_predicciones, etiquetas_reales, imagenes): arr_predicciones, etiqueta_real, img = arr_predicciones[i], etiquetas_reales[i], imagenes[i] plt.grid(False) plt.xticks([]) plt.yticks([]) plt.imshow(img[...,0], cmap=plt.cm.binary) etiqueta_prediccion = np.argmax(arr_predicciones) if etiqueta_prediccion == etiqueta_real: color = 'blue' else: color = 'red' plt.xlabel("{} {:2.0f}% ({})".format(nombres_clases[etiqueta_prediccion], 100*np.max(arr_predicciones), nombres_clases[etiqueta_real]), color=color) def graficar_valor_arreglo(i, arr_predicciones, etiqueta_real): arr_predicciones, etiqueta_real = arr_predicciones[i], etiqueta_real[i] plt.grid(False) plt.xticks([]) plt.yticks([]) grafica = plt.bar(range(10), arr_predicciones, color="#777777") plt.ylim([0, 1]) etiqueta_prediccion = np.argmax(arr_predicciones) grafica[etiqueta_prediccion].set_color('red') grafica[etiqueta_real].set_color('blue') filas = 5 columnas = 5 num_imagenes = filas*columnas plt.figure(figsize=(2*2*columnas, 2*filas)) for i in range(num_imagenes): plt.subplot(filas, 2*columnas, 2*i+1) graficar_imagen(i, predicciones, etiquetas_prueba, imagenes_prueba) plt.subplot(filas, 2*columnas, 2*i+2) graficar_valor_arreglo(i, predicciones, etiquetas_prueba)

Comments


Envíame un mensaje y dime lo que piensas

¡Gracias por tu mensaje!

© 2035 Creado por Tren de ideas con Wix.com

bottom of page