Blog
Esecuzione di Llama 3, Mixtral e GPT-4o

Esecuzione di Llama 3, Mixtral e GPT-4o

May 15, 20248 min read

Ci sono tantissimi modi diversi per eseguire la parte G-Generation di RAG! Oggi mostrerò alcuni modi per eseguire alcuni dei contendenti più interessanti in questo ambito: Llama 3 di Meta, Mixtral di Mistral e il GPT-4o di OpenAI annunciato di recente.

Come possiamo vedere dalla Leaderboard LMSYS qui sotto, il divario (in azzurro) tra modelli closed-source e modelli open-source ha subito un ulteriore ampliamento questa settimana con il nuovo annuncio di OpenAI.

closed-source vs open

Fonte dell'immagine: https://twitter.com/maximelabonne basata su https://chat.lmsys.org/?leaderboard.

Schema di questo blog:

I modi più veloci per eseguire Llama 3 o Mixtral open-source
- Localmente con Ollama
- Endpoint Anyscale
- Endpoint OctoAI
- Endpoint Groq
Eseguire il più recente gpt-4o di OpenAI
Valutare le risposte: GPT-4o, Llama 3, Mixtral

Cominciamo!

Eseguire Llama 3 localmente usando Ollama

Per prima cosa, esegui RAG nel modo consueto, fino all'ultimo passaggio, in cui generi la risposta, la parte G di RAG. Abbiamo molti tutorial per iniziare con RAG, incluso questo in Python.

Per eseguire Llama 3 localmente usando Ollama.

Segui le istruzioni per installare ollama ed eseguire il pull di un modello.
Quella pagina dice che ollama run llama3 per impostazione predefinita eseguirà il pull dell'ultimo modello "instruct", che è fine-tuned per casi d'uso di chat/dialogo E funziona sul tuo computer. Esegui quel comando.
Per Python, pip install ollama.
Nel tuo codice Python RAG, definisci un Prompt e una Domanda, e invoca la chiamata API al tuo modello Llama 3 installato localmente.

Nel mio caso, ho un laptop M2 da 16GB, quindi il modello Ollama scaricato è la versione più quantizzata compilata in gguf di Llama3-8B. Cioè, una versione molto piccola di Llama 3 è ora installata sul mio laptop!

# Separate all the context together by space, reverse order.
# See “Lost in the middle” arxiv.org paper.
contexts_combined = ' '.join(reversed(contexts))
source_combined = ' '.join(reversed(sources))

# Define a Prompt.
SYSTEM_PROMPT = f"""Given the provided Context, your task is to
understand the content and accurately answer the question based
on the information available in the context. 
Provide a complete, clear, concise, relevant response in fewer
than 4 sentences and cite the unique Sources.
Answer: The answer to the question.
Sources: {source_combined}
Context: {contexts_combined}
"""

# Send the Question and Prompt to local! llama 3 chat.
import ollama
start_time = time.time()
response = ollama.chat(
   messages=[
       {"role": "system", "content": SYSTEM_PROMPT,},
       {"role": "user", "content": f"question: {SAMPLE_QUESTION}",}
   ],
   model='llama3',
   stream=False,
   options={"temperature": TEMPERATURE, "seed": RANDOM_SEED,
            "top_p": TOP_P,
           #  "max_tokens": MAX_TOKENS, # not recognized
            "frequency_penalty": FREQUENCY_PENALTY}
)

ollama_llama3_time = time.time() - start_time
pprint.pprint(response['message']['content'].replace('\n', ' '))
print(f"ollama_llama3_time: {format(ollama_llama3_time, '.2f')} seconds")

La risposta sembra piuttosto buona; vedo tre parametri, ma solo la citazione sembra confusa. Il modello locale ha impiegato 13 secondi per eseguire l'inferenza sul mio laptop, ma il costo è stato gratuito.

Eseguire Llama 3 dagli endpoint Anyscale

Per eseguire l'inferenza di Llama 3 dagli endpoint Anyscale:

Segui le istruzioni sulla pagina github degli endpoint Anyscale per installare la riga di comando e poi installare il plugin.
Ottieni il tuo token API dell'endpoint Anysclae e aggiorna le tue variabili d'ambiente.
Per Python, pip install openai.
Leggi informazioni sul modello Llama 3 scaricato da HuggingFace e invocalo usando l’API OpenAI. Ho usato il Llama 3 predefinito su Anyscale playground, che era un modello 70B-Instruct.

import openai

LLM_NAME = "meta-llama/Llama-3-70b-chat-hf"

