Maximizando recursos: Ejecuta servidores de IA avanzados con Google Colab, OLLaMA y ngrok

Utilizar Google Colab junto con ngrok para ejecutar un servidor de IA como OLLaMA, aprovechando así los recursos computacionales de Google Colab mientras se gestionan los modelos y las consultas desde tu equipo local con recursos modestos, es una estrategia ingeniosa. Aquí te explico cómo se puede lograr este flujo de trabajo en pasos generales.

Google Colab, o «Colaboratory», es un servicio gratuito de Jupyter Notebook que permite escribir y ejecutar código de Python directamente desde el navegador. Está especialmente diseñado para la educación, la investigación en Machine Learning (ML) y la ciencia de datos. Lo que distingue a Colab es su capacidad para proporcionar acceso gratuito a recursos computacionales, incluyendo GPUs y TPUs, sin necesidad de configuración. Esto permite a los usuarios ejecutar scripts pesados de procesamiento de datos y entrenamiento de modelos de ML directamente desde sus navegadores, facilitando el aprendizaje y el desarrollo de proyectos de ML sin requerir hardware especializado.

https://colab.research.google.com/

Configurar el entorno en Google Colab

Primero, debes iniciar una nueva sesión en Google Colab y preparar el entorno para ejecutar OLLaMA. Esto implica:

• Instalar OLLaMA y sus dependencias en el notebook de Colab.
• Instalar ngrok en el entorno de Colab para poder crear un túnel hacia el servidor que ejecutarás en Colab.

!curl https://ollama.ai/install.sh | sh
!pip install pyngrok

El siguiente paso es iniciar el servicio OLLaMA, pero para poder ejecutar el LLM desde otros entornos fuera de Colab. Dado que es difícil que los Colabs funcionen bien con código asíncrono y subprocesos, es útil usar Colab para, por ejemplo, ejecutar una máquina virtual lo suficientemente potente como para jugar con modelos más grandes que (digamos) algo que pueda ejecutar en su entorno de desarrollo (si esto es un problema).

Configure ngrok y reenvíe el servicio ollama local a un URI público

ngrok es una herramienta que permite exponer a internet un servidor local que se está ejecutando en tu máquina. Funciona creando un túnel seguro desde un endpoint público en ngrok (accesible desde cualquier lugar de internet) hasta el servidor que se ejecuta en tu puerto local. Esto es particularmente útil para pruebas de desarrollo, demostraciones en vivo de aplicaciones en desarrollo, o hacer accesible temporalmente a un servicio que de otra manera estaría oculto detrás de un firewall o NAT. ngrok es una herramienta esencial para desarrolladores que necesitan compartir sus trabajos en progreso sin desplegarlos en un entorno de producción.

https://ngrok.com/

Ollama aún no se está ejecutando como servicio, pero podemos configurar ngrok antes de esto:

import threading
import time
import os
import asyncio
from pyngrok import ngrok
import threading
import queue
import time
from threading import Thread


token="your-authtoken"
ngrok.set_auth_token(token)


class StoppableThread(threading.Thread):
    def __init__(self, *args, **kwargs):
        super(StoppableThread, self).__init__(*args, **kwargs)
        self._stop_event = threading.Event()

    def stop(self):
        self._stop_event.set()

    def is_stopped(self):
        return self._stop_event.is_set()

def start_ngrok(q, stop_event):
    try:
        # Start an HTTP tunnel on the specified port
        public_url = ngrok.connect(11434)
        # Put the public URL in the queue
        q.put(public_url)
        # Keep the thread alive until stop event is set
        while not stop_event.is_set():
            time.sleep(1)  # Adjust sleep time as needed
    except Exception as e:
        print(f"Error in start_ngrok: {e}")

Obtenga su token de ngriok desde su cuenta en el dashboard de ngrok: https://dashboard.ngrok.com/get-started/your-authtoken

Ejecute ese código para que existan las funciones, luego, en la siguiente celda, inicie ngrok en un hilo separado para que no cuelgue su colab; usaremos una cola para poder compartir datos entre hilos porque queremos saber cuál es el La URL pública de ngrok será cuando se ejecute:

url_queue = queue.Queue()


ngrok_thread = StoppableThread(target=start_ngrok, args=(url_queue, StoppableThread.is_stopped))
ngrok_thread.start()

Esto se estará ejecutando, pero necesita obtener los resultados de la cola para ver qué devolvió ngrok, así que haga lo siguiente:

while True:
    try:
        public_url = url_queue.get()
        if public_url:
            break
        print("Waiting for ngrok URL...")
        time.sleep(1)
    except Exception as e:
        print(f"Error in retrieving ngrok URL: {e}")

print("Ngrok tunnel established at:", public_url)

Esto debería generar algo como:

Ejecute OLLaMA como un proceso asíncrono:

import os
import asyncio

# NB: You may need to set these depending and get cuda working depending which backend you are running.
# Set environment variable for NVIDIA library
# Set environment variables for CUDA
os.environ['PATH'] += ':/usr/local/cuda/bin'
# Set LD_LIBRARY_PATH to include both /usr/lib64-nvidia and CUDA lib directories
os.environ['LD_LIBRARY_PATH'] = '/usr/lib64-nvidia:/usr/local/cuda/lib64'

async def run_process(cmd):
    print('>>> starting', *cmd)
    process = await asyncio.create_subprocess_exec(
        *cmd,
        stdout=asyncio.subprocess.PIPE,
        stderr=asyncio.subprocess.PIPE
    )

    # define an async pipe function
    async def pipe(lines):
        async for line in lines:
            print(line.decode().strip())

        await asyncio.gather(
            pipe(process.stdout),
            pipe(process.stderr),
        )

    # call it
    await asyncio.gather(pipe(process.stdout), pipe(process.stderr))

Eso crea la función para ejecutar un comando asíncrono pero aún no lo ejecuta.

Esto iniciará OLLaMA en un hilo separado para que tu Colab no esté bloqueado:

import asyncio
import threading

async def start_ollama_serve():
    await run_process(['ollama', 'serve'])

def run_async_in_thread(loop, coro):
    asyncio.set_event_loop(loop)
    loop.run_until_complete(coro) 
    loop.close()

# Create a new event loop that will run in a new thread 
new_loop = asyncio.new_event_loop() 

# Start ollama serve in a separate thread so the cell won't block execution 
thread = threading.Thread(target=run_async_in_thread, args=(new_loop, start_ollama_serve()))
thread.start() 

Debería producir algo como:

Ahora ya está todo configurado. Puede realizar los siguientes pasos en Colab, pero podría ser más fácil ejecutarlo en su máquina local si normalmente desarrolla allí.

Ejecute un modelo en OLLaMA de forma remota desde su entorno de desarrollo local

Si aún no ha instalado OLLaMA en su entorno local siga las instrucciónes de la documentación. Reemplace el URI real a continuación con cualquier URI público que ngrok haya informado anteriormente:

export OLLAMA_HOST=https://{longcode}.ngrok-free.app/

En sistemas operativos basados en Windows, el comando para asignar o «exportar» una variable de entorno difiere del utilizado en sistemas basados en Unix (como Linux y MacOS). En Windows, se utiliza el comando set para asignar variables de entorno en la línea de comandos (CMD) o PowerShell.

set OLLAMA_HOST=https://{longcode}.ngrok-free.app/

Ahora puede ejecutar OLLaMA y se ejecutará en el control remoto de su Colab (siempre que siga funcionando).

Por ejemplo, ejecute esto en su máquina local y parecerá que se está ejecutando localmente, pero en realidad se está ejecutando en su Colab y los resultados se envían a cualquier lugar desde donde llame (siempre que OLLAMA_HOST esté configurado correctamente y sea un túnel válido para tu servicio de ollama:

ollama run gemma:2b

La documentación de OLLaMA te brinda un listado de modelos que puedes descargarse.

Ahora puede interactuar con el modelo en la línea de comando localmente, pero el modelo se ejecuta en Colab.

Cuando hagas consultas a OLLaMA desde tu equipo local, las peticiones se enrutarán a través de ngrok hasta el servidor que se ejecuta en Colab, aprovechando sus recursos computacionales. Esto te permite, por ejemplo, descargar modelos o hacer inferencias sin la limitación de los recursos de tu equipo local.

Consideraciones importantes

• Tiempo de vida de la sesión de Colab: Las sesiones gratuitas de Colab tienen un tiempo de vida limitado y se desconectarán después de un periodo de inactividad. Esto significa que tendrás que reiniciar tu servidor OLLaMA y el túnel de ngrok cada vez que inicies una nueva sesión.
• Seguridad: Asegúrate de comprender las implicaciones de seguridad de exponer tu servidor OLLaMA a internet a través de ngrok, especialmente si estás trabajando con datos sensibles.

Este método te permite extender de manera efectiva las capacidades de tu equipo local con los recursos computacionales de Google Colab, proporcionando una solución innovadora para trabajar con modelos de IA avanzados como OLLaMA.