Cómo ejecutar Llama 3 localmente: guía completa

Ejecutar localmente grandes modelos lingüísticos (LLM) como Llama 3 se ha convertido en algo revolucionario en el mundo de la IA. Con plataformas como Hugging Face que promueven la implementación local, los usuarios pueden disfrutar ahora de experiencias ininterrumpidas y privadas con sus modelos.

En este blog, aprenderemos por qué debemos ejecutar LLM como Llama 3 localmente y cómo acceder a ellos con GPT4ALL y Ollama. Además, aprenderemos a servir modelos, a integrar Llama 3 en tu espacio de trabajo y, por último, a utilizarlo para desarrollar la aplicación de IA. No solo lo utilizaremos como chatbot, sino también para mejorar nuestro flujo de trabajo y construir proyectos con él.

¿Por qué ejecutar Llama 3 localmente?

Ejecutar Llama 3 localmente puede parecer desalentador debido a los elevados requisitos de RAM, GPU y potencia de procesamiento. Sin embargo, los avances en los marcos de trabajo y la optimización de modelos han hecho que esto sea más accesible que nunca. He aquí por qué deberías considerarlo:

• Acceso ininterrumpido: No tendrás que preocuparte por límites de tarifa, tiempos de inactividad e interrupciones inesperadas del servicio.
• Rendimiento mejorado: La generación de respuestas es rápida, sin retrasos ni latencias. Incluso en portátiles de nivel medio, se obtienen velocidades de unos 50 tokens por segundo.
• Seguridad mejorada: Tienes pleno control sobre las entradas utilizadas para ajustar el modelo y los datos permanecen localmente en tu dispositivo.
• Costes reducidos: En lugar de pagar elevadas tarifas para acceder a las API o suscribirte al chatbot en línea, puedes utilizar Llama 3 gratuitamente.
• Personalización y flexibilidad: Puedes personalizar los modelos mediante hiperparámetros, añadir topes y cambiar la configuración avanzada.
• Capacidades sin conexión: Una vez descargado el modelo, no necesitas conexión a Internet para utilizarlo.
• Propiedad: Tienes plena propiedad y control sobre el modelo, sus datos y sus resultados.

Lee nuestro artículo, Los pros y los contras de utilizar grandes modelos lingüísticos (LLM) en la nube frente a ejecutar los LLM localmente, para saber más sobre si utilizar los LLM localmente es para ti.

Utilizar Llama 3 con GPT4ALL

GPT4ALL es un software de código abierto que te permite ejecutar modelos lingüísticos populares de gran tamaño en tu máquina local, incluso sin una GPU. Es fácil de usar, lo que la hace accesible a personas sin formación técnica.

Para empezar, descarga e instala el GPT4ALL en Windows desde la página oficial de descargas.

Tras instalar la aplicación, ejecútala y haz clic en el botón "Descargas" para abrir el menú de modelos. Allí, puedes desplazarte hacia abajo y seleccionar el modelo "Llama 3 Instruct" y, a continuación, hacer clic en el botón "Descargar".

Una vez finalizada la descarga, cierra la pestaña y selecciona el modelo de Llama 3 Instruct haciendo clic en el menú desplegable "Elegir un modelo".

Escribe un mensaje y empieza a utilizarlo como ChatGPT. El sistema tiene instalado el kit de herramientas CUDA, por lo que utiliza la GPU para generar una respuesta más rápida.

Utilizar Llama 3 con Ollama

Ahora, vamos a probar la forma más sencilla de utilizar Llama 3 localmente al descargar e instalar Ollama.

Ollama es una potente herramienta que te permite utilizar LLMs localmente. Es rápido y tiene montones de funciones.

Tras instalar Ollama en tu sistema, inicia el terminal/PowerShell y escribe el comando

ollama run llama3

Nota: Descargar el archivo del modelo e iniciar el chatbot dentro del terminal te llevará unos minutos.

Escribe prompts o empieza a hacer preguntas, y Ollama generará la respuesta dentro de tu terminal. La respuesta del chat es superrápida, y puedes seguir haciendo preguntas de seguimiento para profundizar en el tema.

Para salir del chatbot, escribe /bye .

Además de estos dos programas, puedes consultar la página Ejecutar LLM localmente: 7 métodos sencillos, una guía para explorar otras aplicaciones y marcos.

Servidores locales para Llama 3

Ejecutar un servidor local te permite integrar Llama 3 en otras aplicaciones y crear tu propia aplicación para tareas específicas.

Inicia el servidor local de inferencia de modelos. Para ello, introduce el siguiente comando en el terminal.

ollama serve

Para comprobar si el servidor funciona correctamente, ve a la bandeja del sistema, busca el icono de Ollama y haz clic con el botón derecho para ver los registros.

Te llevará a la carpeta Ollama, donde podrás abrir el archivo `server.log` para ver información sobre las peticiones del servidor a través de las API e información del servidor con marcas de tiempo.

Acceder a la API mediante CURL

Puedes acceder simplemente al servidor de inferencia con el comando CURL.

Solo tienes que indicar el nombre del modelo y la indicación y asegurarte de que la transmisión está desactivada para obtener el mensaje completo.

curl http://localhost:11434/api/chat -d '{
  "model": "llama3",
  "messages": [
    { "role": "user", "content": "What are God Particles?" }
  ],
  "stream": false
}'

El comando CURL es nativo de Linux, pero también puedes utilizarlo en Windows PowerShell, como se muestra a continuación.

Acceder a la API con el paquete Python

También puedes instalar el paquete Ollama Python utilizando PIP para acceder al servidor de inferencia.

pip install ollama

Acceder a la API en Python te permite crear aplicaciones y herramientas potenciadas por IA, y es muy fácil de usar.

Solo tienes que proporcionar a las funciones `ollama.chat` el nombre del modelo y el mensaje, y generará la respuesta.

Nota: En el argumento del mensaje, también puedes añadir un aviso del sistema y un aviso del asistente para añadir el contexto.

import ollama

response = ollama.chat(
    model="llama3",
    messages=[
        {
            "role": "user",
            "content": "Tell me an interesting fact about elephants",
        },
    ],
)
print(response["message"]["content"])

El paquete Python de Ollama también proporciona funciones como las llamadas asíncronas y el streaming, que permiten una gestión eficaz de las peticiones a la API y aumentan la velocidad percibida del modelo.

De forma similar a la API de OpenAI, puedes crear una función de chat asíncrona y luego escribir código de transmisión mediante la función asíncrona, lo que permite interacciones eficientes y rápidas con el modelo.

import asyncio
from ollama import AsyncClient

async def chat():
    """
    Stream a chat from Llama using the AsyncClient.
    """
    message = {
        "role": "user",
        "content": "Tell me an interesting fact about elephants"
    }
    async for part in await AsyncClient().chat(
        model="llama3", messages=[message], stream=True
    ):
        print(part["message"]["content"], end="", flush=True)


asyncio.run(chat())

Como puedes ver, el modelo muestra los tokens a medida que se generan.

También puedes utilizar la API de Python para crear el modelo personalizado, convertir el texto en incrustaciones y gestionar los errores. También puedes copiar, borrar, extraer y enviar los modelos.

Integración de Llama 3 en VSCode

Además de utilizar Ollama como chatbot o para generar respuestas, puedes integrarlo en VSCode y utilizar Llama 3 para funciones como el autocompletado, las sugerencias de código contextualizadas, la escritura de código, la generación de docstrings, las pruebas unitarias, etc.

1. En primer lugar, tenemos que inicializar el servidor de inferencia Ollama escribiendo el siguiente comando en el terminal.

ollama serve

2. Ve a Extensiones VSCode, busca la herramienta "CodeGPT" e instálala. CodeGPT te permite conectar cualquier proveedor de modelos utilizando la clave API.

3. Configura el CodeGPT haciendo clic en el icono de chat del CodeGPT en el panel izquierdo. Cambia el proveedor del modelo a Ollama y selecciona el modelo llama3:8b. No tienes que proporcionar una clave API, ya que lo ejecutamos localmente.

4. Escribe el prompt para generar el código Python y luego pulsa el botón "Insertar el código" para transferir el código a tu archivo Python. También puedes escribir instrucciones de seguimiento para mejorar el código.

5. Además del asistente de codificación, puedes utilizar CodeGPT para comprender el código, refactorizarlo, documentarlo, generar las pruebas unitarias y resolver los problemas.

Si quieres sentirte como un profesional de Python, consulta la guía Configurar VSCode para Python para conocer la función principal de VSCode y personalizarla según tus necesidades.

Desarrollar localmente una aplicación de IA

En esta sección, desarrollaremos una aplicación potenciada por IA que lee archivos docx de una carpeta designada, los convierte en incrustaciones y los almacena en un almacén vectorial.

Después, utilizaremos una búsqueda por similitud para recuperar significados relevantes y dar respuestas contextuales a tus preguntas.

Esta aplicación te permitirá comprender rápidamente la esencia de los libros y profundizar en el desarrollo de los personajes.

Configuración

En primer lugar, instalaremos todos los paquetes Python necesarios para cargar los documentos, el almacén vectorial y los marcos LLM.

pip install unstructured[docx] langchain langchainhub langchain_community langchain-chroma

A continuación, inicia el servidor de inferencia Ollama.

ollama serve

Cargar documentos

Es una buena práctica desarrollar y probar tu código en Jupyter Notebook antes de crear la aplicación.

Cargaremos todos los archivos docx de la carpeta utilizando la dirección DirectoryLoader.

from langchain_community.document_loaders import DirectoryLoader

loader = DirectoryLoader("C:/Users/abida/Desktop/Books", glob="**/*.docx")
books = loader.load()
len(books)

4

Puedes crear tu propio chatbot consciente del contexto siguiendo el tutorial Desarrollo de Chatbot con ChatGPT y LangChain: un enfoque consciente del contexto.

Dividir el texto

Alimentar el modelo con un libro entero no es factible, ya que sobrepasaría su ventana de contexto. Para superar esta limitación, debemos dividir el texto en trozos más pequeños y manejables que quepan cómodamente en la ventana contextual del modelo.

En nuestro caso, convertiremos los cuatro libros a un trozo de 500 caracteres.

from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
all_splits = text_splitter.split_documents(books)

Incrustaciones Ollama y almacén vectorial Chroma

Utilizaremos Langchain para convertir el texto en la incrustación y almacenarlo en la base de datos Chroma.

Utilizamos el modelo Ollama Llama 3 como modelo de incrustación.

from langchain_chroma import Chroma
from langchain_community.embeddings import OllamaEmbeddings

vectorstore = Chroma.from_documents(
    documents=all_splits,
    embedding=OllamaEmbeddings(model="llama3", show_progress=True),
    persist_directory="./chroma_db",
)

OllamaEmbeddings: 100%|██████████| 23/23 [01:00<00:00,  2.63s/it]

Vamos a probar nuestra base de datos vectorial mediante algunas búsquedas de similitud.

question = "Who is Zahra?"
docs = vectorstore.similarity_search(question)
docs

Obtuvimos cuatro resultados similares a la pregunta.

Puedes sumergirte en el mundo de las bases de datos vectoriales y Chroma DB si lees el tutorial, Aprende a utilizar Chroma DB: guía paso a paso.

Construir cadenas de Langchain para un sistema de recuperación de preguntas y respuestas

Para construir un sistema adecuado de recuperación de preguntas y respuestas, utilizaremos cadenas de Langchain y empezaremos a añadir los módulos.

En nuestra cadena de preguntas y respuestas, haremos lo siguiente:

1. Utiliza el almacén vectorial como recuperador y formatea los resultados.
2. Después, te proporcionaremos la indicación RAG. Puedes sacarlo fácilmente del Hub Langchain.
3. A continuación, proporcionaremos la función de inferencia Ollama Llama 3.
4. Al final, solo analizaremos los resultados para mostrar la respuesta.

En pocas palabras, antes de pasarla por el modelo Llama 3, tu pregunta se contextualizará mediante la búsqueda de similitudes y la indicación RAG.

from langchain import hub
from langchain_community.llms import Ollama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

llm = Ollama(model="llama3")

retriever = vectorstore.as_retriever()


def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)


