Esplorare le nozioni di base di un framework multi-agente | Intelligenza-Artificiale

introduzione

Intraprendi un viaggio emozionante nel futuro dello sviluppo software con “Launching into Autogen: Exploring the Basics of a Multi-Agent Framework”. Sulla scia del ChatGPT di OpenAI, un regno specializzato noto come agenti LLM sta vivendo un’impennata senza precedenti, rivoluzionando lo sviluppo degli agenti AI. Dall’automazione delle attività banali all’affrontare le sfide nel processo decisionale dinamico, LLM gli agenti stanno spingendo i confini di ciò che una volta era ritenuto impossibile.

Mentre entriamo nell’era dell’informatica spaziale, immaginiamo un mondo in cui i computer si fondono perfettamente con la realtà e l’importanza degli agenti di intelligenza artificiale diventa fondamentale. Immagina di istruire gli agenti attraverso parole e gesti mentre eseguono compiti con capacità di ragionamento e di azione senza precedenti. Tuttavia, siamo agli albori della rivoluzione degli agenti IA e assistiamo alla nascita di nuove infrastrutture, strumenti e framework che consentono agli agenti di affrontare compiti sempre più complessi. Autogenoun framework all’avanguardia per la creazione di sistemi di chat multi-agente, è al centro della nostra esplorazione.

Unisciti a noi in questo articolo mentre sveliamo le complessità degli agenti IA nelle prime fasi della rivoluzione, approfondiamo le capacità di Autogen e scopriamo come dare vita a queste entità intelligenti.

obiettivi formativi

• Comprendi cosa sono gli agenti LLM
• Scopri cos’è Autogen ed esplora le basi della creazione di agenti con Autogen
• Crea agenti con API Autogen e OpenAI
• Esplora i casi d’uso reali degli agenti LLM

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

Cosa sono gli agenti LLM?

I modelli linguistici Vanilla sono ottimi nel fare molte cose, come la traduzione, la risposta alle domande, ecc. Tuttavia, la loro conoscenza e capacità sono limitate. È come un muratore senza i suoi attrezzi mentre costruisce una casa. Tuttavia, è stato osservato che gli LLM possono ragionare e agire avendo a disposizione gli strumenti necessari. La maggior parte dei LLM ha una conoscenza limitata del mondo, ma possiamo aumentarla con informazioni provenienti da fonti personalizzate tramite prompt.

Possiamo raggiungere questo obiettivo tramite due metodi. Recupero Augmented Generation e agenti LLM. In un RAG, forniamo ai modelli informazioni tramite pipeline hardcoded personalizzate. Ma con gli agenti, il LLM, in base al suo ragionamento, utilizzerà uno strumento a sua disposizione. Ad esempio, GPT-4 con uno strumento Serper navigherà in Internet e risponderà di conseguenza, oppure potrà recuperare e analizzare la performance delle azioni quando ha accesso allo strumento Yahoo Finance. Quindi, questa combinazione di LLM, strumenti e un quadro per ragionare e agire è ciò che è un agente AI.

C’è stato un rapido aumento delle piattaforme e degli strumenti per la creazione di agenti LLM. Autogen è uno di questi strumenti. Quindi, capiamo cos’è Autogen e come creare agenti LLM con esso.

Cos’è l’autogen?

Autogen è uno strumento open source di Microsoft per creare robuste applicazioni multi-agente. Progettato da zero, tenendo presente la comunicazione con più agenti. Ci consente di creare applicazioni LLM in cui più agenti conversano tra loro per trovare soluzioni ai problemi forniti. Gli agenti sono altamente personalizzabili, il che significa che possiamo guidarli nell’esecuzione di compiti specifici. Si integra bene anche con l’ecosistema degli strumenti Langchain, il che significa che sfruttiamo gli strumenti Langchain esistenti per potenziare i nostri agenti.

Per eseguire le attività, Autogen fornisce diversi tipi di agenti, come ad esempio:

• Agente assistente: questo agente è responsabile dell’esecuzione di attività quali codifica, revisione, ecc.
• Agente proxy utente: come suggerisce il nome, questi agenti agiscono per conto degli utenti finali. Questo è responsabile di coinvolgere gli esseri umani nel circuito degli agenti per guidare le conversazioni.
• Agente insegnabile: questo agente è configurato per essere altamente insegnabile. Possiamo fornire all’agente informazioni esplicite che sono assenti nei LLM.

Abbiamo solo bisogno di un Assistant Agent e di User Proxy Agent per la maggior parte dei nostri casi d’uso. Vediamo quindi come possiamo configurare gli agenti con Autogen. Esistono altri agenti come RetrieveAssistantAgent e RetrieveUserProxy configurati per RAG.

Di seguito è riportato un diagramma di un tipico flusso di lavoro multi-agente.

Crea agenti con Autogen

