Flusso di lavoro per sviluppatori di app per intelligenza artificiale generativa

Lo sviluppo di un'applicazione di intelligenza artificiale generativa affidabile (app di intelligenza artificiale di generazione) richiede una pianificazione intenzionale, un ciclo rapido di valutazione del feedback sullo sviluppo e un'infrastruttura di produzione scalabile. Questo flusso di lavoro descrive una sequenza consigliata di passaggi che consentono di passare dalla versione di verifica iniziale alla distribuzione di produzione.

0. Prerequisiti

• Raccogliere i requisiti per convalidare l'adattamento dell'intelligenza artificiale alla generazione e identificare i vincoli.
• Progettare l'architettura della soluzione.

1. Costruisci

• Preparare le origini dati e creare gli strumenti necessari.
• Compilare e convalidare il prototipo iniziale (POC).
• Eseguire la distribuzione nell'ambiente di pre-produzione.

2. Valutare & Iterare

• Raccogliere commenti e suggerimenti degli utenti e misurare la qualità
• Risolvere i problemi di qualità affinando la logica e gli strumenti dell'agente in base alla valutazione.
• Incorporare l'input degli esperti della materia (SME) per migliorare continuamente la qualità del sistema degli agenti.

3. Produzione

• Implementare un'app di intelligenza artificiale generativa nell'ambiente di produzione.
• Monitorare le prestazioni e la qualità.
• Gestire e migliorare in base all'utilizzo reale.

Questo flusso di lavoro deve essere iterativo: dopo ogni ciclo di distribuzione o valutazione, tornare ai passaggi precedenti per perfezionare le pipeline di dati o aggiornare la logica dell'agente. Ad esempio, il monitoraggio della produzione potrebbe rivelare nuovi requisiti, attivando gli aggiornamenti alla progettazione dell'agente e un altro ciclo di valutazione. Seguendo questi passaggi sistematicamente e sfruttando le funzionalità di traccia MLflow di Databricks, Agent Framework e Valutazione agente, è possibile creare app di intelligenza artificiale di alta qualità che soddisfino in modo affidabile le esigenze degli utenti, rispettano i requisiti di sicurezza e conformità e continuano a migliorare nel tempo.

0. Prerequisiti

Prima di iniziare a sviluppare l'applicazione di intelligenza artificiale di generazione, non è possibile sottolineare quanto sia importante eseguire correttamente le operazioni seguenti: raccogliere i requisiti e la progettazione della soluzione.

La raccolta dei requisiti include i passaggi seguenti:

• Verifica se l'IA generativa si adatta al tuo caso d'uso.
• Definire l'esperienza utente.
• Definire l'ambito delle origini dati.
• Impostare vincoli di prestazioni.
• Acquisire i vincoli di sicurezza.

La Progettazione della Soluzione include quanto segue:

• Mappare le pipeline di dati.
• Identificare gli strumenti necessari.
• Delineare l'architettura complessiva del sistema.

Posando questa base, si imposta una direzione chiara per le successive fasi Build, Evaluatee Production.

Raccogli i requisiti

La definizione di requisiti chiari e completi per i casi d'uso è un primo passaggio fondamentale per lo sviluppo di un'app di intelligenza artificiale di generazione riuscita. Questi requisiti servono ai seguenti scopi:

• Consentono di determinare se un approccio di intelligenza artificiale di generazione è appropriato per il caso d'uso.
• Guidano la progettazione, l'implementazione e le decisioni di valutazione della soluzione.

Investire tempo all'inizio per raccogliere requisiti dettagliati può impedire sfide significative più avanti nel processo di sviluppo e garantire che la soluzione risultante soddisfi le esigenze degli utenti finali e degli stakeholder. I requisiti ben definiti forniscono le basi per le fasi successive del ciclo di vita dell'applicazione.

Il caso d'uso è adatto per l'intelligenza artificiale generativa?

Prima di impegnarsi in una soluzione di intelligenza artificiale generativa, valutare se i suoi punti di forza intrinseci sono allineati con le vostre esigenze. Di seguito sono riportati alcuni esempi in cui una soluzione di intelligenza artificiale generativa è una soluzione ottimale:

• Generazione di contenuti: L'attività richiede la generazione di contenuti nuovi o creativi che non possono essere ottenuti con modelli statici o logica semplice basata su regole.
• gestione dinamica delle query: le query degli utenti sono aperte o complesse e richiedono risposte flessibili e consapevoli del contesto.
• Sintesi delle informazioni: Il caso d'uso trae vantaggio dalla combinazione o dal riepilogo di diverse fonti di informazioni per produrre un output coerente.
• Agent Systems: L'applicazione richiede più di generare testo in risposta a una richiesta. Potrebbe essere necessario essere in grado di:
  • Pianificazione e processo decisionale: simulare una strategia in più passaggi per raggiungere un obiettivo specifico.
  • Esecuzione di azioni: l'attivazione di processi esterni o la chiamata a vari strumenti per eseguire attività (ad esempio, il recupero di dati, l'esecuzione di chiamate API, l'esecuzione di query SQL, l'esecuzione di codice).
  • Mantenimento dello stato: tenere traccia della cronologia delle conversazioni o del contesto delle attività tra più interazioni per abilitare la continuità.
  • Produzione di output adattivi: Generazione di risposte che si evolvono in base a azioni precedenti, informazioni aggiornate o condizioni mutevoli.

Al contrario, un approccio di intelligenza artificiale di generazione potrebbe non essere ideale nelle situazioni seguenti:

• L'attività è estremamente deterministica e può essere risolta efficacemente con modelli predefiniti o sistemi basati su regole.
• L'intero set di informazioni necessarie è già statico o rientra in un framework semplice e chiuso.
• Sono necessarie risposte con latenza estremamente bassa (millisecondi) e non è possibile gestire il sovraccarico dell'elaborazione generativa.
• Le risposte con modelli semplici sono sufficienti per il caso d'uso previsto.

Importante

Le sezioni seguenti usano le etichette P0, P1e P2 per indicare la priorità relativa.

• 🟢 [P0] sono gli elementi fondamentali o essenziali. Questi devono essere risolti immediatamente.
• 🟡 [P1] gli elementi sono importanti, ma possono seguire dopo P0 i requisiti.
• Gli elementi ⚪ [P2] sono considerazioni o miglioramenti con priorità inferiore che possono essere affrontati quando il tempo e le risorse lo permettono.

Queste etichette aiutano rapidamente i team a vedere quali requisiti richiedono attenzione immediata rispetto a quali possono essere posticipati.

Esperienza utente

Definire il modo in cui gli utenti interagiranno con l'app di intelligenza artificiale di generazione e il tipo di risposte previste.

• 🟢 [P0] Richiesta tipica: Che aspetto avrà una tipica richiesta utente? Raccogliere esempi dai portatori di interesse.
• 🟢 [P0] Risposte previste: Quale tipo di risposte deve generare il sistema (ad esempio, risposte brevi, spiegazioni in formato lungo, narrazioni creative)?
• 🟡 [P1] Modalità di interazione: Come interagiscono gli utenti con l'applicazione (ad esempio, interfaccia di chat, barra di ricerca, assistente vocale)?
• 🟡 [P1] Tono, stile, struttura: Quale tono, stile e struttura devono adottare gli output generati (formale, conversazionale, tecnica, punti elenco o prosa continua)?
• 🟡 [P1]Gestione degli errori: Come l'applicazione dovrebbe gestire le query ambigue, incomplete o non pertinenti? Deve fornire commenti e suggerimenti o richiedere chiarimenti?
• ⚪ [P2] Requisiti di formattazione: Sono presenti linee guida specifiche per la formattazione o la presentazione per gli output (inclusi i metadati o le informazioni supplementari)?

Dati

Determinare la natura, le origini e la qualità dei dati che verranno usati nell'app di intelligenza artificiale di generazione.

• 🟢 [P0] Origini dati: Quali origini dati sono disponibili?
  • Per ogni origine, determinare:
    • I dati sono strutturati o non strutturati?
    • Qual è il formato di origine (ad esempio PDF, HTML, JSON, XML)?
    • Dove risiedono i dati?
    • Quanti dati sono disponibili?
    • Come si dovrebbe accedere ai dati?
