TensorFlow: una herramienta para Machine Learning y Deep Learning

TensorFlow es una biblioteca de software libre y de código abierto, desarrollada por Google, para el aprendizaje automático (machine learning) y el aprendizaje profundo (deep learning). La cual se utiliza para aprendizaje automático, el procesamiento de lenguaje natutal, reconocimiento de imágenes y demás soluciones que tengan que ver con el aprendizaje automático.

Instalarlo no te llevará mucho tiempo. Solo abre una consola y teclea lo siguiente:

$ pip install tensorflow

Una vez instalado verificamos:

$ pip show tensorflow
Name: tensorflow
Version: 2.20.0
Summary: TensorFlow is an open source machine learning framework for everyone.
Home-page: https://www.tensorflow.org/
Author: Google Inc.
Author-email: packages@tensorflow.org
License: Apache 2.0
Location: C:\Users\HP\AppData\Local\Programs\Python\Python313\Lib\site-packages
Requires: absl-py, astunparse, flatbuffers, gast, google_pasta, grpcio, h5py, keras, libclang, ml_dtypes, numpy, opt_einsum, packaging, protobuf, requests, setuptools, six, tensorboard, termcolor, typing_extensions, wrapt
Required-by:

También podemos descargar una imagen de Docker:

$ docker pull tensorflow/tensorflow:latest 
$ docker run -it -p 8888:8888 tensorflow/tensorflow:latest-jupyter 

Con esto descargamos la última versión de la imagen oficial y la ejecutamos (con Jupyter).

TensorFlow nos permite:

• Construir y entrenar modelos de Machine Learning y Deep Learning (redes neuronales, CNN, RNN, etc.). 
• Procesar datos para tareas como clasificación, regresión, clustering o generación de texto/imágenes. 
• Desarrollar aplicaciones de visión por computadora (ej. detección de objetos), NLP (ej. chatbots) y series temporales. 
• Escalar modelos con soporte para GPUs/TPUs y despliegue en producción (web, móvil, edge). 
• Personalizar modelos con capas y funciones avanzadas para investigación o prototipado.

He aquí un ejemplo del uso de TensorFlow para crear, entrenar y evaluar un modelo de red neuronal que clasifica dígitos escritos a mano del conjunto de datos MNIST (imágenes de 28x28 píxeles de dígitos del 0 al 9).

ejemplo_tensor.py

import tensorflow as tf
from tensorflow.keras import layers, models
import numpy as np

# 1. Cargar y preprocesar el conjunto de datos MNIST
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Normalizar los datos (valores de píxeles de 0-255 a 0-1)
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# 2. Crear el modelo de red neuronal
model = models.Sequential([
    layers.Flatten(input_shape=(28, 28)),  # Aplana las imágenes 28x28 a un vector de 784
    layers.Dense(128, activation='relu'),   # Capa densa con 128 neuronas y activación ReLU
    layers.Dense(10, activation='softmax')  # Capa de salida con 10 clases (dígitos 0-9)
])

# 3. Compilar el modelo
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 4. Entrenar el modelo
model.fit(x_train, y_train, epochs=5, batch_size=32, validation_split=0.2)

# 5. Evaluar el modelo en el conjunto de prueba
test_loss, test_accuracy = model.evaluate(x_test, y_test)
print(f'\nPrecisión en el conjunto de prueba: {test_accuracy:.4f}')

# 6. Hacer una predicción (ejemplo con una imagen)
sample_image = x_test[0:1]  # Tomar la primera imagen de prueba
prediction = model.predict(sample_image)
predicted_digit = np.argmax(prediction)
print(f'Dígito predicho para la imagen de prueba: {predicted_digit}')

Ejecución y salida:

$ python ejemplo_tensor.py
Precisión en el conjunto de prueba: 0.9780
Dígito predicho para la imagen de prueba: 7

Usar TensorFlow requiere no solo saber programar en Python, también es indispensable contar con habilidades en:

• Matemáticas y estadística: Conocimientos básicos de álgebra lineal (vectores, matrices), cálculo (derivadas, optimización) y probabilidad (distribuciones, estadística bayesiana). 
• Machine Learning: Entender conceptos como regresión, clasificación, redes neuronales, funciones de pérdida, optimización (ej. gradiente descendente) y métricas de evaluación. 
• Procesamiento de datos: Habilidad para limpiar, normalizar y preprocesar datos (usando Pandas, NumPy, etc.). 
• Programación estructurada: Familiaridad con estructuras de datos, funciones y buenas prácticas de codificación. 
• Conocimiento de Deep Learning: Entender arquitecturas como CNN, RNN o transformers para casos avanzados. 
• Manejo de hardware: Conocimientos básicos de GPUs/TPUs para entrenar modelos grandes (opcional, pero útil). 
• Resolución de problemas: Capacidad para depurar errores y optimizar modelos (hiperparámetros, regularización).

TensorFlow es una de las miles de librerías que ahorran mucho trabajo a la hora de trabajar con Python. Pero es indispensable contar con conocimiento semi avanzado en otras áreas como el Álgebra, Cálculo, Estadística, Probabilidad y las Redes neuronales para sacarle un verdadero provecho. Sin contar que también es necesario habilidades en el manejo de servicios de la nube (GCP, AWS, Azure, etc.) y contenedores (Docker / Kubernetes).

Enlaces:

https://www.tensorflow.org/
https://es.wikipedia.org/wiki/TensorFlow