anyscale_client = openai.OpenAI(
   base_url = "https://api.endpoints.anyscale.com/v1",
   api_key=os.environ.get("ANYSCALE_ENPOINT_KEY"),
)

start_time = time.time()
response = anyscale_client.chat.completions.create(
   messages=[
       {"role": "system", "content": SYSTEM_PROMPT,},
       {"role": "user", "content": f"question: {SAMPLE_QUESTION}",}
   ],
   model=LLM_NAME,
   temperature=TEMPERATURE,
   seed=RANDOM_SEED,
   frequency_penalty=FREQUENCY_PENALTY,
   top_p=TOP_P,
   max_tokens=MAX_TOKENS,
)
llama3_anyscale_endpoints_time = time.time() - start_time

# Print the response.
pprint.pprint(response.choices[0].message.content.replace('\n', ' '))
print(f"llama3_anyscale_endpoints_time: {format(llama3_anyscale_endpoints_time, '.2f')} seconds")

La risposta sembra buona, inclusa una citazione perfetta. Il Llama 3 70B di HuggingFace ha impiegato ~6 secondi per essere invocato dagli endpoint Anyscale.

Esegui Llama 3 dagli endpoint OctoAI

Per eseguire l’inferenza di Llama 3 dagli endpoint OctoAI:

Vai su https://octoai.cloud/text, scegli il modello Llama 3 8B, clicca sul link del modello e vedrai del codice di esempio.
Ottieni il tuo token API dell’endpoint OctoAI e aggiorna le tue variabili d’ambiente.
Per Python, pip install octoai.
Leggi informazioni sul modello Llama 3 8B scaricato da Meta e invocalo.


from octoai.text_gen import ChatMessage
from octoai.client import OctoAI

LLM_NAME = "meta-llama-3-70b-instruct"

octoai_client = OctoAI(
   api_key=os.environ.get("OCTOAI_TOKEN"),
)

start_time = time.time()
response = octoai_client.text_gen.create_chat_completion(
   messages=[
       ChatMessage(
           content=SYSTEM_PROMPT,
           role="system"
       ),
       ChatMessage(
           content=SAMPLE_QUESTION,
           role="user"
       )
   ],
   model=LLM_NAME,
   temperature=TEMPERATURE,
   # seed=RANDOM_SEED, # not recognized
   frequency_penalty=FREQUENCY_PENALTY,
   top_p=TOP_P,
   max_tokens=MAX_TOKENS,
)
llama3_octai_endpoints_time = time.time() - start_time

# Print the response.
pprint.pprint(response.choices[0].message.content.replace('\n', ' '))
print(f"llama3_octai_endpoints_time: {format(llama3_octai_endpoints_time, '.2f')} seconds")

La risposta sembra buona e la citazione è perfetta. Il Llama 3 70B ha impiegato meno di ~4 secondi per essere invocato dagli endpoint OctoAI.

Esegui Llama 3 dagli endpoint Groq LPU

Per eseguire l’inferenza di Llama 3 dagli endpoint Groq:

Vai su console.groq.com e segui le istruzioni.
Ottieni il tuo token API dell’endpoint Groq e aggiorna le tue variabili d’ambiente.
Per Python, pip install groq.
Leggi informazioni sul modello Llama 3 8B scaricato da HuggingFace e invocalo.

from groq import Groq

LLM_NAME = "llama3-70b-8192"

groq_client = Groq(
   api_key=os.environ.get("GROQ_API_KEY"),
)

start_time = time.time()
response = groq_client.chat.completions.create(
   messages=[
       {"role": "system", "content": SYSTEM_PROMPT,},
       {"role": "user", "content": f"question: {SAMPLE_QUESTION}",}
   ],
   model=LLM_NAME,
   temperature=TEMPERATURE,
   seed=RANDOM_SEED,
   frequency_penalty=FREQUENCY_PENALTY,
   top_p=TOP_P,
   max_tokens=MAX_TOKENS,
)
llama3_groq_endpoints_time = time.time() - start_time

# Stampa la risposta.
pprint.pprint(response.choices[0].message.content.replace('\n', ' '))
print(f"llama3_groq_endpoints_time: {format(llama3_groq_endpoints_time, '.2f')} seconds")

La risposta sembra leggermente più concisa, e la citazione è perfetta. Llama 3 20B ha impiegato ~1 secondo per essere invocato dagli endpoint Groq LPU, il che è l’inferenza più veloce finora!

Nota: per eseguire Mixtral, segui tutti gli stessi passaggi, cambia solo LLM_NAME nel nome usato da ciascuna Endpoint Platform per il modello Mixtral.

Esegui GPT-4o da OpenAI

