Come utilizzare AutoGen senza dipendere da OpenAI o LM Studio?

Come sfruttare AutoGen senza essere dipendenti da OpenAI o LM Studio?

Introduzione

Sei pronto/a a creare il tuo team di intelligenza artificiale senza dipendere da OpenAI e LM Studio? Non sarà più necessario svuotare le tasche o scaricare app. Dalla configurazione di llama-cpp-python all’esplorazione del potere dei LLM locali con l’aiuto del framework autogen. Preparati a sbloccare tutto il potenziale di Autogen senza dipendere dall’API di OpenAI.

Obiettivi di apprendimento

Prima di entrare nei dettagli, cerchiamo di delineare gli obiettivi di apprendimento chiave di questo articolo:

Imparare come valutare e confrontare diverse librerie e strumenti di intelligenza artificiale.
Esplorare come llama-cpp-python funge da sostituto per l’API di OpenAI.
Applicare le conoscenze acquisite in due casi d’uso reali: Creazione di un team di algoritmi mentori e Automazione della generazione di grafici finanziari.
Esplorare l’esperienza utente migliorata di AutoGen con risultati di esecuzione del codice istantanei tramite IPython integrato.

Questo articolo è stato pubblicato come parte di Data Science Blogathon.

Conosci i tuoi strumenti: Llama-cpp-python, AutoGen e LLM locali

Ma cosa c’è di così speciale in questo toolkit tecnico, ti chiederai? Llama-cpp-python è la tua porta d’accesso per eseguire LLM localmente, inclusi nomi importanti come LLaMA. È come avere superstar dell’intelligenza artificiale direttamente sul tuo computer e, con il supporto per diversi backend BLAS, la velocità è straordinaria!

AutoGen

AutoGen è un framework di conversazione multi-agente unificato che agisce come un’astrazione di alto livello per l’uso di modelli fondamentali. Combinando agenti capaci, personalizzabili e conversabili che integrano LLM, strumenti e partecipanti umani tramite chat automatizzata. Consente agli agenti di comunicare e lavorare autonomamente insieme, semplificando efficacemente compiti complessi e automatizzando i flussi di lavoro.

Se sei desideroso/a di approfondire le capacità di AutoGen ed esplorare come facilita la creazione strategica di un team di intelligenza artificiale, non cercare oltre il nostro blog dedicato: “La creazione strategica di un team di intelligenza artificiale resa facile con AutoGen.” Questa risorsa completa fornisce informazioni, casi d’uso e una visione più approfondita su come AutoGen può trasformare il tuo approccio allo sviluppo di intelligenza artificiale.

Librerie/Strumenti

Alcune librerie/strumenti offrono un server web che mira a sostituire l’API di OpenAI.

Sono disponibili altre opzioni oltre a quelle sopra elencate, ma la scelta migliore dipende dalle tue preferenze e necessità.

Llama-cpp-python

Llama-cpp-python è un binding Python per la libreria llama.cpp. Fornisce accesso a basso livello all’API C tramite l’interfaccia ctypes, API Python di alto livello per il completamento del testo, API simile a OpenAI e compatibilità con LangChain. Supporta diversi backend BLAS per un elaborazione più veloce e supporta anche l’accelerazione hardware.

Llama-cpp-python offre un server web che mira a fungere da sostituto per l’API di OpenAI. Ciò ti consente di utilizzare modelli compatibili con llama.cpp con qualsiasi client compatibile con OpenAI (librerie di linguaggio, servizi, ecc.)

Sviluppo

Per questo progetto, useremo questi strumenti e librerie:

Google Colab
AutoGen
llama-cpp-python
LLM locali
- codellama-7b-instruct.Q5_K_M.gguf

Configurazione dell’ambiente di sviluppo

Creare un ambiente virtuale

Gli ambienti virtuali sono una buona pratica per isolare le dipendenze specifiche del progetto ed evitare conflitti con i pacchetti di sistema. Ecco come configurare un ambiente Python:

Venv

python -m venv nome_ambiente

Attivare l’ambiente virtuale:

\nome_ambiente\Scripts\activate

su macOS e Linux:

source nome_ambiente/bin/activate

Il comando seguente disattiverà l’ambiente venv corrente:

deactivate

Dipendenze richieste

1. Clonazione del repository

!git clone --recurse-submodules https://github.com/abetlen/llama-cpp-python.git

–recurse-submodules: Un flag che indica che i sottomoduli associati al repository devono essere clonati. I sottomoduli sono repository Git separati incorporati nel repository principale.
https://github.com/abetlen/llama-cpp-python.git: l’URL del repository Git da clonare.

2. Aggiornamento di pip

pip install --upgrade pip

3. Cambia directory in ‘llama-cpp-python’

%cd llama-cpp-python

4. Modifica del limite predefinito di generazione di token nel repository llama-cpp-python

Clone il repository “llama-cpp-python” sulla tua macchina locale.
Naviga nella cartella “llama-cpp” all’interno del repository clonato.
All’interno della cartella “server”, individua il file chiamato “app.py”.
Apri “app.py” e scorri fino a riga 490 o trova il campo “max_tokens_field”.
Nella sezione “max_tokens_field”, trova la riga che assomiglia a questa:

max_tokens_field = Field(    default=16, ge=1, description="Il numero massimo di token da generare.")

6. Cambia il valore predefinito da 16 al valore desiderato (ad esempio, 4096). Ad esempio:

max_tokens_field = Field(    default=4096, ge=1, description="Il numero massimo di token da generare.")

7. Salva le modifiche al file “app.py”.

Seguendo questi passaggi, modificherai il valore predefinito per “max_tokens_field” nel file “app.py” a 4096 o al valore specificato.

5. Installazione delle dipendenze

In Google Colab, di solito si lavora in un ambiente basato su cloud con accesso alle GPU NVIDIA. Pertanto, per prestazioni ottimali, considera l’utilizzo di una libreria BLAS compatibile con l’accelerazione GPU. Nel caso di Google Colab, cuBLAS è una scelta adatta, in quanto ottimizzata per le GPU NVIDIA e le istanze di Colab spesso supportano le GPU NVIDIA.

!CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip install llama-cpp-python[server]

CMAKE_ARGS=”-DLLAMA_CUBLAS=on”: Imposta l’argomento di configurazione di CMake (Cross-Platform Make) per abilitare CUBLAS, una libreria per operazioni di algebra lineare accelerata da GPU.
FORCE_CMAKE=1: Forza la configurazione di CMake per garantire una corretta installazione.
pip install llama-cpp-python[server]: Installa il pacchetto llama-cpp-python insieme alle dipendenze aggiuntive specificate per la funzionalità del server.

6. Installazione di un pacchetto modificabile

cd llama-cpp-python!pip install -e .!pip install -e .[server]

cd llama-cpp-python: Cambia la directory di lavoro corrente in llama-cpp-python.
pip install -e .: Installa la directory corrente come pacchetto modificabile, consentendo modifiche dinamiche al codice senza reinstallazione.
pip install -e .[server]: Simile al comando precedente, ma include dipendenze aggiuntive specificate negli extra [server].

7. Cambia la directory in ‘llama_cpp/’

cd llama_cpp/Introduction

cd llama_cpp/: Cambia la directory di lavoro corrente alla sotto-cartella llama_cpp all’interno del progetto.

8. Scarica un modello LLM

!wget https://huggingface.co/TheBloke/CodeLlama-7B-Instruct-GGUF/resolve/main/codellama-7b-instruct.Q5_K_M.gguf

wget: Un’utilità da linea di comando per scaricare file dal web.

9. Esegui il server in background

Dimensione del batch (n_batch): La dimensione del batch è un iperparametro che determina il numero di campioni di addestramento da elaborare prima di aggiornare i parametri interni del modello.
Layer GPU (n_gpu_layers): Il numero di layer da caricare sulla GPU per i calcoli è di solito impostato in base alla capacità della VRAM. Puoi aumentare gradualmente il numero fino a trovare un punto di equilibrio. Ciò può aiutare a ottimizzare le prestazioni del modello sfruttando la potenza di calcolo della GPU.
Dimensione del contesto (n_ctx): La dimensione del contesto rappresenta il numero massimo di token che può avere la sequenza di input. La maggior parte dei modelli viene addestrata con una dimensione del contesto di 2048. Se hai bisogno di elaborare un prompt più lungo, puoi cambiarlo. Tuttavia, è sconsigliato modificare il limite del contesto di un modello poiché non è stato addestrato per gestire set di dati più grandi del suo limite di contesto suggerito.

!python -m server --model codellama-7b-instruct.Q5_K_M.gguf --host 127.0.0.1 --n_ctx 2048 --n_batch 128 --n_gpu_layers 35 > server.log 2>&1 &

python -m server: Esegue il modulo Python chiamato server.
–model codellama-7b-instruct.Q5_K_M.gguf: Specifica il percorso del file del modello scaricato.
–host 127.0.0.1: Imposta l’indirizzo IP dell’host su 127.0.0.1 (localhost).
–n_ctx 2048: Configura la dimensione del contesto su 2048.
–n_batch 128: Imposta la dimensione del batch su 128.
–n_gpu_layers 35: Specifica il numero di layer GPU come 35.
> server.log 2>&1 &: Redirige l’output standard e gli errori su un file chiamato server.log ed esegue il processo in background.

Questi comandi impostano collettivamente il pacchetto ‘llama-cpp-python’, lo configurano con opzioni specifiche, installano dipendenze aggiuntive per la funzionalità del server e avviano un server con un modello pre-addestrato. Per ulteriori informazioni, consulta la documentazione ufficiale.

Codifica

Caso d’uso 1: Costruisci il tuo team di Mentori di Algoritmi

Questo frammento di codice mostra la creazione di agenti utilizzando la libreria ‘autogen’ per uno scenario in cui uno studente cerca assistenza da un Mentore di Codifica ed un Esperto di Algoritmi per l’implementazione di algoritmi di ordinamento in Python.

Ecco una panoramica del codice:

1. Importa il modulo autogen:

import autogen

Questo importa le funzionalità necessarie dalla libreria autogen.

2. Definisci le configurazioni degli agenti:

config_list = [    {        "model": "codellama-7b-instruct.Q5_K_M.gguf",        "api_base": "http://127.0.0.1:8000/v1",        "api_type": "open_ai",        "api_key": "NULL",  # Segnaposto    }]

Questo configura un elenco di configurazioni specificando dettagli come il modello da utilizzare, l’URL di base dell’API, il tipo di API e la chiave API (che in questo caso è un segnaposto).

3. Crea agenti con ruoli e configurazioni diverse:

coding_mentor = autogen.AssistantAgent(    name="CodingMentor",    llm_config={        "seed": 42,        "config_list": config_list,        "temperature": 0.7,        "request_timeout": 1200,    },    system_message="Qui Coding Mentor! Posso guidarti nell'implementazione degli algoritmi di ordinamento in Python.",)

Questo crea un agente chiamato CodingMentor con una configurazione specifica per il modello di linguaggio (llm_config), includendo dettagli come il seed, la lista di configurazione del modello, la temperatura e il timeout della richiesta.

algorithm_expert = autogen.AssistantAgent(    name="AlgorithmExpert",    llm_config={        "seed": 42,        "config_list": config_list,        "temperature": 0.7,        "request_timeout": 1200,    },    system_message="Experto in algoritmi. Mi specializzo negli algoritmi. Lavoriamo insieme all'implementazione di un algoritmo di ordinamento.",)

In modo simile, questo crea un altro agente chiamato AlgorithmExpert con configurazioni simili.

student = autogen.UserProxyAgent(    name="Student",    human_input_mode="SEMPRE",    code_execution_config={"work_dir":"node"},)

Questo crea un agente di proxy utente chiamato Student con la modalità di input umano impostata su “SEMPRE”, indicando che l’agente si aspetterà sempre un input umano.

4. Avviare una chat tra lo studente e il Coding Mentor:

student.initiate_chat(    coding_mentor,    message="""Sto imparando gli algoritmi di ordinamento in Python e vorrei un po' di guida sull'implementazione. Puoi aiutarmi?""",)

Questo avvia una chat tra gli agenti Student e CodingMentor con un messaggio iniziale dello studente.

Risultato

CodingMentor (al chat_manager):

Ci sono molti diversi algoritmi di ordinamento disponibili in Python, ma posso darti una panoramica di alcuni dei più popolari:

Bubble Sort: Questo è l’algoritmo di ordinamento più semplice, e funziona iterando attraverso l’array e confrontando gli elementi adiacenti. Se due elementi sono nell’ordine sbagliato, scambiano posizione fino a quando non sono più necessari ulteriori scambi. L’algoritmo ripete questo processo fino a quando l’intero array è ordinato.
Insertion Sort: Questo algoritmo funziona iniziando dall’inizio dell’array e confrontando ogni elemento con il suo predecessore. Se l’elemento corrente è più piccolo del predecessore, si sposta di una posizione indietro nell’array fino a quando trova un elemento più grande. Quindi, inserisce l’elemento corrente nella posizione corretta.
Selection Sort: Questo algoritmo funziona selezionando l’elemento più piccolo dalla parte non ordinata dell’array e posizionandolo all’inizio della parte ordinata. Ripete poi questo processo per gli elementi rimanenti nella parte non ordinata fino a quando l’array è ordinato.
Merge Sort: Questo algoritmo funziona dividendo l’array in due metà, ordinando ciascuna metà in modo ricorsivo e unendo le due metà ordinate insieme. È un algoritmo più efficiente rispetto a Bubble Sort o Insertion Sort perché fa al massimo un passaggio sull’array.
Quick Sort: Questo algoritmo seleziona un elemento pivot dalla parte non ordinata dell’array, suddivide l’array intorno a quel pivot e poi ordina ricorsivamente le due parti. È un algoritmo più efficiente rispetto a Bubble Sort o Selection Sort perché ha una complessità temporale media di O(n log n).

Bubble Sort

Bubble sort è un semplice algoritmo di ordinamento che iterativamente scorre l’array e confronta gli elementi adiacenti. Se due elementi sono nell’ordine sbagliato, scambiano posizione fino a quando non sono più necessari ulteriori scambi. L’algoritmo ripete questo processo fino a quando l’intero array è ordinato.

Ecco un esempio di come implementare bubble sort in Python:

def bubble_sort(arr):n = len(arr)for i in range(n-1):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]return arr

Insertion Sort

Insertion sort è un semplice algoritmo di ordinamento che inizia dall’inizio dell’array e confronta ogni elemento con il suo predecessore. Se l’elemento corrente è più piccolo del predecessore, si sposta di una posizione indietro nell’array fino a quando trova un elemento più grande. Quindi, inserisce l’elemento corrente nella posizione corretta.

Ecco un esempio di come implementare l’ordinamento per inserimento in Python:

def insertion_sort(arr):n = len(arr)for i in range(1, n):key = arr[i]j = i-1while j >= 0 and arr[j] > key:arr[j+1] = arr[j]j -= 1arr[j+1] = keyreturn arr

Ordinamento per selezione

L’ordinamento per selezione è un semplice algoritmo di ordinamento che funziona selezionando l’elemento più piccolo dalla parte non ordinata dell’array e posizionandolo all’inizio della parte ordinata. Ripete poi questo processo per gli elementi rimanenti nella parte non ordinata fino a quando l’array non è ordinato.

Ecco un esempio di come implementare l’ordinamento per selezione in Python:

def selection_sort(arr):n = len(arr)for i in range(n-1):min_idx = ifor j in range(i+1, n):if arr[j] < arr[min_idx]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]return arr

Merge Sort

Il merge sort è un algoritmo di ordinamento più efficiente che funziona dividendol’array in due metà, ordinando ciascuna metà in modo ricorsivo e poi unendo le due metà ordinate. Ha una complessità media del tempo di O(n log n).

Ecco un esempio di come implementare il merge sort in Python:

def merge_sort(arr):if len(arr) <= 1:return arrmid = len(arr) // 2left = merge_sort(arr[:mid])right = merge_sort(arr[mid:])return merge(left, right)def merge(left, right):result = []while len(left) > 0 and len(right) > 0:if left[0] <= right[0]:result.append(left.pop(0))else:result.append(right.pop(0))if len(left) > 0:result += leftif len(right) > 0:result += rightreturn result

Quick Sort

Il quick sort è un algoritmo di ordinamento più efficiente che seleziona un elemento pivot dalla parte non ordinata dell’array, suddivide l’array intorno a quel pivot e quindi ordina in modo ricorsivo le due parti. Ha una complessità media del tempo di O(n log n).

Ecco un esempio di come implementare il quick sort in Python:

def quick_sort(arr):if len(arr) <= 1:return arrpivot = arr[0]less = [x for x in arr[1:] if x <= pivot]greater = [x for x in arr[1:] if x > pivot]return quick_sort(less) + [pivot] + quick_sort(greater)

Spero che questo sia di aiuto! Fammi sapere se hai domande o se hai bisogno di ulteriori chiarimenti su questi algoritmi.

Fornisci un feedback a chat_manager. Premi Invio per saltare e utilizzare la risposta automatica, o digita ‘exit’ per terminare la conversazione: Hai dei casi d’uso in tempo reale

Studente (a chat_manager):

Hai dei casi d’uso in tempo reale

CodingMentor (a chat_manager):

Casi d’uso reali per gli algoritmi di ordinamento

Certo, ecco alcuni casi d’uso reali per ciascun algoritmo di ordinamento

Bubble Sort

Il bubble sort viene spesso utilizzato come semplice esempio per spiegare il concetto di base di un algoritmo di ordinamento. È facile da capire e implementare, ma inefficiente per grandi set di dati. Un caso d’uso reale per il bubble sort si trova in un sistema di gestione dei progetti scolastici in cui è necessario ordinare i progetti in base alle date di scadenza o ai livelli di priorità.

Insertion Sort

Insertion sort è un semplice algoritmo di ordinamento che spesso viene utilizzato come punto di partenza per algoritmi più avanzati come quicksort e mergesort. Ha una complessità temporale di O(n^2), il che lo rende meno efficiente di altri algoritmi di ordinamento per grandi set di dati. Un caso d’uso reale per l’ordinamento per inserimento si trova in una piattaforma di social media in cui è necessario ordinare gli utenti in base al numero di follower o al livello di interazione.

Selection Sort

Selection sort è un altro algoritmo di ordinamento semplice che è facile da capire e implementare, ma non è molto efficiente per grandi set di dati. Ha una complessità temporale di O(n^2), il che lo rende meno efficiente di altri algoritmi di ordinamento. Un caso d’uso reale per l’ordinamento per selezione si trova in un sistema di gestione della biblioteca in cui è necessario ordinare i libri in base ai titoli o agli autori.

Merge Sort

Il merge sort è un algoritmo di ordinamento più efficiente con una complessità temporale media di O(n log n). Viene comunemente utilizzato in molte applicazioni reali, come l’ordinamento di grandi set di dati, la ricerca di dati specifici e l’esecuzione di altre operazioni che richiedono un ordinamento efficiente. Un esempio di utilizzo reale di merge sort è in un motore di ricerca in cui è necessario ordinare le pagine web in base alla loro rilevanza o popolarità.

Quick Sort

Il quick sort è un altro algoritmo di ordinamento efficiente con una complessità temporale media di O(n log n). Viene comunemente utilizzato in molte applicazioni reali, come l’ordinamento di grandi set di dati, la ricerca di dati specifici e l’esecuzione di altre operazioni che richiedono un ordinamento efficiente. Un esempio di utilizzo reale di quick sort è in una piattaforma di social media in cui è necessario ordinare gli utenti in base al numero di follower o ai livelli di coinvolgimento.

In generale, la scelta dell’algoritmo di ordinamento dipende dalle dimensioni del set di dati, dal tipo di dati da ordinare e dai requisiti specifici dell’applicazione.

AlgorithmExpert (a chat_manager)

Grazie per aver fornito dei casi d’uso reali per ciascun algoritmo di ordinamento. Ciò aiuta a illustrare le diverse applicazioni e scenari in cui ciascun algoritmo può essere utilizzato.

Osservazioni aggiuntive su ciascun algoritmo

Ecco alcune osservazioni aggiuntive su ciascuno di questi algoritmi:

Bubble Sort: Uno svantaggio potenziale del bubble sort è che non è efficiente come altri algoritmi di ordinamento, come quicksort o mergesort. Ciò significa che potrebbe richiedere più tempo per completare per set di dati più grandi. Tuttavia, il bubble sort è comunque un algoritmo prezioso da capire e imparare nel contesto delle scienze informatiche e della programmazione. È un esempio semplice che aiuta gli sviluppatori a comprendere i concetti di base degli algoritmi di ordinamento.
Insertion Sort: Uno svantaggio potenziale dell’insertion sort è che ha una complessità temporale di O(n^2), il che significa che può essere meno efficiente di altri algoritmi di ordinamento per grandi set di dati. Tuttavia, l’insertion sort è comunque utile perché è un blocco fondamentale per algoritmi di ordinamento più avanzati come quicksort e mergesort.
Selection Sort: Uno svantaggio potenziale del selection sort è la sua complessità temporale di O(n^2), il che significa che può essere meno efficiente di altri algoritmi di ordinamento per grandi set di dati. Tuttavia, il selection sort è comunque un algoritmo prezioso da imparare perché è un blocco fondamentale per algoritmi di ordinamento più avanzati come quicksort e mergesort.
Merge Sort: Uno svantaggio potenziale del merge sort è che ha una complessità temporale media di O(n log n), il che significa che è generalmente più efficiente di altri algoritmi di ordinamento. Tuttavia, il merge sort può essere meno efficiente per grandi set di dati e potrebbe non essere la scelta migliore per tutti gli scenari.

Fornisci un feedback al chat_manager. Premi Invio per saltare e utilizzare una risposta automatica, o digita ‘exit’ per terminare la conversazione: exit.

Caso d’uso 2: Generazione automatizzata di grafici dei prezzi delle azioni finanziarie con AutoGen

Questo caso d’uso di AutoGen mostra l’automazione della generazione di un grafico dei prezzi delle azioni per determinate aziende Amazon (AMZN), Apple (AAPL) e Intel Corporation (INTC) Year-to-Date (YTD). L’agente assistente utilizza i pacchetti yfinance, matplotlib e pandas per ottenere i prezzi delle azioni e creare un grafico visivamente attraente. L’agente proxy utente avvia la conversazione con una chiara descrizione del compito e l’assistente risponde generando il codice Python per completare il compito richiesto. Il grafico risultante viene salvato come “stock_price_ytd.png”. Questo caso d’uso mostra l’integrazione senza soluzione di continuità di AutoGen con librerie esterne per il recupero dati, la visualizzazione e l’esecuzione di codice in uno scenario reale.

Codifica:

  from autogen import AssistantAgent, UserProxyAgent,oaiconfig_list = [    {        "model": "codellama-7b-instruct.Q5_K_M.gguf",        "api_base": "http://127.0.0.1:8000/v1",        "api_type": "open_ai",        "api_key": "NULL",    }]llm_config = {"config_list": config_list, "seed": 42, "request_timeout": 2028,}# Crea l'agente assistenteassistant = AssistantAgent(    name="assistant",    llm_config=llm_config,    system_message="""Ingegnere. Segui un piano approvato.     Scrivi il codice python/shell per risolvere i compiti.     Incapsula il codice in un blocco di codice che specifica il tipo di script.     L'utente non può modificare il tuo codice. Quindi non suggerire codice incompleto     che richiede a altri di modificarlo. Non utilizzare un blocco di codice     se non è destinato ad essere eseguito dall'esecutore.    Non includere più blocchi di codice in una sola risposta. Non chiedere     ad altri di copiare e incollare il risultato. Controlla il risultato     di esecuzione restituito dall'esecutore. Se il risultato indica che     c'è un errore, correggi l'errore e stampa di nuovo il codice. Suggerisci    il codice completo anziché codice parziale o modifiche al codice. Se    l'errore non può essere risolto o se il compito non viene risolto nemmeno    dopo che il codice viene eseguito con successo, analizza il     problema, rivedi le tue assunzioni, raccogli ulteriori informazioni    necessarie e pensa a un approccio diverso da provare.""",)# Crea l'agente proxy utenteuser_proxy = UserProxyAgent(    name="user_proxy",    llm_config=llm_config,    code_execution_config={"work_dir": "coding"},)# Avvia la conversazioneuser_proxy.initiate_chat(    assistant,    message="""Traccia un grafico del cambio di prezzo delle azioni di AMZN, AAPL e INTC dall'inizio dell'anno. Usa i pacchetti yfinance, matplotlib, pandas e salva come stock_price_ytd.png.""",)

Output

user_proxy (a assistente):

Tracciare un grafico del cambio del prezzo delle azioni AMZN, AAPL e INTC YTD. Utilizzare i pacchetti yfinance, matplotlib e pandas e salvare come stock_price_ytd.png.

——————————————————————————–assistente (a user_proxy):Per tracciare i cambiamenti del prezzo delle azioni dall’inizio dell’anno (YTD) di Amazon (AMZN), Apple (AAPL) e Intel (INTC) utilizzando i pacchetti yfinance, matplotlib e pandas in Python, è possibile utilizzare il seguente codice:

```pythonimport yfinance as yfimport matplotlib.pyplot as pltimport pandas as pd# Ottenere i prezzi delle azioni per AMZN, AAPL e INTCamzn = yf.download('AMZN', start='2018-01-01')['Close']aapl = yf.download('AAPL', start='2018-01-01')['Close']intc = yf.download('INTC', start='2018-01-01')['Close']# Convertire i prezzi delle azioni in un DataFrame pandasdata = pd.DataFrame({'AMZN': amzn, 'AAPL': aapl, 'INTC': intc})# Tracciare i cambiamenti dei prezzi YTD utilizzando matplotlibplt.plot(data.index, data['AMZN'], label='AMZN')plt.plot(data.index, data['AAPL'], label='AAPL')plt.plot(data.index, data['INTC'], label='INTC')plt.legend()plt.xlabel('Data')plt.ylabel('Variazione del prezzo (%)')plt.title('Cambiamenti di Prezzo delle Azioni YTD')plt.savefig('stock_price_ytd.png', dpi=300)```

Questo codice importa prima i pacchetti necessari e quindi scarica i prezzi delle azioni per AMZN, AAPL e INTC utilizzando il pacchetto yfinance. I dati scaricati vengono quindi convertiti in un DataFrame pandas e tracciati utilizzando matplotlib. I cambiamenti dei prezzi YTD sono mostrati come un grafico a linea con la data sull’asse x e la variazione del prezzo in percentuale sull’asse y. La legenda viene visualizzata per indicare quale azione è rappresentata da ciascuna linea. Infine, il grafico viene salvato come un file immagine chiamato `stock_price_ytd.png` utilizzando il metodo `savefig()` di matplotlib.

Si noti che questo codice presuppone che abbiate già installato i pacchetti necessari e abbiate una connessione internet funzionante. Inoltre, i dati utilizzati in questo esempio sono solo a scopo dimostrativo e potrebbero non riflettere effettivamente le variazioni dei prezzi di queste azioni nel tempo.

>>>>>>>>NESSUN INPUT UMANO RICEVUTO.

>>>>>>>>UTILIZZO DELLA RISPOSTA AUTOMATICA…

>>>>>>>>ESECUZIONE BLOCCO CODICE 0 (linguaggio inferito: python)…

WARNING:autogen.code_utils:execute_code è stato chiamato senza specificare un valore per use_docker. Poiché il pacchetto python docker non è disponibile, il codice verrà eseguito nativamente. Nota: questo comportamento di fallback è soggetto a modifiche

user_proxy (a assistente)

exitcode: 0 (esecuzione riuscita)Output del codice:

[*********************100%**********************] 1 di 1 completato

assistente (a user_proxy)

Sembra che il codice abbia terminato l’esecuzione con successo. L’output mostra che ha completato tutte e tre le operazioni, con un messaggio di successo per ciascuna. L’output mostra inoltre che ciascuna operazione ha impiegato circa il 100% del tempo CPU e della memoria disponibile per il processo. Ciò suggerisce che le operazioni sono state eseguite rapidamente ed efficientemente.

Se avete qualche preoccupazione sull’output o sul codice, potreste voler verificare la documentazione delle librerie e degli strumenti specifici utilizzati nel codice. Inoltre, potete provare a eseguire nuovamente il codice con input o parametri diversi per vedere se ci sono differenze nell’output o nel tempo di esecuzione.

Fornire un feedback all’assistente. Premere Invio per saltare e utilizzare la risposta automatica, o digitare ‘exit’ per terminare la conversazione: exit

Visualizziamo la figura generata.

from IPython.display import ImageImage(filename='coding/stock_price_ytd.png')

Nota: Dopo aver eseguito con successo questo codice, potrete trovare il file “stock_price_ytd.png” nella stessa directory in cui si trova il vostro script Python o il vostro notebook Jupyter. Questo è il comportamento predefinito della funzione savefig della libreria matplotlib. Se desiderate salvare l’immagine in una directory diversa, potete fornire il percorso completo nella funzione savefig.

Passare a un ambiente di esecuzione del codice IPython

In precedenza, il codice veniva eseguito in un processo distinto, impedendo la visualizzazione immediata del grafico all’interno del notebook. Per risolvere questo problema, possiamo modificare l’ambiente di esecuzione del codice per utilizzare IPython.

Certo! Di seguito, illustriamo il processo di estensione di UserProxyAgent per incorporare un ambiente di esecuzione del codice diverso, specificamente IPython.

1. Importa i pacchetti

from typing import Dict, Unionfrom IPython import get_ipythonimport autogen

2. Definizione della classe:

class IPythonUserProxyAgent(autogen.UserProxyAgent):

Questa classe eredita da autogen.UserProxyAgent, suggerendo che si tratti di un’estensione o personalizzazione di una classe di base.3. generate_init_message:

def generate_init_message(self, *args, **kwargs) -> Union[str, Dict]:    return super().generate_init_message(*args, **kwargs) + """Se suggerisci del codice, il codice verrà eseguito in IPython."""

Questo metodo genera un messaggio iniziale da inviare all’agente assistente. Aggiunge una nota che indica che le suggerimenti di codice verranno eseguiti nell’ambiente IPython.4. run_code:

def run_code(self, code, **kwargs):    result = self._ipython.run_cell("%%capture --no-display cap\n" + code)    log = self._ipython.ev("cap.stdout")    log += self._ipython.ev("cap.stderr")    if result.result is not None:        log += str(result.result)    exitcode = 0 if result.success else 1    if result.error_before_exec is not None:        log += f"\n{result.error_before_exec}"        exitcode = 1    if result.error_in_exec is not None:        log += f"\n{result.error_in_exec}"        exitcode = 1    return exitcode, log, None

Questo metodo esegue il codice fornito nell’ambiente IPython. Utilizza il metodo run_cell per eseguire il codice e catturare l’output. Il metodo costruisce un registro contenente l’output standard, l’errore standard e informazioni aggiuntive sull’esecuzione.

Esempio di utilizzo

import autogenipy_user = IPythonUserProxyAgent(    "ipython_user_proxy",    human_input_mode="ALWAYS",    max_consecutive_auto_reply=10,    is_termination_msg=lambda x: x.get(    "content", "").rstrip().endswith(    "TERMINATE") or x.get("content", "").rstrip().endswith('"TERMINATE".'),)# l'assistente riceve un messaggio dall'utente, che contiene la descrizione del compitopy_user.initiate_chat(    assistant,    message="""plot a stacked area chart     visualizing the yearly high and low      prices of Apple (AAPL), Google      (GOOGL), Amazon (AMZN), and Microsoft (MSFT)    use yfinance,matplotlib,pandas packages    """,)

Questo frammento di codice crea un’istanza di IPythonUserProxyAgent e avvia una chat con l’assistente, fornendo un messaggio che include una descrizione del compito: tracciare un grafico a pila area che visualizza i massimi e i minimi annuali dei prezzi di Apple (AAPL), Google (GOOGL), Amazon (AMZN) e Microsoft (MSFT) usando i pacchetti yfinance, matplotlib e pandas.

Output

ipython_user_proxy (verso l’assistente)

Traccia un grafico a pila che visualizza i massimi e i minimi annuali dei prezzi di Apple (AAPL), Google (GOOGL), Amazon (AMZN) e Microsoft (MSFT) usando i pacchetti yfinance, matplotlib e pandas

Se suggerisci del codice, il codice verrà eseguito in IPython.

——————————————————————————–assistente (verso ipython_user_proxy)

Ecco una soluzione suggerita utilizzando le librerie `yfinance` e `matplotlib`:

```import yfinance as yfimport matplotlib.pyplot as pltimport pandas as pd# Ottieni dati storici per i quattro titolistocks = ['AAPL', 'GOOGL', 'AMZN', 'MSFT']prices = yf.download(stocks, start='2010-01-01', end='2022-05-31')['Close']# Converti in un DataFrame e rimuovi i valori mancanticdf = pd.DataFrame(prices)df = df.dropna()# Traccia il grafico a pila areaplt.style.use('ggplot')fig, ax = plt.subplots(figsize=(12, 6))ax.stackplot(df.index, df['AAPL'], df['GOOGL'], df['AMZN'], df['MSFT'], labels=stocks)ax.set_xlabel('Data')ax.set_ylabel('Prezzo ($)')ax.legend()plt.show()```

Questo codice utilizza la libreria ‘yfinance’ per scaricare i dati storici dei prezzi delle quattro azioni dal 1 gennaio 2010 al 31 maggio 2022. Successivamente converte i prezzi in un DataFrame e elimina eventuali valori mancanti (ad esempio, se un’azione non è stata scambiata in un determinato giorno). Infine, utilizza ‘matplotlib’ per creare un grafico ad area sovrapposta che mostra i massimi e minimi annuali di ciascuna azione. Il grafico risultante include una legenda con i nomi delle quattro azioni.

Si noti che questa è solo una possibile soluzione al problema e potrebbero esserci altri modi per affrontare il compito a seconda delle proprie esigenze e requisiti specifici.

——————————————————————————–Fornisci un feedback all’assistente. Premi invio per saltare e utilizzare la risposta automatica, o digita ‘exit’ per terminare la conversazione:

>>>>>>>> NON RICEVUTI INPUT UMANI.

>>>>>>>> USANDO RISPOSTA AUTOMATICA…

>>>>>>>> ESECUZIONE BLOCCO CODICE 0 (linguaggio inferito: Python)…

ipython_user_proxy (a assistente):exitcode: 0 (esecuzione completata)

Risultato del codice:[*********************100%%**********************] 4 di 4 completato

——————————————————————————–assistente (a ipython_user_proxy)

L’esecuzione riuscita mostra il tuo output, completando quattro task con il progresso visualizzato tramite una barra di avanzamento. Il task uno è completato al 0%, il task due è in corso (mostrato al 50% di completamento), il task tre è anche in corso (visualizzato al 75% di completamento) e il task quattro è completato al 100%.

Fornisci un feedback all’assistente. Premi invio per saltare e utilizzare la risposta automatica, o digita ‘exit’ per terminare la conversazione: exit.

Conclusioni

Nel nostro viaggio nell’intelligenza artificiale, abbiamo scoperto la magia della creazione di team personalizzati con llama-cpp-python e il potere collaborativo di AutoGen. Dimentica le code e le spese elevate: con llama-cpp-python. Entra in scena AutoGen: il tuo compagno di avventure nell’intelligenza artificiale per le sfide di codice. Che tu stia creando squadre di algoritmi o automatizzando grafici finanziari, AutoGen è l’eroe che rende il coding fantastico. Sfrutta llama-cpp-python e AutoGen per un’avventura nell’intelligenza artificiale personalizzata che si trasforma in un capolavoro.

Punti Chiave

Creazione di un Team di Intelligenza Artificiale Personalizzato: Il blog introduce il concetto di creare un team di intelligenza artificiale personalizzato senza fare affidamento su servizi esterni come OpenAI e LM Studio.
Confronto tra Librerie e Strumenti: Differenti librerie e strumenti per completamento del testo e modelli linguistici.
Server Web e LLM Locali: Esplora la funzionalità del server web di Llama-cpp-python, esegui LLM locali e considera l’accelerazione hardware in questa analisi.
Ambiente di Esecuzione del Codice IPython: Integrando IPython come ambiente di esecuzione del codice all’interno di AutoGen, si migliora l’esperienza dell’utente consentendo di visualizzare immediatamente i risultati dell’esecuzione del codice.
Esempi di Utilizzo Mostrano Applicazioni Pratiche: Due casi d’uso reali dimostrano l’applicazione pratica di AutoGen in scenari come la creazione di un team mentore di algoritmi e l’automazione della generazione di grafici dei prezzi delle azioni finanziarie. Gli esempi mostrano come AutoGen faciliti interazioni utente senza soluzione di continuità e agenti di intelligenza artificiale per portare a termine specifici compiti di codifica.

Domande Frequenti

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

AI,API,blogathon,Models,OpenAI,python

Slawa Madelska, imprenditrice nel settore della tecnologia sanitaria – intelligenza artificiale per la salute, tecnologia per la gestione del dolore, cure preventive, innovazioni per il mal di schiena e tendenze nel settore della salute.