Modelli Amazon Nova: guida con esempi

Cosa sono i modelli Amazon Nova?

I modelli Nova di Amazon sono modelli fondamentali molto attesi, accessibili tramite il servizio Amazon Bedrock. Sono progettati per una varietà di applicazioni, tra cui inferenza rapida a basso costo, comprensione multimediale e generazione creativa di contenuti. Vediamo ciascun modello.

Amazon Nova Micro

Il modello più veloce della famiglia, con la massima velocità e un basso costo computazionale. Micro è ideale per applicazioni che richiedono generazione solo‑testo rapida, con una velocità di inferenza di 200 token/secondo.

Alcuni dei migliori casi d’uso di Micro sono analisi in tempo reale, chatbot interattivi e servizi di generazione di testo ad alto traffico.

Benchmark di Nova Micro. (Fonte: Amazon)

Amazon Nova Lite

Il membro multimodale economico della famiglia Nova, Lite offre un buon equilibrio tra velocità e alta accuratezza in molte attività, in particolare per ragionamento e traduzione rispetto a controparti come GPT-4o o Llama.

Gestisce grandi volumi di richieste in modo efficiente mantenendo al contempo un’elevata accuratezza. Lite può essere una scelta ottimale per applicazioni in cui la velocità è molto importante e serve un modello in grado di gestire più modalità.

Benchmark di Nova Lite. (Fonte: Amazon)

Amazon Nova Pro

Il modello più avanzato della famiglia Nova per l’elaborazione del testo, Nova Pro, offre un’accuratezza notevole mantenendo costi computazionali relativamente bassi rispetto a modelli con capacità simili.

Secondo Amazon, Nova Pro è adatto ad applicazioni come il riassunto di video, il question answering, il ragionamento matematico, lo sviluppo software e agenti AI in grado di eseguire workflow multi‑step. Come i modelli Micro e Lite, anche Nova Pro supporta attualmente il fine‑tuning.

Benchmark di Nova Pro. (Fonte: Amazon)

Amazon Nova Premier

Il modello multimodale più capace della famiglia, in arrivo all’inizio del 2025, dovrebbe rappresentare un salto di qualità rispetto al modello Pro.

Amazon Nova Canvas

Canvas è la soluzione di Nova per la generazione di immagini. Può generare immagini di alta qualità, offrire controllo su palette di colori e stile e fornire funzionalità come inpainting, outpainting, estensione delle immagini, style transfer e rimozione dello sfondo. Il modello è indicato per creare immagini di marketing, mockup di prodotto, ecc.

Amazon Nova Reel

Nova Reel è un modello di generazione video progettato per output video di alta qualità e facilmente personalizzabili. Nova Reel consente di creare e controllare stile visivo, ritmo e movimento della camera nei video. Reel, come gli altri modelli Nova, include controlli di sicurezza integrati che favoriscono la generazione di contenuti allineati.

Come accedere ai modelli Amazon Nova tramite Amazon Bedrock Playground

Puoi usare il Playground di Amazon Bedrock per testare e confrontare più modelli tramite un’interfaccia pronta all’uso.

Darò per scontato che tu abbia Amazon CLI e Bedrock configurati e pronti all’uso. In caso contrario, puoi consultare il mio tutorial su AWS Multi‑Agent Orchestrator, dove spiego nel dettaglio i passaggi per configurare un ambiente per l’uso dei modelli forniti dai servizi Bedrock. Inoltre, il post sul blog di Nils Durner offre schermate passo‑passo per guidarti nella configurazione dei servizi Bedrock.

Amazon Bedrock Playground

Confrontando Nova Micro e Pro, ho notato che il divario di accuratezza tra i due modelli non è evidente. Sebbene Micro sia più del doppio più veloce di Pro nella generazione di testo, fornisce risposte adeguate per la maggior parte dei casi d’uso comuni. Pro, invece, tende a produrre risposte leggermente più dettagliate e lunghe.

Come accedere ai modelli Amazon Nova tramite le API di Amazon Bedrock

Per usare i modelli Nova via API e integrarli nel tuo codice, assicurati innanzitutto che il tuo account AWS, l’AWS CLI e l’accesso ai modelli siano configurati correttamente (la documentazione fornisce indicazioni a riguardo).

Quindi, installa la libreria boto3, l’SDK AWS per Python, che ti consente di lavorare con i loro modelli.

pip install boto3Offerto da

Puoi interagire con i modelli in modo programmatico usando uno script come quello seguente:

import boto3
import json 

client = boto3.client(service_name="bedrock-runtime")

messages = [
    {"role": "user", "content": [{"text": "Write a short poem"}]},
]

model_response = client.converse(
    modelId="us.amazon.nova-lite-v1:0", 
    messages=messages
)

print("\\n[Full Response]")
print(json.dumps(model_response, indent=2))

print("\\n[Response Content Text]")
print(model_response["output"]["message"]["content"][0]["text"])Offerto da

Progetto demo con Nova Micro e AWS Multi‑Agent Orchestrator

Ora realizziamo un progetto demo per testare le capacità agentiche di Nova Micro. Useremo il framework AWS Multi‑Agent Orchestrator per configurare una semplice applicazione Python composta da due agenti: Python Developer Agent e ML Expert Agent. Se vuoi configurare l’orchestrator, puoi usare questa guida ad AWS Multi‑Agent Orchestrator.