Per eseguire l’inferenza più recente di GPT-4o da OpenAI:

Ottieni il tuo token API OpenAI e aggiorna le tue variabili d’ambiente.
Segui le istruzioni su come chiamare il nuovo modello.
Per Python, pip install --upgrade openai --quiet.
Leggi informazioni sul nuovo modello GPT-4o e invocalo.

import openai, pprint
from openai import OpenAI

LLM_NAME = "gpt-4o" # "gpt-3.5-turbo"

openai_client = OpenAI(
   # This is the default and can be omitted
   api_key=os.environ.get("OPENAI_API_KEY"),
)

start_time = time.time()
response = openai_client.chat.completions.create(
   messages=[
       {"role": "system", "content": SYSTEM_PROMPT,},
       {"role": "user", "content": f"question: {SAMPLE_QUESTION}",}
   ],
   model=LLM_NAME,
   temperature=TEMPERATURE,
   seed=RANDOM_SEED,
   frequency_penalty=FREQUENCY_PENALTY,
   top_p=TOP_P,
   max_tokens=MAX_TOKENS,
)
chatgpt_4o_turbo_time = time.time() - start_time

# Print the question and answer along with grounding sources and citations.
print(f"Question: {SAMPLE_QUESTION}")
for i, choice in enumerate(response.choices, 1):
   message = choice.message.content.replace('\n', '')
   pprint.pprint(f"Answer: {message}")
print(f"chatgpt_4o_turbo_time: {format(chatgpt_4o_turbo_time, '.5f')}")

Il nuovo modello GPT-4o sembra valido e include una citazione della fonte di grounding. Ha impiegato 2 secondi per eseguire l’inferenza.

Valutazione rapida delle risposte usando Ragas

Spiego in questo blog come usare Ragas open source per valutare i sistemi RAG. Qui sotto uso solo una domanda e risposta. Una valutazione più realistica userebbe ~20 domande.

import os, sys
import pandas as pd
import numpy as np
import ragas, datasets
from langchain_community.embeddings import HuggingFaceEmbeddings
from ragas.embeddings import LangchainEmbeddingsWrapper

from ragas.metrics import (
   # context_recall,
   # context_precision,
   # faithfulness,
   answer_relevancy,
   answer_similarity,
   answer_correctness
   )

# Read ground truth answers from file.
eval_df = pd.read_csv(file_path, header=0, skip_blank_lines=True)

# Possible LLM model choices to evaluate:
# openai gpt-4o = 'Custom_RAG_answer'
LLM_TO_EVALUATE = 'Custom_RAG_answer'
# LLM_TO_EVALUATE = 'llama3_ollama_answer'
# LLM_TO_EVALUATE = 'llama3_anyscale_answer'
# LLM_TO_EVALUATE = 'llama3_octoai_answer'
# LLM_TO_EVALUATE = 'llama3_groq_answer'
# LLM_TO_EVALUATE = 'mixtral_8x7b_anyscale_answer'

CONTEXT_TO_EVALUATE='Custom_RAG_context'
eval_metrics=[
    answer_relevancy,
    answer_similarity,
    answer_correctness,]
metrics = ['answer_relevancy', 'answer_similarity', 'answer_correctness']
  
# Change the default llm-as-critic, to save $.
LLM_NAME = "gpt-3.5-turbo"
ragas_llm = ragas.llms.llm_factory(model=LLM_NAME)

# Change the default embeddings to HuggingFace models.
EMB_NAME = "BAAI/bge-large-en-v1.5"
lc_embeddings = HuggingFaceEmbeddings(model_name=EMB_NAME)
ragas_emb = LangchainEmbeddingsWrapper(embeddings=lc_embeddings)

# Modifica ogni metrica.
for metric in metrics:
   globals()[metric].llm = ragas_llm
   globals()[metric].embeddings = ragas_emb

# Esegui la valutazione.
ragas_result, score = _eval_ragas.evaluate_ragas_model(
   eval_df, eval_metrics, LLM_TO_EVALUATE,
   CONTEXT_TO_EVALUATE, EVALUATE_WHAT)

# Visualizza i risultati.
print(f"Utilizzando {eval_df.shape[0]} domande di valutazione, Punteggio medio = {score}")
display(ragas_result.head())

Di seguito è riportata una tabella che riassume i risultati.