• 🟡 [P1] Aggiornamenti dei dati: Con quale frequenza vengono aggiornati i dati? Quali meccanismi sono disponibili per la gestione degli aggiornamenti?
• 🟡 [P1] Qualità dei dati: Esistono problemi di qualità noti o incoerenze?
  • Valutare se sarà necessario un monitoraggio qualitativo delle origini dati.

Prendere in considerazione la creazione di una tabella di inventario per consolidare queste informazioni, ad esempio:

Fonte di dati	Fonte	Tipi di file	Grandezza	Frequenza di aggiornamento
Origine dati 1	Volume del catalogo Unity	JSON	10 GB	Quotidiano
Origine dati 2	API pubblica	XML	NA (API)	In tempo reale
Origine dati 3	SharePoint	PDF, .docx	500 MB	Mensile

Vincoli di prestazioni

Acquisire i requisiti di prestazioni e risorse per l'applicazione di intelligenza artificiale generativa.

latenza

• 🟢 [P0] Tempo al primo token: Qual è il ritardo massimo accettabile prima di distribuire il primo token dell'output?
  • Nota: la latenza viene in genere misurata usando p50 (median) e p95 (95° percentile) per acquisire prestazioni medie e peggiori.
• 🟢 [P0] Tempo di completamento: Qual è il tempo di risposta accettabile (time-to-completion) per gli utenti?
• 🟢 [P0] Latenza di streaming: Se le risposte vengono trasmessi, è accettabile una latenza complessiva più elevata?

scalabilità

• 🟡 [P1]utenti simultanei o richieste &: Quanti utenti o richieste simultanee deve supportare il sistema?
  • Nota: la scalabilità viene spesso misurata in termini di QPS (query al secondo) o QPM (query al minuto).
• 🟡 [P1] Modelli di utilizzo: Quali sono i modelli di traffico previsti, i picchi di carico o i picchi di utilizzo basati sul tempo?

vincoli di costo

• 🟢 [P0] Limitazioni dei costi di inferenza: Quali sono i vincoli di costo o le limitazioni del budget per le risorse di calcolo dell'inferenza?

Valutazione

Stabilire come verrà valutata e migliorata l'app di intelligenza artificiale generativa nel tempo.

• 🟢 [P0] Indicatori KPI aziendali: quale obiettivo aziendale o indicatore KPI deve influire sull'applicazione? Definire i valori e le destinazioni di base.
• 🟢 [P0] Feedback degli stakeholder: chi fornirà feedback iniziale e continuativo sulle prestazioni e sugli output dell'applicazione? Identificare gruppi di utenti specifici o esperti di dominio.
• 🟢 [P0] Misurazione della qualità: quali metriche (ad esempio, accuratezza, pertinenza, sicurezza, punteggi umani) verranno usate per valutare la qualità degli output generati?
  • In che modo queste metriche verranno calcolate durante lo sviluppo (ad esempio, su dati sintetici, set di dati curati manualmente)?
  • Come verrà misurata la qualità nell'ambiente di produzione (ad esempio, la registrazione e l'analisi delle risposte alle query utente reali)?
  • Qual è la tolleranza complessiva per l'errore? (ad esempio, accettare una determinata percentuale di piccole inesattezze effettive o richiedere quasi 100% correttezza per i casi d'uso critici.
  • L'obiettivo è quello di creare un set di valutazione da query utente effettive, dati sintetici o una combinazione di entrambi. Questo set offre un modo coerente per valutare le prestazioni man mano che il sistema si evolve.
• 🟡 [P1] I cicli di feedback: come raccogliere i commenti degli utenti (ad esempio, i pollici su/giù, i moduli di sondaggio) e usati per migliorare in modo iterativo?
  • Pianificare la frequenza con cui verranno esaminati e incorporati i feedback.

Sicurezza

Identificare eventuali considerazioni sulla sicurezza e sulla privacy.

• 🟢 [P0] Riservatezza dei dati: Sono presenti elementi di dati sensibili o riservati che richiedono una gestione speciale?
• 🟡 [P1] Controlli di accesso: È necessario implementare controlli di accesso per limitare determinati dati o funzionalità?
• 🟡 [P1] Valutazione delle minacce & mitigazione: La tua applicazione deve proteggersi da minacce comuni per l'intelligenza artificiale generativa, come l'iniezione di comandi o gli input utente dannosi?

Distribuzione

Comprendere in che modo la soluzione di intelligenza artificiale di generazione verrà integrata, distribuita, monitorata e gestita.

• integrazione 🟡[P1]: Come deve essere integrata la soluzione di intelligenza artificiale di generazione con i sistemi e i flussi di lavoro esistenti?
  • Identificare i punti di integrazione (ad esempio Slack, CRM, strumenti BI) e i connettori dati necessari.
  • Determinare il flusso delle richieste e delle risposte tra l'app di intelligenza artificiale di generazione e i sistemi downstream (ad esempio, API REST, webhook).
• 🟡 [P1] Distribuzione: Quali sono i requisiti per la distribuzione, il ridimensionamento e il controllo delle versioni dell'applicazione? Questo articolo illustra come gestire il ciclo di vita end-to-end in Databricks usando MLflow, Unity Catalog, Agent Framework, Agent Evaluatione Model Serving.
• 🟡 [P1] Monitoraggio della produzione & osservabilità: Come si monitorerà l'applicazione una volta in produzione?
  • Registrazione delle tracce &: cattura tracce di esecuzione complete.
  • Metriche di qualità: valutare continuamente le metriche chiave (ad esempio correttezza, latenza, pertinenza) sul traffico live.
  • Avvisi & dashboard: imposta avvisi per i problemi critici.
  • Ciclo di feedback: incorporare il feedback degli utenti nell'ambiente di produzione (pollici su o giù) per rilevare i problemi in anticipo e favorire miglioramenti iterativi.

Esempio

Si consideri ad esempio come si applicano queste considerazioni e requisiti a un'applicazione RAG agentica ipotetica usata da un team di supporto clienti di Databricks:

Area	Considerazioni	Requisiti
Esperienza utente	Modalità di interazione. Esempi di query utente tipici. Formato e stile di risposta previsti. Gestione di query ambigue o irrilevanti.	Interfaccia di chat integrata con Slack. Query di esempio: "Come si riduce il tempo di avvio del cluster?" "Che tipo di piano di supporto ho?" Risposte tecniche chiare con frammenti di codice e collegamenti alla documentazione pertinente, se appropriato. Fornire suggerimenti contestuali ed eseguire l'escalation per supportare i tecnici quando necessario.
Logica dell'agente	Comprensione e classificazione delle query. Pianificazione e processo decisionale in più passaggi. Selezione ed esecuzione autonoma degli strumenti. Gestione dello stato e del contesto tra le interazioni. Gestione degli errori e meccanismi di fallback.	Pianificazione alimentata da modelli linguistici di grandi dimensioni (LLM) con ripieghi deterministici. Eseguire l'integrazione con un set di strumenti predefiniti, ad esempio il recupero della documentazione o lo strumento di recupero di Salesforce. Mantenere lo stato della conversazione per interazioni coerenti a più turni e un recupero degli errori affidabile.
Dati	Numero e tipo di origini dati. Formato e posizione dei dati. Dimensioni dei dati e frequenza di aggiornamento. Qualità e coerenza dei dati.	Quattro origini dati. Documentazione aziendale (HTML, PDF). Ticket di supporto risolti (JSON). Post del forum della comunità (tabella Delta). Connettore Salesforce. Dati archiviati in Unity Catalog e aggiornati settimanalmente. Dimensioni totali dei dati: 5 GB. Struttura dei dati coerente e qualità gestite da documenti dedicati e team di supporto.
Prestazione	Latenza massima accettabile. Vincoli di costo. Utilizzo previsto e concorrenza.	Requisito di latenza massima. Vincoli di costo. Carico di picco previsto.
Valutazione	Disponibilità del set di dati di valutazione. Metriche di qualità. Raccolta di commenti e suggerimenti degli utenti.	Gli esperti in materia di ogni area del prodotto aiutano a esaminare gli output e a regolare risposte errate per creare il set di dati di valutazione. Indicatori KPI aziendali. Aumento della frequenza di risoluzione dei ticket di supporto. Riduzione del tempo impiegato dall'utente per ogni ticket di supporto. Metriche di qualità. Risposta valutata dall'LLM per correttezza e rilevanza. LLM giudica la precisione del recupero delle informazioni. Voto positivo o negativo dell'utente. Raccolta di commenti e suggerimenti. Slack verrà configurato per fornire un pollice in su o in giù.
Sicurezza	Gestione dei dati sensibili. Requisiti di controllo di accesso.	Nessun dato sensibile dei clienti deve trovarsi nell'origine di recupero. Autenticazione utente tramite l'accesso Single Sign-On di Databricks Community.
Distribuzione	Integrazione con i sistemi esistenti. Distribuzione e controllo delle versioni.	Integrazione con il sistema di ticket di supporto. Agente distribuito come endpoint di gestione del modello di Databricks.

