Remove obsolete Docker configuration and documentation; add new Dockerfile, docker-compose, and update README for project setup
This commit is contained in:
Binary file not shown.
|
Before Width: | Height: | Size: 21 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 84 KiB |
@@ -1,117 +0,0 @@
|
||||
### Passo 0: Gestire Windows
|
||||
La natura di questa guida è permettere agli utenti Windows di lavorare con Docker e con la GPU nei progetti pytorch (similarmente tensorflow). Rispettare questi passi, possibilmente in ordine:
|
||||
1. Installare i driver aggiornati della propria GPU Nvidia
|
||||
2. Installare [Nvidia Toolkit](https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=11&target_type=exe_local) dal sito ufficiale Nvidia.
|
||||
1. Se tutto va a buon fine lanciare in Powershell il comando `nvidia-smi` e dovrebbe comparire un output simile a questo:
|
||||
|
||||
```bash
|
||||
Fri Mar 7 13:57:22 2025
|
||||
+-----------------------------------------------------------------------------------------+
|
||||
| NVIDIA-SMI 570.124.03 Driver Version: 572.60 CUDA Version: 12.8 |
|
||||
|-----------------------------------------+------------------------+----------------------+
|
||||
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |
|
||||
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |
|
||||
| | | MIG M. |
|
||||
|=========================================+========================+======================|
|
||||
| 0 NVIDIA GeForce RTX 4090 On | 00000000:0C:00.0 On | Off |
|
||||
| 31% 57C P2 312W / 450W | 14791MiB / 24564MiB | 91% Default |
|
||||
| | | N/A |
|
||||
+-----------------------------------------+------------------------+----------------------+
|
||||
|
||||
+-----------------------------------------------------------------------------------------+
|
||||
| Processes: |
|
||||
| GPU GI CI PID Type Process name GPU Memory |
|
||||
| ID ID Usage |
|
||||
|=========================================================================================|
|
||||
| No running processes found |
|
||||
+-----------------------------------------------------------------------------------------+
|
||||
```
|
||||
|
||||
3. Windows mantiene la compatibilità con i vari tool e framework appoggiandosi a WSL2, ossia la virtualizzazione integrata di Linux. È quindi necessario avere l'opzione di virtualizzazione abilitata nel proprio BIOS del computer. Se WSL2 si apre significa che è già attiva e non devi fare niente. Si consiglia una versione Ubuntu ma non dovrebbero esserci problemi con altre distro.
|
||||
4. WSL2 permette il pass through della GPU solo installando nella distro WSL2 scelta le dipendenze necessarie come indicato [sul sito Nvidia](https://docs.nvidia.com/cuda/wsl-user-guide/index.html). Anche da WSL2 lanciare il comando `nvidia-smi` e aspettarsi un output simile al precedente.
|
||||
5. Installare Docker su Windows e nelle impostazioni sotto al tab `Generale` controllare che sia abilitato l'uso di WSL2. Oramai di default è abilitato ma per scrupolo controllare.
|
||||
### Passo 1: Creare un file Dockerfile
|
||||
|
||||
1. **Crea il Dockerfile**: All'interno della tua directory del progetto, crea un file chiamato `Dockerfile`. (Sì, senza estensione)
|
||||
|
||||
2. **Contenuto del Dockerfile**:
|
||||
```dockerfile
|
||||
# Usa l'immagine base di PyTorch con supporto per CUDA 12.6 e CuDNN 9
|
||||
FROM pytorch/pytorch:2.6.0-cuda12.6-cudnn9-devel
|
||||
|
||||
# Imposta il working directory all'interno del container
|
||||
WORKDIR /upo-appAI
|
||||
|
||||
# Copia i file necessari nel container
|
||||
COPY requirements.txt .
|
||||
|
||||
# Installa le dipendenze Python dalla lista in requirements.txt
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Copia i file del progetto all'interno del container
|
||||
COPY . /upo-appAI
|
||||
```
|
||||
|
||||
### Passo 2: Costruire l'immagine Docker
|
||||
|
||||
1. **Costruisci l'immagine**: Apri un terminale e naviga alla directory `upo-appAI`. Esegui il seguente comando per costruire l'immagine Docker:
|
||||
```bash
|
||||
docker build -t appAI .
|
||||
```
|
||||
Da questo momento l'immagine avrà il nome di `appAI`
|
||||
### Passo 3: Creare e gestire un container
|
||||
Per il momento ci occuperemo di crearne uno ma se serve agganciarlo ad un IDE l'operazione potrebbe richiedere configurazioni specifiche per il singolo IDE. Ad esempio Pycharm di Jetbrains crea un nuovo container a partire dalla immagine compilata o addirittura direttamente dal dockerfile, quindi se interessa Pycharm saltare al punto che lo tratta senza creare il container come indicato qui sotto, anche se raccomandato leggerlo per conoscenza.
|
||||
|
||||
**Avvia il container**: Una volta che l'immagine è stata costruita, puoi avviare un container con il comando che segue avendo cura di essere nel percorso della cartella di progetto:
|
||||
```bash
|
||||
docker run --name appAI_container --gpus all -v ${PWD}:/upo-appAI -it appAI /bin/sh
|
||||
```
|
||||
Questo comando monta la directory corrente sul volume del container e ti dà accesso a una shell interattiva. Attenzione:
|
||||
* In PowerShell, la sintassi corretta per ottenere il percorso corrente è `${PWD}` mentre su shell Linux sarebbe `$(pwd)`, se capita di usare comandi suggeriti da vari LLM prestarci attenzione.
|
||||
* Si può sostituire col percorso assoluto della cartella di progetto.
|
||||
|
||||
È importante il `--gpus all` altrimenti CUDA non funziona. Sostituire `all` con il nome della GPU nel caso ce ne sia più di una e non interessa usarle tutte.
|
||||
Per scrupolo, controlliamo che funzioni tutto bene nel container lanciando il comando nella shell del cocker appena avviato:
|
||||
```shell
|
||||
python -c "import torch; print(torch.__version__); print('CUDA available:', torch.cuda.is_available())"
|
||||
```
|
||||
Ci si aspetta questo output:
|
||||
```bash
|
||||
2.6.0+cu126
|
||||
CUDA available: True
|
||||
```
|
||||
|
||||
Una alternativa è lanciare il comando `nvidia-smi` aspettandosi come output qualcosa di molto simile a quanto visto sopra.
|
||||
|
||||
Per accedere in un secondo momento alla shell del Docker usare il comando:
|
||||
```shell
|
||||
docker exec -it appAI_container /bin/sh
|
||||
```
|
||||
|
||||
|
||||
#### Manipolazione Generale
|
||||
Per gestire i container docker si può passare da GUI (Windows) o da CLI ma in entrambi i casi i container non possono essere modificati runtime.
|
||||
|
||||
##### Rimozione container
|
||||
O da GUI usando i 3 puntini verticali sul nome del container, o da CLI coi comandi
|
||||
```shell
|
||||
docker stop appAI_container # STOP del docker prima della rimozione
|
||||
docker rm appAI_container # Eliminazione effettiva del contenitore
|
||||
```
|
||||
|
||||
##### Riavvio Container
|
||||
Sempre o da GUI o col comando:
|
||||
```bash
|
||||
docker restart appAI_container
|
||||
```
|
||||
|
||||
#### Pycharm
|
||||
Premessa: pycharm non si aggancia ad un container esistente di default quindi o si crea una connessione di rete (anche locale) oppure pycharm ha bisogno di creare il suo. Per ragioni di comodità si sceglie di lasciar creare un nuovo container a pycharm.
|
||||
Per usare docker come python interpreter bisogna aggiungerne un nuovo interprete e selezionare docker. Qui si può scegliere se selezionare l'immagine già compilata o partire dal Dockerfile. Attenzione!!! Qui non è possibile specificare il `--gpus all` e andrà fatto dopo la creazione del Docker. Una volta finito andare nelle opzioni di esecuzione in `Edit Configurations` tirando giù il menu a tendina di fianco al bottone play in alto a destra.
|
||||
|
||||
<img src="Configurazione Ambiente di Lavoro - Run and Debug config.png" alt="Configurazione Ambiente di Lavoro - Edit Docker Container Settings" width="650" style="display: block; margin: auto;" />
|
||||
|
||||
In `docker container setting` fare click sul simbolo della cartella. Si aprirà una finestra in cui in fondo bisogna inserire dentro a `Run options` l'opzione `--gpus all`.
|
||||
|
||||
<img src="Configurazione Ambiente di Lavoro - Edit Docker Container Settings.png" alt="Configurazione Ambiente di Lavoro - Edit Docker Container Settings" width="650" style="display: block; margin: auto;" />
|
||||
|
||||
@@ -1,14 +0,0 @@
|
||||
# Usa l'immagine base di PyTorch con supporto per CUDA 12.6 e CuDNN 9
|
||||
FROM pytorch/pytorch:2.6.0-cuda12.6-cudnn9-devel
|
||||
|
||||
# Imposta il working directory all'interno del container
|
||||
WORKDIR /upo-appAI
|
||||
|
||||
# Copia i file necessari nel container
|
||||
COPY requirements.txt .
|
||||
|
||||
# Installa le dipendenze Python dalla lista in requirements.txt
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Copia i file del progetto all'interno del container
|
||||
COPY . /upo-appAI
|
||||
@@ -1,7 +0,0 @@
|
||||
pandas
|
||||
numpy
|
||||
tqdm
|
||||
scikit-learn
|
||||
matplotlib
|
||||
seaborn
|
||||
optuna
|
||||
14
Dockerfile
Normal file
14
Dockerfile
Normal file
@@ -0,0 +1,14 @@
|
||||
# Per ora abbiamo bisogno solo di python, se nel futuro avremo bisogno di pytorch/cuda possiamo sempre tornare indietro
|
||||
#FROM pytorch/pytorch:2.6.0-cuda12.6-cudnn9-devel
|
||||
FROM python:3.11-slim
|
||||
|
||||
# Copio tutti i dati del progetto nella workdir
|
||||
# (dopo aver definito la workdir mi trovo già in essa)
|
||||
WORKDIR /app
|
||||
COPY src .
|
||||
COPY requirements.txt .
|
||||
COPY LICENSE .
|
||||
|
||||
# Installo le dipendenze
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
CMD ["python", "src/app.py"]
|
||||
@@ -1,69 +1,37 @@
|
||||
## 1. Sistema di Pianificazione Domestica Intelligente Adattiva
|
||||
Assolutamente. Ecco il piano di lavoro completo per il tuo progetto di esame, formattato come documento interno per una consultazione più semplice.
|
||||
|
||||
- **Ambito:** Domotica (si può simulare facilmente).
|
||||
- **Idea:** Un sistema con diversi agenti che collaborano per pianificare le attività domestiche (pulizie, spesa, preparazione pasti) in modo adattivo in base a:
|
||||
- **Preferenze dell'utente:** Apprese tramite interazione o configurazione iniziale.
|
||||
- **Disponibilità di risorse:** Simulate (es. "frigorifero vuoto", "tempo libero").
|
||||
- **Eventi imprevisti:** Simulati (es. "ospiti inattesi", "cambio di programma").
|
||||
- **Intelligenza Dimostrata:** Gli agenti devono negoziare e ri-pianificare le attività in base alle nuove informazioni e priorità, utilizzando l'LLM per generare piani di azione coerenti e spiegazioni delle decisioni prese. Ad esempio, se arrivano ospiti, l'agente "cucina" potrebbe chiedere all'agente "spesa" di aggiungere ingredienti extra e all'agente "pulizie" di concentrarsi su determinate aree.
|
||||
- **LLM Usage:**
|
||||
- Generare suggerimenti per i piani di azione.
|
||||
- Fornire spiegazioni in linguaggio naturale delle decisioni prese dagli agenti.
|
||||
- Adattare il tono e il contenuto delle comunicazioni in base al contesto.
|
||||
- **Agenti Potenziali:**
|
||||
- Agente "Pianificatore": Coordina le attività.
|
||||
- Agente "Cucina": Gestisce i pasti.
|
||||
- Agente "Pulizie": Organizza la pulizia.
|
||||
- Agente "Spesa": Si occupa degli acquisti.
|
||||
- Agente "Calendario": Tiene traccia degli impegni.
|
||||
- **Simulazione:** Puoi simulare lo stato della casa (frigorifero, calendario, "stanze sporche") tramite variabili o semplici file di testo che gli agenti possono leggere e modificare. Gli "eventi imprevisti" possono essere input manuali o generati casualmente.
|
||||
---
|
||||
### **Progetto di Esame: Agente di Pianificazione Viaggi Intelligente**
|
||||
|
||||
## 2. Sistema di Raccomandazione di Itinerari Turistici Adattivo
|
||||
#### **Obiettivo**
|
||||
Creare un sistema di pianificazione viaggi basato su **LLM Agents** che genera itinerari personalizzati e adattivi in base a vincoli e informazioni in tempo reale. L'obiettivo è dimostrare la capacità del sistema di ragionare, adattarsi a eventi esterni e comunicare in modo intelligente.
|
||||
|
||||
- **Ambito:** Turismo (facile da simulare con dati pubblici).
|
||||
- **Idea:** Un sistema che raccomanda itinerari turistici personalizzati in base a:
|
||||
- **Interessi dell'utente:** Ricavati da input diretto o (idealmente) da una breve interazione con l'LLM.
|
||||
- **Vincoli:** Tempo disponibile, budget, preferenze di trasporto.
|
||||
- **Condizioni esterne:** Simulate (es. "meteo avverso", "chiusura di un'attrazione").
|
||||
- **Intelligenza Dimostrata:** Il sistema non si limita a presentare una lista statica di luoghi, ma adatta l'itinerario in tempo reale in base ai vincoli e agli eventi, magari suggerendo alternative o modificando l'ordine delle visite. L'LLM può essere usato per generare descrizioni coinvolgenti dei luoghi e per rispondere a domande specifiche.
|
||||
- **LLM Usage:**
|
||||
- Comprendere gli interessi dell'utente tramite conversazione.
|
||||
- Generare descrizioni dei luoghi di interesse.
|
||||
- Suggerire attività alternative in caso di imprevisti.
|
||||
- Creare riepiloghi e narrazioni dell'itinerario.
|
||||
- **Agenti Potenziali:**
|
||||
- Agente "Profilo Utente": Gestisce gli interessi e i vincoli.
|
||||
- Agente "Ricerca Luoghi": Recupera informazioni sui punti di interesse (potresti usare un piccolo database simulato o API pubbliche).
|
||||
- Agente "Pianificatore Itinerari": Genera e adatta il percorso.
|
||||
- Agente "Comunicazione": Interagisce con l'utente.
|
||||
- **Simulazione:** Puoi simulare le "condizioni esterne" come cambiamenti meteo o chiusure tramite input manuali o eventi casuali. I dati sui luoghi turistici possono essere semplificati.
|
||||
---
|
||||
#### **1. Input Utente e Analisi Preliminare**
|
||||
L'utente interagisce con una semplice interfaccia, fornendo una richiesta di viaggio che include:
|
||||
* **Vincoli finanziari:** Budget massimo.
|
||||
* **Preferenze di viaggio:** Tipologia di vacanza (es. mare, montagna, città) e mezzo di trasporto preferito (es. treno, aereo).
|
||||
* **Tempistiche:** Date di viaggio e durata.
|
||||
|
||||
## 3. Sistema di Supporto Tecnico Adattivo
|
||||
L'**Agente di Comunicazione** riceve queste informazioni e, usando un **LLM**, le interpreta e le formatta per gli agenti successivi.
|
||||
|
||||
- **Ambito:** Supporto clienti (si può simulare un ambiente di problemi tecnici).
|
||||
- **Idea:** Un sistema che aiuta a risolvere problemi tecnici simulati per un software o un dispositivo.
|
||||
- **Intelligenza Dimostrata:** Il sistema non segue un semplice albero decisionale predefinito, ma adatta la sua strategia di troubleshooting in base alle risposte dell'utente e ai risultati dei tentativi di soluzione (simulati). L'LLM può essere usato per interpretare le descrizioni dei problemi e generare suggerimenti di soluzione in linguaggio naturale.
|
||||
- **LLM Usage:**
|
||||
- Comprendere la descrizione del problema fornita dall'utente.
|
||||
- Generare potenziali cause e soluzioni.
|
||||
- Fornire spiegazioni chiare dei passaggi da seguire.
|
||||
- Adattare il tono e la complessità delle spiegazioni all'utente.
|
||||
- **Agenti Potenziali:**
|
||||
- Agente "Diagnostico": Analizza il problema.
|
||||
- Agente "Base di Conoscenza": Accede a informazioni (simulate) su problemi e soluzioni.
|
||||
- Agente "Esecutore (Simulato)": Simula l'esecuzione di azioni di troubleshooting e ne riporta un "risultato" (successo/fallimento).
|
||||
- Agente "Comunicazione": Interagisce con l'utente.
|
||||
- **Simulazione:** Puoi simulare un ambiente software/hardware con "problemi" definiti (es. "errore di connessione", "applicazione che non si avvia"). L'agente "Esecutore" simulerebbe l'applicazione di una soluzione e restituirebbe un esito.
|
||||
---
|
||||
#### **2. Processo di Pianificazione e Acquisizione Dati**
|
||||
Questo processo si basa sulla collaborazione di più agenti specializzati, in linea con l'approccio dei modelli di ragionamento.
|
||||
* **Agente Pianificatore:** Sulla base della richiesta iniziale, questo agente genera internamente una serie di **idee di viaggio** iniziali.
|
||||
* **Agente Meteo:** Per ogni destinazione, richiede le previsioni del tempo tramite un'API REST, come quella di `open-meteo.com`.
|
||||
* **Agente Notizie:** Interroga un'API di notizie (`newsapi.com`) per rilevare eventuali eventi imprevisti o avvisi importanti per le località considerate.
|
||||
* **Agente Ricerca:** Per ogni idea di viaggio, raccoglie informazioni essenziali sui **punti di interesse**, sfruttando un database statico o un'API semplificata, come suggerito nelle linee guida del progetto.
|
||||
* **Agente Logistico:** Ottiene dati simulati su opzioni di viaggio (voli, treni) e costi per ciascuna destinazione.
|
||||
|
||||
## Punti Chiave per Dimostrare "Intelligenza"
|
||||
---
|
||||
#### **3. Valutazione e Selezione Adattiva**
|
||||
L'**Agente Pianificatore** valuta le idee di viaggio in base alle informazioni raccolte dagli altri agenti.
|
||||
* **Valutazione Logica:** Analizza il budget e la compatibilità dei mezzi di trasporto.
|
||||
* **Adattabilità:** Scarta o modifica le proposte se le condizioni esterne lo rendono necessario. Ad esempio, non proporrà un viaggio al mare se sono previste forti piogge, o cambierà l'ordine delle tappe in base a notizie rilevanti.
|
||||
|
||||
- **Adattabilità:** Il sistema deve cambiare il suo comportamento o piano d'azione in risposta a nuove informazioni o eventi.
|
||||
- **Ragionamento:** Gli agenti devono mostrare una logica nel loro processo decisionale, anche se semplice. L'LLM può aiutare a esplicitare questo ragionamento.
|
||||
- **Collaborazione:** Se ci sono più agenti, la loro interazione e coordinazione per raggiungere un obiettivo comune è fondamentale.
|
||||
- **Comunicazione Intelligente:** L'uso dell'LLM per generare un linguaggio naturale che sia informativo, adattivo al contesto e all'utente.
|
||||
|
||||
## Considerazioni per Sviluppo Non Eccessivo
|
||||
|
||||
- **Semplificare la Simulazione:** Non è necessario creare un ambiente complesso. L'uso di variabili, file di testo o semplici API può essere sufficiente.
|
||||
- **Concentrarsi sull'Interazione Agente-Agente e Agente-LLM:** Il cuore del progetto dovrebbe essere come gli agenti si coordinano e come utilizzano l'LLM per prendere decisioni e comunicare.
|
||||
- **Non Ambire alla Perfezione:** Un prototipo funzionante che dimostri i concetti chiave è più importante di un sistema completo e rifinito.
|
||||
---
|
||||
#### **4. Presentazione dei Risultati**
|
||||
Infine, il sistema presenta all'utente un massimo di tre proposte di viaggio.
|
||||
* **Itinerari Dettagliati:** Ogni proposta include un riepilogo del viaggio, le tappe suggerite e i costi stimati.
|
||||
* **Ragionamenti (Note):** Vengono aggiunte note esplicative che descrivono il processo decisionale degli agenti, dimostrando il "perché" della scelta fatta. Ad esempio, "Abbiamo evitato la città A perché le notizie riportano un evento di traffico locale".
|
||||
51
README.md
51
README.md
@@ -1,11 +1,46 @@
|
||||
# upo-appAI
|
||||
Progetto per il corso di Applicazioni intelligenti.
|
||||
|
||||
|
||||
|
||||
|
||||
### Esame
|
||||
# **Progetto di Esame: Agente di Pianificazione Viaggi Intelligente**
|
||||
Questa è la repository per l'esame di Applicazioni Intelligenti che consiste in:
|
||||
- Progetto per 2/3 del voto.
|
||||
- Orale per 1/3 dei punti compreso da:
|
||||
- Presentazione (come se lo facessimo ad un cliente) di gruppo
|
||||
- Orale singolo con domande del corso (teoria e strumnenti visti
|
||||
- Orale singolo con domande del corso (teoria e strumenti visti)
|
||||
|
||||
L'obiettivo di questo progetto è creare un sistema basato su **LLM Agents** e deve dimostrare la capacità di ragionare, adattarsi a eventi esterni e comunicare in modo intelligente.
|
||||
|
||||
Una prima idea è quella di fare un sistema che genera itinerari personalizzati e adattivi in base a vincoli e informazioni in tempo reale.
|
||||
|
||||
## Installazione
|
||||
Per l'installazione si possono seguire i seguenti step per creare l'ambiente corretto o utilizzare un ambiente Docker già pronto:
|
||||
|
||||
**Ambiente**: Per prima cosa si deve creare un nuovo environment Python:
|
||||
```sh
|
||||
python -m venv .venv
|
||||
```
|
||||
|
||||
**Attivare l'ambiente**: dobbiamo usare uno dei seguenti comandi, in base al fatto che siamo su Windows o Unix.\
|
||||
*Nota*: nel caso Windows non faccia partire lo script per policy interne di sicurezza, bisogna far eseguire questo comando prima di attivare l'ambiente virtuale creato: ``` Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser ```
|
||||
|
||||
|Sistema Operativo|Comando|
|
||||
|:---|:---|
|
||||
|Unix| ``` source .venv/bin/activate ``` |
|
||||
|Windows| ``` .venv/Scripts/activate ``` |
|
||||
|Windows (PS)| ``` .venv/Scripts/Activate.ps1 ``` |
|
||||
|
||||
**Dipendenze**: Infine installiamo le dipendenze nell'ambiente appena creato:
|
||||
```sh
|
||||
python -m pip install -r requirements.txt
|
||||
```
|
||||
|
||||
**Run**: Successivamente si può far partire il progetto tramite il comando:
|
||||
```sh
|
||||
python src/app.py
|
||||
```
|
||||
|
||||
### Docker
|
||||
Alternativamente, se si ha installato Docker, si può utilizzare il [Dockerfile](Dockerfile) e il [docker-compose.yaml](docker-compose.yaml) per creare il container con tutti i file necessari e già in esecuzione:
|
||||
```sh
|
||||
docker compose up -d
|
||||
```
|
||||
|
||||
## Applicazione
|
||||
TODO
|
||||
|
||||
8
docker-compose.yaml
Normal file
8
docker-compose.yaml
Normal file
@@ -0,0 +1,8 @@
|
||||
services:
|
||||
app:
|
||||
build: .
|
||||
container_name: upo-app-ai
|
||||
ports:
|
||||
- "8000:8000"
|
||||
volumes:
|
||||
- .:/app
|
||||
17
requirements.txt
Normal file
17
requirements.txt
Normal file
@@ -0,0 +1,17 @@
|
||||
# Qui ho messo alcune librerie utili utilizzate durante il corso.
|
||||
# Se si nota che alcune non sono necessarie, si potrebbero rimuovere
|
||||
# in modo da evitare conflitti o problemi futuri.
|
||||
# Per ogni roba ho fatto un commento per evitare di dimenticarmi cosa fa chi.
|
||||
|
||||
# per fare richieste HTTP
|
||||
requests
|
||||
# per l'elaborazione del linguaggio naturale in locale (https://huggingface.co/learn/llm-course/chapter1/3?fw=pt)
|
||||
transformers
|
||||
# per fare una UI web semplice con input e output
|
||||
gradio
|
||||
# per interagire con l'API di OpenAI e di altri (basta cambiare il baseurl)
|
||||
openai
|
||||
# per fare in modo di ottenere dati validati e strutturati
|
||||
pydantic
|
||||
# per gestire variabili d'ambiente (generalmente API keys o opzioni)
|
||||
dotenv
|
||||
4
src/app.py
Normal file
4
src/app.py
Normal file
@@ -0,0 +1,4 @@
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("Hello World!")
|
||||
|
||||
Reference in New Issue
Block a user