Qwen (Alibaba Cloud) Tutorial: Introduzione e Fine-Tuning

E se chiunque potesse usare l’intelligenza artificiale avanzata, non solo le big tech? È questa la grande idea alla base di Qwen, una nuova famiglia di modelli IA creata da Alibaba Cloud.

Qwen (abbreviazione di Tongyi Qianwen) punta a rendere i modelli di IA facilmente accessibili a tutti con un set di strumenti sviluppati da Alibaba Cloud. Qwen lo fa offrendo:

• Una gamma di modelli di IA pronti all’uso
• Modelli già addestrati e facilmente adattabili
• Strumenti che semplificano l’integrazione dell’IA nei progetti

Con Qwen non servono grandi risorse o conoscenze super specialistiche per usare IA avanzata.

In questo tutorial, noi:

1. Esploreremo le caratteristiche principali dei modelli Qwen, incluse le loro capacità multilingue e di elaborazione multimodale.
2. Ti guideremo nel processo di accesso e installazione dei modelli Qwen.
3. Mostreremo esempi pratici di utilizzo di Qwen per attività come generazione di testo e domanda-risposta.
4. Esploreremo il fine-tuning dei modelli Qwen su dataset personalizzati per applicazioni specialistiche.
5. Discuteremo le implicazioni più ampie e le prospettive future di Qwen.

Che cos’è Qwen?

Qwen è una serie di potenti modelli addestrati su enormi dataset multilingue e multimodali. Sviluppato da Alibaba Cloud, Qwen spinge l’IA a nuovi livelli, rendendola più intelligente e utile per l’elaborazione del linguaggio naturale, la visione artificiale e la comprensione audio.

Questi modelli sono in grado di svolgere un’ampia gamma di compiti, tra cui:

• Generazione di testo e comprensione
• Domanda-risposta
• Didascalie e analisi di immagini
• Visual question answering
• Elaborazione audio
• Uso di tool e pianificazione di compiti

I modelli Qwen sono pre-addestrati su fonti di dati eterogenee e perfezionati tramite post-training su dati di alta qualità.

Famiglia di modelli

La famiglia Qwen comprende diversi modelli specializzati pensati per esigenze e casi d’uso differenti.

La famiglia di modelli Qwen è progettata per versatilità e facile personalizzazione, offrendo fine-tuning per applicazioni o settori specifici. Questa flessibilità, unita a capacità potenti, rende Qwen una grande risorsa per la tecnologia IA in diversi ambiti.

Caratteristiche principali di Qwen

La famiglia di modelli Qwen offre uno strumento potente e versatile per varie applicazioni di IA. Vediamo le caratteristiche chiave che distinguono Qwen:

Supporto multilingue

Qwen eccelle nella comprensione e generazione multilingue, con forti capacità in inglese e cinese, oltre al supporto per molte altre lingue. I modelli Qwen2 più recenti hanno ampliato il repertorio linguistico includendo 27 lingue aggiuntive, coprendo regioni come Europa occidentale, Europa orientale e centrale, Medio Oriente, Asia orientale e Asia meridionale.

Questo ampio supporto linguistico consente a Qwen di facilitare la comunicazione interculturale, eseguire traduzioni di alta qualità, gestire scenari di code-switching e servire applicazioni globali con generazione di contenuti localizzati.

Generazione di testo

I modelli Qwen sono molto abili in vari compiti di generazione di testo. Alcune applicazioni chiave includono:

• Scrittura di articoli: generazione di contenuti estesi, coerenti e contestualmente pertinenti
• Riassunto: condensazione di testi lunghi in sintesi concise
• Composizione poetica: creazione di versi con attenzione a ritmo e stile
• Generazione di codice: scrittura di codice funzionale in più linguaggi di programmazione

La capacità dei modelli di mantenere il contesto su sequenze lunghe (fino a 32.768 token) consente la generazione di output estesi e coerenti.

Domanda-risposta

Qwen è ottimo anche nel rispondere a domande sia fattuali sia aperte. Questa funzione consente:

• Recupero di informazioni: estrazione rapida di fatti rilevanti da una vasta base di conoscenza
• Ragionamento analitico: risposte ponderate a quesiti complessi e aperti
• Risposte specifiche per compito: risposte su misura per vari domini, dalla cultura generale a campi specialistici

Comprensione delle immagini

Con il modello Qwen-VL, la famiglia Qwen estende le sue capacità a compiti multimodali che coinvolgono immagini. Le funzionalità principali includono:

• Image captioning: generazione di testo descrittivo per contenuti visivi
• Visual question answering: risposte a domande sul contenuto delle immagini
• Comprensione di documenti: estrazione di informazioni da immagini contenenti testo e grafica
• Elaborazione multi-immagine: gestione di conversazioni che coinvolgono più immagini
• Supporto per immagini ad alta risoluzione: elaborazione di immagini fino a 448x448 pixel (e risoluzioni ancora più alte con Qwen-VL-Plus e Qwen-VL-Max)

Open source

Una delle caratteristiche più importanti di Qwen è la sua natura open source, che porta diversi vantaggi alla comunità IA:

• Accessibilità: accesso gratuito e utilizzo dei modelli
• Trasparenza: l’architettura del modello e il processo di training sono aperti a esame e miglioramento
• Personalizzazione: gli utenti possono eseguire fine-tuning dei modelli per applicazioni o domini specifici
• Sviluppo guidato dalla community: favorisce la collaborazione e l’avanzamento rapido delle tecnologie IA
• Considerazioni etiche: consente discussioni più ampie e implementazioni di pratiche di IA responsabile

L’approccio open source ha portato a un ampio supporto da parte di progetti e strumenti di terze parti:

Qwen: accesso e installazione

Ora che conosci Qwen e le sue caratteristiche principali, è il momento di imparare a usarlo nella pratica!

Accesso ai modelli Qwen

I modelli Qwen sono disponibili su diverse piattaforme, il che li rende molto accessibili per vari casi d’uso.

Passaggi di installazione e primi passi

In questa sezione ti guiderò nell’utilizzo del modello linguistico Qwen-7B tramite Hugging Face. Copriremo la configurazione dell’ambiente, l’accesso a Hugging Face e l’esecuzione del modello.

Prerequisiti

• Python 3.7 o successivo
• pip (installer di pacchetti Python)

Passo 1: Installa le librerie richieste

Per prima cosa, installa le librerie necessarie:

pip install transformers torch huggingface_hubOfferto da

Passo 2: Accedi a Hugging Face

Per accedere al modello Qwen-7B, devi effettuare l’accesso al tuo account Hugging Face. Questo è necessario perché alcuni modelli potrebbero avere restrizioni d’uso, ma puoi comunque accedere ai modelli privati di tua proprietà o della tua organizzazione. Questo aiuta a monitorare l’uso dell’API e ad applicare eventuali limiti di richiesta.

Per accedere, segui questi passaggi:

1. Vai su Hugging Face.

2. Vai alle impostazioni del profilo e crea un access token.

3. Nel terminale, esegui:

huggingface-cli loginOfferto da

4. Quando richiesto, inserisci il tuo access token.

Passo 3: Crea uno script Python e importa i pacchetti

Ora creeremo un file Python o un Jupyter Notebook in cui inizieremo a scrivere il codice.

Per prima cosa importeremo due classi dalla libreria transformers:

• AutoModelForCausalLM: questa classe seleziona automaticamente l’architettura del modello appropriata in base al nome del modello che fornisci.
• AutoTokenizer: questa classe carica il tokenizer corretto per il modello che stai usando.

from transformers import AutoModelForCausalLM, AutoTokenizerOfferto da

Passo 4: Specifica il nome del modello

Ora specifichiamo quale modello vogliamo usare. "Qwen/Qwen-7B" si riferisce alla versione da 7 miliardi di parametri del modello Qwen ospitata su Hugging Face Model Hub, ma sentiti liberə di usare altri modelli Qwen.

model_name = "Qwen/Qwen-7B"Offerto da