Progettazione di soluzioni

Fonti dati & strumenti

Quando si progetta un'app di intelligenza artificiale generativa, è importante identificare e mappare le varie origini dati e strumenti necessari per supportare la tua soluzione. Possono trattarsi di set di dati strutturati, pipeline di elaborazione dati non strutturate o di query su API esterne. Di seguito sono riportati gli approcci consigliati per incorporare fonti di dati o strumenti diversi nell'app di intelligenza artificiale generativa.

Dati strutturati

I dati strutturati si trovano in genere in formati tabulari ben definiti (ad esempio, una tabella Delta o un file CSV) ed è ideale per le attività in cui le query sono predeterminate o devono essere generate in modo dinamico in base all'input dell'utente. Consultare strumenti per il recupero strutturato dell'intelligenza artificiale per raccomandazioni sull'aggiunta di dati strutturati alla tua app di intelligenza artificiale generativa.

Dati non strutturati

I dati non strutturati includono documenti non elaborati, PDF, messaggi di posta elettronica, immagini e altri formati non conformi a uno schema fisso. Tali dati richiedono un'elaborazione aggiuntiva, in genere tramite una combinazione di analisi, suddivisione in blocchi e incorporamento, per eseguire query e usare in modo efficace in un'app di intelligenza artificiale di generazione. Consulta gli strumenti dell'agente di recupero AI non strutturato per consigli sull'aggiunta di dati strutturati alla tua app Gen AI.

API esterne azioni &

In alcuni scenari, l'app di intelligenza artificiale di generazione potrebbe dover interagire con i sistemi esterni per recuperare i dati o eseguire azioni. Nei casi in cui l'applicazione richiede la chiamata di strumenti o l'interazione con le API esterne, è consigliabile:

• Gestire le credenziali DELL'API con un Connessione al catalogo Unity: Usare una connessione al catalogo Unity per gestire in modo sicuro le credenziali api. Questo metodo garantisce che i token e i segreti siano gestiti centralmente e controllati dall'accesso.
• Invoke mediante il Databricks SDK:
  Inviare richieste HTTP a servizi esterni usando la funzione http_request dalla libreria di databricks-sdk. Questa funzione sfrutta una connessione del catalogo Unity per l'autenticazione e supporta metodi HTTP standard.
• sfruttare le funzioni del catalogo Unity:
  Racchiudere connessioni esterne in una funzione del Catalogo Unity per aggiungere logica personalizzata di pre-elaborazione o post-elaborazione.
• strumento esecutore Python:
  Per eseguire in modo dinamico il codice per la trasformazione dei dati o le interazioni con le API usando le funzioni Python, usare lo strumento executor Python predefinito.

Esempio di :

Un'applicazione di analisi interna recupera i dati di mercato live da un'API finanziaria esterna. L'applicazione usa:

• connessione esterna del catalogo Unity per archiviare in modo sicuro le credenziali API.
• Una funzione personalizzata di Unity Catalog incapsula la chiamata API per aggiungere la pre-elaborazione (ad esempio la normalizzazione dei dati) e la post-elaborazione, come la gestione degli errori.
• Inoltre, l'applicazione potrebbe richiamare direttamente l'API tramite Databricks SDK.

Approccio di implementazione

Quando si sviluppa un'app di intelligenza artificiale di generazione, sono disponibili due opzioni principali per implementare la logica dell'agente: sfruttare un framework open source o creare una soluzione personalizzata usando il codice Python. Di seguito è riportata una suddivisione dei vantaggi e dei svantaggi per ogni approccio.

Uso di un framework (ad esempio LangChain, LlamaIndex, CrewAI o AutoGen)

Pro:

• componenti predefiniti: I framework sono dotati di strumenti preconfezionati per la gestione delle richieste, il concatenamento delle chiamate e l'integrazione con varie origini dati, che possono accelerare lo sviluppo.
• Community e documentazione: Approfitta del supporto della community, dei tutorial e degli aggiornamenti regolari.
• Modelli di progettazione comuni: Framework in genere forniscono una struttura modulare chiara e modulare per orchestrare le attività comuni, semplificando così la progettazione complessiva dell'agente.

Contro:

• Aggiunta astrazione: framework open source spesso introducono livelli di astrazione che potrebbero non essere necessari per il caso d'uso specifico.
• Dipendenze dagli aggiornamenti: Si potrebbe essere dipendenti dai gestori del framework per le correzioni di bug e gli aggiornamenti delle funzionalità, che possono rallentare la capacità di adattarsi rapidamente ai nuovi requisiti.
• Potenziale sovraccarico: l'astrazione extra può causare problemi di personalizzazione se l'applicazione necessita di un controllo più dettagliato.

Uso di Python puro

Pro:

• flessibilità: Sviluppo in Python puro consente di personalizzare l'implementazione esattamente in base alle proprie esigenze senza essere vincolati dalle decisioni di progettazione di un framework.
• Adattamento rapido: È possibile modificare rapidamente il codice e incorporare le modifiche in base alle esigenze, senza attendere gli aggiornamenti da un framework esterno.
• Semplicità: evitare livelli non necessari di astrazione, che possono potenzialmente comportare una soluzione più snella e più efficiente.

Contro:

• maggiore impegno di sviluppo: Compilazione da zero potrebbe richiedere più tempo e competenze per implementare funzionalità che un framework dedicato potrebbe altrimenti fornire.
• Reinventare la rotellina: Potrebbe essere necessario sviluppare funzionalità comuni (ad esempio il concatenamento degli strumenti o la gestione delle richieste) autonomamente.
• Responsabilità della manutenzione: Tutti gli aggiornamenti e le correzioni di bug diventano responsabilità dell'utente, che può essere difficile per i sistemi complessi.

In definitiva, la decisione deve essere guidata dalla complessità del progetto, dalle esigenze di prestazioni e dal livello di controllo necessario. Nessuno dei due approcci è intrinsecamente superiore; ognuno offre vantaggi distinti a seconda delle preferenze di sviluppo e delle priorità strategiche.

1. Costruire

In questa fase si trasforma la progettazione della soluzione in un'applicazione di intelligenza artificiale di generazione funzionante. Invece di perfezionare tutto in anticipo, iniziare con un modello di verifica minimo (POC) che può essere testato rapidamente. In questo modo è possibile eseguire la distribuzione in un ambiente di pre-produzione il prima possibile, raccogliere query rappresentative da utenti o PMI effettive e perfezionare in base al feedback reale.

Il processo di compilazione segue questi passaggi chiave:

un. Preparare gli strumenti di & dati: Assicurarsi che i dati necessari siano accessibili, analizzati e pronti per il recupero. Implementare o registrare le funzioni e le connessioni del catalogo Unity (ad esempio, le API di recupero o le chiamate API esterne) necessarie all'agente. b. Agente di compilazione: Orchestrare la logica di base, a partire da un approccio POC semplice. c. Controllo qualità: Convalidare la funzionalità essenziale prima di esporre l'app a più utenti. d. Distribuire l'agente di pre-produzione: Rendere disponibile il prototipo per gli utenti tester e gli esperti in materia per un feedback iniziale. e. Raccogliere commenti e suggerimenti degli utenti: Usare l'utilizzo reale per identificare aree di miglioramento, dati o strumenti aggiuntivi necessari e potenziali perfezionamenti per l'iterazione successiva.

