TensorFlow para principiantes: así puedes crear tu primera IA en 15 minutos

La inteligencia artificial (IA) es hoy una de las tecnologías más importantes en diferentes sectores. Aunque parece compleja, la IA consiste en sistemas informáticos que realizan tareas que antes solo podían hacer los humanos. Estos sistemas analizan datos, encuentran patrones y toman decisiones con cierta autonomía.

Desde los asistentes de voz en nuestros móviles hasta las recomendaciones personalizadas en plataformas de streaming, la IA ya está en nuestra vida diaria.

TensorFlow destaca como una herramienta clave para desarrollar aplicaciones de IA. Creada por Google en 2015 y luego liberada como software libre, esta biblioteca permite a los programadores crear y entrenar modelos de aprendizaje profundo. Su nombre viene de su funcionamiento: usa “tensores”, que son estructuras de datos que permiten hacer cálculos matemáticos complejos de forma eficiente.

Aunque es potente, TensorFlow está diseñada para ser accesible incluso para principiantes en programación y ciencia de datos. Con una comunidad activa y buena documentación, cualquiera puede empezar a crear modelos avanzados con relativa facilidad.

En este tutorial te mostramos cómo empezar con TensorFlow y crear tus propios modelos de IA para resolver problemas reales.

Si quieres crear aplicaciones que predigan gastos, detecten caras en fotos o incluso recomienden ingredientes para pizzas según el gusto, TensorFlow es perfecto. Esta herramienta sirve tanto para pequeños proyectos personales como para grandes aplicaciones comerciales.

La instalación es muy fácil. Con solo escribir pip install tensorflow pandas matplotlib en tu terminal ya tendrás todo lo necesario para empezar a experimentar con IA.

Tu primera red neuronal

Para empezar con TensorFlow, puedes crear una red neuronal simple. Por ejemplo, este modelo predice precios de casas según su tamaño:

import tensorflow as tf
import numpy as np

# Datos (tamaño en pies cuadrados y precio)
temp_data = np.array([[1400], [1600], [1800], [2000], [2200]], dtype=float)
price_data = np.array([[200000], [250000], [300000], [350000], [400000]], dtype=float)

# Normalización
temp_data /= 2200
price_data /= 400000

# Creación del modelo
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=[1]),
    tf.keras.layers.Dense(units=1)
])

model.compile(optimizer='sgd', loss='mean_squared_error')
model.fit(temp_data, price_data, epochs=500, verbose=1)

# Hacer una predicción
prediction_input = np.array([[2400 / 2200]])
prediction = model.predict(prediction_input)
print(f"Precio predicho: ${prediction[0][0] * 400000:.2f}")

Este código hace lo siguiente:

• Importa TensorFlow para el aprendizaje automático y NumPy para trabajar con números
• Crea dos grupos de datos: tamaños de casas y sus precios
• Normaliza los datos (los divide por su valor máximo) para que el entrenamiento funcione mejor
• Crea un modelo con una capa de entrada y una capa con una neurona
• Configura el modelo con un optimizador y una función de error
• Entrena el modelo durante 500 rondas
• Hace una predicción para una casa de 2400 pies cuadrados

Redes neuronales más avanzadas

Una vez domines lo básico, puedes probar con modelos más complejos:

• Redes neuronales convolucionales (CNN): Perfectas para trabajar con imágenes. Con pocas líneas de código puedes crear un sistema que clasifique fotos:

from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.models import Sequential

model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)),
    MaxPooling2D(pool_size=(2, 2)),
    Flatten(),
    Dense(128, activation='relu'),
    Dense(1, activation='sigmoid')
])

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

Así funciona este modelo:

• La primera capa aplica 32 filtros a una imagen de 64×64 píxeles con 3 canales de color (RGB)
• La segunda capa reduce el tamaño de la imagen, quedándose con lo importante
• La capa Flatten convierte la matriz en una lista simple de números
• Las dos últimas capas procesan estos datos para decidir qué hay en la imagen (por ejemplo, si hay un gato o no)
• Redes LSTM: Ideales para datos que cambian con el tiempo, como texto o precios de acciones:

lstm_model = tf.keras.Sequential([
    tf.keras.layers.LSTM(50, return_sequences=True, input_shape=(100, 1)),
    tf.keras.layers.LSTM(50),
    tf.keras.layers.Dense(1)
])

# Compilar el modelo LSTM
lstm_model.compile(optimizer='adam', loss='mean_squared_error')

Este modelo LSTM:

• Analiza secuencias de 100 pasos (podrían ser precios durante 100 días)
• La primera capa LSTM procesa la secuencia y la pasa a la siguiente
• La segunda capa LSTM resume esta información
• La capa final hace una predicción (por ejemplo, el precio para el día siguiente)

Caso práctico: Detectar diabetes con TensorFlow

Este ejemplo muestra cómo crear un modelo para detectar diabetes usando datos médicos reales:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Cargar datos
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
column_names = ["Embarazos", "Glucosa", "PresionArterial", "GrosorPiel", 
                "Insulina", "IMC", "FuncionPedigri", "Edad", "Resultado"]
data = pd.read_csv(url, names=column_names)

# Separar características y etiquetas
X = data.iloc[:, :-1].values
y = data.iloc[:, -1].values

# Dividir datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Estandarizar los datos
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Crear el modelo
model = tf.keras.Sequential([
    tf.keras.layers.Dense(16, activation='relu', input_shape=(X_train.shape[1],)),
    tf.keras.layers.Dense(8, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# Configurar el modelo
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Entrenar el modelo
history = model.fit(X_train, y_train, epochs=100, batch_size=16,
                    validation_data=(X_test, y_test), verbose=1)

# Evaluar el modelo
loss, accuracy = model.evaluate(X_test, y_test)
print(f"Precisión del modelo: {accuracy:.4f}")

# Hacer predicciones
predictions = model.predict(X_test[:5])
for i, pred in enumerate(predictions):
    print(f"Paciente {i+1}: {'Diabetes' if pred[0] > 0.5 else 'No diabetes'}")

Este ejemplo más completo:

• Carga datos reales de pacientes para predecir si tienen diabetes
• Divide los datos en dos grupos: 80% para entrenar y 20% para probar
• Ajusta los datos para que todas las variables tengan la misma escala
• Crea una red neuronal con tres capas
• Usa una función especial en la última capa para obtener una probabilidad (0-1)
• Entrena el modelo durante 100 rondas y mide su precisión con datos nuevos
• Hace predicciones para nuevos pacientes

¿Te animas a probarlo?

TensorFlow hace que la IA sea accesible para cualquiera con conocimientos básicos de programación. Ya sea que quieras crear sistemas de recomendación, aplicaciones que reconozcan imágenes o herramientas de análisis, TensorFlow te da todo lo necesario para convertir tus ideas en realidad.

¿Te interesa alguna otra biblioteca de aprendizaje automático? ¿Tienes algún proyecto en mente donde aplicar estos conocimientos?