Costruire un'intelligenza artificiale responsabile con Guardrails AI | Intelligenza-Artificiale

introduzione

Modelli linguistici di grandi dimensioni (LLM) sono onnipresenti in varie applicazioni come applicazioni di chat, assistenti vocali, agenti di viaggio e call center. Man mano che vengono rilasciati nuovi LLM, migliorano la generazione di risposte. Tuttavia, le persone lo utilizzano sempre più ChatGPT e altri LLM, che possono fornire suggerimenti con informazioni di identificazione personale o linguaggio tossico. Per proteggersi da questi tipi di dati, è in fase di studio una libreria chiamata Guardrails-AI. Questa libreria mira ad affrontare questi problemi fornendo un modo sicuro ed efficiente per generare risposte.

obiettivi formativi

• Acquisisci una comprensione del ruolo di Guardrails nel migliorare la sicurezza e l'affidabilità delle applicazioni IA, in particolare quelle che utilizzano Large Language Models (LLM).
• Scopri le funzionalità di Guardrails-AI, inclusa la sua capacità di rilevare e mitigare contenuti dannosi come linguaggio tossico, informazioni di identificazione personale (PII) e chiavi segrete.
• Esplora Guardrails Hub, un repository online di validatori e componenti, e scopri come sfruttarlo per personalizzare e migliorare la funzionalità di Guardrails-AI per le loro applicazioni specifiche.
• Scopri come Guardrails-AI può rilevare e mitigare i contenuti dannosi sia nei prompt degli utenti che nelle risposte LLM, rispettando così gli standard di privacy e sicurezza degli utenti.
• Acquisisci esperienza pratica nella configurazione di Guardrails-AI per applicazioni AI installando validatori dal Guardrails Hub e personalizzandoli per adattarli ai casi d'uso specifici.

Questo articolo è stato pubblicato come parte del Blogathon sulla scienza dei dati.

Cos'è Guardrails-AI?

Guardrails-AI è un open source progetto che ci consente di creare applicazioni AI responsabili e affidabili con modelli linguistici di grandi dimensioni. Guardrails-AI applica i guardrail sia ai prompt utente di input che alle risposte generate dai modelli linguistici di grandi dimensioni. Supporta anche la generazione di output strutturati direttamente dai modelli linguistici di grandi dimensioni.

Guardrails-AI utilizza varie protezioni per convalidare i prompt dell'utente, che spesso contengono informazioni di identificazione personale, linguaggio tossico e password segrete. Queste convalide sono fondamentali per lavorare con modelli closed source, che possono comportare seri rischi per la sicurezza dei dati a causa della presenza di dati PII e API Secret. Guardrails controlla anche la presenza di Prompt Injection e Jailbreak, che gli hacker possono utilizzare per ottenere informazioni riservate da Large Language Models. Ciò è particolarmente importante quando si lavora con modelli closed source che non sono eseguiti localmente.

D’altro canto, i guardrail possono essere applicati anche alle risposte generate dai Large Language Models. A volte, Modelli linguistici di grandi dimensioni generare output che potrebbero contenere un linguaggio tossico, oppure il LLM potrebbe avere allucinazioni sulla risposta o potrebbe includere informazioni sulla concorrenza nella sua generazione. Tutti questi devono essere convalidati prima che la risposta possa essere inviata all'utente finale. Quindi i guardrail sono dotati di diversi componenti per fermarli.

I guardrail vengono forniti con Guardrails Hub. In questo Hub vengono sviluppati diversi componenti dalla comunità open source. Ciascun componente è un validatore diverso, che convalida il prompt di input o la risposta del modello linguistico di grandi dimensioni. Possiamo scaricare questi validatori e lavorare con loro nel nostro codice.

Iniziare con Guardrails-AI

In questa sezione inizieremo con l'intelligenza artificiale di Guardrails. Inizieremo scaricando l'IA di Guardrails. Per questo, lavoreremo con il seguente codice.

Passaggio 1: download di Guardrails

!pip install -q guardrails-ai

Il comando precedente scaricherà e installerà la libreria guardrails-ai per Python. Il guardrails-ai contiene un hub in cui sono presenti molti singoli componenti guardrail che possono essere applicati ai prompt Sser e alle risposte generate dal modello linguistico di grandi dimensioni. La maggior parte di questi componenti sono creati dalla comunità open source.

Per lavorare con questi componenti del Gaurdrails Hub, dobbiamo registrarci al Gaurdrails Hub con il nostro account GitHub. Puoi fare clic sul collegamento qui (https://hub.guardrailsai.com/) per iscriverti a Guardrails Hub. Dopo la registrazione, otteniamo un token che possiamo passare ai guardrail configurati per funzionare con questi componenti.

Passaggio 2: configurare i guardrail

Ora eseguiremo il comando seguente per configurare i nostri guardrail.

!guardrails configure

Prima di eseguire il comando precedente, possiamo andare a questo link https://hub.guardrailsai.com/tokens per ottenere il token API. Ora, quando eseguiamo questo comando, ci viene richiesto un token API e il token che abbiamo appena ricevuto lo passeremo qui. Dopo aver passato il token, otterremo il seguente output.

Vediamo che abbiamo effettuato l'accesso con successo. Ora possiamo scaricare diversi componenti dal Guardrails Hub.

Passaggio 3: importa il rilevatore di linguaggio tossico

Iniziamo importando il rilevatore di linguaggio tossico:

!guardrails hub install hub://guardrails/toxic_language

Quanto sopra scaricherà il componente Linguaggio tossico da Guardrails Hub. Proviamolo attraverso il codice seguente:

from guardrails.hub import ToxicLanguage
from guardrails import Guard

guard = Guard().use(
    ToxicLanguage, threshold=0.5, 
    validation_method="sentence", 
    on_fail="exception")

guard.validate("You are a great person. We work hard every day 
to finish our tasks")

• Qui, importiamo prima il validatore ToxicLanguage da gaurdrails.hub e la classe Gaurd dal modulo gaurdrails.
• Quindi istanziamo un oggetto di Gaurd() e chiamiamolo la funzione use().
• A questa funzione use() passiamo il Validator, cioè il ToxicLanguage, poi passiamo la soglia=0.5.
• Il validation_method è impostato su frase, questo indica che la tossicità del prompt dell'utente è misurata a livello di frase, infine abbiamo dato on_fail uguale a eccezione, il che significa che solleva un'eccezione quando la convalida fallisce.
• Infine, chiamiamo la funzione di validazione dell'oggetto guard() e le passiamo le frasi che vogliamo validare.
• Entrambe queste frasi non contengono alcun linguaggio tossico.

L'esecuzione del codice produrrà il seguente output sopra. Otteniamo un oggetto ValidationOutcome che contiene diversi campi. Vediamo che il campo validation_passed è impostato su True, il che significa che il nostro input ha superato la convalida del linguaggio tossico.

Fase 4: input tossici

Ora proviamo con alcuni input tossici:

try:
  guard.validate(
          "Please look carefully. You are a stupid idiot who can't do \
          anything right. You are a good person"
  )
except Exception as e:
  print(e)

Qui sopra abbiamo fornito un input tossico. Abbiamo racchiuso la funzione validate() all'interno del blocco try-eccetto perché questo genererà un'eccezione. Dall'esecuzione del codice e dall'osservazione dell'output, abbiamo visto che è stata generata un'eccezione e vediamo un errore di convalida non riuscita. È stato anche in grado di produrre la frase particolare in cui è presente la tossicità.

Una delle operazioni necessarie da eseguire prima di inviare un prompt utente a LLM è rilevare i dati PII presenti. Pertanto è necessario convalidare la richiesta dell'utente per qualsiasi informazione di identificazione personale prima di trasmetterla a LLM.

Passaggio 5: scarica il componente

Ora scarichiamo questo componente dal Gaurdrails Hub e testiamolo con il codice seguente:

!guardrails hub install hub://guardrails/detect_pii

from guardrails import Guard
from guardrails.hub import DetectPII

guard = Guard().use(
    DetectPII(
        pii_entities=("EMAIL_ADDRESS","PHONE_NUMBER")
    )
)

result = guard.validate("Please send these details to my email address")

if result.validation_passed:
  print("Prompt doesn't contain any PII")
else:
  print("Prompt contains PII Data")

result = guard.validate("Please send these details to my email address \
(email protected)")

if result.validation_passed:
  print("Prompt doesn't contain any PII")
else:
  print("Prompt contains PII Data")

• Per prima cosa scarichiamo DetectPII dall'hub guardrails.
• Importiamo DetectPII dall'hub guardrail.
• Allo stesso modo, definiamo un oggetto Gaurd(), quindi chiamiamo la funzione .use() e le passiamo DetectPII().
• A DetectPII, passiamo la variabile pii_entities, alla quale passiamo un elenco di entità PII che vogliamo rilevare nel prompt dell'utente. Qui passiamo l'indirizzo email e il numero di telefono come entità da rilevare.
• Infine, chiamiamo la funzione .validate() dell'oggetto guard() e le passiamo il prompt dell'utente. Il primo prompt è qualcosa che non contiene dati PII.
• Scriviamo una condizione if per verificare se la validazione è passata o meno.
• Allo stesso modo diamo un altro prompt che contiene dati PII come l'indirizzo email, e anche per questo controlliamo con una condizione if per verificarne la validazione.
• Nell'immagine di output possiamo vedere che, per il primo esempio, la convalida è stata superata poiché non sono presenti dati PII nel primo Prompt. Nel secondo output vediamo le informazioni PII, quindi vediamo l'output “Il prompt contiene dati PII”.

Quando si lavora con LLM per la generazione di codice, ci saranno casi in cui gli utenti potrebbero inserire le chiavi API o altre informazioni cruciali all'interno del codice. Questi devono essere rilevati prima che il testo venga passato ai modelli linguistici di grandi dimensioni a codice chiuso tramite Internet. Per questo, scaricheremo il seguente validatore e lavoreremo con esso nel caso.

Passaggio 6: download di Validator

!guardrails hub install hub://guardrails/secrets_present

• Per prima cosa scarichiamo SecretsPresent Validator dall'hub guardrails.
• Importiamo SecretsPresent dall'hub guardrail.
• Per lavorare con questo Validatore, creiamo un Guard Object chiamando la Guard Class chiamando la funzione .use() e dandogli il SecretsPresent Validator.
• Quindi, gli passiamo il prompt dell'utente, dove contiene il codice, indicandolo per il debug.
• Quindi chiamiamo la funzione .validate(), le passiamo la funzione e stampiamo la risposta.
• Facciamo di nuovo la stessa cosa, ma questa volta passiamo al prompt dell'utente, dove includiamo una chiave segreta API e la passiamo al validatore.

L'esecuzione di questo codice ha prodotto il seguente output. Possiamo vedere che nel primo caso validation_passed era impostato su True. Perché in questo prompt dell'utente non è presente alcuna chiave API o alcun segreto di questo tipo. Nel secondo prompt dell'utente, validation_passed è impostato su False. Questo perché esiste una chiave segreta, ovvero la chiave API meteo presente nel prompt dell'utente. Quindi vediamo un errore di convalida non riuscita.

Conclusione

Guardrails-AI è uno strumento essenziale per creare applicazioni IA responsabili e affidabili con modelli linguistici di grandi dimensioni (LLM). Fornisce una protezione completa contro contenuti dannosi, informazioni di identificazione personale (PII), linguaggio tossico e altri dati sensibili che potrebbero compromettere la sicurezza e la protezione degli utenti. Guardrails-AI offre una vasta gamma di validatori che possono essere personalizzati e adattati per soddisfare le esigenze di diverse applicazioni, garantendo l'integrità dei dati e la conformità agli standard etici. Sfruttando i componenti disponibili nel Guardrails Hub, gli sviluppatori possono migliorare le prestazioni e la sicurezza degli LLM, creando in definitiva un'esperienza utente più positiva e mitigando i rischi associati alla tecnologia AI.

Punti chiave

• Guardrails-AI è progettato per migliorare la sicurezza e l'affidabilità delle applicazioni IA convalidando le richieste di input e le risposte LLM.
• Rileva e mitiga in modo efficace linguaggio tossico, informazioni personali, chiavi segrete e altre informazioni sensibili nei prompt dell'utente.
• La libreria supporta la personalizzazione dei guardrail attraverso vari validatori, rendendola adattabile a diverse applicazioni.
• Utilizzando Guardrails-AI, gli sviluppatori possono mantenere sistemi di IA etici e conformi che proteggono le informazioni degli utenti e rispettano gli standard di sicurezza.
• Il Guardrails Hub offre una selezione diversificata di validatori, consentendo agli sviluppatori di creare robusti guardrail per i loro progetti di intelligenza artificiale.
• L'integrazione di Guardrails-AI può aiutare a prevenire i rischi per la sicurezza e a proteggere la privacy degli utenti negli LLM closed-source.

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell'autore.