Instalación de Olama y configuración de clúster local con ExoLabs
Contenido del curso
Osvaldo Frias
Ignacio Robles
Daniel Hernandez
Gabriel Obregón
camilo plata
Luis Rebollo
Santiago Pineda Botero
Kevin Fiorentino
Juan Diego Ussa Aponte
Daniel Andres Rojas Paredes
Mitchell Phillip Bermin Suarez
Juan Diego Ussa Aponte
Andres David Martinez Torres
Luis Rebollo
Gerardo Miguel Pérez Solis
Cynthia Mercedes Gorozabel Villavicencio
Eduardo López Barrientos
Andres Rodriguez
Iván Pineda
Jose Daniel Barría Reyes
MARIA TERESA PANIAGUA RIVERA
Frank Stephano Alayza Herrera
Boris Turcios
Bryan Castano
Diego Ortiz
Henry Stivens Adarme Muñoz
Sería buena referencia saber qué modelo de macbook se está utilizando, creo que no se menciona en algún momento
Opino igual, sería genial que el profesor dijera cual Macbook tiene para usar como benchmark.
Se ve super claro en el min 3:42
🎯 Objetivo principal
Ejecutar modelos LLM (Large Language Models) de forma local, usando herramientas como Olama, DeepSig y ExoLabs, sin depender de la nube.
🧰 Herramienta 1: Olama Permite correr modelos LLM en tu propia computadora
Cómo instalar Olama
🔹 Busca “Olama” en Google
🔹 Descarga según tu sistema operativo (macOS, Windows, Linux)
🔹 Ejecuta el archivo descargado y sigue las instrucciones del sistema
🔹 Abre la terminal → Escribe olama → Verifica comandos disponibles
🔹 Copia desde la web de Olama el comando del modelo que quieras usar (ej. deepsig r1-7b)
Cómo funciona Olama
🟢 Descarga automática del modelo al ejecutarlo
🟢 Puedes hacer preguntas simples (“¿cuánto es dos más dos?”)
⚠️ Usa recursos del equipo (CPU y memoria >2 GB durante el uso)
🌐 Herramienta 2: ExoLabs Crea una red local de computadoras para sumar potencia de procesamiento
¿Qué hace ExoLabs?
🔸 Conecta varias computadoras en red (tipo P2P como Torrent)
🔸 Comparte tareas y datos entre equipos
🔸 Ideal para mantener privacidad y reducir costos
Ventajas
✔️ Menor costo: puedes usar equipos económicos
✔️ Más privacidad: los datos no salen de tu red
✔️ Control técnico: decides cómo y con qué recursos ejecutar modelos
🔧 ¿Cómo montar una red local con ExoLabs?
📌 Conecta varias computadoras mediante router y switch (Ethernet o WiFi)
📌 Instala ExoLabs en cada una
📌 Al ejecutarse, se conectan automáticamente y muestran:
▪️ Memoria disponible
▪️ Teraflops
▪️ Componentes activos (CPU/GPU)
🧠 Modelos que puedes usar con ExoLabs
📍 Dependen de la memoria total de la red
📍 Ejemplo: DeepSig r1-70b → requiere 70 GB
✅ Al conectar suficientes equipos, puedes ejecutar modelos muy grandes localmente
🔒 Ventajas de ejecutar LLMs en local
🔐 Privacidad: datos sensibles permanecen en tu red
⚙️ Control total: eliges modelo, recursos y configuración
Estoy que le paso un trapo a esa pantalla jajaja
No podia dejar de verla, me distrajo mucho jajaja
El fine-tuning se utiliza en diversos casos de uso para adaptar modelos de lenguaje a necesidades específicas. Aquí tienes 10 ejemplos:
Cada uno de estos casos aprovecha el fine-tuning para mejorar la relevancia y efectividad del modelo según el contexto específico donde se aplique.
Muy útil y fácil de usar Ollama para levantar y experimentar con modelos locales.
Tambien, en vez de probar el modelo de ML en la terminal, pueden utilizar la interfaz de Ollama cuando la tengan descargada
acabo de entender que por el procesador especial de las mac se pued ehacer este cluster, ose aque si yo quisiera hacerlo con diferentes pcs de otros fabricantes y epocas no se podria (legacy quipment basicamente )
Muy bonito pero me quede con las gans de como la red p2p resolvia el ejercicio del hola mundo en assembler.
en youtube esta el video completo
Muy bueno tener de manera local ha Olama, pero ahora con la llegada de OpenClaw todo los agentes que corren de manera local acaban de dar un gran salto
Gran clase. Definitivamente poder ejecutar algo por mi mismo me dejo mejor sensacion. Mucho mejor que ver la clase de manera pasiva. Mas fomatos como estos!
Correr un modelo en local ofrece varios beneficios comparado con usar una versión web o API:
Estos aspectos son importantes para proyectos que requieren seguridad y personalización.
Los modelos locales aseguran privacidad y dominio de datos.
Adecuado para instituciones y empresas que ocupan salvaguardar sus datos.
Excelente para mantener autonomía y poseer capacidad personalizada de análisis de datos para la toma de decisiones.
Esta clase a pesar de tener un tiempo es una maravilla, llevo muchos años desarrollando y un par usando IA en mis desarrollos pero siempre se tiene esa "espinita" de como es que funcionan los modelos y la arquitectura.
De las mejores clases que eh visto no solo en este curso, en toda la plataforma. Buena práctica con los MACs todos montados.
wow me encanta la energía que transmite el profe ! Nice 👍🏻
Instale en mi pc la version deepseek-r1:32b de 20gb y funciona relativamente bien, 32gb y rtx4060. Deepseek cual memoria utiliza, la vram o ram?
VRAM mi estimado
Gracias
Fue increible ver la prueba irl!
la pantalla esta sucia jejejeje =p
Hola Chicos, Yo le pregunte a DeepSeek r-1 como funciona el SGD para entrenar NN "Obvio ya l ose" y esto fue su respuesta.
me gusto mucho ver su razonamiento , es fantastico ver como piensa el model oantes de darte una respuesta, auqne esta funcionalidad ya la tienene GPT-o4 y Gemini deep thinking. me gusto mucho verlo en localhost:
<user-question>
>>> hi, explain to me the Stochastic Gradient Descent Algorithm SGD to train a neuronal network, how does it work?
</user-question>
<model thinking>
Okay, so I need to understand how Stochastic Gradient Descent (SGD) works
for training a neural network. From what I remember, machine learning
models use some kind of optimization algorithm to adjust their parameters
and minimize the cost function. But I'm not exactly sure how SGD fits into
this.
First, let me think about what gradient descent is. I know it's an
optimization algorithm that helps find the minimum value of a function by
moving in the direction opposite to the gradient (which points towards
increasing values). So, for training a neural network, we need to minimize
the cost or loss function with respect to the model parameters.
But wait, what's the difference between batch gradient descent and
stochastic gradient descent? I think in batch GD, you use all the training
examples to compute the gradient each time. That makes sense because it
gives a precise direction but is slow if you have a large dataset. On the
other hand, SGD must be different. Maybe instead of using all the data
points, it uses just one example per iteration? So, each update to the
parameters is based on a single sample from the training set.
Yes, that sounds right. But then how accurate are those updates? Since
you're only looking at one sample, wouldn't the gradient be noisy or not
representative of the whole dataset? I guess it might cause more
fluctuations in the learning process, but perhaps it's faster and can help
escape local minima because the frequent updates provide a kind of
randomness.
So, if SGD uses one example per iteration, how do we train the entire
model then? Do we go through the training data multiple times, each time
picking different examples (like shuffling them)? That would make sense.
It's called epoch in machine learning terms—each pass through all examples
is an epoch. But with SGD, instead of using the entire dataset per epoch,
you might process just one example at a time or a small batch.
Wait, sometimes I've heard about something called mini-batch GD as well.
So maybe there are different variants: batch (all), stochastic (one), and
mini-batch (a few). Mini-batches balance between the noise of SGD and the
speed of processing large batches. It's probably more efficient than batch
because you can process several samples at once, which is faster on modern
hardware like GPUs.
Now, how does the learning rate come into play with SGD? I think the
learning rate determines how big the steps are when moving towards the
minimum. If it's too high, we might overshoot and diverge; if it's too
low, convergence will be very slow. So finding a good learning rate is
crucial.
Also, how often do we update the weights in SGD? Since each example
triggers an update, that means more frequent updates but also maybe slower
convergence per update. But over time, perhaps with decreasing learning
rates, the model can converge despite the noise.
I'm trying to wrap my head around why we use mini-batches instead of just
single examples. Processing one sample at a time might be computationally
intensive if the dataset is large because each weight update would require
handling all layers and propagating gradients through them. Using
mini-batches allows us to vectorize operations, making computations more
efficient on GPUs.
Let me think about the steps involved in one iteration of SGD:
1. Pick a training example (or a small batch).
2. Compute the loss for this example.
3. Calculate the gradient of the loss with respect to each parameter using
backpropagation.
4. Update each parameter by subtracting the learning rate multiplied by
the computed gradient.
Yes, that seems about right. And we repeat this process multiple times
over the entire dataset (or subsets), adjusting the parameters iteratively
until the model's performance stabilizes or reaches a minimum.
Another thing I'm thinking about is how the order of examples affects the
training. If you shuffle the data every epoch, does it help with
generalization? Maybe by preventing the algorithm from learning the order
too much rather than the features themselves.
I also recall that sometimes people use decayed learning rates or adaptive
optimizers like Adam to combine the benefits of different methods. But
maybe that's beyond the basic SGD explanation.
Putting it all together: SGD is an optimization algorithm where we update
model parameters iteratively by computing gradients on one sample (or a
small batch) at a time, using backpropagation to calculate those gradients
efficiently. The learning rate controls how big each step is towards
minimizing the loss function, and through multiple epochs or passes over
the data, the model's weights are adjusted until they find a good minimum.
I think I have a basic understanding now, but there might be nuances I'm
missing, like handling different types of loss functions or more complex
models. Also, edge cases where the learning rate is too high or low could
cause issues like divergence or slow convergence.
...done thinking.
</model-thinking>
<local-model-r1-answer>
Stochastic Gradient Descent (SGD) is an optimization algorithm used to
train neural networks by minimizing a cost function through iterative
parameter updates. Here's a step-by-step explanation of how it works:
1. **Initialization**: Start with initial values for the model parameters,
often set randomly.
2. **Shuffle Training Data**: Optionally, shuffle the training dataset to
ensure varied examples are used in each iteration.
3. **Iterate Through Examples**:
- For each example (or small batch of examples):
- Compute the loss using the current parameters.
- Calculate the gradient of this loss with respect to each parameter
using backpropagation.
- Update each parameter by subtracting the product of the learning
rate and the computed gradient.
4. **Adjust Learning Rate**: The learning rate controls the step size
towards the minimum. It's crucial for convergence speed and avoiding local
minima; often, it may be decayed or adjusted dynamically.
5. **Repeat Until Convergence**: Continue iterating through the dataset
(epochs) until the loss function stabilizes or meets a predefined
threshold.
**Key Points**:
- **Efficiency**: SGD is computationally efficient, especially with large
datasets, as it processes only one sample (or a small batch) per
iteration.
- **Noise and Fluctuations**: The use of single samples
introduces noise but can help escape local minima due to frequent updates.
- **Mini-batch Processing**: Balances the benefits of batch and stochastic
approaches by processing small batches, enhancing computational efficiency
on GPUs.
In summary, SGD efficiently optimizes neural network parameters by
iteratively adjusting them based on gradients computed from individual or
mini-batches of training examples, using a learning rate to control step size.
</local-model-r1-answer>
\n genial, debo decir que elevo todos mis cores al mscximo de mi CPU.
PD: Ya me habia visto la demostracion del modelo en local cluster en McBooks de platzi en un PlatziLive de un Jueves hacia muchos meses atras, fue genial ver esto al inicico del 2025 cuando llego la fiebre de DeepSeek r1 que impacto la Industria AI WorldWide. fue genial verlo aquella vez y cool verlo de nuevo hoy.
🙋🏽♂️ No me queda claro por qué hay que descargar Ollama. ¿No se puede correr el modelo de Deepseek directamente? ¿Qué hace Ollama en este caso?
El modelo Deepseek o cualquier otro no se puede correr directamente. El modelo no es un ejecutable, el modelo es una estructura con la información de la red neuronal. Necesita algo que lo pueda ejecutar, necesita un runtime o framework que lo interprete, como PyTorch, TensorFlow, ONNX Runtime, llama.cpp. Pero aplicaciones como Ollama o LMStudio lo hace más fácil.