un. Preparare gli strumenti dati &

Dalla fase di progettazione della soluzione si avrà un'idea iniziale delle origini dati e degli strumenti necessari per l'app. In questa fase, mantenerlo minimo: concentrarsi su un numero sufficiente di dati per convalidare il modello di verifica. In questo modo si garantisce un'iterazione rapida senza investimenti iniziali elevati in pipeline complesse.

Dati

1. Identificare un subset rappresentativo di dati
   • Per dati strutturati, selezionare le tabelle chiave o le colonne più rilevanti per lo scenario iniziale.
   • Per dati non strutturati, classificare in ordine di priorità solo un subset di documenti rappresentativi. Usare una pipeline di base di incorporamento/suddivisione in blocchi con di Ricerca a vettori di intelligenza artificiale mosaici mosaici in modo che l'agente possa recuperare blocchi di testo pertinenti, se necessario.
2. Configurare l'accesso ai dati
   • Se hai bisogno che la tua app effettui chiamate API esterne, archivia le credenziali in modo sicuro usando una connessione di Unity Catalog .
3. Convalida la copertura di base
   • Verificare che i subset di dati scelti rispondano adeguatamente alle query dell'utente che si prevede di testare.
   • Salvare eventuali origini dati aggiuntive o trasformazioni complesse per le iterazioni future. L'obiettivo attuale dovrebbe essere dimostrare la fattibilità di base e raccogliere feedback.

Strumenti

Dopo aver configurato le origini dati, il passaggio successivo consiste nell'implementare e registrare gli strumenti che l'agente chiamerà in fase di esecuzione a Unity Catalog. Uno strumento è una funzione a interazione singola, ad esempio una query SQL o una chiamata API esterna, che l'agente può richiamare per il recupero, la trasformazione o l'azione.

Strumenti di recupero dati

• Query di dati strutturati vincolati: Se le query sono fisse, incapsularle in una funzione SQL di Unity Catalog o in una funzione UDF Python. In questo modo la logica viene centralizzata e individuabile.
• query di dati aperte e strutturate: Se le query sono più aperte, è consigliabile impostare uno spazio Genie per gestire query da testo a SQL.
• funzioni di supporto per dati non strutturati: Per i dati non strutturati archiviati nella Ricerca Vettoriale di Mosaic AI, creare uno strumento di recupero di dati non strutturati che l'agente può chiamare per recuperare testi pertinenti.

strumenti per chiamate API

• chiamate API esterne:è possibile invocare direttamente le chiamate API usando il metodo http_request del Databricks SDK.
• wrapper facoltativi: Se è necessario implementare la logica di pre-elaborazione o post-elaborazione (ad esempio la normalizzazione dei dati o la gestione degli errori), eseguire il wrapping della chiamata API in una funzione del catalogo Unity .

mantenerlo minimo

• Iniziare solo con gli strumenti essenziali: Concentrarsi su un singolo percorso di recupero o su un set limitato di chiamate API. È possibile aggiungere altro durante l'iterazione.
• Convalida in modo interattivo: Testare ogni strumento in modo indipendente (ad esempio, in un notebook) prima di incorporarlo nel sistema dell'agente.

Dopo che i prototipi sono pronti, procedere con la creazione dell'agente. L'agente orchestra questi strumenti per rispondere a query, recuperare i dati ed eseguire azioni in base alle esigenze.

b. Agente di compilazione

Dopo che i dati e gli strumenti sono a disposizione, è possibile creare l'agente che risponde alle richieste in ingresso, ad esempio le query degli utenti. Per creare un agente prototipo iniziale, usare python o playground di intelligenza artificiale. Seguire questa procedura:

1. Inizia semplice
   • Selezionare un modello di progettazione di base: Per un prototipo, iniziare con una catena di base (ad esempio una sequenza fissa di passaggi) o un singolo agente che chiama strumenti (dove l'LLM può chiamare dinamicamente uno o due strumenti essenziali).
     • Se il tuo scenario si allinea con uno dei notebook di esempio forniti nella documentazione di Databricks, adatta quel codice come base.
   • prompt minimo: resistere alla richiesta di over engineer a questo punto. Mantenere le istruzioni concise e direttamente pertinenti alle attività iniziali.
2. Incorpora strumenti
   • Integrazione degli strumenti : Se si usa un pattern di progettazione a catena, i passaggi che chiamano ogni strumento saranno codificati in modo rigido. In un agente chiamante degli strumenti è fornire uno schema in modo che LLM sappia come richiamare la funzione.
     • Verificare che gli strumenti in isolamento funzionino come previsto, prima di incorporarli nel sistema dell'agente e testarli in un test end-to-end.
   • Guardrails: Se l'agente può modificare sistemi esterni o eseguire codice, assicurarsi di disporre di controlli di sicurezza e protezioni di base (ad esempio, limitare il numero di chiamate o limitare determinate azioni). Implementare questi elementi all'interno di una funzione del catalogo Unity .
3. Traccia e registrare l'agente con MLflow
   • Traccia ogni passaggio: Utilizzare MLflow Tracing per acquisire input, output e tempo trascorso per ogni passaggio, al fine di debuggare i problemi e misurare le prestazioni.
   • Registrare l'agente: Usare il tracciamento di MLflow per registrare il codice e la configurazione dell'agente.

In questa fase, perfezione non è l'obiettivo. Si vuole un agente semplice e funzionante che è possibile distribuire per feedback anticipato da utenti di test e PMI. Il passaggio successivo consiste nell'eseguire un rapido controllo qualitativo prima di renderlo disponibile in un ambiente di pre-produzione.

c. Controllo qualità

Prima di esporre l'agente a un pubblico di pre-produzione più ampio, eseguire un controllo di qualità offline "sufficiente" per individuare eventuali problemi gravi prima di distribuirlo a un endpoint. In questa fase, in genere non si avrà un set di dati di valutazione di grandi dimensioni e affidabile, ma è comunque possibile eseguire un passaggio rapido per assicurarsi che l'agente si comporti come previsto in una manciata di query di esempio.

1. Testare interattivamente in un notebook
   • Test manuali: Contatta manualmente il tuo agente con richieste rappresentative. Prestare attenzione a se recupera i dati corretti, chiama gli strumenti correttamente e segue il formato desiderato.
   • Esaminare le tracce MLflow: Se è stato abilitato il tracciamento MLflow, rivedere passo passo i dati di telemetria. Verificare che l'agente selezioni gli strumenti appropriati, gestisca correttamente gli errori e non generi richieste o risultati intermedi imprevisti.
   • Controlla latenza: Annotare il tempo necessario per l'esecuzione di ogni richiesta. Se i tempi di risposta o l'utilizzo dei token sono troppo elevati, potrebbe essere necessario eliminare i passaggi o semplificare la logica prima di continuare.
2. Controllo dell'atmosfera
   • Questa operazione può essere eseguita in un notebook o in AI Playground.
   • coerenza & correttezza: L'output dell'agente ha senso per le query che hai testato? Ci sono imprecisioni evidenti o dettagli mancanti?
   • casi limite: Se si è provato a eseguire alcune query fuori dal comune, l'agente ha ancora risposto in modo logico o almeno ha fallito con grazia (ad esempio, rifiutando di rispondere in modo educato anziché produrre output insensato)?
   • Adesione alla richiesta: Se sono state fornite istruzioni di alto livello, come il tono desiderato o la formattazione, l'agente le sta seguendo?
3. Valutare la qualità "sufficientemente buona"
   • Se si è limitati alle query di test a questo punto, è consigliabile generare dati sintetici. Consulta Crea un set di valutazione.
   • Risolvere i problemi principali: Se si individuano gravi difetti (ad esempio, l'agente chiama ripetutamente strumenti o output non validi), risolvere questi problemi prima di esponerli a un pubblico più ampio. Consulta Problemi di qualità comuni e come risolverli.
   • Decidere la fattibilità: Se l'agente soddisfa un livello base di usabilità e correttezza per un piccolo set di query, è possibile procedere. In caso contrario, perfezionare le richieste, correggere i problemi relativi allo strumento o ai dati e ripetere il tentativo.
4. Pianificare i passaggi successivi
   • Miglioramenti del tracciamento: Documenta eventuali carenze che si decide di posticipare. Dopo aver raccolto commenti e suggerimenti reali in fase di pre-produzione, è possibile rivedere questi elementi.

Se tutto sembra fattibile per un'implementazione limitata, è possibile distribuire l'agente in fase di pre-produzione. Un processo di valutazione approfondito verrà eseguito in fasi successive, soprattutto dopo avere più dati reali, feedback delle PMI e un set di valutazione strutturato. Per il momento, concentrarsi sulla garanzia che l'agente dimostri in modo affidabile le funzionalità di base.

d. Distribuire l'agente di pre-produzione

Dopo che l'agente soddisfa una soglia di qualità di base, il passaggio successivo consiste nell'ospitarlo in un ambiente di pre-produzione in modo da comprendere come gli utenti eseguono query sull'app e raccolgono il loro feedback per guidare lo sviluppo. Questo ambiente può essere l'ambiente di sviluppo durante la fase di prova concettuale. Il requisito principale è che l'ambiente è accessibile per selezionare tester interni o esperti di dominio.

1. Distribuire l'agente
   • Registrare e loggare l'agente: Innanzitutto, loggare l'agente come modello MLflow e registrarlo in Unity Catalog.
   • Distribuire con Agent Framework: Usare Agent Framework per accettare l'agente registrato e distribuirlo come endpoint di gestione del modello.
2. tabelle di inferenza
   • Agent Framework archivia automaticamente richieste, risposte e tracce insieme ai metadati in una tabella di inferenza nel catalogo Unity per ogni endpoint di gestione.
3. Proteggere e configurare
   • Controllo di accesso:Limitare l'accesso agli endpoint al gruppo di test (PMI, utenti esperti). Ciò garantisce l'utilizzo controllato ed evita l'esposizione imprevista dei dati.
   • autenticazione: Verificare che tutti i segreti, i token API o le connessioni di database necessari siano configurati correttamente.

È ora disponibile un ambiente controllato per raccogliere feedback sulle query reali. Uno dei modi in cui è possibile interagire rapidamente con l'agente è AI Playground, in cui è possibile selezionare l'endpoint model serving appena creato ed eseguire query sull'agente.

e. Raccogliere commenti e suggerimenti degli utenti

Dopo aver distribuito l'agente in un ambiente di pre-produzione, il passaggio successivo consiste nel raccogliere feedback da utenti reali e PMI per individuare lacune, individuare imprecisioni e perfezionare ulteriormente l'agente.

1. Usare l' di revisione dell'app

   • Quando si distribuisce l'agente con Agent Framework, viene creata una semplice app di revisione. Fornisce un'interfaccia intuitiva in cui i tester possono porre domande e valutare immediatamente le risposte dell'agente.
   • Tutte le richieste, le risposte e il feedback degli utenti (pollici su/giù, commenti scritti) vengono registrate automaticamente in una tabella di inferenza , semplificando l'analisi in un secondo momento.

2. Usare l'interfaccia utente di monitoraggio per esaminare i log

   • Tenere traccia delle valutazioni positive/negative o dei feedback testuali nella UI di monitoraggio per identificare le risposte che i tester hanno trovato particolarmente utili (o meno utili).

3. Coinvolgere esperti di dominio

   • Incoraggiare le PMI a eseguire scenari tipici e insoliti. La conoscenza del dominio consente di identificare errori sottili, ad esempio errori di interpretazione errata dei criteri o dati mancanti.
   • Mantenere un backlog di problemi, dalle modifiche minime delle richieste ai refactoring della pipeline di dati di dimensioni maggiori. Decidere quali correzioni assegnare priorità prima di procedere.

4. Curare i nuovi dati di valutazione

   • Convertire interazioni rilevanti o problematiche in test case. Nel corso del tempo, questi costituiscono la base di un set di dati di valutazione più affidabile.
   • Se possibile, aggiungere risposte corrette o previste a questi casi. Ciò consente di misurare la qualità nei cicli di valutazione successivi.

5. Eseguire l'iterazione in base al feedback

   • Applicare correzioni rapide come piccoli cambiamenti nei documenti guida o nuove linee guida per affrontare i problemi urgenti.
   • Per problemi più complessi, ad esempio la necessità di una logica avanzata in più passaggi o di nuove origini dati, raccogliere prove sufficienti prima di investire in modifiche principali dell'architettura.

Sfruttando il feedback dell'app di revisione, dei log delle tabelle di inferenza e delle informazioni dettagliate sulle PMI, questa fase di pre-produzione consente di individuare i gap chiave e perfezionare l'agente in modo iterativo. Le interazioni reali raccolte in questo passaggio creano la base per la creazione di un set di valutazione strutturato, consentendo di passare da miglioramenti ad hoc a un approccio più sistematico alla misurazione della qualità. Dopo aver risolto i problemi ricorrenti e stabilizzato le prestazioni, si sarà pronti per una distribuzione di produzione con una valutazione affidabile.

2. Valutare & iterare

Dopo che l'app di intelligenza artificiale di generazione è stata testata in un ambiente di pre-produzione, il passaggio successivo consiste nel misurare, diagnosticare e perfezionare sistematicamente la qualità. Questa fase di "valutazione e iterazione" trasforma il feedback non elaborato e i log in un set di valutazione strutturato, consentendo di testare ripetutamente i miglioramenti e assicurarsi che l'app soddisfi gli standard necessari per accuratezza, pertinenza e sicurezza.

Questa fase include i passaggi seguenti:

• Raccogliere query reali dai log: Convertire le interazioni di alto valore o problematiche dalle tabelle di inferenza in test case.
• Aggiungere etichette di esperti:, se possibile, collegare le verità fondamentali o le linee guida di stile e policy a questi casi per poter misurare la correttezza, la fondatezza e altre dimensioni di qualità in modo più obiettivo.
• Sfruttare Agent Evaluation: Usare giudici LLM predefiniti o controlli personalizzati per quantificare la qualità dell'app.
• Iterare: Migliorare la qualità affinando la logica dell'agente, le pipeline di dati o i prompt. Eseguire nuovamente la valutazione per verificare se sono stati risolti i problemi chiave.

Si noti che queste funzionalità funzionano anche se l'app di intelligenza artificiale generativa viene eseguita all'esterno di Databricks. Instrumentando il codice con MLflow Tracing, è possibile acquisire tracce da qualsiasi ambiente e unificarle in Databricks Data Intelligence Platform per la valutazione e il monitoraggio coerenti. Man mano che si continuano a incorporare nuove query, feedback e informazioni sulle PMI, il set di dati di valutazione diventa una risorsa vivente che supporta un ciclo di miglioramento continuo, assicurando che l'app di intelligenza artificiale di generazione rimanga affidabile, affidabile e allineata agli obiettivi aziendali.

a. Valutare l'agente

Una volta che il tuo agente sta operando in un ambiente di pre-produzione, il passaggio successivo consiste nel misurare sistematicamente le sue prestazioni oltre i controlli empirici ad hoc. la valutazione dell'agente di intelligenza artificiale Mosaic consente di creare set di valutazione, eseguire controlli di qualità con giudici LLM predefiniti o personalizzati e di eseguire rapidamente l'iterazione in aree problematiche.

Valutazioni offline e online

Quando si valutano applicazioni di intelligenza artificiale di generazione, esistono due approcci principali: valutazione offline e valutazione online. Questa fase del ciclo di sviluppo è incentrata sulla valutazione offline, che si riferisce alla valutazione sistematica al di fuori delle interazioni degli utenti live. La valutazione online viene illustrata in un secondo momento quando si discute del monitoraggio dell'agente nell'ambiente di produzione.

Teams spesso si affida troppo al "test dell'atmosfera" per troppo tempo nel flusso di lavoro dello sviluppatore, provando in modo informale una manciata di query e giudicando soggettivamente se le risposte sembrano ragionevoli. Sebbene ciò fornisca un punto di partenza, manca il rigore e la copertura necessari per creare applicazioni di qualità di produzione.

Al contrario, un processo di valutazione offline appropriato esegue le operazioni seguenti:

• Stabilisce una baseline di qualità prima di una distribuzione più ampia, creando metriche chiare per il miglioramento.
• Identifica specifici punti deboli che richiedono attenzione, superando la limitazione dei test solo i casi d'uso previsti.
• Rileva regressioni di qualità durante il perfezionamento dell'app confrontando automaticamente le prestazioni tra le versioni.
• Fornisce metriche quantitative per illustrare il miglioramento agli stakeholder.
• consente di individuare casi perimetrali e potenziali modalità di errore prima che gli utenti eseseguono l'operazione.
• riduce i rischi di distribuzione di un agente sottoperformante nell'ambiente di produzione.

Investire tempo nella valutazione offline paga dividendi significativi nel lungo periodo, aiutandoti a realizzare risposte costantemente di alta qualità.

Creare un set di valutazione

Un set di valutazione funge da base per misurare le prestazioni dell'app di intelligenza artificiale di generazione. Analogamente a un gruppo di test nello sviluppo software tradizionale, questa raccolta di query rappresentative e risposte previste diventa il benchmark di qualità e il set di dati di test di regressione.

È possibile creare un set di valutazione tramite diversi approcci complementari:

1. trasformare i log delle tabelle di inferenza negli esempi di valutazione

   I dati di valutazione più importanti provengono direttamente dall'utilizzo reale. La distribuzione di pre-produzione ha generato registri delle tabelle di inferenza contenenti richieste, risposte dell'agente, chiamate agli strumenti e contesto recuperato.

   La conversione di questi log in un set di valutazione offre diversi vantaggi:

   • Copertura del mondo reale: Comportamenti degli utenti imprevisti che potresti non aver previsto sono inclusi.
   • incentrato sul problema: È possibile filtrare in modo specifico per commenti e suggerimenti negativi o risposte lente.
   • Distribuzione rappresentativa: viene acquisita la frequenza effettiva di diversi tipi di query.

2. Generare dati di valutazione sintetica

   Se non si dispone di un set curato di query utente, è possibile generare automaticamente un set di dati di valutazione sintetica. Questo "set iniziale" di interrogazioni consente di valutare rapidamente se l'agente:

   • Restituisce risposte coerenti e accurate.
   • Risponde nel formato corretto.
   • Rispetta le linee guida relative a struttura, tonalità e politiche.
   • Recupera correttamente il contesto (per RAG).

   I dati sintetici in genere non sono perfetti. Pensaci come una pietra di passaggio temporanea. Vorrai anche:

   • Chiedi alle PMI o agli esperti di dominio di esaminare ed eliminare eventuali query irrilevanti o ripetitive.
   • Sostituire o aumentarlo in un secondo momento con i log di utilizzo reali.

3. Curare manualmente le query

   Se si preferisce non basarsi su dati sintetici o non si dispone ancora di log di inferenza, identificare da 10 a 15 query reali o rappresentative e creare un set di valutazione da questi. Le query rappresentative possono provenire da interviste agli utenti o brainstorming dei sviluppatori. Anche un breve elenco curato può esporre difetti evidenti nelle risposte dell'agente.

Questi approcci non si escludono a vicenda ma complementari. Un set di valutazione efficace si evolve nel tempo e in genere combina esempi di più origini, tra cui:

• Iniziare con esempi curati manualmente per testare le funzionalità di base.
• Facoltativamente, aggiungere dati sintetici per ampliare la copertura prima di avere dati utente reali.
• Incorporare gradualmente i log reali man mano che diventano disponibili.
• Aggiornare continuamente con nuovi esempi che riflettono la modifica dei modelli di utilizzo.

Pratiche migliori per le query di valutazione

Quando si crea il set di valutazione, includere deliberatamente tipi di query diversi, ad esempio:

• Sia i modelli di utilizzo previsti che quelli imprevisti , ad esempio richieste molto lunghe o brevi.
• Potenziali tentativi di uso improprio o attacchi di inserimento prompt (ad esempio tentativi di rivelare la richiesta di sistema).
• Query complesse che richiedono più passaggi di ragionamento o chiamate di strumenti.
• Casi limite con informazioni minime o ambigue, ad esempio errori di ortografia o query vaghe.
• Esempi che rappresentano diversi livelli di competenza utente e sfondi.
• Query che testano potenziali distorsioni nelle risposte, ad esempio "confrontare società A e società B".

Tenere presente che il set di valutazione deve crescere ed evolversi insieme all'applicazione. Man mano che si individuano nuove modalità di errore o comportamenti utente, aggiungere esempi rappresentativi per garantire che l'agente continui a migliorare in tali aree.

Aggiungere criteri di valutazione

Ogni esempio di valutazione deve avere criteri per valutare la qualità. Questi criteri fungono da standard in base ai quali vengono misurate le risposte dell'agente, consentendo la valutazione obiettivo in più dimensioni di qualità.

Dati di verità fondamentale o risposte di riferimento

Quando si valuta l'accuratezza effettiva, esistono due approcci principali: fatti previsti o risposte di riferimento. Ognuno ha uno scopo diverso nella strategia di valutazione.

Usare i fatti previsti (scelta consigliata)

L'approccio expected_facts prevede l'inserimento dei fatti chiave che devono essere visualizzati in una risposta corretta. Per un esempio, vedere set di esempio di valutazione con request, response, guidelinese expected_facts.

Questo approccio offre vantaggi significativi:

• Consente flessibilità nel modo in cui i fatti vengono espressi nella risposta.
• Rende più semplice per le PMI fornire la verità sul terreno.
• Supporta diversi stili di risposta assicurando al tempo stesso che le informazioni di base siano presenti.
• Abilita una valutazione più affidabile tra le versioni del modello o le impostazioni dei parametri.

Il giudice di correttezza predefinito controlla se la risposta dell'agente incorpora questi fatti essenziali, indipendentemente dalla formulazione, dall'ordinamento o da contenuti aggiuntivi.

Usare la risposta prevista (alternativa)

In alternativa, è possibile fornire una risposta di riferimento completa. Questo approccio funziona meglio nelle situazioni seguenti:

• Hai risposte di livello eccellente create dagli esperti.
• L'esatta formulazione o struttura della risposta è importante.
• Si stanno valutando le risposte in contesti altamente regolamentati.

Databricks consiglia in genere di usare expected_factsexpected_response perché offre maggiore flessibilità garantendo al tempo stesso l'accuratezza.

Linee guida per la conformità di stili, toni o criteri

Oltre all'accuratezza effettiva, potrebbe essere necessario valutare se le risposte rispettano specifici requisiti di stile, tono o criteri.

Solo linee guida

Se il problema principale riguarda l'applicazione di requisiti di stile o criteri anziché l'accuratezza effettiva, è possibile fornire linee guida senza fatti previsti:

# Per-query guidelines
eval_row = {
    "request": "How do I delete my account?",
    "guidelines": {
        "tone": ["The response must be supportive and non-judgmental"],
        "structure": ["Present steps chronologically", "Use numbered lists"]
    }
}

# Global guidelines (applied to all examples)
evaluator_config = {
    "databricks-agent": {
        "global_guidelines": {
            "rudeness": ["The response must not be rude."],
            "no_pii": ["The response must not include any PII information (personally identifiable information)."]
        }
    }
}

Il giudice LLM delle linee guida interpreta queste istruzioni in linguaggio naturale e valuta se la risposta è conforme a esse. Questo funziona particolarmente bene per dimensioni di qualità soggettive come tono, formattazione e conformità alle politiche organizzative.

Combinare i dati di base e le linee guida

Per una valutazione completa, è possibile combinare controlli di accuratezza effettivi con linee guida di stile. Vedere Set di valutazione di esempio con request, response, guidelinese expected_facts. Questo approccio garantisce che le risposte siano effettivamente accurate e conformi agli standard di comunicazione dell'organizzazione.

Usare risposte pre-registrate

Se sono già state acquisite coppie di richiesta-risposta dallo sviluppo o dai test, è possibile valutarle direttamente senza richiamare l'agente. Ciò è utile per:

• Analisi dei modelli esistenti nel comportamento dell'agente.
• Confronto delle prestazioni rispetto alle versioni precedenti.
• Risparmiare tempo e costi non rigenerando le risposte.
• Valutazione di un agente utilizzato al di fuori di Databricks.

Per informazioni dettagliate sulla fornitura delle colonne pertinenti nel dataframe di valutazione, vedere Esempio: Come passare output generati in precedenza a Agent Evaluation. La valutazione dell'agente di intelligenza artificiale mosaica usa questi valori pre-acquisiti anziché chiamare di nuovo l'agente, applicando comunque gli stessi controlli di qualità e metriche.

Procedure consigliate per i criteri di valutazione

Quando si definiscono i criteri di valutazione:

1. Essere specifici e obiettivi: Definire criteri chiari e misurabili interpretati da diversi analizzatori in modo analogo.
   • Prendere in considerazione l'aggiunta di metriche personalizzate per misurare i criteri di qualità desiderati.
2. Concentrarsi sul valore dell'utente: Assegnare priorità ai criteri in linea con gli elementi più importanti per gli utenti.
3. Iniziare con semplicità: Iniziare con un set di criteri di base ed espandersi man mano che cresce la comprensione delle esigenze di qualità.
4. Copertura equilibrata: Includere criteri che affrontano aspetti diversi della qualità (ad esempio, correttezza fattuale, stile e sicurezza).
5. Eseguire l'iterazione in base al feedback: perfezionare i criteri in base al feedback degli utenti e ai requisiti in continua evoluzione.

Vedere Procedure consigliate per lo sviluppo di un set di valutazione per altre informazioni sulla creazione di set di dati di valutazione di alta qualità.

Eseguire valutazioni

Dopo aver preparato un set di valutazione con query e criteri, è possibile eseguire una valutazione usando mlflow.evaluate(). Questa funzione gestisce l'intero processo di valutazione, dalla chiamata dell'agente all'analisi dei risultati.

Flusso di lavoro di valutazione di base

L'esecuzione di una valutazione di base richiede solo alcune righe di codice. Per informazioni dettagliate, vedere Eseguire una valutazione.

Quando viene attivata la valutazione:

1. Per ogni riga nel set di valutazione, mlflow.evaluate() esegue le operazioni seguenti:
   • Chiama il tuo agente con la richiesta (se non hai già fornito una risposta precisa).
   • Applica i giudici LLM integrati per valutare gli aspetti della qualità.
   • Calcola metriche operative come l'utilizzo e la latenza dei token.
   • Registra le motivazioni dettagliate per ogni valutazione.
2. I risultati vengono registrati automaticamente in MLflow, creando:
   • Valutazioni della qualità per ciascuna riga.
   • Metriche aggregate in tutti gli esempi.
   • Log dettagliati per il debug e l'analisi.

Personalizzare la valutazione

È possibile personalizzare la valutazione in base alle esigenze specifiche usando parametri aggiuntivi. Il parametro evaluator_config consente di eseguire le operazioni seguenti:

• Seleziona i giudici predefiniti da eseguire.
• Impostare le linee guida globali applicabili a tutti gli esempi.
• Configurare le soglie per i giudici.
• Fornire esempi di pochi scatti per guidare le valutazioni dei giudici.

Per informazioni dettagliate ed esempi, vedere esempi di .

Valutare gli agenti all'esterno di Databricks

Una potente funzionalità di Valutazione agente è la possibilità di valutare le app di intelligenza artificiale di generazione distribuite ovunque, non solo in Databricks.

Quali giudici sono coinvolti

Per impostazione predefinita, Agent Evaluation seleziona automaticamente i giudici LLM appropriati in base ai dati disponibili nel set di valutazione. Per informazioni dettagliate sulla valutazione della qualità, vedere Come viene valutata la qualità dai giudici LLM.

Analizzare i risultati della valutazione

Dopo aver eseguito una valutazione, l'interfaccia utente di MLflow fornisce visualizzazioni e informazioni dettagliate per comprendere le prestazioni dell'app. Questa analisi consente di identificare i modelli, diagnosticare i problemi e assegnare priorità ai miglioramenti.

Esplorare i risultati della valutazione

Quando si apre l'interfaccia utente di MLflow dopo l'esecuzione di mlflow.evaluate(), sono disponibili diverse visualizzazioni interconnesse. Per informazioni su come spostarsi tra questi risultati nell'interfaccia utente di MLflow, vedere Esaminare l'output usando l'interfaccia utente di MLflow.

Per indicazioni su come interpretare i modelli di errore, vedere b. Migliorare l'agente e gli strumenti.

L'intelligenza artificiale personalizzata valuta le metriche &

Mentre i giudici predefiniti coprono molti controlli comuni (ad esempio correttezza, stile, criteri e sicurezza), potrebbe essere necessario valutare aspetti specifici del dominio delle prestazioni dell'app. I giudici e le metriche personalizzati consentono di estendere le funzionalità di valutazione per soddisfare i requisiti di qualità univoci.

giudici LLM personalizzati

Per informazioni dettagliate su come creare un giudice LLM personalizzato da un prompt, vedere Creare giudici di intelligenza artificiale da un prompt.

I giudici personalizzati eccellono nella valutazione di dimensioni soggettive o sfumate della qualità che traggono vantaggio dal giudizio umano, ad esempio:

• Conformità specifica del dominio (legale, medica, finanziaria).
• Stile di comunicazione e voce del marchio.
• Sensibilità culturale e appropriatezza.
• Qualità di ragionamento complessa.
• Convenzioni di scrittura specializzate.

L'output del giudice viene visualizzato nell'interfaccia utente di MLflow insieme ai giudici predefiniti, con le stesse motivazioni dettagliate che spiegano le valutazioni.

metriche personalizzate

Per valutazioni più programmatiche deterministiche, è possibile creare metriche personalizzate usando l'elemento decorator @metric. Guarda @metric decoratore.

Le metriche personalizzate sono ideali per:

• Verifica dei requisiti tecnici, ad esempio la convalida del formato e la conformità dello schema.
• Verifica della presenza o dell'assenza di contenuto specifico.
• Esecuzione di misurazioni quantitative, ad esempio la lunghezza della risposta o i punteggi di complessità.
• Implementazione di regole di convalida specifiche dell'azienda.
• Integrazione con sistemi di convalida esterni.

b. Migliorare agente e strumenti

Dopo l'esecuzione della valutazione e l'identificazione dei problemi di qualità, il passaggio successivo consiste nell'affrontare sistematicamente tali problemi per migliorare le prestazioni. I risultati della valutazione forniscono preziose informazioni dettagliate su dove e come il tuo agente sta fallendo, consentendoti di apportare miglioramenti mirati anziché rettifiche casuali.

problemi di qualità comuni e come risolverli

Le valutazioni dei giudici LLM dai risultati della valutazione puntano a tipi specifici di errori nel sistema agente. Questa sezione illustra questi modelli di errore comuni e le relative soluzioni. Per informazioni su come interpretare gli output dei giudici LLM, vedere output dei giudici di intelligenza artificiale.

Migliori pratiche per l'iterazione di qualità

Durante l'iterazione dei miglioramenti, mantenere una documentazione rigorosa. Per esempio:

1. Versiona le tue modifiche
   • Registrare ogni iterazione significativa usando MLflow Tracking.
   • Salvare richieste, configurazioni e parametri chiave all'interno di un file di configurazione centrale. Verificare che sia registrato con l'agente.
   • Per ogni nuovo agente distribuito, mantieni un changelog nel tuo repository che dettagli cosa è cambiato e perché.
2. Documentare sia ciò che ha funzionato che non ha funzionato
   • Documentare approcci riusciti e non riusciti.
   • Si noti l'impatto specifico di ogni modifica sulle metriche. Collegarsi di nuovo all'esecuzione Agent Evaluation su MLflow.
3. allinearsi alle parti interessate
   • Usare l'app Di revisione per convalidare i miglioramenti con le PMI.
     • Comunicare le modifiche ai revisori usando le istruzioni del revisore .
   • Per il confronto affiancato di versioni diverse di un agente, è consigliabile creare più endpoint dell'agente e usare il modello in AI Playground. In questo modo gli utenti possono inviare la stessa richiesta a endpoint separati ed esaminare la risposta e le tracce affiancate.

3. Produzione

Dopo aver valutato e migliorato in modo iterativo la tua app, hai raggiunto un livello di qualità che soddisfi i tuoi requisiti ed è pronto per un uso più ampio. La fase di produzione prevede la distribuzione dell'agente raffinato nell'ambiente di produzione e l'implementazione del monitoraggio continuo per mantenere la qualità nel tempo.

La fase di produzione include:

• Distribuire l'agente nell'ambiente di produzione: Configurare un endpoint pronto per la produzione con le impostazioni di sicurezza, ridimensionamento e autenticazione appropriate.
• Monitorare l'agente nell'ambiente di produzione: Stabilire una valutazione continua della qualità, un rilevamento delle prestazioni e un avviso per garantire che l'agente mantenga una qualità e un'affidabilità elevate nell'uso reale.

In questo modo viene creato un ciclo di feedback continuo in cui i dati analitici di monitoraggio determinano ulteriori miglioramenti, che è possibile testare, distribuire e continuare a monitorare. Questo approccio garantisce che l'app rimanga di alta qualità, conforme e allineata alle esigenze aziendali in continua evoluzione per tutto il ciclo di vita.

un. Distribuire l'agente nell'ambiente di produzione

Dopo aver completato una valutazione approfondita e un miglioramento iterativo, si è pronti per distribuire l'agente in un ambiente di produzione. [Mosaic AI Agent Framework](/generative-ai/agent-framework/build-gen AI-apps.md#agent-framework) semplifica questo processo gestendo automaticamente molti problemi di distribuzione.

Processo di distribuzione

La distribuzione dell'agente nell'ambiente di produzione prevede i passaggi seguenti:

1. Annota e registra l'agente come modello MLflow nel Catalogo Unity.
2. Distribuire l'agente usando Agent Framework.
3. Configurare l'autenticazione per eventuali risorse dipendenti di cui il tuo agente ha bisogno di accedere.
4. Testare la distribuzione per verificare la funzionalità nell'ambiente di produzione.
   • Dopo aver pronto l'endpoint di gestione del modello, è possibile interagire con l'agente in AI Playground, in cui è possibile testare e verificare la funzionalità.

Per i passaggi di implementazione dettagliati, vedere Distribuire un agente per l'applicazione di intelligenza artificiale generativa.

Considerazioni sulla distribuzione di produzione

Quando si passa all'ambiente di produzione, tenere presenti le considerazioni chiave seguenti:

prestazioni e scalabilità

• Bilanciare i costi e le prestazioni in base ai modelli di utilizzo previsti.
• Valutare la possibilità di abilitare scalabilità a zero per gli agenti usati in modo intermittente per ridurre i costi.
• Comprendere i requisiti di latenza in base alle esigenze dell'esperienza utente dell'applicazione.

sicurezza e governance

• Assicurarsi che siano presenti controlli di accesso appropriati a livello di catalogo Unity per tutti i componenti dell'agente.
• Usare la pass-through di autenticazione predefinita per le risorse di Databricks, laddove possibile.
• Configurare la gestione delle credenziali appropriata per le API esterne o le origini dati.

approccio di integrazione

• Determinare il modo in cui l'applicazione interagirà con l'agente, ad esempio usando un'API o un'interfaccia incorporata.
• Valutare come gestire e visualizzare le risposte dell'agente nell'applicazione.
  • Se l'applicazione client necessita di contesto aggiuntivo, ad esempio riferimenti al documento di origine o punteggi di attendibilità, progetta il tuo agente per includere questi metadati nelle risposte, ad esempio usando output personalizzati.
• Pianificare la gestione degli errori e i meccanismi di fallback per quando l'agente non è disponibile.

raccolta feedback

• Sfruttare il feedback dell'app di revisione per gli stakeholder durante l'implementazione iniziale.
• Meccanismi di progettazione per raccogliere commenti e suggerimenti degli utenti direttamente nell'interfaccia dell'applicazione.
  • L'endpoint di feedback creato per raccogliere commenti e suggerimenti dall'app di revisione può essere usato anche dalle applicazioni esterne per fornire feedback sull'agente. Vedi Fornisci feedback su un agente implementato.
• Assicurarsi che i dati di feedback vengano trasmessi al processo di valutazione e miglioramento.

b. Monitorare l'agente nell'ambiente di produzione

Dopo aver distribuito l'agente nell'ambiente di produzione, è essenziale monitorare continuamente le prestazioni, la qualità e i modelli di utilizzo. A differenza del software tradizionale in cui la funzionalità è deterministica, le app di intelligenza artificiale di generazione possono presentare deviazioni di qualità o comportamenti imprevisti quando incontrano input reali. Un monitoraggio efficace consente di rilevare i problemi in anticipo, comprendere i modelli di utilizzo e migliorare continuamente la qualità dell'applicazione.

Configurare il monitoraggio dell'agente

Mosaic AI offre funzionalità di monitoraggio predefinite che consentono di tenere traccia delle prestazioni dell'agente senza creare un'infrastruttura di monitoraggio personalizzata:

1. Crea un di monitoraggio per l'agente distribuito.
2. Configurare la frequenza e la frequenza di campionamento in base alle esigenze di traffico e monitoraggio.
3. Seleziona le metriche di qualità per valutare automaticamente le richieste campione.

Dimensioni di monitoraggio chiave

In generale, un monitoraggio efficace deve coprire tre dimensioni critiche:

1. metriche operative

   • Volume delle richieste e schemi.
   • Latenza della risposta.
   • Tassi di errore e tipi.
   • Utilizzo e costi dei token.

2. metriche di qualità

   • Rilevanza per le query dell'utente.
   • Radicamento nel contesto recuperato.
   • Conformità alla sicurezza e alle linee guida.
   • Percentuale di pass di qualità complessiva.

3. commenti e suggerimenti degli utenti

   • Feedback esplicito (pollici su/giù).
   • Segnali impliciti (domande di completamento, conversazioni abbandonate).
   • Problemi segnalati ai canali di supporto.

Usare l'interfaccia utente di monitoraggio

L'interfaccia utente di monitoraggio fornisce informazioni dettagliate visualizzate su queste dimensioni tramite due schede.

• scheda Grafici: visualizzare le tendenze nel volume delle richieste, metriche di qualità, latenza ed errori nel tempo.
• scheda di log: Esamina le singole richieste e risposte, inclusi i risultati della loro valutazione.

Le funzionalità di filtro consentono agli utenti di cercare query specifiche o filtrare in base al risultato della valutazione. Per altre informazioni, vedere Usare l'interfaccia utente di monitoraggio.

Creare dashboard e avvisi

Per un monitoraggio completo:

• Creare dashboard personalizzate, usando i dati di monitoraggio archiviati nella tabella delle tracce valutate.
• Configurare gli avvisi per le soglie operative o di qualità critica.
• Pianificare revisioni di qualità regolari con le principali parti interessate.

Ciclo di miglioramento continuo

Il monitoraggio è più utile quando restituisce al processo di miglioramento.

1. Identificare i problemi tramite il monitoraggio delle metriche e dei commenti degli utenti.
2. Esporta esempi problematici nel set di valutazione.
3. Diagnosticare le cause radice usando l'analisi della traccia MLflow e i risultati del giudice LLM (come descritto in Problemi di qualità comuni e come risolverli).
4. Sviluppare e testare miglioramenti con il vostro set di valutazione ampliato.
5. Distribuire gli aggiornamenti e monitorare l'impatto.

Questo approccio iterativo e a ciclo chiuso consente di garantire che l'agente continui a migliorare in base a modelli di utilizzo reali, mantenendo la qualità elevata, adattandosi al cambiamento dei requisiti e dei comportamenti degli utenti. Con Il monitoraggio dell'agente è possibile ottenere visibilità sulle prestazioni dell'agente nell'ambiente di produzione, consentendo di risolvere in modo proattivo i problemi e ottimizzare qualità e prestazioni.