Questo tutorial illustra un’implementazione dettagliata del framework Microsoft SkillOpt, incentrata sull’ottimizzazione e l’analisi evolutiva delle competenze linguistiche strumentali. Verranno spiegati in maniera passo-passo i modi per configurare l’ambiente di lavoro, eseguire valutazioni delle competenze di base, e addestrarne una seguendo un percorso di ottimizzazione, visualizzando progressi e utilizzo delle risorse.

Configurazione dell’Ambiente SkillOpt

Per poter utilizzare SkillOpt, è necessario iniziare preparando l’ambiente Colab. L’esempio mostra come caricare una chiave API utilizzabile da OpenAI:

    • Importazione di librerie essenziali come os, re, json, glob e difflib.
    • Utilizzo di Colab Secrets per accedere all’API key OpenAI, oppure di una chiave personalizzata.
    • Istruzione per installare i dipendenti necessari tramite git clone e pip install.
    • Definizione di modelli base e ottimizzatori, nonché di variabili di configurazione.
import os, re, json, glob, subprocess, pathlib, difflib

try:


from google.colab import userdata


OPENAIKEY = userdata.get("OPENAIAPI_KEY")


except Exception:


OPENAIKEY = os.environ.get("OPENAIAPI_KEY", "")


OPENAIKEY = OPENAIKEY or "sk-PASTE-YOUR-KEY-HERE"


assert OPENAIKEY.startswith("sk-"), "Inserisci una chiave OpenAI valida (Colab -> Secrets -> OPENAIAPI_KEY)."


...

Valutazione della Competenza di Base

Il progetto inizia valutando una competenza di base. Per ottenere una rappresentazione dei risultati, vengono utilizzate funzioni di supporto:

    • Un helper per eseguire comandi SkillOpt.
    • Un parser per estrarre la precisione di output.

La competenza di base viene valutata sul set di dati SearchQA, su un subset non visto (valid_unseen), utilizzando un modello di destinazione (gpt-4o-mini). Questo fornisce una rappresentazione dei livelli di precisione iniziale.

def run_cli(args, tag):

print("\n" + "#"80 + f"\n# {tag}\n# $ " + " ".join(args) + "\n" + "#"80)


p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)


buf = []


for line in p.stdout:


print(line, end=""); buf.append(line)


p.wait(); return "".join(buf)



def parse_acc(txt):


...



seed = "skillopt/envs/searchqa/skills/initial.md"


if not pathlib.Path(seed).exists():


seed = "baselineskill.md"; pathlib.Path(seed).writetext("Rispondi alle domande dal contesto fornito.\n")


baseout = runcli([...], "BASELINE EVAL")


base = parseacc(baseout)

L'output fornisce metriche di prestazione iniziali, che fungono da punto di partenza per il ciclo di ottimizzazione.

Addestramento e Visualizzazione

Si esegue, successivamente, il ciclo di addestramento completo, utilizzando i parametri definiti in RUN_KNOBS. Vengono configurati dettagli come numero di epoche, batch, learning rate, slow update e l’utilizzo di un meta-skill. I risultati dell’addestramento vengono salvati e visualizzati seguendo una dashboard di tipo grafico.

trainout = runcli([

"python", "scripts/train.py",


"--config", CFG,


"--split_dir", SPLIT,


"--optimizer_model", "gpt-4o",


"--target_model", "gpt-4o-mini"


], "TRAIN")



import pandas as pd, matplotlib.pyplot as plt


hist = json.loads(pathlib.Path(f"{RUN}/history.json").read_text())


df = pd.json_normalize(hist)

Gli indicatori come precisione delle competenze (train/val), budget di modifica, learning rate e uso totale di token vengono visualizzati tramite grafici. Questi forniscono un’idea chiara sull’efficacia dell’ottimizzazione e sull’utilizzo delle risorse (token, budget, etc.) in tempo reale.

Analisi dell’Evoluzione delle Competenze

Una volta completata l’ottimizzazione, si analizza l’evoluzione della competenza in base alle tracce generate dal sistema di addestramento. Vengono esaminati:

    • Snapshot delle competenze: file che salvano la versione migliorata.
    • Diff delle versioni: paragono la base con la versione migliorata.
    • Analisi meta: come l’algoritmo valuta e migliora la competenza.
snaps = sorted(glob.glob(f"{RUN}/skills/skill_v*.md"))

best  = pathlib.Path(f"{RUN}/bestskill.md").readtext()


diff = difflib.unifieddiff(pathlib.Path(snaps[0]).readtext().splitlines(),


best.splitlines(), snaps[0].split('/')[-1], "best_skill.md", lineterm="")


...

Confronto con Competenze Baseline

Il confronto tra le competenze iniziali e quelle ottimizzate permette di valutare l’efficacia del processo. Vengono forniti dettagli:

    • Tasso di precisione pre e post ottimizzazione.
    • Risorse utilizzate (token, budget).
    • Variabilità nel learning rate.

Questi confronti sono essenziali per capire dove e quando l’ottimizzazione ha prodotto effetti positivi.

Utilizzo del Budget di Modifica

L’implementazione tiene traccia del budget per modifiche strumentali delle competenze, permettendo di gestire l’accuratezza dell’output rispetto al costo.

    • Il budget di modifica è legato a quanto si è disposti a "aggiustare" una competenza.
    • Vengono mostrate analisi grafiche di come il budget viene utilizzato durante l’addestramento.
    • Viene incluso un grafico della cumulazione del numero di token per step del training.

Analisi Token

Ogni passo del training ha un suo costo in termini di token, e SkillOpt mantiene traccia precisa di questo. Vengono mostrati grafici che rappresentano:

    • L’applicazione del budget di modifica al training.
    • La crescita esponenziale del costo token.
    • Una rappresentazione del costo in relazione ai progressi nella competenza.

Questo aiuta a capire dove il modello sta imparando di più in termini di costo.

Ottenimento delle Tracce di Patch

Le patch generate durante il training vengono salvate per analisi successive:

patch = (sorted(glob.glob(f"{RUN}/steps/step_/patches/.json")) or [None])[0]

analy = (sorted(glob.glob(f"{RUN}/steps/step_/analysis/")) or [None])[0]


...

Queste file JSON e analisi contengono informazioni su come il modello ha effettuato un aggiornamento alla competenza, che può essere utile per ulteriore tuning manuale.

Applicazione Pratica e Possibili Estensioni

L’applicazione di SkillOpt non si limita a SearchQA. Può essere utilizzato per: