Fundamentos de PyTorch para modelos de machine learning
Contenido del curso
David Stiwen Rugeles Cano
DANIEL VILLALOBOS
Johanna Vargas
Gabriel Obregón
TITANIC SOFT
Frank Stephano Alayza Herrera
Edwin yamid Castillo Riapira
Miguel Angel Otero Otero
Mauricio Gonzalo Aliendre Pérez
Byron Miguel Piedrahita Hernandez
Roberto Carlos Jacobo Fuentes
Claudia Ramirez
Johan Fuentes
Roger Christian Cansaya Olazabal
Gonzalo Blasco
Laura Roa
NESTOR IVAN RONCANCIO CABALLERO
Pablo Torres Pérez
Tadeo Juarez
Santiago Pineda Botero
Juan Camilo Noreña López
Alfonso Neil Jiménez Casallas
Josadec Pedraza
David Ricardo Aristizábal Ramírez
augusto garzon
me dolió la cabeza, investigue en internet un poco pero creo que le tome la idea, mi aporte.
conceptos clave:
Función de activación: existen muchas y depende del problema que se trata de solucionar, básicamente es un umbral ante el que responde o no una neurona, ¿recuerdan a McFly de volver al futuro?, el no respondía cuando se la montaban, a menos que le dijeran gallina, la función de activación de McFly era esa palabra. (claro no es tan fácil pero se entiende)
Función de coste: como sabes que el modelo esta respondiendo mal? bueno porque sabes la respuesta correcta, la función de coste es la diferencia que hay entre las respuestas azarosas que da el modelo vs las respuestas correctas o esperadas, como es una función se puede graficar, así que empiezas desde el primer valor al azar y vas reajustando hasta que el error sea casi 0, la grafica que se da al hacer esto es el descenso del gradiente.
Backpropagation: es un algoritmo que en términos mas mundanos busca la culpa, empezando por la ultima capa (la de salida), es como esa estrategia de los 5 porqués que creó Honda, empieza a preguntar de pa a atrás capa por capa cual fue la neurona que causo el error y en esa cadena de responsables se ajustan los pesos, como cuando en una empresa algo sale mal y empieza a escalar el problema capa por capa hasta encontrar el responsable
(obviamente no es tan simple, se calculan las derivadas parciales de las funciones de coste y de activación capa por capa)
que buena explicacion gracias. yo ando intentando entender
Gracias por tu aporte, me ha ayudado a comprender mejor los conceptos.
🎯 PYTORCH EN RESUMEN
🧠 ¿Qué es PyTorch?
🔢 ¿Qué es un Tensor?
🔁 ¿Qué es Autograd?
🛠️ Optimizer: Motor del Aprendizaje
📌 Tipos de optimizadores en PyTorch:
🏗️ Modelo MLP (Multi Layer Perceptron): Pasos
Importar librerías: import torch, torch.nn, torch.optim, torch.nn.functional, time
Definir la arquitectura: class MLP(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(MLP, self).__init__()
self.layer1 = nn.Linear(input_dim, hidden_dim)
self.layer2 = nn.Linear(hidden_dim, output_dim)
def forward(self, x):
x = F.relu(self.layer1(x))
return self.layer2(x)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
⚡ Uso de GPU en PyTorch
✅ ¿Se puede usar GPU? ¡Sí!
Mejora la velocidad de entrenamiento.
Ideal para grandes volúmenes de datos y modelos complejos.
🔍 Cómo verificar y usar la GPU:
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.randn(2000000, 10).to(device)
y = torch.randn(2000000, 1).to(device)
Espectacular, gracias por el aporte 👍
esta imagen la haces con alguna ia
# 1. Preparar el modelo model = MLP(input_dim=10, hidden_dim=64, output_dim=1) criterion = nn.MSELoss() # Mean Squared Error optimizer = optim.Adam(model.parameters(), lr=0.01) # 2. Preparar datos (ejemplo) X_train = torch.randn(1000, 10) y_train = torch.randn(1000, 1) # 3. Ciclo de entrenamiento model.train() for epoch in range(100): # Forward pass predictions = model(X_train) loss = criterion(predictions, y_train) # Backward pass optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 10 == 0: print(f"Época {epoch}, Pérdida: {loss.item():.4f}")
En mi caso me salto el siguiente error:
RuntimeError: Expected all tensors to be on the same device, but found at least two devices, cpu and cuda:0! (when checking argument for argument mat1 in method wrapper_CUDA_addmm)
Y tuve que agregar model.to(device) después de declarar model para que me funcione:
model = MLP(imput_dim=10, hidden_dim=32, output_dim=1) model.to(device)
Donde estan los recursos de esta clase?
Hice un NotebooKLM para poder entender mejor como funciona y le pedi resumen con todas fuentes que encontro y infografias mapas mentales y audio y un video para entenderlo mucho mejor
Que buena explicacion gracias
Los fundamentos de PyTorch se centran en la estructura del tensor, que es una representación n-dimensional similar a listas o matrices. Esta estructura permite realizar cálculos eficientes. PyTorch incluye un mecanismo llamado autograd, que calcula derivadas automáticamente, facilitando el entrenamiento de modelos de machine learning. También cuenta con optimizadores como Adam, que ajustan los parámetros del modelo durante el aprendizaje. Comprender estos conceptos es esencial para construir y entrenar redes neuronales en este framework.
Clase 7 — Fundamentos de PyTorch para modelos de machine learning
Idea central
PyTorch es la herramienta práctica que permite convertir toda la teoría anterior (redes neuronales, backpropagation, optimización) en código ejecutable que entrena modelos reales.
Es el puente entre:
Conceptos clave
1️⃣ Tensor: la unidad básica
Un tensor es una estructura numérica n-dimensional (generaliza escalar, vector y matriz).
En deep learning:
👉 Sin tensores no hay redes neuronales.
2️⃣ Autograd: derivadas automáticas
PyTorch incluye Autograd, que:
👉 Es lo que vuelve práctico el deep learning moderno.
3️⃣ Optimizer: cómo aprende el modelo
El optimizer ajusta los pesos para minimizar la función de pérdida.
Ejemplo común:
Controla:
Cómo se construye un modelo en PyTorch
Paso 1: Definir la arquitectura (MLP)
Se crea una clase que hereda de nn.Module:
nn.Linear)ReLU)forward() → define el flujo de datos👉 Aquí se define la estructura del cerebro artificial.
Paso 2: Definir entrenamiento
Elementos clave:
👉 Este ciclo es literalmente el aprendizaje.
4️⃣ Uso de GPU
PyTorch permite mover tensores a:
Código típico:
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
Esto es esencial para:
Qué aprendimos en toda la unidad 1
Ahora puedes ver la secuencia completa:
👉 Ya tienes las bases matemáticas + conceptuales + técnicas de los LLMs.
Mini-resumen en una frase
PyTorch convierte la teoría del aprendizaje profundo en modelos reales entrenables mediante tensores, autograd y optimización.
Se que debemos tener algunos conceptos claros antes de iniciar este curso pero siento que ya se asumen muchas cosas y los videos estan muy largos para la cantidad de conceptos que se explican. Me encantan las explicaciones del profe pero si seria genial dedicarle un video a cada concepto
muy bueno, espero que en la ruta de IA expliquen con más detenimiento y más interactivo respecto a ir desarrollando el código explicando su funcionamiento para un mayor entendimiento, sin embargo, sé que tomaría mucho más tiempo el curso.
OJO: Un vector es esencialmente un array de 1 dimensión, mientras que un tensor puede tener cualquier número de dimensiones.
[1, 2, 3][[1, 2], [3, 4]]5) es un tensor de rango 0.El término "tensor" es el nombre matemáticamente correcto para este tipo de estructura de datos. En física y matemáticas, los tensores son objetos que generalizan escalares, vectores y matrices a dimensiones superiores. El deep learning se basa en operaciones matemáticas complejas (como el cálculo tensorial), usar el término correcto es más preciso y universal.
Hey que onda, estudie línea por línea y deje en comentarios lo que aprendí. Esta es la primera parte, de seguro te puede ayudar en algo.
# Seleccionamos el dispositivo: GPU si está disponible, sino CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Usando dispositivo:", device)
# Plantilla de la estructura de nuestra red neuronal. Multicapa Percepton(MLP) es una red neuronal
class MLP(nn.Module): # Con nn.module heredamos funciones especiales para poder trabajar un MLP
def __init__(self, input_dim, hidden_dim, output_dim): # En esta función creamos las capas. Input_diem: Numero de caracteristicas de nuestros datos, hidden_dim: Numero de neuronas en la capa oculta, puedes poner tantas como quieras, normalmente se usa 32, 68 o 124 para empezar, no pongas pocas porque no aprendera la red ni demasiadas porque causara sobreajuste, output_dim: numero de neuronas de salida, ponemos 1 porque solo necesitas la prediccion de un solo valor. Si predijieramos si una imagen es perro o gato tendriamos 2 de salida, la neurona que tenga el valor mas alto indicaria si es gato o perro
super(MLP, self).__init__() # Aqui llamamos a la clase padre de nn.Module para poder hacer esas funciones especiales (en segundo plano) de Pytorch como gestionar parametros, hacer el modelo visible, configurar el sistema para el entrenamiento, etc.
self.fc1 = nn.Linear(input_dim, hidden_dim) # Aqui creamos la capa oculta con 32 neuronas. Podemos tener tantas capas ocultas como queramos. Aqui la capa realizará un multipricacion matricial (x*W) y desuma (+b) para cada neurona simultaneamente
self.fc2 = nn.Linear(hidden_dim, output_dim) # Aqui creamos la capa de salida con 1 neurona. Esta neurona tomara los resultados de las 32 neuronas de la capa oculta y el resultado de esta neurona de salida sera la prediccion final del modelo
def forward(self, x): # En esta funcion ahora si ponemos a funcionar las capas
x = F.relu(self.fc1(x)) # Primero pasamos los datos X (los datos de entrenamiento) por la capa oculta y despues aplicamos la funcion de activacion con F.relu para poder aprender patrones mas complejos de los datos
x = self.fc2(x) # Ahora el resultado de la capa oculta se lo pasamos a la capa de salida que nos da la prediccion en una salida en la variable X
return x # Retornamos la prediccion final del modelo (X)
Existen varias alternativas a PyTorch para el desarrollo de modelos de Machine Learning y Deep Learning. Algunas de las más destacadas son:
TensorFlow: Desarrollado por Google, es uno de los frameworks más populares. Ofrece flexibilidad y una amplia comunidad.
Keras: Inicialmente un wrapper para TensorFlow, Keras permite construir y entrenar modelos de manera más sencilla, ideal para principiantes.
MXNet: Utilizado por Amazon, es conocido por su eficiencia en el uso de recursos y su capacidad para escalar.
Caffe: Aunque más limitado en comparación, es rápido y eficiente para aplicaciones de visión por computadora.
Cada uno tiene sus ventajas y desventajas, así que la elección dependerá de tus necesidades específicas en el desarrollo de modelos.
El descenso del gradiente es un algoritmo de optimización que se utiliza para minimizar la función de pérdida en modelos de machine learning. Funciona calculando el gradiente (o derivada) de la función de pérdida respecto a los parámetros del modelo y ajustando estos parámetros en la dirección opuesta al gradiente. Este proceso se repite iterativamente hasta que se alcanza un mínimo.
Los biases (sesgos) son parámetros adicionales en las redes neuronales que permiten ajustar la salida del modelo, independientemente de la entrada. Esto ayuda a que el modelo aprenda patrones más complejos, ya que le permite desplazarse hacia arriba o hacia abajo en la función de activación.
entendí la referencia
Profe, no encontré los recursos de esta clase. ¿Nos podría ayudar a hacer la práctica?
Gracias
Yo escribí el link a mano y apareció, por si aún lo necesitas es:
¿Dónde encaja la función forward aquí?
La función forward es literalmente la línea de ensamblaje principal de tu red neuronal. Cuando heredas de nn.Module, defines las piezas individuales (como las capas lineales) en la inicialización, pero es exclusivamente en el método forward donde dictas exactamente cómo fluyen los datos a través de ellas. Imagina que estás construyendo un sistema de purificación de agua: primero compras los filtros de carbón y las mallas de arena (esto es la inicialización), y luego conectas las tuberías para que el agua pase primero por la arena, luego por el carbón y finalmente salga limpia (esto es el forward). Aquí es donde aplicas las funciones de activación, como ReLU, decidiendo qué información matemática pasa a la siguiente capa y cuál se bloquea. Sin esta función, tus capas serían solo variables aisladas sin capacidad de procesar información secuencialmente.