Passo 5: Carica il tokenizer

Successivamente, dobbiamo caricare il tokenizer.

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)Offerto da

Questa riga carica il tokenizer associato al modello Qwen-7B. Il parametro trust_remote_code=True è necessario perché i modelli Qwen potrebbero richiedere l’esecuzione di codice personalizzato durante il caricamento.

Passo 6: Carica il modello

Il passo successivo è caricare il modello.

model = AutoModelForCausalLM.from_pretrained(model_name, trust_remote_code=True)Offerto da

Questo carica il modello Qwen-7B vero e proprio. Anche qui usiamo trust_remote_code=True per consentire l’esecuzione di eventuale codice personalizzato associato al modello.

Passo 7: Test di esempio

Una volta caricato il modello, possiamo testare se funziona generando del testo a partire da un input.

input_text = "Once upon a time"
inputs = tokenizer(input_text, return_tensors="pt")Offerto da

Qui prepariamo l’input per il modello:

• Definiamo una stringa input_text come prompt.
• Usiamo il tokenizer per convertire questo testo in un formato comprensibile al modello. L’argomento return_tensors="pt" specifica che vogliamo l’output in formato tensor di PyTorch.

Ora generiamo il testo:

outputs = model.generate(**inputs, max_new_tokens=50)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)Offerto da

La prima riga di codice dice al modello di generare testo:

• Passiamo i nostri inputs tokenizzati al metodo generate.
• **inputs scompatta il dizionario restituito dal tokenizer.
• max_new_tokens=50 limita la generazione a un massimo di 50 nuovi token.

generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)Offerto da

Questo passaggio converte l’output del modello (in formato ID di token) in testo leggibile:

• outputs seleziona la prima e unica (in questo caso) sequenza generata.
• skip_special_tokens=True indica al decoder di ignorare token speciali come padding o end-of-sequence.

Infine, stampiamo il testo generato per vedere il risultato.

print(generated_text)Offerto da

Once upon a time, in a far-off kingdom, there lived a young princess named Lily. 
She was known throughout the land for her kindness and beauty. Despite living in a grand castle with everything she could ever want, Lily felt something was missing in her life. She longed for adventure and to see the world beyond the castle walls.
One day, while walking in the royal gardens, she stumbled upon a hidden door overgrown with vines. Curiosity got the better of her, and she decided to see where it led. As she pushed open the creaky door, she found herself stepping into a magical forest filled with talking animals and glowing flowers.
Little did Lily know that this discovery would be the beginning of an extraordinary journey that would change her life forever…Offerto da

Note e consigli

Ecco alcune note e consigli utili:

1. Il modello Qwen-7B è grande (7 miliardi di parametri). Assicurati che il sistema abbia RAM sufficiente e preferibilmente una GPU per un’elaborazione più veloce. 
2. Se riscontri problemi di memoria, valuta l’uso di un modello più piccolo.
3. Il parametro trust_remote_code=True è necessario per i modelli Qwen poiché richiedono codice personalizzato per funzionare correttamente.
4. Controlla sempre la licenza del modello e le eventuali restrizioni d’uso sulla sua pagina Hugging Face.
5. Hai configurato ed eseguito correttamente il modello Qwen! Sperimenta con input diversi ed esplora le capacità del modello.

Qwen: deployment

I modelli Qwen possono essere distribuiti utilizzando la Platform for AI (PAI) e l’Elastic AI Serving (EAS) di Alibaba Cloud. Vediamo come distribuire un modello Qwen in pochi clic:

Qwen: esempi d’uso

Esploriamo alcuni esempi pratici di utilizzo di Qwen per generazione di testo e compiti di domanda-risposta.

Generazione di testo

Qwen è davvero bravo a generare testo coerente e contestualmente pertinente a partire da prompt. Vediamo alcuni esempi:

Completamento di testo di base

prompt = "The future of artificial intelligence is"
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(inputs, max_new_tokens=50)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)Offerto da