Ora, tuffiamoci nella configurazione degli agenti Autogen. Ma prima, imposta l’ambiente. Se il caso d’uso richiede l’esecuzione di codice, gli agenti lo faranno nell’ambiente corrente e, secondo la documentazione ufficiale, è meglio farlo all’interno di un contenitore. Per iniziare rapidamente, puoi utilizzare Spazi di codice GitHub. Assicurati di installare “pyautogen”.

A partire da ora, Autogen supporta solo i modelli OpenAI. Per utilizzare in modo efficace gli agenti, dobbiamo configurare i nostri modelli. Possiamo configurare più modelli OpenAI e utilizzare quelli di cui abbiamo bisogno. Esistono diversi modi per configurare i modelli, ma definiremo un file JSON.

File JSON

#OAI_CONFIG_LIST
(
    {
        "model": "gpt-4",
        "api_key": "<your OpenAI API key here>"
    },
    {
        "model": "gpt-4",
        "api_key": "<your Azure OpenAI API key here>",
        "base_url": "<your Azure OpenAI API base here>",
        "api_type": "azure",
        "api_version": "2023-07-01-preview"
    },
    {
        "model": "gpt-3.5-turbo",
        "api_key":  "<your OpenAI API key here>"
    }
)

Ora definisci un elenco di configurazione per i modelli.

import autogen

config_list = autogen.config_list_from_json(
    "OAI_CONFIG_LIST",
    filter_dict={
        "model": {
            "gpt-3.5-turbo"
        }
    }
)

Questo metodo cercherà prima OAI_CONFIG_LIST nella variabile di ambiente. In caso di esito negativo, cercherà il file Json OAI_CONFIG_LIST nella directory corrente. filter_dict serve per filtrare i modelli in base ad alcuni parametri, qui è impostato su model.

Configurazione per LLM

Ora definiamo la configurazione per LLM. In questo esempio, utilizzeremo uno strumento di funzione Jupyter Notebook per eseguire script Python per eseguire una semplice attività di tracciamento di grafici.

llm_config = {
    "functions": (
        {
            "name": "python",
            "description": "run cell in ipython and return the execution result.",
            "parameters": {
                "type": "object",
                "properties": {
                    "cell": {
                        "type": "string",
                        "description": "Valid Python cell to execute.",
                    }
                },
                "required": ("cell"),
            },
        },
    ),
    "config_list": config_list,
    "timeout": 120,
}

Definiremo la funzione per eseguire script Python nel notebook IPython.

from IPython import get_ipython

def exec_python(cell):
    ipython = get_ipython()
    result = ipython.run_cell(cell)
    log = str(result.result)
    if result.error_before_exec is not None:
        log += f"\n{result.error_before_exec}"
    if result.error_in_exec is not None:
        log += f"\n{result.error_in_exec}"
    return log

Utilizzo dell’Assistente Agente e dell’Agente proxy utente

Abbiamo quasi finito di costruire il nostro sistema multi-agente. Gli unici pezzi mancanti sono gli agenti di cui abbiamo parlato prima. Qui avremo bisogno di un agente assistente e di un agente proxy utente. Ecco come possiamo definire questi agenti.

chatbot = autogen.AssistantAgent(
    name="chatbot",
    system_message="For coding tasks, only use the functions you have been provided with. \
                    Reply TERMINATE when the task is done.",
    llm_config=llm_config,
)

# create a UserProxyAgent instance named "user_proxy"
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    is_termination_msg=lambda x: x.get("content", "") and x.get("content", "").\
                       rstrip().endswith("TERMINATE"),
    human_input_mode="NEVER",
    max_consecutive_auto_reply=10,
    code_execution_config={"work_dir": "coding"},
)

UserProxyAgent ha un parametro human_input_mode, che inserisce un essere umano reale nel ciclo dell’agente in base al suo valore. Se impostato su SEMPRE, richiede input dopo ogni risposta; per TERMINATE, richiede solo alla fine dell’esecuzione e per NEVER, non richiede input dall’utente.

Registrare le funzioni con l’agente proxy dell’utente.

user_proxy.register_function(
    function_map={
        "python": exec_python,
    }
)

Ora esegui gli agenti.

# start the conversation
user_proxy.initiate_chat(
    chatbot,
    message="plot a curve for sin wave",
)

L’esecuzione dell’agente mostrerà i registri sul tuo sistema su ciò che sta accadendo.

Registro di esecuzione

Nel registro di esecuzione riportato sopra, puoi vedere che l’agente “chatbot” dell’Assistente genera il codice, il codice viene quindi eseguito e vengono rilevati potenziali errori. Il proxy dell’utente invia quindi l’errore all’assistente e, ancora una volta, esegue il codice della soluzione, in questo caso installando Matplotlib e, infine, esegue il codice finale e restituisce l’output.

Possiamo anche estenderlo aggiungendo un altro agente assistente alla conversazione, come un critico o un revisore. Ciò contribuirà a rendere l’output più personalizzato. Ecco come puoi farlo.