Useremo anche Chainlit, un pacchetto Python open‑source, per implementare una semplice UI per l’applicazione. Per iniziare, installa le librerie necessarie:

chainlit==1.2.0
multi_agent_orchestrator==0.0.18Offerto da

Cominciamo importando le librerie necessarie:

import uuid
import chainlit as cl
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator, OrchestratorConfig
from multi_agent_orchestrator.classifiers import BedrockClassifier, BedrockClassifierOptions
from multi_agent_orchestrator.agents import AgentResponse
from multi_agent_orchestrator.agents import BedrockLLMAgent, BedrockLLMAgentOptions, AgentCallbacks
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator
from multi_agent_orchestrator.types import ConversationMessage
import asyncio
import chainlit as clOfferto da

Il framework usa un Classifier per scegliere il miglior agente per la richiesta in arrivo dell’utente. Usiamo “anthropic.claude-3-haiku-20240307-v1:0” come modello per il nostro Classifier.

class ChainlitAgentCallbacks(AgentCallbacks):
    def on_llm_new_token(self, token: str) -> None:
        asyncio.run(cl.user_session.get("current_msg").stream_token(token))

# Initialize the orchestrator
custom_bedrock_classifier = BedrockClassifier(BedrockClassifierOptions(
    model_id='anthropic.claude-3-haiku-20240307-v1:0',
    inference_config={
        'maxTokens': 500,
        'temperature': 0.7,
        'topP': 0.9
    }
))

orchestrator = MultiAgentOrchestrator(options=OrchestratorConfig(
        LOG_AGENT_CHAT=True,
        LOG_CLASSIFIER_CHAT=True,
        LOG_CLASSIFIER_RAW_OUTPUT=True,
        LOG_CLASSIFIER_OUTPUT=True,
        LOG_EXECUTION_TIMES=True,
        MAX_RETRIES=3,
        USE_DEFAULT_AGENT_IF_NONE_IDENTIFIED=False,
        MAX_MESSAGE_PAIRS_PER_AGENT=10,
    ),
    classifier=custom_bedrock_classifier
)Offerto da

Poi definiamo due agenti basati su Nova Micro, uno come esperto sviluppatore Python e l’altro come esperto di machine learning.

def create_python_dev():
    return BedrockLLMAgent(BedrockLLMAgentOptions(
        name="Python Developer Agent",
        streaming=True,
        description="Experienced Python developer specialized in writing, debugging, and evaluating only Python code.",
        model_id="amazon.nova-micro-v1:0",
        callbacks=ChainlitAgentCallbacks()
    ))

def create_ml_expert():
    return BedrockLLMAgent(BedrockLLMAgentOptions(
        name="Machine Learning Expert",
        streaming=True,
        description="Expert in areas related to machine learning including deep learning, pytorch, tensorflow, scikit-learn, and large language models.",
        model_id="amazon.nova-micro-v1:0",
        callbacks=ChainlitAgentCallbacks()
    ))
    

# Add agents to the orchestrator
orchestrator.add_agent(create_python_dev())
orchestrator.add_agent(create_ml_expert())Offerto da

Infine, impostiamo il corpo principale dello script per la UI di Chainlit in modo da gestire le richieste degli utenti e le risposte degli agenti.

@cl.on_chat_start
async def start():
    cl.user_session.set("user_id", str(uuid.uuid4()))
    cl.user_session.set("session_id", str(uuid.uuid4()))
    cl.user_session.set("chat_history", [])

@cl.on_message
async def main(message: cl.Message):
    user_id = cl.user_session.get("user_id")
    session_id = cl.user_session.get("session_id")
    msg = cl.Message(content="")
    await msg.send()  # Send the message immediately to start streaming
    cl.user_session.set("current_msg", msg)
    response:AgentResponse = await orchestrator.route_request(message.content, user_id, session_id, {})
    # Handle non-streaming responses
    if isinstance(response, AgentResponse) and response.streaming is False:
        # Handle regular response
        if isinstance(response.output, str):
            await msg.stream_token(response.output)
        elif isinstance(response.output, ConversationMessage):
                await msg.stream_token(response.output.content[0].get('text'))
    await msg.update()

if __name__ == "__main__":
    cl.run()Offerto da

Il risultato è la UI di Chainlit, che ti permette di chattare in pratica e liberamente con i modelli Nova.

Esecuzione della nostra app su Chainlit

I modelli di generazione di immagini e video sono disponibili anche via API. Puoi fare riferimento alla documentazione per script che mostrano come utilizzarli.

Conclusione

I modelli Amazon Nova rappresentano un passo avanti nell’ecosistema dei modelli fondamentali, combinando accuratezza allo stato dell’arte, velocità, convenienza e capacità multimodali. Man mano che la suite LLM di Amazon cresce con nuovi prodotti, sta diventando una scelta potente per creare applicazioni convenienti e scalabili sull’infrastruttura AWS.

Che tu stia sviluppando applicazioni AI agentiche, creando chatbot per l’assistenza clienti o esplorando come developer, sperimentare con i modelli Nova è un’esperienza che vale la pena. È utile anche approfondire AWS, Bedrock e gli strumenti LLM di Amazon.

In questo articolo abbiamo coperto gli aspetti chiave di questi modelli, come sperimentarli e come creare una semplice applicazione AI agentica usando i modelli Nova.