The future of artificial intelligence is bright and full of potential. As technology continues to advance, AI will play an increasingly important role in various aspects of our lives. From healthcare and education to transportation and entertainment, AI will revolutionize the way we live and work. However, it's crucial to ensure that AI is developed and used responsibly, with proper ethical considerations and safeguards in place.Offerto da

Scrittura creativa

prompt = "Write a short poem about the changing seasons:"
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(inputs, max_new_tokens=100, temperature=0.7)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)Offerto da

Leaves of gold and crimson fall,
As autumn's whisper fills the air.
Winter's chill soon follows all,
Blanketing the earth with care.
Spring awakens with gentle rain,
Coaxing buds to bloom anew.
Summer's warmth returns again,
Painting skies in vibrant blue.
Nature's cycle, ever turning,
Each season brings its own delight.
In this dance, we're always learning,
Of life's beauty, day and night.Offerto da

Generazione di codice

prompt = "Write a Python function to calculate the Fibonacci sequence:"
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(inputs, max_new_tokens=200, temperature=0.2)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)Offerto da

def fibonacci(n):
    """
    Calculate the Fibonacci sequence up to the nth term.
    
    Args:
    n (int): The number of terms in the sequence to calculate.
    
    Returns:
    list: A list containing the Fibonacci sequence up to the nth term.
    """
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    
    fib_sequence = [0, 1]
    for i in range(2, n):
        fib_sequence.append(fib_sequence[i-1] + fib_sequence[i-2])
    
    return fib_sequence
# Example usage:
print(fibonacci(10))  Offerto da

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]Offerto da

Domanda-risposta

Qwen può essere usato per rispondere a un’ampia gamma di domande, da quesiti fattuali a domande più aperte o analitiche. Ecco alcuni esempi:

Domanda fattuale

question = "What is the capital of France?"
inputs = tokenizer(question, return_tensors="pt")
outputs = model.generate(inputs, max_new_tokens=50)
answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"Q: {question}\nA: {answer}")Offerto da

Q: What is the capital of France?
A: The capital of France is Paris. Paris is the largest city in France and serves as the country's political, economic, and cultural center. It is known for its iconic landmarks such as the Eiffel Tower, the Louvre Museum, and Notre-Dame Cathedral.Offerto da

Domanda aperta

question = "What are the potential ethical concerns surrounding artificial intelligence?"
inputs = tokenizer(question, return_tensors="pt")
outputs = model.generate(inputs, max_new_tokens=200, temperature=0.7)
answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"Q: {question}\nA: {answer}")Offerto da

Q: What are the potential ethical concerns surrounding artificial intelligence?
A: There are several potential ethical concerns surrounding artificial intelligence (AI):
1. Privacy and data protection: AI systems often require large amounts of data, raising concerns about personal information collection and use.
2. Bias and discrimination: AI algorithms can perpetuate or amplify existing biases in training data, leading to unfair treatment of certain groups.
3. Job displacement: As AI becomes more advanced, it may replace human workers in various industries, potentially leading to unemployment and economic inequality.
4. Accountability and transparency: It can be challenging to understand how AI systems make decisions, making it difficult to assign responsibility for errors or harmful outcomes.
5. Autonomous weapons: The development of AI-powered weapons raises concerns about the ethics of warfare and the potential for uncontrolled escalation.
6. Superintelligence: There are concerns about the potential development of AI systems that surpass human intelligence, potentially posing existential risks to humanity.
7. Human autonomy: As AI systems become more integrated into our lives, there are concerns about the erosion of human decision-making and free will.
8. Security risks: AI systems can be vulnerable to hacking or manipulation, potentially leading to severe consequences in critical applications.
9. Social manipulation: AI-powered systems could be used to influence human behavior on a large scale, raising concerns about democracy and free will.
10. Ethical decision-making: As AI systems are tasked with making complex decisions, there are concerns about their ability to navigate ethical dilemmas appropriately.
Addressing these concerns requires ongoing dialogue between technologists, ethicists, policymakers, and the public to ensure responsible development and deployment of AI technologies.Offerto da

Questi esempi mostrano come Qwen possa gestire vari tipi di generazione di testo e compiti di domanda-risposta. 

