10.8 Introducción a TensorFlow y PyTorch

TensorFlow y PyTorch son dos de las bibliotecas más utilizadas y populares en el campo del aprendizaje profundo. Son conocidos por su capacidad para manejar cálculos complejos y tienen un sólido soporte para varios algoritmos de aprendizaje profundo. Aunque ambas bibliotecas tienen similitudes, difieren en sus filosofías y usabilidad, lo que las hace únicas.

TensorFlow, desarrollado por el equipo de Google Brain, proporciona una de las plataformas más completas y flexibles para el aprendizaje automático y el aprendizaje profundo. Ofrece múltiples APIs, siendo TensorFlow Core el nivel más bajo, que proporciona un control completo de la programación. Esta característica lo convierte en una herramienta ideal para investigadores de aprendizaje automático y otros profesionales que requieren niveles de control finos sobre sus modelos. TensorFlow también es una excelente opción para la computación distribuida, lo que permite que porciones del gráfico se calculen en diferentes GPUs/núcleos de CPU.

Otra ventaja de TensorFlow es su plataforma TensorFlow Extended (TFX), que es una plataforma de aprendizaje automático de extremo a extremo para construir tuberías de ML listas para producción. Esta plataforma proporciona un conjunto de bibliotecas y herramientas de TensorFlow que permiten a científicos de datos y desarrolladores crear, entrenar y desplegar modelos de aprendizaje automático a escala.

Por otro lado, PyTorch, desarrollado por el equipo de investigación de inteligencia artificial de Facebook, es una biblioteca dinámica de redes neuronales que enfatiza la simplicidad y facilidad de uso. PyTorch es una excelente opción para investigadores, estudiantes y otros profesionales que desean experimentar con nuevas ideas y conceptos en el aprendizaje profundo sin preocuparse demasiado por los detalles técnicos. PyTorch también ofrece una forma más pythonica de construir redes neuronales que TensorFlow.

En resumen, tanto TensorFlow como PyTorch son excelentes bibliotecas para el aprendizaje profundo. Mientras que TensorFlow es más adecuado para aquellos que requieren niveles finos de control sobre sus modelos y prefieren una plataforma más completa y flexible, PyTorch es más adecuado para aquellos que desean experimentar con nuevas ideas y conceptos en el aprendizaje profundo sin preocuparse demasiado por los detalles técnicos.

Ejemplo:

Aquí tienes un ejemplo simple de cómo usar TensorFlow para crear y entrenar un modelo lineal simple:

import tensorflow as tf
import numpy as np

# Model parameters
W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)

# Model input and output
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)

# Loss
loss = tf.reduce_sum(tf.square(linear_model - y))

# Optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

# Training data
x_train = [1, 2, 3, 4]
y_train = [0, -1, -2, -3]

# Training loop
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
for i in range(1000):
    sess.run(train, {x: x_train, y: y_train})

# Evaluate training accuracy
curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))

Por otro lado, PyTorch, respaldado por el laboratorio de investigación de inteligencia artificial de Facebook, prioriza en mayor medida el control del usuario y, como tal, es más flexible. A diferencia del paradigma de gráfico estático de TensorFlow, PyTorch utiliza un paradigma de gráfico dinámico que permite una mayor flexibilidad en la construcción de arquitecturas complejas. Esta característica hace que PyTorch sea más fácil de aprender y más ligero de usar, y proporciona capacidades pythonicas como la capacidad de depurar modelos en tiempo real.

Aquí tienes un ejemplo similar en PyTorch:

import torch
from torch.autograd import Variable

# N is batch size; D_in is input dimension;
# H is hidden dimension; D_out is output dimension.
N, D_in, H, D_out = 64, 1000, 100, 10

# Create random Tensors to hold inputs and outputs, and wrap them in Variables.
x = Variable(torch.randn(N, D_in))
y = Variable(torch.randn(N, D_out), requires_grad=False)

# Use the nn package to define our model and loss function.
model = torch.nn.Sequential(
    torch.nn.Linear(D_in, H),
    torch.nn.ReLU(),
    torch.nn.Linear(H, D_out),
)
loss_fn = torch.nn.MSELoss(size_average=False)

# Use the optim package to define an Optimizer that will update the weights of
# the model for us.
learning_rate = 1e-4
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# Training loop
for t in range(500):
    # Forward pass
    y_pred = model(x)

    # Compute and print loss
    loss = loss_fn(y_pred, y)
    print(t, loss.data[0])

    # Zero gradients, perform a backward pass,

 and update the weights.
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

Tanto TensorFlow como PyTorch son excelentes opciones para el aprendizaje profundo y en gran medida dependen de las preferencias personales. Si planeas realizar muchas computaciones científicas, es posible que encuentres que TensorFlow es más fácil de usar. Sin embargo, si eres nuevo en el aprendizaje profundo o prefieres una forma más directa de hacer las cosas, entonces PyTorch puede ser la mejor opción.

Estas bibliotecas amplían las capacidades de Python en el ámbito de la ciencia de datos, el aprendizaje automático y el aprendizaje profundo, lo que añade a las razones por las que Python es un lenguaje tan popular en la informática científica. En la próxima sección, nos enfocaremos en ejercicios prácticos para ayudarte a familiarizarte más con estas bibliotecas.