En este tutorial, exploramos cómo construir redes neuronales desde cero utilizando Tinygrad sin dejar de ser totalmente prácticos con tensores, autogrado, mecanismos de atención y arquitecturas de transformadores. Nosotros mismos construimos progresivamente cada componente, desde operaciones tensoriales básicas hasta atención de múltiples cabezales, bloques transformadores y, finalmente, un modelo mini-GPT funcional. A lo largo de cada etapa, observamos cómo la simplicidad de Tinygrad nos ayuda a comprender qué sucede bajo el capó cuando los modelos entrenan, optimizan y fusionan núcleos para lograr rendimiento. Consulta los CÓDIGOS COMPLETOS aquí.
Configuramos Tinygrad en nuestro entorno Colab e inmediatamente comenzamos a experimentar con tensores y diferenciación automática. Creamos un pequeño gráfico de cálculo y observamos cómo fluyen los gradientes a través de operaciones matriciales. A medida que imprimimos los resultados, obtenemos una comprensión intuitiva de cómo Tinygrad maneja la retropropagación internamente. Consulta los CÓDIGOS COMPLETOS aquí.
qkv = x.reshape(B * T, C).dot(self.qkv).reshape(B, T, 3, self.num_heads, self.head_dim) q, k, v = qkv[:, :, 0]qkv[:, :, 1]qkv[:, :, 2]
escala = (self.head_dim ** -0.5) atención = (q @ k.transpose(-2, -1)) * escala atención = atención.softmax(axis=-1) salida = (attn @ v).transpose(1, 2).reshape(B, T, C) return out.reshape(B * T, C).dot(self.out).reshape(B, T, C) clase TransformerBlock: def __init__(self, dim, num_heads): self.attn = MultiHeadAttention(dim, num_heads) self.ff1 = Tensor.glorot_uniform(dim, 4 * dim) self.ff2 = Tensor.glorot_uniform(4 * dim, dim) self.ln1_w = Tensor.ones(dim) self.ln2_w = Tensor.ones(dim) def __call__(self, x): x = x + self.attn(self._layernorm(x, self.ln1_w)) ff = x.reshape(-1, x.shape[-1]) ff = ff.dot(self.ff1).gelu().dot(self.ff2) x = x + ff.reshape(x.shape) return self._layernorm(x, self.ln2_w) def _layernorm(self, x, w): media = x.media(eje=-1, keepdim=True) var = ((x – media) ** 2).media(eje=-1, keepdim=True) devuelve w * (x – media) / (var + 1e-5).sqrt()
Diseñamos nuestro propio módulo de atención multicabezal y un bloque transformador íntegramente desde cero. Implementamos las proyecciones, puntuaciones de atención, softmax, capas de avance y normalización de capas manualmente. A medida que ejecutamos este código, vemos cómo cada componente contribuye al comportamiento general de una capa de transformador. Consulta los CÓDIGOS COMPLETOS aquí.
self.ln_f = Tensor.ones(dim) self.head = Tensor.glorot_uniform(dim, vocab_size) def __call__(self, idx): B, T = idx.shape[0]idx.forma[1]
tok_emb = self.tok_emb[idx.flatten()].reshape(B, T, self.dim) pos_emb = self.pos_emb[:T].reshape(1, T, self.dim) x = tok_emb + pos_emb para bloque en self.blocks: x = block(x) media = x.mean(axis=-1, keepdim=True) var = ((x – media) ** 2).mean(axis=-1, keepdim=True) x = self.ln_f * (x – media) / (var + 1e-5).sqrt() return x.reshape(B * T, self.dim).dot(self.head).reshape(B, T, self.vocab_size) def get_params(self): params = [self.tok_emb, self.pos_emb, self.ln_f, self.head]
para bloquear en self.blocks: params.extend([block.attn.qkv, block.attn.out, block.ff1, block.ff2, block.ln1_w, block.ln2_w]) return params model = MiniGPT(vocab_size=256, dim=64, num_heads=4, num_layers=2, max_len=16) params = model.get_params() total_params = sum(p.numel() for p in params) print(f”Modelo inicializado con {total_params:,} parámetros”)
Montamos la arquitectura MiniGPT completa utilizando los componentes creados anteriormente. Incorporamos tokens, agregamos información posicional, apilamos múltiples bloques de transformadores y proyectamos las salidas finales en logits de vocabulario. A medida que inicializamos el modelo, comenzamos a apreciar cómo se puede construir un transformador compacto con sorprendentemente pocas piezas móviles. Consulta los CÓDIGOS COMPLETOS aquí.
return Tensor(x, dtype=”int32″), Tensor(y, dtype=”int32″) optimizador = optim.Adam(params, lr=0.001) pérdidas = []
print(“Entrenamiento para predecir el token anterior en secuencia…”) con Tensor.train(): para el paso en el rango(20): start = time.time() x_batch, y_batch = gen_data(batch_size=16, seq_len=16) logits = model(x_batch) B, T, V = logits.shape[0]forma.logits[1]forma.logits[2]
pérdida = logits.reshape(B * T, V).sparse_categorical_crossentropy(y_batch.reshape(B * T)) optimizador.zero_grad() loss.backward() optimizador.step() pérdidas.append(loss.numpy()) transcurrido = tiempo.tiempo() – comienza si el paso % 5 == 0: print(f”Paso {paso:3d} | Pérdida: {loss.numpy():.4f} | Tiempo: {elapsed*1000:.1f}ms”) print(“\n\n⚡ PARTE 5: Evaluación diferida y fusión del kernel”) print(“-” * 60) N = 512 a = Tensor.randn(N, N) b = Tensor.randn(N, N) print(“Creando cálculo: (A @ BT + A).sum()”) lazy_result = (a @ bT + a).sum() print(“→ Aún no se ha realizado ningún cálculo (evaluación diferida)”) print(“\nLlamando a .realize() para ejecutar…”) start = time.time() realizado = lazy_result.realize() transcurrido = time.time() – start print(f” ✓ Calculado en {elapsed*1000:.2f}ms”) print(f”Resultado: {realized.numpy():.4f}”) print(“\nNota: ¡Las operaciones se fusionaron en núcleos optimizados!”)
Entrenamos el modelo MiniGPT con datos sintéticos simples y observamos que la pérdida disminuye en los pasos. También exploramos el modelo de ejecución diferida de Tinygrad mediante la creación de un núcleo fusionado que se ejecuta sólo cuando se realiza. A medida que monitoreamos los tiempos, entendemos cómo la fusión del kernel mejora el rendimiento. Consulta los CÓDIGOS COMPLETOS aquí.
Implementamos una función de activación personalizada y verificamos que los gradientes se propaguen correctamente a través de ella. Luego imprimimos un resumen de todos los conceptos principales cubiertos en el tutorial. Al terminar, reflexionamos sobre cómo cada sección desarrolla nuestra capacidad para comprender, modificar y ampliar los aspectos internos del aprendizaje profundo utilizando Tinygrad.
En conclusión, reforzamos nuestra comprensión de cómo funcionan realmente las redes neuronales bajo las abstracciones modernas y experimentamos de primera mano cómo Tinygrad nos permite jugar con cada detalle interno. Construimos un transformador, lo entrenamos con datos sintéticos, experimentamos con evaluación diferida y fusión de núcleos, e incluso creamos operaciones personalizadas, todo dentro de un marco mínimo y transparente. Por fin, reconocemos cómo este flujo de trabajo nos prepara para una experimentación más profunda, ya sea que ampliemos el modelo, integremos conjuntos de datos reales o continuemos explorando las capacidades de bajo nivel de Tinygrad.
Consulta los CÓDIGOS COMPLETOS aquí. No dude en consultar nuestra página de GitHub para tutoriales, códigos y cuadernos. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 100.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.
Asif Razzaq es el director ejecutivo de Marktechpost Media Inc.. Como empresario e ingeniero visionario, Asif está comprometido a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, Marktechpost, que se destaca por su cobertura en profundidad del aprendizaje automático y las noticias sobre aprendizaje profundo que es técnicamente sólida y fácilmente comprensible para una amplia audiencia. La plataforma cuenta con más de 2 millones de visitas mensuales, lo que ilustra su popularidad entre el público.
🙌 Siga MARKTECHPOST: agréguenos como fuente preferida en Google.