Puoi regolare parametri come max_new_tokens e temperature per controllare la lunghezza e la creatività delle risposte generate in base alle tue esigenze.

Fine-tuning dei modelli Qwen

Il fine-tuning dei modelli Qwen ti permette di adattarli a compiti specifici, potenzialmente migliorandone le prestazioni per il tuo caso d’uso. Questo processo prevede l’addestramento del modello pre-addestrato su un dataset personalizzato, consentendo di apprendere conoscenze specifiche per il compito mantenendo le capacità generali di comprensione del linguaggio.

In questa sezione, illustreremo il processo di fine-tuning del modello Qwen-7B su un dataset personalizzato. Useremo tecniche di fine-tuning efficienti per rendere questo processo gestibile anche per modelli grandi. Nel nostro esempio, effettuiamo il fine-tuning per migliorare le prestazioni su compiti di traduzione e risposta a domande fattuali. Questo processo consente al modello di apprendere da un dataset personalizzato mantenendo le sue capacità generali di comprensione del linguaggio.

Prerequisiti

Prima di iniziare, assicurati di avere installato quanto segue:

pip install datasets torch accelerate peftOfferto da

Passo 1: Prepara il tuo dataset

Per prima cosa, prepara il dataset in formato JSON. Ogni voce deve avere i campi "prompt" e "completion". Salvalo come custom_dataset.json. Useremo questo esempio:

[
  {
    "prompt": "Translate to French: 'Hello, how are you?'",
    "completion": "Bonjour, comment allez-vous?"
  },
  {
    "prompt": "What is the capital of Spain?",
    "completion": "The capital of Spain is Madrid."
  }
]Offerto da

Passo 2: Configura lo script di fine-tuning

Ora aggiungiamo i seguenti import:

import torch
from transformers import TrainingArguments, Trainer
from datasets import load_dataset
from peft import LoraConfig, get_peft_modelOfferto da

Passo 3: Prepara il dataset

Definiremo quindi una funzione per pre-processare il dataset e caricarlo usando la libreria datasets di Hugging Face:

def preprocess_function(examples):
    inputs = [f"{prompt}\n" for prompt in examples["prompt"]]
    targets = [f"{completion}\n" for completion in examples["completion"]]
    model_inputs = tokenizer(inputs, max_length=512, truncation=True, padding="max_length")
    labels = tokenizer(targets, max_length=512, truncation=True, padding="max_length")
    model_inputs["labels"] = labels["input_ids"]
    return model_inputs
dataset = load_dataset("json", data_files="custom_dataset.json")
tokenized_dataset = dataset["train"].train_test_split(test_size=0.1)
tokenized_dataset = tokenized_dataset.map(preprocess_function, batched=True, remove_columns=dataset["train"].column_names)Offerto da

Passo 4: Configura LoRA per un fine-tuning efficiente

Per rendere il fine-tuning più efficiente, useremo LoRA (Low-Rank Adaptation). Questa tecnica consente di fare fine-tuning di grandi modelli con meno parametri:

lora_config = LoraConfig(
    r=8,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora_config)Offerto da

Passo 5: Definisci gli argomenti di training

Ora imposteremo gli argomenti di training che controllano vari aspetti del processo di fine-tuning:

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    per_device_eval_batch_size=4,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
    evaluation_strategy="steps",
    eval_steps=500,
    save_strategy="steps",
    save_steps=1000,
    learning_rate=1e-4,
    fp16=True,
    gradient_checkpointing=True,
    gradient_accumulation_steps=4,
)Offerto da

Passo 6: Crea il Trainer e avvia il fine-tuning

Con dataset e argomenti di training pronti, possiamo creare un oggetto Trainer e avviare il processo di fine-tuning:

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset["train"],
    eval_dataset=tokenized_dataset["test"],
    tokenizer=tokenizer,
)
trainer.train()Offerto da

Passo 8: Salva il modello ottimizzato

Al termine del fine-tuning, salveremo il modello per poterlo usare in seguito:

trainer.save_model("./fine_tuned_qwen")Offerto da