critic = autogen.AssistantAgent(
    name="Critic",
    system_message="""Critic. You are a helpful assistant highly \
    skilled in evaluating the quality of a \
    given visualization code by providing a score from 1 (bad) - 10 (good)\
     while providing clear rationale. \
    YOU MUST CONSIDER VISUALIZATION BEST PRACTICES for each evaluation.\
     Specifically, you can carefully \
    evaluate the code across the following dimensions
- bugs (bugs):  are there bugs, logic errors, syntax error or typos?\
 Are there any reasons why the code may \
fail to compile? How should it be fixed? If ANY bug exists,\
 the bug score MUST be less than 5.
- Data transformation (transformation): Is the data transformed\
 appropriately for the visualization type? E.g., \
is the dataset appropriated filtered, aggregated, or grouped\
 if needed? If a date field is used, is the date field\
 first converted to a date object etc?

YOU MUST PROVIDE A SCORE for each of the above dimensions.
{bugs: 0, transformation: 0, compliance: 0, type: 0, encoding: 0, aesthetics: 0}
Do not suggest code. 
Finally, based on the critique above, suggest a concrete list of actions that the coder \
should take to improve the code.
""",
    llm_config=llm_config,
)
groupchat = autogen.GroupChat(agents=(user_proxy, coder, critic), messages=(), max_round=12)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=llm_config)

user_proxy.initiate_chat(manager, message="plot a curve for inverse sin wave in \
                                           the -pi/2 to pi/2 region")

L’esecuzione precedente aggiungerà un critico per suggerire miglioramenti alla trama e l’Assistente proverà a generare codici conformi. Quando abbiamo bisogno di più di due agenti, utilizziamo un chat manager.

In questo esempio, abbiamo utilizzato GPT 3.5. Per attività di codifica e ragionamento più complicate, è preferibile GPT-4. Possiamo fare di più con meno agenti con modelli capaci come GPT-4. Inoltre, il GPT-3.5 a volte tende a rimanere bloccato in un loop. Quindi, GPT-4 è una scelta molto migliore per applicazioni severe. Inoltre, un nuovo tipo di sperimentazione EcoAssistente è in fase di sviluppo (codice). Questo agente risolve il costo più elevato derivante dall’utilizzo di modelli capaci come GPT-4 tramite una gerarchia di modelli. L’idea è quella di avviare un dialogo con modelli economicamente vantaggiosi e, se non si raggiunge l’obiettivo finale, utilizzare quelli capaci ma costosi. Un vantaggio significativo di questo approccio è l’effetto sinergico. Poiché gli agenti condividono un unico database, i codici dei modelli più grandi possono essere recuperati successivamente dai modelli più piccoli. Migliorando così l’efficienza e riducendo i costi.

Casi d’uso nel mondo reale

La portata degli agenti IA nel mondo reale è immensa. Molte aziende hanno iniziato a implementare agenti nei sistemi esistenti. Ecco quindi alcuni casi d’uso degli agenti AI che possono essere molto utili.

• Agenti personali: Uno degli usi più cruciali di un agente AI sarebbe un assistente personale simile a Jarvis su dispositivi elettronici che esegue compiti basati su comandi di testo, vocali o gestuali.
• Istruttori di intelligenza artificiale: I modelli di chat possono realizzare solo un certo numero di cose. Ma un agente AI dotato di strumenti può fare molto di più. Gli istruttori di intelligenza artificiale in vari campi, come l’istruzione, il diritto e la terapia, possono essere utili per molti utenti.
• Esperienza utente del software: L’esperienza utente del software può essere migliorata in molteplici modi implementando agenti efficienti. Invece di navigare manualmente e fare clic sui pulsanti per svolgere le attività, gli agenti AI le eseguiranno automaticamente in base ai comandi vocali, come ordinare cibo, taxi, fare la spesa, ecc.
• Calcolo spaziale: Gli agenti IA saranno i messaggeri dell’informatica spaziale, dove i computer tradizionali si fonderanno perfettamente con il mondo reale. Gli agenti possono elaborare i dati nell’ambiente circostante per estrarre informazioni utili e fare cose complicate.

Conclusione

Gli agenti IA stanno diventando sempre più popolari. Nei tempi a venire, non c’è dubbio che verranno integrati nella maggior parte dei sistemi software, in un modo o nell’altro. Questa è ancora la prima fase di sviluppo dell’agente, simile a Internet negli anni ’90. In pochissimo tempo ci saranno agenti molto migliori che risolveranno nuovi problemi. E le librerie e gli strumenti come Langchain non potranno che evolversi.

Punti chiave

• Autogen è un framework applicativo multi-agente open source di Microsoft.
• Autogen ci consente di creare senza problemi un sistema multi-agente per risolvere compiti complicati.
• Fornisce agenti assistenti e agenti proxy utente per svolgere attività come la generazione di codice, la generazione di testo, ecc.
• Sebbene sia corretto utilizzare GPT-3.5 per cose basilari come la generazione di testo, attività di codifica più complicate richiedono modelli capaci come GPT-4.

Domande frequenti

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

Imparentato