Endpoint del modello	Risposta	Latenza (secondi)	Costo	Punteggio risposta Ragas
`Ollama Llama 3`	Secondo il contesto e le fonti forniti [1, 65535], in Hierarchical Navigable Small World Graph (HNSW), ci sono due parametri principali: * `M`: Grado massimo dei nodi su ogni livello del grafo. Va da 2 a 2048. * `ef` o `efConstruction`: Questo parametro specifica un intervallo di ricerca, che può essere utilizzato durante la costruzione dell'indice o la ricerca dei target. Questi parametri mirano a migliorare le prestazioni e a controllare il compromesso tra tasso di recall (migliorato aumentando ef) e tempo di ricerca (aumentato con valori di M più grandi).	`13.74`	`Gratuito`	`0.76`
`Anyscale endpoints Llama 3`	`Secondo il contesto, i parametri per HNSW sono: * M: Grado massimo del nodo, che va da 2 a 2048. Questo parametro limita il grado massimo dei nodi su ogni livello del grafo. * efConstruction (durante la creazione dell'indice): specifica un intervallo di ricerca durante la creazione di un indice. * ef (durante la ricerca dei target): specifica un intervallo di ricerca durante la ricerca dei target.
Fonte:`[` https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)`'`	`5.94`	`Playground gratuito`	`0.80`
`Anyscale Mixtral`	`Il parametro M per HNSW si riferisce al grado massimo del nodo, ovvero il numero massimo di connessioni che un nodo può avere nella struttura del grafo. Va da 2 a 2048. Inoltre, efConstruction ed ef sono parametri usati per specificare l'intervallo di ricerca rispettivamente durante la creazione dell'indice e la ricerca dei target.
Fonti: 1.`[` https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)` 2. `[`https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)`'`	`3.57`	`Playground gratuito`	`0.79`
`OctoAI Llama 3`	`Secondo il contesto fornito, i parametri per HNSW (Hierarchical Navigable Small World Graph) sono: * M: Grado massimo del nodo, che va da 2 a 2048. Questo parametro limita il grado massimo dei nodi su ogni livello del grafo. * efConstruction: Un parametro usato durante la creazione di un indice per specificare un intervallo di ricerca. * ef: Un parametro usato durante la ricerca dei target per specificare un intervallo di ricerca.
Fonte:`[` https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)` `	`4.43`	`$0.15 per milione di token`	`0.73`
`Groq Llama 3`	`Secondo il contesto fornito, i parametri per HNSW sono: * M: Grado massimo del nodo, che va da 2 a 2048. * efConstruction: Un parametro usato durante la creazione dell'indice per specificare un intervallo di ricerca. * ef: Un parametro usato durante la ricerca dei target per specificare un intervallo di ricerca.
Fonte: `[`https://milvus.io/docs/index.md`](https://milvus.io/docs/index.md)	`1.21`	`Beta
gratuita`	`0.79`
`Openai gpt-4o`	I parametri per HNSW sono i seguenti:``- M: Grado massimo del nodo, che limita le connessioni che ogni nodo può avere nel grafo. L'intervallo è [2, 2048].``- efConstruction: Parametro usato durante la creazione dell'indice per specificare un intervallo di ricerca.``- ef: Parametro usato durante la ricerca dei target per specificare un intervallo di ricerca.``Fonti:`https://milvus.io/docs/index.md`	`2.13`	`$5/M input
$15/M output`	`0.803`

Fonte: codice dell’autore e https://console.anyscale.com/v2/playground, https://console.groq.com/playground?model=llama3-70b-8192, https://octoai.cloud/text?selectedTags=Chat, https://openai.com/api/pricing/.

Conclusione

Oggi abbiamo molte opzioni tra modelli ed endpoint di inferenza tra cui scegliere per la parte G-Generation di RAG! Tutti gli endpoint provati in questo blog presentano qualità delle risposte variabile (come valutata da un critico GPT), latenze e costi da considerare.

Aggiornato il Jul 28, 2026

Christy Bergman
Christy Bergman is a passionate Developer Advocate at Zilliz. She previously worked in distributed computing at Anyscale and as a Specialist AI/ML Solutions Architect at AWS. Christy studied applied math, is a self-taught coder, and has published papers, including one with ACM Recsys. She enjoys hiking and bird watching.

Continua a leggere

Migrating from S3 Vectors to Zilliz Cloud: Unlocking the Power of Tiered Storage

Learn how Zilliz Cloud bridges cost and performance with tiered storage and enterprise-grade features, and how to migrate data from AWS S3 Vectors to Zilliz Cloud.

Smarter Autoscaling in Zilliz Cloud: Always Optimized for Every Workload

With the latest upgrade, Zilliz Cloud introduces smarter autoscaling—a fully automated, more streamlined, elastic resource management system.

Vector Databases vs. Key-Value Databases

Use a vector database for AI-powered similarity search; use a key-value database for high-throughput, low-latency simple data lookups.