Il fine-tuning del modello Qwen-7B sul tuo dataset personalizzato migliorerà le sue prestazioni su compiti simili a quelli dei dati di training. In questo caso, il modello dovrebbe migliorare nella traduzione dall’inglese al francese e nel rispondere a domande fattuali sulle capitali.

Utilizzo del modello ottimizzato

Dopo il fine-tuning, puoi usare il modello per l’inferenza:

fine_tuned_model = AutoModelForCausalLM.from_pretrained("./fine_tuned_qwen", trust_remote_code=True)
fine_tuned_tokenizer = AutoTokenizer.from_pretrained("./fine_tuned_qwen", trust_remote_code=True)
def generate_response(prompt):
    inputs = fine_tuned_tokenizer(prompt, return_tensors="pt").to(fine_tuned_model.device)
    outputs = fine_tuned_model.generate(**inputs, max_new_tokens=50)
    return fine_tuned_tokenizer.decode(outputs[0], skip_special_tokens=True)
# Example usage
prompt = "Translate to French: 'Good morning, have a nice day!'"
response = generate_response(prompt)
print(f"Prompt: {prompt}\n Response: {response}")Offerto da

Prompt: Translate to French: 'Good morning, have a nice day!'
Response: Bonjour, passez une bonne journée !Offerto da

Consigli per un fine-tuning efficace

Ecco alcuni consigli da considerare per un fine-tuning efficace:

• Assicurati che il tuo dataset personalizzato sia di alta qualità e rappresentativo del compito target.
• Sebbene dataset più grandi diano in genere risultati migliori, anche poche centinaia di esempi possono aiutare per compiti specifici.
• Sperimenta con diversi learning rate, dimensioni di batch e numero di epoche per ottimizzare le prestazioni.
• Valuta regolarmente il modello su un set di validazione tenuto da parte per prevenire l’overfitting.
• Se lavori con memoria GPU limitata, valuta l’uso dell’accumulo di gradienti per simulare batch più grandi.
• Usa il training a precisione mista per velocizzare il fine-tuning e ridurre l’uso di memoria.
• Per compiti specifici di dominio, valuta un pre-training continuato su dati di dominio prima del fine-tuning sul tuo dataset specifico.

Eseguire il fine-tuning di Qwen sul tuo dataset personalizzato ti consente di creare un modello specializzato che eccelle nel tuo compito specifico mantenendo l’ampia conoscenza e le capacità del modello pre-addestrato originale. Questo approccio sfrutta la potenza dei large language model per le tue applicazioni e i tuoi domini unici.

Qwen: prospettive future

Man mano che Qwen evolve, possiamo aspettarci diversi sviluppi interessanti:

• Le future iterazioni dei modelli Qwen offriranno probabilmente capacità ancora più avanzate di comprensione linguistica, generazione ed elaborazione multimodale.
• La ricerca continua potrebbe portare a modelli più efficienti che offrono alte prestazioni con requisiti computazionali inferiori.
• Man mano che la community IA esplora e sperimenta con Qwen, è probabile che vedremo applicazioni nuove in vari settori e domini.
• Progressi nell’IA etica: la natura aperta di Qwen consente un controllo più ampio e la collaborazione su pratiche di IA etica, potenzialmente portando a sistemi più responsabili ed equi.

Conclusione

Concludendo la nostra esplorazione di Qwen, è chiaro che questi strumenti rappresentano un salto in avanti verso un’IA accessibile, potente e versatile. Qwen è più di un insieme di modelli potenti: rappresenta una visione di IA avanzata accessibile e adattabile a tutti. Offrendo questi strumenti come risorse open source, Alibaba Cloud sta guidando innovazione e progresso nell’IA.

Se vuoi restare aggiornatə sulle ultime novità dell’IA, ti consiglio questi articoli:

• Cos’è Buffer of Thoughts (BoT) e come funziona?
• MatMul-Free LLM: concetti chiave spiegati
• Cos’è Claude 3.5 Sonnet? Come funziona, casi d’uso e Artifacts