rag_prompt = hub.pull("rlm/rag-prompt")
qa_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

Puedes construir una aplicación similar con LLamaIndex. Para ello, sigue el enlace al tutorial LlamaIndex: un marco de datos para las aplicaciones basadas en grandes modelos lingüísticos (LLM).

Probar la cadena de recuperación de preguntas y respuestas

Haz preguntas relevantes sobre los libros para comprender mejor la historia.

question = "What is the story of the 'Gené is Missing' book?"
qa_chain.invoke(question)

Como vemos, utilizar los libros como contexto proporciona una respuesta precisa.

'Based on the provided context, "Gené is Missing" appears to be a mystery novel that revolves around uncovering the truth about Gené\'s life and potential involvement in murders. The story follows different perspectives, including Simon trying to prove his innocence, flashbacks of Gené\'s past, and detective Jacob investigating the case.'

Hagamos ahora una pregunta sobre el personaje.

question = "Who is Arslan?"
qa_chain.invoke(question)

Se ha generado una respuesta precisa.

'Arslan is Zahra\'s brother\'s best friend. He is someone that Zahra visits in the book "A Boy with Honest Dreams" by Abid Ali Awan to gather information about Ali.'

Construir la aplicación de IA

Para crear una aplicación de IA completa que se ejecute sin problemas en tu terminal, combinaremos todo el código de las secciones anteriores en un único archivo Python.

code AI_app.py

Además, mejoraremos el código para permitir la consulta interactiva, lo que te permite plantear preguntas a la aplicación repetidamente hasta que termines explícitamente la sesión escribiendo "salir".

from langchain_chroma import Chroma
from langchain_community.embeddings import OllamaEmbeddings
from langchain import hub
from langchain_community.llms import Ollama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# loading the vectorstore
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=OllamaEmbeddings(model="llama3"))

# loading the Llama3 model
llm = Ollama(model="llama3")

# using the vectorstore as the retriever
retriever = vectorstore.as_retriever()

# formating the docs
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# loading the QA chain from langchain hub
rag_prompt = hub.pull("rlm/rag-prompt")

# creating the QA chain
qa_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

# running the QA chain in a loop until the user types "exit"
while True:
    question = input("Question: ")
    if question.lower() == "exit":
        break
    answer = qa_chain.invoke(question)

    print(f"\nAnswer: {answer}\n")

Ejecuta la aplicación escribiendo `Python` y el nombre del archivo en el terminal.

python AI_app.py

Es genial. Hemos creado nuestra propia aplicación RAG AI localmente con pocas líneas de código.

Todo el código fuente de este tutorial está disponible en el repositorio GitHub kingabzpro/using-llama3-locally. Compruébalo y recuerda poner una estrella ⭐en el repositorio.

Conclusión

La capacidad de ejecutar Llama 3 localmente y crear aplicaciones no habría sido posible sin los incansables esfuerzos de la comunidad de código abierto de IA. Esta comunidad de personas entregadas trabaja día y noche para que la IA sea accesible a todos, permitiéndonos aprovechar el poder de estos modelos y construir nuestros propios sistemas.

De este modo, podemos garantizar la privacidad y la seguridad de los datos, al tiempo que evitamos las cuotas de suscripción o API. Si quieres formar parte de este ecosistema, contribuye al proyecto, difunde la palabra y también haz donaciones.

En este tutorial, hemos aprendido a utilizar Llama 3 localmente en un ordenador portátil. También hemos aprendido sobre el servidor de inferencia y cómo podemos utilizarlo para integrar Llama 3 en VSCode.

Finalmente, construimos el sistema de recuperación de preguntas y respuestas utilizando Langchain, Chroma y Ollama. Los datos nunca salieron del sistema local, y ni siquiera tuviste que pagar un solo euro para construirlo. Aparte de las aplicaciones más sencillas, puedes construir sistemas complejos utilizando las mismas herramientas que hemos empleado en este tutorial.

El siguiente paso natural en tu viaje de aprendizaje es seguir el itinerario de habilidades Desarrollo de grandes modelos lingüísticos. Aprenderás sobre aprendizaje profundo, arquitectura de transformadores, cómo afinar los LLM y los LLMOps.