LeaderGPU® | Soluzioni GPU per l'HPC (High Performance Computing)

Qwen3-Coder: un paradigma infranto

Tue, 12 Aug 2025 14:11:06 +0200

Siamo abituati a pensare che i modelli open-source siano sempre inferiori alle loro controparti commerciali in termini di qualità. Può sembrare che siano sviluppati esclusivamente da appassionati che non possono permettersi di investire somme ingenti per creare dataset di alta qualità e addestrare i modelli su decine di migliaia di GPU moderne.

È una storia diversa quando grandi aziende come OpenAI, Anthropic o Meta si assumono il compito. Non solo dispongono delle risorse necessarie, ma anche dei migliori specialisti di reti neurali del mondo. Purtroppo, i modelli che creano, soprattutto le ultime versioni, sono closed-source. Gli sviluppatori spiegano questo fatto citando i rischi di un uso incontrollato e la necessità di garantire la sicurezza dell'IA.

Da un lato, il loro ragionamento è comprensibile: molte questioni etiche rimangono irrisolte e la natura stessa dei modelli di rete neurale permette di influenzare solo indirettamente il risultato finale. D'altra parte, mantenere i modelli chiusi e offrire l'accesso solo attraverso le proprie API è anche un modello di business solido.

Tuttavia, non tutte le aziende si comportano in questo modo. Ad esempio, l'azienda francese Mistral AI offre modelli sia commerciali che open-source, consentendo a ricercatori e appassionati di utilizzarli nei loro progetti. Ma occorre prestare particolare attenzione ai risultati ottenuti dalle aziende cinesi, la maggior parte delle quali costruisce modelli open-weight e open-source in grado di competere seriamente con le soluzioni proprietarie.

DeepSeek, Qwen3 e Kimi K2

Il primo grande passo avanti è stato fatto con DeepSeek-V3. Questo modello linguistico multimodale di DeepSeek AI è stato sviluppato con l'approccio Mixture of Experts (MoE) e conta ben 671B parametri, con 37B parametri più rilevanti attivati per ogni token. Soprattutto, tutti i suoi componenti (pesi del modello, codice di inferenza e pipeline di addestramento) sono stati resi pubblici.

Ciò lo ha reso immediatamente uno dei LLM più interessanti per gli sviluppatori di applicazioni di IA e per i ricercatori. Il successivo titolo è stato DeepSeek-R1, il primo modello di ragionamento open-source. Il giorno del suo rilascio, ha fatto tremare il mercato azionario statunitense dopo che i suoi sviluppatori hanno dichiarato che l'addestramento di un modello così avanzato era costato solo 6 milioni di dollari.

Mentre il clamore intorno a DeepSeek si è poi raffreddato, i successivi rilasci non sono stati meno importanti per l'industria globale dell'intelligenza artificiale. Stiamo parlando, ovviamente, di Qwen 3. Abbiamo parlato delle sue caratteristiche in dettaglio nel nostro articolo. Le sue caratteristiche sono state trattate in dettaglio nella nostra recensione Cosa c'è di nuovo in Qwen 3, quindi non ci soffermeremo qui. Poco dopo è apparso un altro giocatore: Kimi K2 di Moonshot AI.

Con la sua architettura MoE, i suoi parametri 1T (32B attivati per token) e il suo codice open-source, Kimi K2 ha rapidamente attirato l'attenzione della comunità. Piuttosto che concentrarsi sul ragionamento, Moonshot AI puntava a prestazioni allo stato dell'arte in matematica, programmazione e profonda conoscenza interdisciplinare.

L'asso nella manica di Kimi K2 era la sua ottimizzazione per l'integrazione negli agenti di intelligenza artificiale. Questa rete è stata letteralmente progettata per fare pieno uso di tutti gli strumenti disponibili. Eccelle in compiti che richiedono non solo la scrittura di codice, ma anche test iterativi in ogni fase di sviluppo. Tuttavia, ha anche dei punti deboli, di cui parleremo più avanti.

Kimi K2 è un modello linguistico di grandi dimensioni in tutti i sensi. L'esecuzione della versione completa richiede ~2 TB di VRAM (FP8: ~1 TB). Per ovvie ragioni, non è una cosa che si può fare a casa e nemmeno molti server con GPU sono in grado di gestirla. Il modello necessita di almeno 8 acceleratori NVIDIA® H200. Le versioni quantizzate possono essere d'aiuto, ma a un costo notevole per la precisione.

Codificatore Qwen3

Visto il successo di Moonshot AI, Alibaba ha sviluppato un proprio modello simile a Kimi K2, ma con vantaggi significativi di cui parleremo tra poco. Inizialmente è stato rilasciato in due versioni:

Qwen3-Coder-480B-A35B-Instruct (~250 GB VRAM)
Qwen3-Coder-480B-A35B-Instruct-FP8 (~120 GB di VRAM)

Pochi giorni dopo sono apparsi modelli più piccoli senza il meccanismo di ragionamento, che richiedevano una quantità di VRAM molto inferiore:

Qwen3-Coder-30B-A3B-Instruct (~32 GB VRAM)
Qwen3-Coder-30B-A3B-Instruct-FP8 (~18 GB VRAM)

Qwen3-Coder è stato progettato per l'integrazione con gli strumenti di sviluppo. Include uno speciale parser per le chiamate di funzione (qwen3coder_tool_parser.py, analogo alle chiamate di funzione di OpenAI). Insieme al modello, è stata rilasciata un'utilità per la console, in grado di svolgere funzioni che vanno dalla compilazione del codice all'interrogazione di una base di conoscenza. L'idea non è nuova, si tratta essenzialmente di un'estensione pesantemente rielaborata dell'applicazione di codice Gemini di Anthropic.

Il modello è compatibile con le API di OpenAI, consentendo di distribuirlo localmente o su un server remoto e di collegarlo alla maggior parte dei sistemi che supportano tali API. Ciò include sia applicazioni client già pronte che librerie di apprendimento automatico. Ciò lo rende utilizzabile non solo per il segmento B2C ma anche per quello B2B, offrendo una sostituzione senza soluzione di continuità del prodotto di OpenAI senza alcuna modifica della logica applicativa.

Una delle sue caratteristiche più richieste è l'estensione della lunghezza del contesto. Per impostazione predefinita, supporta 256k token, ma può essere aumentata fino a 1M utilizzando il meccanismo YaRN (Yet another RoPe extensioN). I moderni LLM sono in genere addestrati su insiemi di dati brevi (2k-8k token) e una lunghezza del contesto elevata può far perdere le tracce dei contenuti precedenti.

YaRN è un elegante "trucco" che fa credere al modello di lavorare con le solite sequenze brevi, mentre in realtà ne elabora di molto più lunghe. L'idea chiave è quella di "allungare" o "dilatare" lo spazio posizionale preservando la struttura matematica che il modello si aspetta. In questo modo è possibile elaborare efficacemente sequenze lunghe decine di migliaia di token senza dover ricorrere alla riqualificazione o alla memoria supplementare richiesta dai metodi tradizionali di estensione del contesto.

Scaricare ed eseguire l'inferenza

Assicurarsi di aver installato CUDA® in precedenza, utilizzando le istruzioni ufficiali di NVIDIA® o la guida Installare il toolkit CUDA® in Linux. Per verificare la presenza del compilatore richiesto:

nvcc --version

Risultato atteso:

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2024 NVIDIA Corporation
Built on Tue_Feb_27_16:19:38_PST_2024
Cuda compilation tools, release 12.4, V12.4.99
Build cuda_12.4.r12.4/compiler.33961263_0

Se si ottiene:

Command 'nvcc' not found, but can be installed with:
sudo apt install nvidia-cuda-toolkit

è necessario aggiungere i binari di CUDA® a $PATH del sistema.

export PATH=/usr/local/cuda-12.4/bin:$PATH

export LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64:$LD_LIBRARY_PATH

Questa è una soluzione temporanea. Per una soluzione definitiva, modificare ~/.bashrc e aggiungere le stesse due righe alla fine.

Ora, preparate il vostro sistema per gestire gli ambienti virtuali. Si può usare il venv integrato in Python o il più avanzato Miniforge. Supponendo che Miniforge sia installato:

conda create -n venv python=3.10

conda activate venv

Installare PyTorch con il supporto CUDA® corrispondente al sistema:

pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu124

Installare quindi le librerie essenziali:

Transformers - La libreria di modelli principale di Hugging Face
Accelerate - consente l'inferenza multi-GPU
HuggingFace Hub - per il download/upload di modelli e set di dati
Safetensors - formato sicuro per i pesi dei modelli
vLLM - libreria di inferenza raccomandata per Qwen

pip install transformers accelerate huggingface_hub safetensors vllm

Scaricare il modello:

hf download Qwen/Qwen3-Coder-30B-A3B-Instruct --local-dir ./Qwen3-30B

Eseguire l'inferenza con il parallelismo dei tensori (dividendo i tensori degli strati tra le GPU, ad esempio 8):

python -m vllm.entrypoints.openai.api_server \
--model /home/usergpu/Qwen3-30B \
--tensor-parallel-size 8 \
--gpu-memory-utilization 0.9 \
--dtype auto \
--host 0.0.0.0 \
--port 8000

Avvia il server API OpenAI di vLLM.

Test e integrazione

cURL

Installare jq per la stampa di JSON:

sudo apt -y install jq

Testare il server:

curl -s http://127.0.0.1:8000/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "/home/usergpu/Qwen3-30B",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello! What can you do?"}
  ],
  "max_tokens": 180
}' | jq -r '.choices[0].message.content'

VSCode

Per integrarsi con Visual Studio Code, installare l'estensione Continue e aggiungerla a config.yaml:

- name: Qwen3-Coder 30B
  provider: openai
  apiBase: http://[server_IP_address]:8000/v1
  apiKey: none
  model: /home/usergpu/Qwen3-30B
  roles:
    - chat
    - edit
    - apply

Qwen-Agent

Per una configurazione basata su GUI con Qwen-Agent (compresi RAG, MCP e interprete di codice):

pip install -U "qwen-agent[gui,rag,code_interpreter,mcp]"

Aprire l'editor nano:

nano script.py

Esempio di script Python per lanciare Qwen-Agent con una WebUI Gradio:

from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

llm_cfg = {
    'model': '/home/usergpu/Qwen3-30B',
    'model_server': 'http://localhost:8000/v1',
    'api_key': 'EMPTY',
    'generate_cfg': {'top_p': 0.8},
}

tools = ['code_interpreter']

bot = Assistant(
    llm=llm_cfg,
    system_message="You are a helpful coding assistant.",
    function_list=tools
)

WebUI(bot).run()

Eseguire lo script:

python script.py

Il server sarà disponibile all'indirizzo: http://127.0.0.1:7860

È anche possibile integrare Qwen3-Coder in framework di agenti come CrewAI per automatizzare compiti complessi con set di strumenti come la ricerca sul web o la memoria di database vettoriali.

Vedi anche:

Come installare CrewAI con la GUI

Wed, 23 Jul 2025 15:05:43 +0200

Le capacità dei modelli di reti neurali crescono di giorno in giorno. Ricercatori e aziende commerciali investono sempre di più nella loro formazione. Ma da soli, questi modelli non possono agire in modo autonomo. Per risolvere compiti specifici, hanno bisogno di una guida: estensione del contesto e definizione della direzione. Questo approccio non è sempre efficiente, soprattutto per problemi complessi.

Ma cosa succederebbe se permettessimo a una rete neurale di agire autonomamente? E se le fornissimo molti strumenti per interagire con il mondo esterno? Si otterrebbe un agente AI in grado di risolvere compiti determinando autonomamente quali strumenti utilizzare. Sembra complicato, ma funziona molto bene. Tuttavia, anche per un utente avanzato, creare un agente AI da zero può essere un compito non banale.

Il motivo è che le librerie più diffuse non dispongono di un'interfaccia grafica. Richiedono l'interazione attraverso un linguaggio di programmazione come Python. Questo innalza drasticamente la soglia di ingresso e rende gli agenti di intelligenza artificiale troppo complessi per un'implementazione indipendente. Questo è esattamente il caso di CrewAI.

Cos'è CrewAI

CrewAI è una libreria molto popolare e comoda, ma non è dotata di un'interfaccia grafica predefinita. Questo ha spinto gli sviluppatori indipendenti a creare un'interfaccia non ufficiale. La natura open source di CrewAI ha reso il compito molto più facile e presto la comunità ha rilasciato il progetto CrewAI Studio.

Sviluppatori e appassionati hanno acquisito una conoscenza più approfondita dell'architettura del sistema e hanno potuto creare strumenti su misura per compiti specifici. Gli utenti abituali potevano creare agenti AI senza scrivere una sola riga di codice. È diventato più facile assegnare compiti e gestire l'accesso alle reti neurali e agli strumenti. È stato inoltre possibile esportare e importare agenti da un server all'altro e condividerli con amici, colleghi o con la comunità open source.

Un altro vantaggio di CrewAI Studio è la sua flessibilità di distribuzione. Può essere installato come una normale applicazione o come un contenitore Docker, il metodo preferito in quanto include tutte le librerie e i componenti necessari per l'esecuzione del sistema.

Installazione

Aggiornare i pacchetti del sistema operativo e le applicazioni installate alle versioni più recenti:

sudo apt update && sudo apt -y upgrade

Utilizzare lo script di installazione automatica dei driver o seguire la nostra guida Installa i driver NVIDIA® in Linux:

sudo ubuntu-drivers autoinstall

Riavviare il server per rendere effettive le modifiche:

sudo shutdown - r now

Dopo la riconnessione via SSH, installare le utility del server web Apache 2, che consentiranno di accedere al generatore di file .htpasswd utilizzato per l'autenticazione di base degli utenti:

sudo apt install -y apache2-utils

Installare Docker Engine utilizzando lo script di shell ufficiale:

curl -sSL https://get.docker.com/ | sh

Aggiungere Docker Compose al sistema:

sudo apt install -y docker-compose

Clonare il repository:

git clone https://github.com/strnad/CrewAI-Studio.git

Navigare nella directory scaricata:

cd CrewAI-Studio

Creare un file .htpasswd per l'utente usergpu. Verrà richiesto di inserire la password due volte:

htpasswd -c .htpasswd usergpu

Ora modificare il file di distribuzione del contenitore. Per impostazione predefinita, ci sono due contenitori:

sudo nano docker-compose.yaml

Cancellare la sezione:

ports:
  - "5432:5432"

E aggiungere il seguente servizio:


nginx:
  image: nginx:latest
  container_name: crewai_nginx
  ports:
    - "80:80"
  volumes:
    - ./nginx.conf:/etc/nginx/nginx.conf:ro
    - ./.htpasswd:/etc/nginx/.htpasswd:ro
  depends_on:
    - web

Nginx avrà bisogno di un file di configurazione, quindi crearne uno:

sudo nano nginx.conf

Incollare quanto segue:

events {}

http {
  server {
    listen 80;

    location / {
      proxy_pass http://web:8501;

      # WebSocket headers
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";

      # Forward headers
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;

      auth_basic "Restricted Content";
      auth_basic_user_file /etc/nginx/.htpasswd;
    }
  }
}

Tutte le variabili di servizio importanti per CrewAI sono definite nel file .env. Aprire il file .env_example per modificarlo:

nano .env_example

Aggiungere le seguenti righe:

OLLAMA_HOST="http://open-webui:11434"
OLLAMA_MODELS="ollama/llama3.2:latest"

E aggiungere la configurazione di Postgres:

POSTGRES_USER="admin"
POSTGRES_PASSWORD="your_password"
POSTGRES_DB="crewai_db"
AGENTOPS_ENABLED="False"

Ora copiare il file di esempio e rinominarlo in .env, in modo che il sistema possa leggerlo durante la distribuzione del contenitore:

cp .env_example .env

In questo esempio, utilizzeremo modelli locali con inferenza gestita da Ollama. Si consiglia la nostra guida Open WebUI: Tutto in uno, e durante la distribuzione aggiungere -e OLLAMA_HOST=0.0.0.0 per consentire a CrewAI di connettersi direttamente al contenitore Ollama. Scaricare il modello desiderato (per esempio, llama3.2:latest) tramite WebUI o collegandosi alla console del contenitore ed eseguendo:

ollama pull llama3.2:latest

Una volta che tutto è stato configurato, lanciare il deployment:

sudo docker-compose up -d --build

A questo punto, visitando http://[your_server_ip]/ verranno richieste le credenziali di accesso. Una volta inserite correttamente, apparirà l'interfaccia CrewAI.

Caratteristiche

Esploriamo le entità chiave utilizzate da CrewAI. Questo aiuterà a capire come configurare i flussi di lavoro. L'entità centrale di Agent è un task executor autonomo. Ogni agente ha degli attributi che lo aiutano a svolgere i propri compiti:

Role. Una breve descrizione del lavoro, di 2-3 parole.
Backstory. Opzionale; aiuta il modello linguistico a capire come l'agente deve comportarsi e su quali esperienze basarsi.
Goal. L'obiettivo che l'agente deve perseguire.
Allow delegation. Consente all'agente di delegare compiti (o parti di essi) ad altri.
Verbose. Indica all'agente di registrare azioni dettagliate.
LLM Provider and Model. Specifica il modello e il provider da utilizzare.
Temperature. Determina la creatività della risposta. Più alto = più creativo.
Max iterations. Numero di tentativi che l'agente ha a disposizione per avere successo, agendo come una salvaguardia (ad esempio, contro i loop infiniti).

Gli agenti operano analizzando iterativamente gli input, ragionando e traendo conclusioni utilizzando gli strumenti disponibili.

L'input è definito da un'entità Task. Ogni compito include una descrizione, un agente assegnato e, facoltativamente, un risultato atteso. Per impostazione predefinita, i compiti vengono eseguiti in modo sequenziale, ma possono essere parallelizzati usando il flag Async execution.

Il lavoro autonomo degli agenti è supportato da Tools che consente l'interazione con il mondo reale. CrewAI include strumenti per la ricerca sul web, il parsing dei siti, le chiamate API e la gestione dei file, migliorando il contesto e aiutando gli agenti a raggiungere gli obiettivi.

Infine, c'è Crew entity che unisce agenti con ruoli diversi in una squadra per affrontare problemi complessi. Possono comunicare, delegare, rivedere e correggere l'un l'altro, formando essenzialmente un'intelligenza collettiva.

Utilizzando

Ora che si ha familiarità con le entità, costruiamo ed eseguiamo un flusso di lavoro minimo di CrewAI. In questo esempio, seguiremo i progressi globali nello sviluppo di farmaci contro il cancro.

Utilizzeremo tre agenti:

Oncology Drug Pipeline Analyst - segue i nuovi sviluppi dalle fasi iniziali alla sperimentazione clinica.
Regulatory and Approval Watchdog - monitora le approvazioni di nuovi farmaci e le modifiche normative.
Scientific Literature and Innovation Scout - analizza le pubblicazioni scientifiche e i brevetti relativi all'oncologia.

Aprire la sezione Agenti e creare il primo agente:

Per ora, utilizziamo il modello llama3.2:latest scaricato in precedenza, ma in uno scenario reale, scegliete quello che meglio si adatta all'attività. Ripetere la procedura per gli altri agenti e passare alla creazione dell'attività.

Riunire tutti gli agenti in una squadra e assegnare loro il compito preparato:

Attivare gli strumenti necessari dall'elenco:

Infine, andare alla pagina Kickoff! e fare clic su Run Crew! Dopo alcune iterazioni, il sistema restituirà un risultato, ad esempio:

Prima di concludere, controlliamo la sezione Import/export. Il flusso di lavoro o l'equipaggio possono essere esportati come JSON per essere trasferiti a un altro server CrewAI. È anche possibile creare un'applicazione a pagina singola (SPA) con un solo clic, perfetta per la distribuzione in produzione:

Conclusione

CrewAI semplifica notevolmente la creazione di agenti AI, consentendo l'integrazione in qualsiasi applicazione o l'utilizzo autonomo. La libreria si basa sull'idea di intelligenza distribuita, in cui ogni agente è un esperto di dominio e la squadra combinata supera un singolo agente generalista.

Essendo scritta in Python, CrewAI si integra facilmente con piattaforme e strumenti di ML. La sua natura open source consente l'estensione attraverso moduli di terze parti. La comunicazione tra agenti riduce l'uso di token distribuendo l'elaborazione del contesto.

Di conseguenza, le attività complesse vengono completate in modo più rapido ed efficiente. La barriera d'ingresso più bassa fornita da CrewAI Studio espande la portata degli agenti AI e dei sistemi multi-agente. Il supporto per i modelli locali garantisce un migliore controllo dei dati sensibili.

Vedi anche:

Cosa c'è di nuovo in Qwen 3

Mon, 14 Jul 2025 08:05:08 +0200

La corsa globale all'intelligenza artificiale sta accelerando. Istituti di ricerca, aziende private e persino intere nazioni sono in competizione per la leadership nel settore dell'IA. In linea di massima, questa corsa può essere suddivisa in diverse fasi. La prima fase ha riguardato la creazione di IA ristretta. I modelli di rete neurale esistenti, come GPT, MidJourney e AlphaFold, dimostrano che questa fase è stata raggiunta con successo.

La fase successiva prevede l'evoluzione dell'IA in AGI (Artificial General Intelligence). L'AGI dovrebbe eguagliare l'intelligenza umana nella risoluzione di un'ampia gamma di compiti, dalla scrittura di storie all'esecuzione di calcoli scientifici, dalla comprensione di situazioni sociali all'apprendimento autonomo. Al momento in cui scriviamo, questo livello non è ancora stato raggiunto.

Lo stadio finale dello sviluppo dell'intelligenza artificiale viene definito ASI (Artificial Super Intelligence). Essa supererebbe di gran lunga le capacità umane in tutti i settori. Ciò consentirebbe di sviluppare tecnologie che oggi non possiamo nemmeno immaginare e di gestire sistemi globali con una precisione superiore alle capacità umane. Tuttavia, questo potrebbe diventare realtà solo dopo decenni (o addirittura secoli) di continui progressi.

Di conseguenza, la maggior parte dei partecipanti alla corsa all'intelligenza artificiale si concentra sul raggiungimento dell'AGI mantenendo il controllo su di essa. Lo sviluppo dell'intelligenza artificiale è strettamente legato a una serie di complesse sfide tecniche, etiche e legali. Tuttavia, i potenziali vantaggi superano di gran lunga i costi, ed è per questo che aziende come Alibaba Group stanno investendo molto in questo settore.

Il rilascio di Qwen 3 segna una pietra miliare significativa non solo per le reti neurali di un'azienda, ma anche a livello globale. Rispetto al suo predecessore, il modello introduce diverse importanti innovazioni.

Caratteristiche

Qwen 2.5 è stato preaddestrato su un set di dati di 18 miliardi di token, mentre il nuovo modello ha raddoppiato questa quantità a 36 miliardi di token. Il set di dati più grande ha migliorato significativamente l'accuratezza del modello di base. È interessante notare che, oltre ai dati Internet disponibili pubblicamente e raccolti attraverso il parsing, il sistema è stato addestrato anche su documenti PDF. Questi sono tipicamente ben strutturati e densi di conoscenza, il che aiuta il modello a fornire risposte più accurate e a comprendere meglio formulazioni complesse.

Una delle direzioni più promettenti nello sviluppo dell'IA è la costruzione di modelli capaci di ragionare, in grado di espandere il contesto del compito attraverso un processo iterativo. Da un lato, ciò consente una risoluzione dei problemi più completa, ma dall'altro il ragionamento tende a rallentare notevolmente il processo. Per questo motivo, gli sviluppatori di Qwen 3 hanno introdotto due modalità operative:

Thinking mode. Il modello costruisce il contesto passo dopo passo prima di fornire una risposta finale. Questo permette di affrontare problemi complessi che richiedono una comprensione profonda.
Non-thinking mode. Il modello risponde quasi istantaneamente, ma può produrre risposte più superficiali senza un'analisi approfondita.

Questo controllo manuale sul comportamento del modello migliora l'esperienza dell'utente nella gestione di molti compiti di routine. Ridurre l'uso della modalità di riflessione riduce anche in modo significativo il carico della GPU, consentendo di elaborare un maggior numero di token nello stesso lasso di tempo.

Oltre a questa scelta binaria, esiste anche un meccanismo di commutazione morbida. Questo comportamento ibrido consente al modello di adattarsi al contesto utilizzando meccanismi di ponderazione interni. Se il modello ritiene che un compito sia difficile, innesca automaticamente un ragionamento o addirittura un'autoverifica. Può anche rispondere a indicazioni dell'utente come "Pensiamo passo dopo passo".

Un altro miglioramento significativo è l'ampliamento del supporto multilingue. Mentre Qwen 2.5 supportava solo 29 lingue, la versione 3 è ora in grado di comprendere e generare testo in 119 lingue e dialetti. Questo ha migliorato notevolmente la capacità di seguire le istruzioni e la comprensione del contesto. Di conseguenza, Qwen 3 può ora essere utilizzato efficacemente in ambienti non inglesi.

Inoltre, Qwen 3 è ora significativamente meglio integrato con i server MCP, fornendo al modello gli strumenti per approfondire la risoluzione dei problemi ed eseguire le azioni. Ora può interagire con fonti esterne e gestire direttamente processi complessi.

Formazione del modello

Formazione preliminare

Un salto di qualità così sostanziale non sarebbe stato possibile senza un sistema di formazione in più fasi. Inizialmente, il modello è stato preaddestrato su 30B token con una lunghezza del contesto di 4K, consentendogli di acquisire conoscenze generali e competenze linguistiche di base.

È seguita una fase di affinamento con dati più scientifici e ben strutturati. Durante questa fase, il modello ha acquisito anche la capacità di scrivere efficacemente applicazioni in più linguaggi di programmazione.

Infine, è stato addestrato su un set di dati di alta qualità con un contesto esteso. Di conseguenza, Qwen 3 supporta ora una lunghezza effettiva del contesto di 128K tokens, pari a circa 350 pagine di testo digitato, a seconda della lingua. Ad esempio, le lingue basate sul cirillico hanno spesso token più corti a causa della morfologia e dell'uso di prefissi, suffissi, ecc.

Pipeline di ragionamento

La costruzione di modelli in grado di ragionare è un processo affascinante ma che richiede molto lavoro e che combina varie tecniche esistenti volte a simulare il pensiero umano. Sulla base delle informazioni disponibili pubblicamente, possiamo ipotizzare che l'addestramento al ragionamento di Qwen 3 abbia coinvolto quattro fasi principali:

Cold start for long chains of thought. Addestramento del modello a suddividere i problemi in più fasi senza un precedente adattamento. Questo lo aiuta ad apprendere il pensiero iterativo e a sviluppare un livello base di capacità di ragionamento.
Reinforcement learning based on reasoning. In questa fase, i premi non dipendono solo dalla risposta finale, ma anche dalla capacità del modello di costruire catene di ragionamento logiche, interpretabili e strutturate. Viene valutata anche l'assenza di errori e allucinazioni.
Merging reasoning modes. Gli esseri umani si basano tipicamente su due stili di pensiero: veloce (intuitivo) e lento (analitico). A seconda del tipo di compito, il modello neurale deve imparare a passare da uno stile all'altro e a integrarli. Questo viene solitamente fatto utilizzando esempi che mescolano entrambi gli stili o attraverso token speciali che indicano quale stile applicare.
General reinforcement learning. Questa fase finale assomiglia a un ambiente sandbox in cui il modello impara a interagire con gli strumenti, a eseguire compiti a più fasi e a sviluppare un comportamento adattivo. Qui, inoltre, si sintonizza con le preferenze dell'utente.

Conclusione

Qwen 3 è una pietra miliare per Alibaba Group. La sua qualità di formazione e la sua metodologia lo rendono un serio concorrente di attori affermati come OpenAI e Anthropic. I miglioramenti rispetto alla versione precedente sono sostanziali.

Un ulteriore vantaggio è la sua natura open-source, con la base di codice pubblicamente disponibile su GitHub sotto la licenza Apache 2.0.

L'ulteriore sviluppo della famiglia di modelli Qwen contribuirà a rafforzare la sua posizione nell'arena globale dell'intelligenza artificiale e a ridurre il divario con i modelli commerciali a codice chiuso. E tutti i risultati attuali sono, in un modo o nell'altro, passi avanti verso il progresso dell'umanità nella costruzione dell'IA.

Vedi anche:

Server MCP basato su N8N

Wed, 02 Jul 2025 15:28:18 +0200

Lo sviluppo delle reti neurali generative ha subito una notevole accelerazione negli ultimi anni. Sono diventate notevolmente più veloci e precise nelle risposte e hanno imparato a ragionare. Tuttavia, le loro capacità sono ancora fondamentalmente limitate dalla loro architettura. Per esempio, ogni LLM esistente al momento in cui scriviamo ha una data di scadenza della conoscenza. Ciò significa che ogni giorno che passa, un LLM di questo tipo ha sempre più probabilità di produrre risposte errate, semplicemente perché manca di informazioni sugli eventi che si sono verificati dopo quella data.

Questa limitazione impone di riqualificare il modello interamente su dati più freschi, il che è costoso e richiede molto tempo. Ma c'è un altro modo. Se si consente al modello di interagire con il mondo esterno, può trovare e aggiornare autonomamente le informazioni richieste durante una conversazione con l'utente, senza bisogno di riqualificarsi.

Questo è più o meno il funzionamento del meccanismo RAG (Retrieval Augmented Generation). Quando risponde a una domanda, il modello interroga prima un database vettoriale preparato in precedenza e, se trova informazioni rilevanti, le incorpora nella domanda. In questo modo, spiegando e aggiornando il DB vettoriale, la qualità delle risposte LLM può essere notevolmente migliorata.

Ma c'è un altro modo, ancora più interessante, per incorporare un contesto aggiornato nei prompt. Si chiama MCP, che sta per Model Context Protocol. È stato originariamente sviluppato da Anthropic per il suo modello Claude. Il momento chiave è stato quando il codice sorgente di MCP è stato reso open-source, consentendo a migliaia di ricercatori di intelligenza artificiale di costruire server personalizzati per vari scopi.

L'essenza di MCP consiste nel dare a un modello di rete neurale l'accesso a strumenti con cui può aggiornare in modo indipendente le proprie conoscenze ed eseguire varie azioni per risolvere in modo efficiente determinati compiti. È il modello stesso a decidere quale strumento utilizzare e se è appropriato in ogni situazione.

Il supporto per MCP è apparso presto in vari IDE come Cursor e in piattaforme di automazione come N8N. Quest'ultima è particolarmente intuitiva, in quanto i flussi di lavoro vengono creati visivamente, rendendo più facile la comprensione. In N8N è possibile collegarsi a un server MCP esistente o crearne uno proprio. Inoltre, è possibile organizzare una connessione diretta all'interno di un singolo flusso di lavoro. Ma andiamo per gradi.

Creazione di un semplice agente AI

Prima di iniziare, assicuratevi che il requisito principale sia soddisfatto: avete un LLM pronto per le connessioni. Può trattarsi di un modello in esecuzione locale con Ollama o di un servizio esterno come ChatGPT di OpenAI. Nel primo caso, è necessario conoscere l'indirizzo dell'API locale di Ollama (e facoltativamente la sua autenticazione), mentre nel secondo caso è necessario un account OpenAI attivo con crediti sufficienti.

La creazione di un agente inizia con il nodo chiave AI Agent. Come minimo, deve essere collegato ad altri due nodi, uno per agire come trigger e l'altro per connettersi all'LLM. Se non si specifica un trigger, il sistema ne creerà uno automaticamente, attivando l'agente alla ricezione di qualsiasi messaggio nella chat interna:

L'unico pezzo mancante è l'LLM. Ad esempio, è possibile utilizzare la nostra Open WebUI: Tutto in uno per configurare Ollama con un'interfaccia web. L'unica modifica richiesta è che i contenitori per N8N e Open WebUI devono trovarsi sulla stessa rete. Ad esempio, se il contenitore N8N si trova su una rete denominata web, nel comando di installazione per Open WebUI, sostituire --network=host con --network=web.

In alcuni casi, è necessario impostare manualmente la variabile d'ambiente OLLAMA_HOST, ad esempio: -e OLLAMA_HOST=0.0.0.0. Questo permette di collegarsi all'API di Ollama non solo da localhost, ma anche da altri contenitori. Supponiamo che Ollama sia distribuito in un contenitore chiamato ollama-webui. Allora l'URL di base per la connessione da N8N sarà:

http://open-webui:11434

Prima di collegare il nodo Ollama Chat Model, non dimenticate di scaricare almeno un modello. È possibile farlo dall'interfaccia web o tramite la CLI del contenitore. Il comando seguente scarica il modello Llama 3.1 con 8 miliardi di parametri:

ollama pull llama3.1:8b

Una volta scaricato e installato, il modello apparirà automaticamente nell'elenco di quelli disponibili:

Un flusso di lavoro minimo di un agente AI funzionante si presenta come segue:

In questa forma, l'agente può usare solo un modello e non memorizza i dati di input o migliora i prompt usando strumenti esterni. Quindi ha senso aggiungere almeno il nodo Simple Memory. Per carichi leggeri, è sufficiente memorizzare richieste e risposte.

Ma torniamo a MCP. Per iniziare, creare un server utilizzando il nodo speciale MCP Server Trigger:

Questo nodo è completamente autonomo e non richiede un'attivazione esterna. Viene attivato esclusivamente da una richiesta esterna in arrivo al suo indirizzo webhook. Per impostazione predefinita, ci sono due URL: Test URL e Production URL. Il primo viene usato durante lo sviluppo, mentre il secondo funziona solo quando il flusso di lavoro viene salvato e attivato.

Il trigger è inutile da solo, ha bisogno di strumenti collegati. Ad esempio, colleghiamo uno degli strumenti più semplici: una calcolatrice. Questa si aspetta un'espressione matematica come input. I nodi comunicano utilizzando un semplice JSON, quindi per far sì che la calcolatrice calcoli 2 + 2, l'input dovrebbe essere:

[
  {
    "query": {
      "input": "2 + 2"
    }
  }
]

Gli LLM possono facilmente generare tali JSON dalle descrizioni dei task in testo semplice e inviarli al nodo, che esegue i calcoli e restituisce il risultato. Colleghiamo il client MCP all'agente:

Vale la pena notare che questo nodo non ha bisogno di connessioni aggiuntive. Nelle sue impostazioni, è sufficiente specificare l'indirizzo dell'endpoint a cui invierà i dati dall'agente AI. Nel nostro esempio, questo indirizzo punta al contenitore chiamato n8n.

Naturalmente, in questa fase è possibile specificare qualsiasi indirizzo di server MCP esterno disponibile. Ma per questo articolo, utilizzeremo un'istanza locale in esecuzione all'interno di N8N. Vediamo come si comportano il client e il server quando all'agente AI viene chiesto di eseguire una semplice operazione matematica:

Dopo aver ricevuto la richiesta, l'Agente AI:

Cerca nella memoria semplice per vedere se l'utente l'ha già chiesta in precedenza o se è possibile riutilizzare un contesto.
Invia la richiesta all'LLM, che scompone correttamente l'espressione matematica e prepara il JSON corrispondente.
Inviare il JSON allo strumento Calcolatrice e ricevere il risultato.
Utilizzare l'LLM per generare la risposta finale e inserire il risultato nella risposta.
Memorizzare il risultato in Simple Memory.
Emettere il messaggio nella chat.

Allo stesso modo, gli agenti possono lavorare con altri strumenti sul server MCP. Invece di Simple Memory, è possibile utilizzare opzioni più avanzate come MongoDB, Postgres, Redis o persino qualcosa come Zep. Naturalmente, queste opzioni richiedono una manutenzione minima del database, ma le prestazioni complessive aumenteranno in modo significativo.

Ci sono anche molte più opzioni per la selezione degli strumenti. Il nodo MCP Server Trigger supporta oltre 200 strumenti. Questi possono essere di qualsiasi tipo, da semplici richieste HTTP a integrazioni precostituite con servizi Internet pubblici. All'interno di un singolo flusso di lavoro, è possibile creare sia un server che un client. Una cosa importante da notare: questi nodi non possono essere collegati visivamente nell'editor, e questo è un comportamento previsto:

Al posto del trigger predefinito, è possibile utilizzare altre opzioni, come la ricezione di un messaggio tramite messenger, l'invio di un modulo di un sito web o l'esecuzione in base a una pianificazione. In questo modo è possibile impostare flussi di lavoro che reagiscono a eventi o eseguono operazioni di routine, come l'esportazione quotidiana di dati da Google Ads.

E le possibilità offerte dagli agenti di intelligenza artificiale non finiscono qui. È possibile costruire sistemi multi-agente utilizzando diversi modelli di rete neurale che lavorano insieme per risolvere i compiti con maggiore precisione, considerando molti più fattori di influenza nel processo.

Vedi anche:

Come installare N8N

Mon, 23 Jun 2025 14:30:26 +0200

Gli agenti di intelligenza artificiale nel 2025 rimangono uno degli approcci più promettenti per risolvere compiti complessi utilizzando modelli linguistici di grandi dimensioni. Questi agenti sono autonomi e in grado di selezionare da soli vari strumenti per svolgere i compiti assegnati. Questo approccio consente di ottenere risultati con un minore coinvolgimento umano e una qualità superiore. Inoltre, apre la possibilità di scoprire modi più originali ed efficaci di affrontare i problemi.

Anziché limitarsi a formulare un compito, si incarica la rete neurale di risolverlo autonomamente, in base alle risorse assegnatele. Tuttavia, perché questo schema funzioni, è necessario un meccanismo che colleghi le interfacce delle reti neurali con vari strumenti, che si tratti di una ricerca sul Web o di un database vettoriale per la memorizzazione dei risultati intermedi.

n8n è una piattaforma di automazione che supporta l'integrazione con varie reti neurali e servizi pubblici. Gli utenti possono progettare visivamente le modalità di elaborazione dei dati e i risultati finali da ottenere. A differenza delle classiche soluzioni no-code, n8n consente di includere codice arbitrario in qualsiasi fase del processo, il che è particolarmente utile quando le funzionalità integrate non sono sufficienti.

Il risultato è un sistema che unisce la semplicità del no-code alla flessibilità della programmazione tradizionale. Tuttavia, per comprenderlo appieno, è necessario dedicare un po' di tempo all'esplorazione e alla revisione di esempi di flussi di lavoro per una migliore comprensione. In questo articolo vi spiegheremo come implementare n8n sui server LeaderGPU.

Preparazione del server

Aggiornare il sistema

Aggiornare l'elenco dei pacchetti e aggiornare tutti i pacchetti installati:

sudo apt update && sudo apt -y upgrade

Installare automaticamente il driver NVIDIA® consigliato (proprietario) o utilizzare la nostra guida passo-passo Installa i driver NVIDIA® in Linux:

sudo ubuntu-drivers autoinstall

Ora riavviare il server:

sudo shutdown -r now

Installare Docker

È possibile utilizzare lo script di installazione ufficiale:

curl -sSL https://get.docker.com/ | sh

Aggiungiamo la chiave GPG e il repository di NVIDIA® container toolkit per l'integrazione di Docker:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Aggiornare l'elenco dei pacchetti e installare NVIDIA® container toolkit:

sudo apt update && sudo apt -y install nvidia-container-toolkit

Riavviare Docker per applicare le modifiche e abilitare il toolkit installato:

sudo systemctl restart docker

Installare n8n

Per consentire al sistema di memorizzare i dati, è necessario creare un volume prima di lanciare il contenitore:

sudo docker volume create n8n_data

Avviamo ora un contenitore che aprirà la porta 5678 per le connessioni esterne e monterà il volume n8n_data creato nella directory /home/node/.n8n all'interno del contenitore:

sudo docker run -d --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

La prima volta che si lancia l'applicazione, si potrebbe rimanere perplessi di fronte al seguente messaggio di errore:

Non si tratta esattamente di un errore, ma piuttosto di un avvertimento su come configurare correttamente il sistema per l'accesso. Il problema è che, per impostazione predefinita, il sistema non dispone di un certificato TLS/HTTPS. Senza di esso, la connessione non sarà sicura. Quindi, avete tre opzioni:

Connect your own certificate. È possibile farlo specificando i percorsi dei file dei certificati tramite variabili d'ambiente o configurando un server proxy inverso.
Create an SSH tunnel and forward port 5678 a localhost sul computer da cui ci si connette. In questo modo, si otterrà immediatamente una connessione personale sicura. Tuttavia, nessun altro potrà accedere al server dall'esterno.
Bypass the warning. Se si tratta di un server di prova non destinato alla produzione e non ci si preoccupa della sicurezza, si può disabilitare l'avviso impostando la variabile d'ambiente N8N_SECURE_COOKIE su FALSE. Questo è fortemente sconsigliato perché rende il server vulnerabile a potenziali attacchi. Tuttavia, potrebbe essere accettabile in scenari specifici.

Questo articolo analizzerà in dettaglio ogni opzione, in modo da poter scegliere quella giusta.

Connessione al server

Se non avete ancora un certificato SSL, vi consigliamo di ordinarne uno da LeaderSSL. Può essere utilizzato per qualsiasi sito web, negozio online o per verificare l'autenticità di un'e-mail.

Uso delle variabili d'ambiente

Il modo più semplice per configurare l'HTTPS è caricare il certificato sul server e specificarlo tramite le variabili d'ambiente di Docker. Si inizia creando una cartella per i file del certificato:

mkdir ~/n8n-certs

È possibile caricare questi file (tipicamente cert.crt e privkey.key) in questa directory utilizzando qualsiasi metodo. Per informazioni più dettagliate, vedere:

Ora lanciamo il contenitore con un comando completo:

sudo docker run -d \
--name n8n \
-p 5678:5678 \
-v n8n_data:/home/node/.n8n \
-v ~/n8n-certs:/certs \
-e N8N_PROTOCOL=https \
-e N8N_SSL_CERT="/certs/cert.crt" \
-e N8N_SSL_KEY="/certs/privkey.key" \
docker.n8n.io/n8nio/n8n

Ecco la ripartizione di ogni argomento:

sudo docker run -d lancia il contenitore Docker in modalità daemon (in background)
--name n8n assegna il nome al contenitore n8n
-p 5678:5678 inoltra la porta 5678 al contenitore
-v n8n_data:/home/node/.n8n crea e monta un volume chiamato n8n_data nella directory nascosta /home/node/.n8n all'interno del contenitore
-v ~/n8n-certs:/certs monta la directory dei certificati
-e N8N_PROTOCOL=https obbliga N8N a utilizzare il protocollo HTTPS
-e N8N_SSL_CERT="/certs/cert.crt" imposta il percorso del file del certificato
-e N8N_SSL_KEY="/certs/privkey.key" imposta il percorso della chiave del certificato
docker.n8n.io/n8nio/n8n sorgente dell'immagine del contenitore

Traefik

Una configurazione leggermente più complessa ma flessibile prevede l'utilizzo del server reverse proxy Traefik per proteggere la connessione a N8N. Il file di configurazione si basa sul metodo ufficiale specificato nella documentazione. Innanzitutto, installare lo strumento docker-compose:

sudo apt -y install docker-compose

Traefik e N8N verranno distribuiti insieme e devono trovarsi sulla stessa rete. Creare una rete chiamata web.

sudo docker network create web

Ora, creare un file docker-compose.yml per definire ed eseguire entrambi i contenitori:

nano docker-compose.yml

services:
  traefik:
    image: "traefik"
    container_name: "proxy"
    restart: always
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.mytlschallenge.acme.tlschallenge=true"
      - "--certificatesresolvers.mytlschallenge.acme.email=${SSL_EMAIL}"
      - "--certificatesresolvers.mytlschallenge.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - traefik_data:/letsencrypt
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - web

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: "n8n"
    restart: always
    ports:
      - "127.0.0.1:5678:5678"
    labels:
      - traefik.enable=true
      - traefik.http.routers.n8n.rule=Host(`${SUBDOMAIN}.${DOMAIN_NAME}`)
      - traefik.http.routers.n8n.tls=true
      - traefik.http.routers.n8n.entrypoints=web,websecure
      - traefik.http.routers.n8n.tls.certresolver=mytlschallenge
      - traefik.http.middlewares.n8n.headers.SSLRedirect=true
      - traefik.http.middlewares.n8n.headers.STSSeconds=315360000
      - traefik.http.middlewares.n8n.headers.browserXSSFilter=true
      - traefik.http.middlewares.n8n.headers.contentTypeNosniff=true
      - traefik.http.middlewares.n8n.headers.forceSTSHeader=true
      - traefik.http.middlewares.n8n.headers.SSLHost=${DOMAIN_NAME}
      - traefik.http.middlewares.n8n.headers.STSIncludeSubdomains=true
      - traefik.http.middlewares.n8n.headers.STSPreload=true
      - traefik.http.routers.n8n.middlewares=n8n@docker
    environment:
      - N8N_HOST=${SUBDOMAIN}.${DOMAIN_NAME}
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - WEBHOOK_URL=https://${SUBDOMAIN}.${DOMAIN_NAME}/
      - GENERIC_TIMEZONE=${GENERIC_TIMEZONE}
    volumes:
      - n8n_data:/home/node/.n8n
      - ./local-files:/files
    networks:
      - web

volumes:
  n8n_data:
  traefik_data:

networks:
  web:
    name: web

Oltre al file docker-compose.yml, creeremo un altro file chiamato .env. Questo file conterrà variabili come il nome del dominio e l'indirizzo e-mail usati per richiedere un certificato SSL a Let's Encrypt. Se dovessimo cambiare qualcosa, come il nome del dominio, basterà aggiornarlo in questo file e poi ricreare il contenitore.

nano .env

DOMAIN_NAME=example.com
SUBDOMAIN=n8n
GENERIC_TIMEZONE=Europe/Amsterdam
SSL_EMAIL=user@example.com

Infine, distribuire entrambi i contenitori:

sudo docker-compose up -d

Ora, N8N è disponibile qui: https://n8n.example.com.

Gestore del proxy Nginx

A differenza di Traefik, che si configura tramite file, Nginx Proxy Manager offre un'interfaccia web di facile utilizzo. Tuttavia, non rileva i servizi in modo dinamico, è necessario aggiungerli manualmente. Tuttavia, funziona bene per servizi statici come N8N.

Creare un altro file docker-compose.yml in una cartella separata con il seguente contenuto:

services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    container_name: proxy
    restart: unless-stopped
    ports:
      - '80:80'
      - '443:443'
      - '81:81'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    networks:
      - web

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    environment:
      - N8N_HOST=n8n.example.com
      - N8N_PORT=5678
      - WEBHOOK_URL=https://n8n.example.com/
      - N8N_PROTOCOL=http
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - web

volumes:
  n8n_data:

networks:
  web:
    external: true

Distribuire con:

sudo docker-compose up -d

Aprire quindi l'interfaccia web a: http://your_hostname_or_ip:81

Nome utente: admin@example.com
Password: changeme

Verrà richiesto di aggiornare le credenziali. Successivamente, aprite Hosts → Proxy Hosts → Add Proxy Host e inserite il vostro nome di dominio (ad esempio, n8n.example.com):

Compilare i campi necessari:

Impostare Destination/IP su n8n.
Impostare Port su 5678.
Nella scheda SSL, scegliere Request a new SSL certificate with Let’s Encrypt.
Inserite il vostro indirizzo e-mail e accettate i termini.
Fare clic su Websockets support.
Cliccare facoltativamente su Force SSL.

Dopo aver premuto il pulsante Save, il certificato verrà richiesto e installato:

Una volta fatto, aprendo il dominio si accederà all'interfaccia N8N.

Tunnel SSH

Se non si ha bisogno di accedere all'N8N dall'esterno, è possibile inoltrare la porta 5678 tramite SSH. In questo modo si cripta tutto il traffico e l'N8N sarà disponibile all'indirizzo http://localhost:5678/.

Nota: questa configurazione non funziona per le integrazioni con servizi esterni come i messenger che richiedono un accesso pubblico HTTPS.

Il modo più semplice per inoltrare la porta è il popolare client SSH PuTTY. Una volta installato, aprire SSH → Tunnels e impostare Source port - 5678 e Destination - localhost:5678. Quindi fare clic su Add.

Tornare a Session, inserire l'IP del server e fare clic su Open. Una volta autenticati, il tunnel è attivo. Aprire http://localhost:5678 in un browser per accedere a N8N.

Nota: la connessione funziona solo quando la sessione SSH è attiva. La chiusura di PuTTY interromperà il tunnel.

Bypassare

Questo metodo non è consigliato per l'uso su reti pubbliche. Se si lancia il contenitore con la variabile d'ambiente N8N_SECURE_COOKIE=false, l'avviso scomparirà e si potrà accedere via HTTP:

sudo docker run -d --name n8n -p 5678:5678 -e N8N_SECURE_COOKIE=false -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

Warning: Questo espone il pannello di amministrazione di N8N tramite HTTP non criptato, rendendolo vulnerabile agli attacchi MITM (Man-In-The-Middle) e consentendo potenzialmente a un aggressore di prendere il controllo del server.

Vedi anche:

Triton™ Inference Server

Wed, 26 Feb 2025 16:40:21 +0100

I requisiti aziendali possono variare, ma tutti condividono un principio fondamentale: i sistemi devono funzionare rapidamente e fornire la massima qualità possibile. Quando si tratta di inferenza di reti neurali, l'uso efficiente delle risorse di calcolo diventa fondamentale. Qualsiasi sottoutilizzo della GPU o tempo di inattività si traduce direttamente in perdite finanziarie.

Consideriamo un mercato come esempio. Queste piattaforme ospitano numerosi prodotti, ciascuno con diversi attributi: descrizioni testuali, specifiche tecniche, categorie e contenuti multimediali come foto e video. Tutti i contenuti richiedono una moderazione per mantenere condizioni eque per i venditori ed evitare che merci vietate o contenuti illegali appaiano sulla piattaforma.

La moderazione manuale è possibile, ma è lenta e inefficiente. Nell'ambiente competitivo di oggi, i venditori hanno bisogno di espandere rapidamente la propria gamma di prodotti: più velocemente gli articoli appaiono sul marketplace, maggiori sono le possibilità di essere scoperti e acquistati. La moderazione manuale è inoltre costosa e soggetta a errori umani, che potrebbero consentire il passaggio di contenuti inappropriati.

La moderazione automatica, che utilizza reti neurali appositamente addestrate, offre una soluzione. Questo approccio offre molteplici vantaggi: riduce sostanzialmente i costi di moderazione, migliorando al contempo la qualità. Le reti neurali elaborano i contenuti molto più velocemente degli esseri umani, consentendo ai venditori di superare più rapidamente la fase di moderazione, soprattutto quando si gestiscono grandi volumi di prodotti.

L'approccio ha le sue sfide. L'implementazione di una moderazione automatizzata richiede lo sviluppo e l'addestramento di modelli di reti neurali, che richiedono personale qualificato e notevoli risorse informatiche. Tuttavia, i vantaggi diventano evidenti subito dopo l'implementazione iniziale. L'aggiunta dell'implementazione automatica dei modelli può snellire in modo significativo le operazioni in corso.

Inferenza

Supponiamo di aver capito le procedure di apprendimento automatico. Il passo successivo è determinare come eseguire l'inferenza del modello su un server in affitto. Per un singolo modello, di solito si sceglie uno strumento che funziona bene con il framework specifico su cui è stato costruito. Tuttavia, quando si ha a che fare con più modelli creati in framework diversi, si hanno due opzioni.

Si possono convertire tutti i modelli in un unico formato, oppure scegliere uno strumento che supporti più framework. Triton™ Inference Server si adatta perfettamente al secondo approccio. Supporta i seguenti backend:

TensorRT™
TensorRT-LLM
vLLM
Pitone
PyTorch (LibTorch)
Runtime ONNX
Tensorflow
FIL
DALI

Inoltre, è possibile utilizzare qualsiasi applicazione come backend. Ad esempio, se avete bisogno di una post-elaborazione con un'applicazione C/C++, potete integrarla senza problemi.

Scalare

Triton™ Inference Server gestisce in modo efficiente le risorse di calcolo su un singolo server eseguendo più modelli contemporaneamente e distribuendo il carico di lavoro sulle GPU.

L'installazione avviene tramite un container Docker. Gli ingegneri DevOps possono controllare l'allocazione delle GPU all'avvio, scegliendo di utilizzare tutte le GPU o di limitarne il numero. Sebbene il software non gestisca direttamente lo scaling orizzontale, è possibile utilizzare bilanciatori di carico tradizionali come HAproxy o distribuire le applicazioni in un cluster Kubernetes.

Preparazione del sistema

Per configurare Triton™ su un server LeaderGPU con Ubuntu 22.04, aggiornare prima il sistema con questo comando:

sudo apt update && sudo apt -y upgrade

Innanzitutto, installare i driver NVIDIA® utilizzando lo script di autoinstallazione:

sudo ubuntu-drivers autoinstall

Riavviare il server per applicare le modifiche:

sudo shutdown -r now

Una Volta™ che il server è di nuovo online, installare Docker utilizzando il seguente script di installazione:

curl -sSL https://get.docker.com/ | sh

Poiché Docker non è in grado di passare le GPU ai container per impostazione predefinita, è necessario NVIDIA® Container Toolkit. Aggiungere il repository NVIDIA® scaricando e registrando la sua chiave GPG:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Aggiornare la cache dei pacchetti e installare il toolkit:

sudo apt update && sudo apt -y install nvidia-container-toolkit

Riavviare Docker per abilitare le nuove funzionalità:

sudo systemctl restart docker

Il sistema operativo è ora pronto all'uso.

Installazione del server di inferenza Triton™

Scarichiamo il repository del progetto:

git clone https://github.com/triton-inference-server/server

Questo repository contiene esempi di reti neurali preconfigurate e uno script per il download del modello. Navigare nella directory examples:

cd server/docs/examples

Scaricare i modelli eseguendo il seguente script, che li salverà in ~/server/docs/examples/model_repository:

./fetch_models.sh

L'architettura di Triton™ Inference Server richiede che i modelli siano memorizzati separatamente. È possibile memorizzarli localmente in una qualsiasi directory del server o su una memoria di rete. Quando si avvia il server, è necessario montare questa directory nel contenitore nel punto di montaggio /models. Questo serve come repository per tutte le versioni dei modelli.

Avviare il contenitore con questo comando

sudo docker run --gpus=all --rm -p8000:8000 -p8001:8001 -p8002:8002 -v ~/server/docs/examples/model_repository:/models nvcr.io/nvidia/tritonserver:25.01-py3 tritonserver --model-repository=/models

Ecco cosa fa ogni parametro:

--gpus=all specifica che tutte le GPU disponibili saranno utilizzate nel server;
--rm distrugge il contenitore dopo il completamento o l'arresto del processo;
-p8000:8000 inoltra la porta 8000 per ricevere le richieste HTTP;
-p8001:8001 inoltra la porta 8001 per ricevere le richieste gRPC;
-p8002:8002 inoltra la porta 8002 per richiedere le metriche;
-v ~/server/docs/examples/model_repository:/models inoltra la directory con i modelli;
nvcr.io/nvidia/tritonserver:25.01-py3 indirizzo del contenitore dal catalogo NGC;
tritonserver --model-repository=/models lancia il Triton™ Inference Server con la posizione del repository dei modelli a /models.

L'output del comando mostrerà tutti i modelli disponibili nel repository, ognuno pronto ad accettare richieste:

+----------------------+---------+--------+
| Model                | Version | Status |
+----------------------+---------+--------+
| densenet_onnx        | 1       | READY  |
| inception_graphdef   | 1       | READY  |
| simple               | 1       | READY  |
| simple_dyna_sequence | 1       | READY  |
| simple_identity      | 1       | READY  |
| simple_int8          | 1       | READY  |
| simple_sequence      | 1       | READY  |
| simple_string        | 1       | READY  |
+----------------------+---------+--------+

I tre servizi sono stati lanciati con successo sulle porte 8000, 8001 e 8002:

I0217 08:00:34.930188 1 grpc_server.cc:2466] Started GRPCInferenceService at 0.0.0.0:8001
I0217 08:00:34.930393 1 http_server.cc:4636] Started HTTPService at 0.0.0.0:8000
I0217 08:00:34.972340 1 http_server.cc:320] Started Metrics Service at 0.0.0.0:8002

Utilizzando l'utilità nvtop, possiamo verificare che tutte le GPU sono pronte ad accettare il carico:

Installazione del client

Per accedere al nostro server, dobbiamo generare una richiesta appropriata usando il client incluso nell'SDK. Possiamo scaricare questo SDK come contenitore Docker:

sudo docker pull nvcr.io/nvidia/tritonserver:25.01-py3-sdk

Eseguire il contenitore in modalità interattiva per accedere alla console:

sudo docker run -it --gpus=all --rm --net=host nvcr.io/nvidia/tritonserver:25.01-py3-sdk

Verifichiamo questo con il modello DenseNet in formato ONNX, utilizzando il metodo INCEPTION per preelaborare e analizzare l'immagine mug.jpg:

/workspace/install/bin/image_client -m densenet_onnx -c 3 -s INCEPTION /workspace/images/mug.jpg

Il client contatterà il server, che creerà un batch e lo elaborerà utilizzando le GPU disponibili nel container. Ecco l'output:

Request 0, batch size 1
Image '/workspace/images/mug.jpg':
   15.349562 (504) = COFFEE MUG
   13.227461 (968) = CUP
   10.424891 (505) = COFFEEPOT

Preparazione del repository

Affinché Triton™ gestisca correttamente i modelli, è necessario preparare il repository in un modo specifico. Ecco la struttura della directory:

model_repository/ 
        └── your_model/ 
                ├── config.pbtxt 
                └── 1/
                    └── model.*

Ogni modello ha bisogno di una propria directory contenente un file di configurazione config.pbtxt con la sua descrizione. Ecco un esempio:

name: "Test"
platform: "pytorch_libtorch"
max_batch_size: 8
input [
  {
    name: "INPUT_0"
    data_type: TYPE_FP32
    dims: [ 3, 224, 224 ]
  }
]
output [
  {
    name: "OUTPUT_0"
    data_type: TYPE_FP32
    dims: [ 1000 ]
  }
]

In questo esempio, un modello chiamato Test verrà eseguito sul backend PyTorch. Il parametro max_batch_size imposta il numero massimo di elementi che possono essere elaborati simultaneamente, consentendo un efficiente bilanciamento del carico tra le risorse. L'impostazione di questo valore a zero disabilita il batching, facendo sì che il modello elabori le richieste in modo sequenziale.

Il modello accetta un ingresso e produce un'uscita, entrambi utilizzando il tipo di numero FP32. I parametri devono corrispondere esattamente ai requisiti del modello. Per l'elaborazione delle immagini, una tipica specifica di dimensione è dims: [ 3, 224, 224 ], dove:

3 - numero di canali di colore (RGB);
224 - altezza dell'immagine in pixel;
224 - larghezza dell'immagine in pixel.

L'output dims: [ 1000 ] rappresenta un vettore unidimensionale di 1000 elementi, adatto alle attività di classificazione delle immagini. Per determinare la dimensione corretta del modello, consultare la relativa documentazione. Se il file di configurazione è incompleto, Triton™ cercherà di generare automaticamente i parametri mancanti.

Avvio di un modello personalizzato

Avviamo l'inferenza del modello DeepSeek-R1 distillato di cui abbiamo parlato in precedenza. Per prima cosa, creeremo la struttura di directory necessaria:

mkdir ~/model_repository && mkdir ~/model_repository/deepseek && mkdir ~/model_repository/deepseek/1

Navigare nella directory del modello:

cd ~/model_repository/deepseek

Creare un file di configurazione config.pbtxt:

nano config.pbtxt

Incollare quanto segue:

# Copyright 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#  * Neither the name of NVIDIA CORPORATION nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    
# Note: You do not need to change any fields in this configuration.
    
backend: "vllm"
    
# The usage of device is deferred to the vLLM engine
instance_group [
  {
    count: 1
    kind: KIND_MODEL
  }
]

Salvare il file premendo Ctrl + O, poi l'editor con Ctrl + X. Navigare nella directory 1:

cd 1

Creare un file di configurazione del modello model.json con i seguenti parametri:

{
    "model":"deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
    "disable_log_requests": true,
    "gpu_memory_utilization": 0.9,
    "enforce_eager": true
}

Si noti che il valore di gpu_memory_utilization varia a seconda della GPU e deve essere determinato sperimentalmente. Per questa guida, useremo 0.9. La struttura della directory all'interno di ~/model_repository dovrebbe ora apparire come segue:

└── deepseek
        ├── 1
        │   └── model.json
        └── config.pbtxt

Impostare la variabile LOCAL_MODEL_REPOSITORY per comodità:

LOCAL_MODEL_REPOSITORY=~/model_repository/

Avviare il server di inferenza con questo comando:

sudo docker run --rm -it --net host --shm-size=2g  --ulimit memlock=-1 --ulimit stack=67108864 --gpus all -v $LOCAL_MODEL_REPOSITORY:/opt/tritonserver/model_repository  nvcr.io/nvidia/tritonserver:25.01-vllm-python-py3 tritonserver --model-repository=model_repository/

Ecco cosa fa ogni parametro:

--rm rimuove automaticamente il contenitore dopo l'arresto;
-it esegue il contenitore in modalità interattiva con output da terminale;
--net utilizza lo stack di rete dell'host invece dell'isolamento del contenitore;
--shm-size=2g imposta la memoria condivisa a 2 GB;
--ulimit memlock=-1 rimuove il limite di blocco della memoria;
--ulimit stack=67108864 imposta la dimensione dello stack a 64 MB;
--gpus all abilita l'accesso a tutte le GPU del server;
-v $LOCAL_MODEL_REPOSITORY:/opt/tritonserver/model_repository monta la directory locale del modello nel contenitore;
nvcr.io/nvidia/tritonserver:25.01-vllm-python-py3 specifica il contenitore con il supporto del backend vLLM;
tritonserver --model-repository=model_repository/ lancia il Triton™ Inference Server con la posizione del repository dei modelli in model_repository.

Testare il server inviando una richiesta con curl, utilizzando un semplice prompt e un limite di risposta di 4096 token:

curl -X POST localhost:8000/v2/models/deepseek/generate -d '{"text_input": "Tell me about the Netherlands?", "max_tokens": 4096}'

Il server riceve ed elabora con successo la richiesta.

Il task scheduler interno di Triton™ gestisce tutte le richieste in arrivo quando il server è sotto carico.

Conclusione

Triton™ Inference Server eccelle nell'implementazione di modelli di apprendimento automatico in produzione, distribuendo in modo efficiente le richieste sulle GPU disponibili. Questo massimizza l'uso delle risorse del server in affitto e riduce i costi dell'infrastruttura di calcolo. Il software funziona con diversi backend, tra cui vLLM per modelli linguistici di grandi dimensioni.

Poiché si installa come contenitore Docker, è possibile integrarlo facilmente in qualsiasi pipeline CI/CD moderna. Provatelo voi stessi noleggiando un server da LeaderGPU.

DeepSeek-R1: il futuro dei LLM

Wed, 19 Feb 2025 15:10:33 +0100

Sebbene le reti neurali generative si siano sviluppate rapidamente, negli ultimi anni i loro progressi sono rimasti piuttosto costanti. La situazione è cambiata con l'arrivo di DeepSeek, una rete neurale cinese che non solo ha avuto un impatto sul mercato azionario, ma ha anche catturato l'attenzione di sviluppatori e ricercatori di tutto il mondo. A differenza di altri grandi progetti, il codice di DeepSeek è stato rilasciato con la licenza MIT. Questo passaggio all'open source si è guadagnato il plauso della comunità, che ha iniziato a esplorare le capacità del nuovo modello.

L'aspetto più impressionante è che l'addestramento di questa nuova rete neurale è costato 20 volte meno rispetto ai concorrenti che offrono una qualità simile. L'addestramento del modello ha richiesto solo 55 giorni e 5,6 milioni di dollari. Quando DeepSeek è stato rilasciato, ha innescato uno dei più grandi cali di un giorno nella storia del mercato azionario statunitense. Anche se alla fine i mercati si sono stabilizzati, l'impatto è stato significativo.

Questo articolo esaminerà la precisione con cui i titoli dei media riflettono la realtà ed esplorerà quali configurazioni di LeaderGPU sono adatte per installare questa rete neurale.

Caratteristiche architettoniche

DeepSeek ha scelto un percorso di massima ottimizzazione, che non sorprende viste le restrizioni all'esportazione della Cina negli Stati Uniti. Queste restrizioni impediscono al Paese di utilizzare ufficialmente i modelli di GPU più avanzati per lo sviluppo dell'intelligenza artificiale.

Il modello impiega la tecnologia Multi Token Prediction (MTP), che prevede più token in una singola fase di inferenza invece di uno solo. Questo funziona grazie alla decodifica parallela dei token combinata con speciali strati mascherati che mantengono l'autoregressività.

I test MTP hanno dato risultati notevoli, aumentando la velocità di generazione di 2-4 volte rispetto ai metodi tradizionali. L'eccellente scalabilità della tecnologia la rende preziosa per le applicazioni di elaborazione del linguaggio naturale attuali e future.

Il modello Multi-Head Latent Attention (MLA) presenta un meccanismo di attenzione potenziato. Quando il modello costruisce lunghe catene di ragionamenti, mantiene l'attenzione sul contesto in ogni fase. Questa miglioria migliora la gestione dei concetti astratti e delle dipendenze dal testo.

La caratteristica principale di MLA è la capacità di regolare dinamicamente i pesi dell'attenzione su diversi livelli di astrazione. Quando elabora query complesse, MLA esamina i dati da più prospettive: il significato delle parole, la struttura delle frasi e il contesto generale. Queste prospettive formano livelli distinti che influenzano l'output finale. Per mantenere la chiarezza, MLA bilancia attentamente l'impatto di ogni livello, rimanendo concentrato sul compito principale.

Gli sviluppatori di DeepSeek hanno incorporato la tecnologia Mixture of Experts (MoE) nel modello. Essa contiene 256 reti neurali esperte pre-addestrate, ognuna specializzata per compiti diversi. Il sistema attiva 8 di queste reti per ogni input di token, consentendo un'elaborazione efficiente dei dati senza aumentare i costi di calcolo.

Nel modello completo con 671 parametri, solo 37 sono attivati per ogni token. Il modello seleziona in modo intelligente i parametri più rilevanti per l'elaborazione di ciascun token in ingresso. Questa efficiente ottimizzazione consente di risparmiare risorse computazionali mantenendo alte le prestazioni.

Una caratteristica fondamentale di qualsiasi chatbot a rete neurale è la lunghezza della finestra di contesto. Llama 2 ha un limite di contesto di 4.096 token, GPT-3.5 gestisce 16.284 token, mentre GPT-4 e DeepSeek possono elaborare fino a 128.000 token (circa 100.000 parole, equivalenti a 300 pagine di testo dattiloscritto).

R - sta per Ragionamento

DeepSeek-R1 ha acquisito un meccanismo di ragionamento simile a quello di OpenAI o1, che gli consente di gestire compiti complessi in modo più efficiente e accurato. Invece di fornire risposte immediate, il modello espande il contesto generando ragionamenti passo-passo in piccoli paragrafi. Questo approccio migliora la capacità della rete neurale di identificare relazioni complesse tra i dati, ottenendo risposte più complete e precise.

Quando si trova di fronte a un compito complesso, DeepSeek utilizza il suo meccanismo di ragionamento per scomporre il problema in componenti e analizzare ciascuno di essi separatamente. Il modello sintetizza poi questi risultati per generare una risposta per l'utente. Sebbene questo sembri essere l'approccio ideale per le reti neurali, comporta sfide significative.

Tutti i moderni LLM condividono un tratto preoccupante: le allucinazioni artificiali. Quando gli viene posta una domanda a cui non può rispondere, invece di riconoscere i propri limiti, il modello potrebbe generare risposte fittizie supportate da fatti inventati.

Se applicate a una rete neurale di ragionamento, queste allucinazioni potrebbero compromettere il processo di pensiero, basando le conclusioni su informazioni fittizie anziché reali. Ciò potrebbe portare a conclusioni errate, una sfida che i ricercatori e gli sviluppatori di reti neurali dovranno affrontare in futuro.

Consumo di VRAM

Vediamo come eseguire e testare DeepSeek R1 su un server dedicato, concentrandoci sui requisiti di memoria video della GPU.

Modello	VRAM (Mb)	Dimensione del modello (Gb)
deepseek-r1:1.5b	1,952	1.1
deepseek-r1:7b	5,604	4.7
deepseek-r1:8b	6,482	4.9
deepseek-r1:14b	10,880	9
deepseek-r1:32b	21,758	20
deepseek-r1:70b	39,284	43
deepseek-r1:671b	470,091	404

Le prime tre opzioni (1.5b, 7b, 8b) sono modelli di base in grado di gestire in modo efficiente la maggior parte dei compiti. Questi modelli funzionano senza problemi su qualsiasi GPU consumer con 6-8 GB di memoria video. Le versioni di medio livello (14b e 32b) sono ideali per le attività professionali, ma richiedono più VRAM. I modelli più grandi (70b e 671b) richiedono GPU specializzate e sono utilizzati principalmente per la ricerca e le applicazioni industriali.

Selezione del server

Per aiutarvi a scegliere un server per l'inferenza DeepSeek, ecco le configurazioni ideali di LeaderGPU per ogni gruppo di modelli:

1,5b / 7b / 8b / 14b / 32b / 70b

Per questo gruppo, qualsiasi server con i seguenti tipi di GPU sarà adatto. La maggior parte dei server LeaderGPU è in grado di eseguire queste reti neurali senza problemi. Le prestazioni dipendono principalmente dal numero di core CUDA®. Si consigliano server con più GPU, come ad esempio:

671b

Ora il caso più impegnativo: come si fa a eseguire l'inferenza su un modello con una dimensione di base di 404 GB? Ciò significa che saranno necessari circa 470 GB di memoria video. LeaderGPU offre diverse configurazioni con le seguenti GPU in grado di gestire questo carico:

A100
H100

Entrambe le configurazioni gestiscono il carico del modello in modo efficiente, distribuendolo uniformemente su più GPU. Ad esempio, ecco come appare un server con 8xH100 dopo aver caricato il modello deepseek-r1:671b:

Il carico di calcolo viene bilanciato dinamicamente tra le GPU, mentre le interconnessioni NVLink® ad alta velocità impediscono i colli di bottiglia nello scambio di dati, garantendo le massime prestazioni.

Conclusione

DeepSeek-R1 combina molte tecnologie innovative come Multi Token Prediction, Multi-Head Latent Attention e Mixture of Experts in un unico modello significativo. Questo software open-source dimostra che gli LLM possono essere sviluppati in modo più efficiente con meno risorse computazionali. Il modello ha diverse versioni, dalla più piccola di 1,5b alla più grande di 671b, che richiedono hardware specializzato con più GPU di fascia alta che lavorano in parallelo.

Noleggiando un server di LeaderGPU per l'inferenza di DeepSeek-R1, avrete a disposizione un'ampia gamma di configurazioni, affidabilità e tolleranza ai guasti. Il nostro team di supporto tecnico vi aiuterà a risolvere qualsiasi problema o domanda, mentre l'installazione automatica del sistema operativo riduce i tempi di implementazione.

Scegliete il vostro server LeaderGPU e scoprite le possibilità che si aprono utilizzando i moderni modelli di reti neurali. Se avete domande, non esitate a farle nella nostra chat o via e-mail.

Intel Habana Gaudi 2: installazione e test

Thu, 23 Jan 2025 13:41:09 +0100

Prima di iniziare l'installazione del software degli acceleratori Gaudi 2, c'è una caratteristica importante che vale la pena menzionare. Siamo abituati al fatto che l'addestramento e l'inferenza delle reti neurali possono essere eseguiti utilizzando le GPU. Tuttavia, Intel Habana Gaudi 2 è molto diverso dalle GPU e rappresenta un'altra classe di dispositivi progettati esclusivamente per accelerare le attività di intelligenza artificiale.

Molte applicazioni e framework già noti non funzioneranno senza aver prima preparato il sistema operativo e, in alcuni casi, senza uno speciale GPU Migration Toolkit. Questo spiega il gran numero di passaggi preparatori che descriviamo in questo articolo. Iniziamo con ordine.

Passo 1. Installare lo stack software SynapseAI

Per iniziare a lavorare con gli acceleratori Intel Habana Gaudi 2, è necessario installare lo stack SynapseAI. Esso comprende uno speciale compilatore di grafi che trasforma la topologia del modello di rete neurale per ottimizzare efficacemente l'esecuzione sull'architettura Gaudi, librerie API per la scalabilità orizzontale e un SDK separato per la creazione di algoritmi e modelli di apprendimento automatico ad alte prestazioni.

Separatamente, notiamo che SynapseAI è la parte che permette di creare un ponte tra framework popolari come PyTorch/TensorFlow e gli acceleratori di intelligenza artificiale Gaudi 2. Questo permette di lavorare con astrazioni familiari. Ciò consente di lavorare con astrazioni già note e Gaudi 2 ottimizza autonomamente i calcoli Gli operatori specifici per i quali gli acceleratori non dispongono di supporto hardware vengono eseguiti sulla CPU.

Per semplificare l'installazione dei singoli componenti di SynapseAI, è stato creato un comodo script di shell. Scarichiamolo:

wget -nv https://vault.habana.ai/artifactory/gaudi-installer/latest/habanalabs-installer.sh

Rendere il file eseguibile:

chmod +x habanalabs-installer.sh

Eseguire lo script:

./habanalabs-installer.sh install --type base

Seguire le indicazioni del sistema durante l'installazione. Il file di registro contiene un rapporto dettagliato. È possibile vedere quali pacchetti sono stati installati e se gli acceleratori sono stati trovati e inizializzati con successo.

I registri sono qui: /var/log/habana_logs/install-YYY-MM-DD-HH-MM-SS.log

[  +3.881647] habanalabs hl5: Found GAUDI2 device with 96GB DRAM
[  +0.008145] habanalabs hl0: Found GAUDI2 device with 96GB DRAM
[  +0.032034] habanalabs hl3: Found GAUDI2 device with 96GB DRAM
[  +0.002376] habanalabs hl4: Found GAUDI2 device with 96GB DRAM
[  +0.005174] habanalabs hl1: Found GAUDI2 device with 96GB DRAM
[  +0.000390] habanalabs hl2: Found GAUDI2 device with 96GB DRAM
[  +0.007065] habanalabs hl7: Found GAUDI2 device with 96GB DRAM
[  +0.006256] habanalabs hl6: Found GAUDI2 device with 96GB DRAM

Proprio come l'utility nvidia-smi fornisce informazioni sulle GPU installate e sui processi di calcolo in esecuzione, SynapseAI ha un programma simile. È possibile eseguirlo per ottenere un rapporto sullo stato attuale degli acceleratori Gaudi 2 AI:

hl-smi

Passo 2. Test di TensorFlow

TensorFlow è una delle piattaforme più popolari per l'apprendimento automatico. Utilizzando lo stesso script di installazione, è possibile installare una versione pre-costruita di TensorFlow con il supporto per gli acceleratori Gaudi 2. Iniziamo installando le dipendenze generali:

./habanalabs-installer.sh install -t dependencies

Successivamente, installeremo le dipendenze per TensorFlow:

./habanalabs-installer.sh install -t dependencies-tensorflow

Installare la piattaforma TensorFlow all'interno di un ambiente virtuale implementato utilizzando il meccanismo Python Virtual Environment (venv):

./habanalabs-installer.sh install --type tensorflow --venv

Attiviamo l'ambiente virtuale creato:

source habanalabs-venv/bin/activate

Creare un semplice esempio di codice Python che utilizzi le capacità dell'acceleratore Gaudi 2:

nano example.py


import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import os
# Import Habana Torch Library
import habana_frameworks.torch.core as htcore
class SimpleModel(nn.Module):
   def __init__(self):
       super(SimpleModel, self).__init__()
       self.fc1   = nn.Linear(784, 256)
       self.fc2   = nn.Linear(256, 64)
       self.fc3   = nn.Linear(64, 10)
   def forward(self, x):
       out = x.view(-1,28*28)
       out = F.relu(self.fc1(out))
       out = F.relu(self.fc2(out))
       out = self.fc3(out)
       return out
def train(net,criterion,optimizer,trainloader,device):
   net.train()
   train_loss = 0.0
   correct = 0
   total = 0
   for batch_idx, (data, targets) in enumerate(trainloader):
       data, targets = data.to(device), targets.to(device)
       optimizer.zero_grad()
       outputs = net(data)
       loss = criterion(outputs, targets)
       loss.backward()
       # API call to trigger execution
       htcore.mark_step()
       optimizer.step()
       # API call to trigger execution
       htcore.mark_step()
       train_loss += loss.item()
       _, predicted = outputs.max(1)
       total += targets.size(0)
       correct += predicted.eq(targets).sum().item()
   train_loss = train_loss/(batch_idx+1)
   train_acc = 100.0*(correct/total)
   print("Training loss is {} and training accuracy is {}".format(train_loss,train_acc))
def test(net,criterion,testloader,device):
   net.eval()
   test_loss = 0
   correct = 0
   total = 0
   with torch.no_grad():
       for batch_idx, (data, targets) in enumerate(testloader):
           data, targets = data.to(device), targets.to(device)
           outputs = net(data)
           loss = criterion(outputs, targets)
           # API call to trigger execution
           htcore.mark_step()
           test_loss += loss.item()
           _, predicted = outputs.max(1)
           total += targets.size(0)
           correct += predicted.eq(targets).sum().item()
   test_loss = test_loss/(batch_idx+1)
   test_acc = 100.0*(correct/total)
   print("Testing loss is {} and testing accuracy is {}".format(test_loss,test_acc))
def main():
   epochs = 20
   batch_size = 128
   lr = 0.01
   milestones = [10,15]
   load_path = './data'
   save_path = './checkpoints'
   if(not os.path.exists(save_path)):
       os.makedirs(save_path)
   # Target the Gaudi HPU device
   device = torch.device("hpu")
   # Data
   transform = transforms.Compose([
       transforms.ToTensor(),
   ])
   trainset = torchvision.datasets.MNIST(root=load_path, train=True,
                                           download=True, transform=transform)
   trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                           shuffle=True, num_workers=2)
   testset = torchvision.datasets.MNIST(root=load_path, train=False,
                                       download=True, transform=transform)
   testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                           shuffle=False, num_workers=2)
   net = SimpleModel()
   net.to(device)
   criterion = nn.CrossEntropyLoss()
   optimizer = optim.SGD(net.parameters(), lr=lr,
                       momentum=0.9, weight_decay=5e-4)
   scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.1)
   for epoch in range(1, epochs+1):
       print("=====================================================================")
       print("Epoch : {}".format(epoch))
       train(net,criterion,optimizer,trainloader,device)
       test(net,criterion,testloader,device)
       torch.save(net.state_dict(), os.path.join(save_path,'epoch_{}.pth'.format(epoch)))
       scheduler.step()
if __name__ == '__main__':
   main()

Infine, eseguite l'applicazione:

python3 example.py

Per uscire dall'ambiente virtuale, eseguire il seguente comando:

deactivate

Passo 3. Clonare il repository di formazione

Clonare il repository con il codice MLperf:

git clone https://github.com/mlcommons/training_results_v3.0

Creare una cartella separata che sarà utilizzata dal contenitore Docker con MLperf:

mkdir -p mlperf

Cambiare la directory:

cd mlperf

Esportiamo alcune variabili d'ambiente:

export MLPERF_DIR=/home/usergpu/mlperf

export SCRATCH_DIR=/home/usergpu/mlperf/scratch

export DATASETS_DIR=/home/usergpu/mlperf/datasets

Creare nuove directory utilizzando le variabili create:

mkdir -p $MLPERF_DIR/Habana

mkdir -p $SCRATCH_DIR

mkdir -p $DATASETS_DIR

Copiare l'applicazione di benchmark in $MLPERF_DIR/Habana:

cp -R training_results_v3.0/Intel-HabanaLabs/benchmarks/ $MLPERF_DIR/Habana

Esportare un'altra variabile che memorizzerà un link per scaricare la versione desiderata del contenitore Docker:

export MLPERF_DOCKER_IMAGE=vault.habana.ai/gaudi-docker-mlperf/ver3.1/pytorch-installer-2.0.1:1.13.99-41

Passo 4. Installare Docker

La nostra istanza esegue Ubuntu Linux 22.04 LTS e non supporta Docker per impostazione predefinita. Quindi, prima di scaricare ed eseguire i container, è necessario installare il supporto per Docker. Aggiorniamo la cache dei pacchetti e installiamo alcuni pacchetti di base che ci serviranno in seguito:

sudo apt update && sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Per installare Docker, è necessario aggiungere un repository di progetto con firma digitale. Scaricare la chiave di firma digitale e aggiungerla all'archivio chiavi del sistema operativo:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Docker può essere eseguito su piattaforme con diverse architetture. Il comando seguente rileverà l'architettura del server e aggiungerà la riga del repository corrispondente all'elenco del gestore di pacchetti APT:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aggiornare la cache dei pacchetti e le policy e installare docker-ce (Docker Community Edition):

sudo apt update && apt-cache policy docker-ce && sudo apt install docker-ce

Infine, verificare che il demone Docker sia attivo e funzionante:

sudo systemctl status docker

Passo 5. Eseguire il contenitore Docker

Avviamo il contenitore in modalità privilegiata utilizzando le variabili precedentemente specificate:

sudo docker run --privileged --security-opt seccomp=unconfined \
  --name mlperf3.0 -td                    \
  -v /dev:/dev                            \
  --device=/dev:/dev                      \
  -e LOG_LEVEL_ALL=6                      \
  -v /sys/kernel/debug:/sys/kernel/debug  \
  -v /tmp:/tmp                            \
  -v $MLPERF_DIR:/root/MLPERF             \
  -v $SCRATCH_DIR:/root/scratch           \
  -v $DATASETS_DIR:/root/datasets/        \
  --cap-add=sys_nice --cap-add=SYS_PTRACE \
  --user root --workdir=/root --net=host  \
  --ulimit memlock=-1:-1 $MLPERF_DOCKER_IMAGE

Per comodità, è possibile accedere al terminale all'interno del contenitore tramite SSH:

sudo docker exec mlperf3.0 bash -c "service ssh start"

Per aprire una shell di comando (bash) nella sessione corrente, eseguire il seguente comando:

sudo docker exec -it mlperf3.0 bash

Passo 6. Preparare un set di dati

Per eseguire i test di implementazione di Bert da MLperf, è necessario un set di dati preparato. Il metodo ottimale è quello di generare un set di dati da dati precaricati. Il repository MLperf include uno script speciale, prepare_data.sh, che richiede un insieme specifico di pacchetti per funzionare. Passiamo alla seguente directory:

cd /root/MLPERF/Habana/benchmarks/bert/implementations/PyTorch

Installare tutti i pacchetti necessari utilizzando l'elenco pre-generato e il gestore di pacchetti pip:

pip install -r requirements.txt

Impostare la variabile PYTORCH_BERT_DATA per indicare allo script dove memorizzare i dati:

export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert

Eseguire lo script:

bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATA

La procedura di generazione è piuttosto lunga e può richiedere diverse ore. Si prega di essere pazienti e di non interrompere il processo. Se si prevede di disconnettersi dalla sessione SSH, si consiglia di utilizzare l'utilità schermo immediatamente prima di avviare il contenitore Docker.

Passo 7. Impacchettare il set di dati

Il passo successivo consiste nel "tagliare" il dataset in pezzi uguali per il successivo lancio di MLperf. Creiamo una cartella separata per i dati impacchettati:

mkdir $PYTORCH_BERT_DATA/packed

Eseguire lo script di impacchettamento:

python3 pack_pretraining_data_pytorch.py \
  --input_dir=$PYTORCH_BERT_DATA/hdf5/training-4320/hdf5_4320_shards_uncompressed \
  --output_dir=$PYTORCH_BERT_DATA/packed \
  --max_predictions_per_seq=76

Passo 8. Eseguire un test

Ora che il set di dati è stato preparato, è il momento di eseguire il test. Tuttavia, è impossibile farlo senza una preparazione preliminare. Gli autori del test Bert hanno lasciato alcuni valori codificati nello script, che interferiranno con l'esecuzione del test. Innanzitutto, rinominare la seguente directory:

mv $PYTORCH_BERT_DATA/packed $PYTORCH_BERT_DATA/packed_data_500_pt

Cambiare la directory:

cd /root/MLPERF/Habana/benchmarks/bert/implementations/HLS-Gaudi2-PT

Poiché l'editor GNU Nano non è installato all'interno del contenitore, deve essere installato separatamente. In alternativa, si può usare l'editor Vi integrato:

apt update && apt -y install nano

Ora, modificate lo script di lancio del test:

nano launch_bert_pytorch.sh

Individuare la prima riga:

DATA_ROOT=/mnt/weka/data/pytorch/bert_mlperf/packed_data

Sostituire con la seguente:

DATA_ROOT=/root/datasets/pytorch_bert

Trovare la seconda riga:

INPUT_DIR=$DATA_ROOT/packed

Sostituire con la seguente:

INPUT_DIR=$DATA_ROOT/packed_data_500_pt

Salvare il file e uscire.

Il codice del test include una funzione di limitazione che impedisce al gradiente di superare determinati valori, impedendo una potenziale crescita esponenziale. Per ragioni a noi sconosciute, questa funzione è assente nella versione di PyTorch utilizzata nel contenitore, causando l'interruzione anomala del test durante la fase di riscaldamento.

Una possibile soluzione potrebbe essere quella di rimuovere temporaneamente questa funzione dal codice del file fastddp.py. Per farlo, aprire il file:

nano ../PyTorch/fastddp.py

Trovate e commentate le seguenti tre righe di codice usando il simbolo # (shebang), in modo che appaiano così:

#from habana_frameworks.torch import _hpex_C
#    clip_global_grad_norm = _hpex_C.fused_lamb_norm(grads, 1.0)
#    _fusion_buffer.div_((clip_global_grad_norm * _all_reduce_group_size).to(_fusion_buffer.dtype))

Inoltre, salvare il file e uscire. Cambiare la directory:

cd ../HLS-Gaudi2-PT

Infine, eseguire lo script. Ci vorranno circa 20 minuti per completarlo:

./launch_bert_pytorch.sh

Vedi anche:

NVIDIA® RTX™ 50: aspettative e realtà

Thu, 23 Jan 2025 13:34:30 +0100

The highlight of CES 2025 was NVIDIA® CEO Jensen Huang’s speech. The revelation of new GPU specifications within minutes caught many off guard. In this article, we’ll examine how expert predictions matched the actual announcements.

Diamo prima un'occhiata alla linea di prodotti. La serie RTX™ 40 è stata lanciata con 6 modelli, dalla RTX™ 4060 alla RTX™ 4090. Sebbene molti si aspettassero una gamma simile per la serie RTX™ 50, ciò non è avvenuto. Invece, la famiglia RTX™ 50 comprende solo 4 modelli: RTX™ 5070, RTX™ 5070 Ti, RTX™ 5080 e RTX™ 5090. Potremmo vedere sia la RTX™ 5050 che la RTX5060 in futuro, ma nessuna fonte ufficiale ha ancora verificato queste schede grafiche.

Processo tecnologico

La legge di Moore, l'osservazione empirica secondo cui "il numero di transistor in un circuito integrato raddoppia ogni due anni circa", viene spesso definita non più rilevante per le prestazioni dei chip. Dal 2022, Jensen Huang ha ripetutamente dichiarato morta la legge di Moore. Ha invece proposto un nuovo concetto che enfatizza lo sviluppo simultaneo di architettura, microchip, librerie software e algoritmi.

Insieme, questo cambiamento ci permette di concentrarci sulle prestazioni complessive del sistema piuttosto che sul solo numero di transistor. Il concetto di efficienza di calcolo ha suscitato discussioni continue nella comunità tecnologica. Sebbene i punti di vista sull'argomento siano diversi, è chiaro che il settore si trova ad affrontare barriere fisiche ed economiche che impediscono un'ulteriore miniaturizzazione.

Diamo un'occhiata alla tecnologia di processo delle GPU di nuova generazione. La presentazione non ne ha parlato in modo specifico, ma tutte le schede della generazione precedente sono state costruite con il processo 4N. The RTX™ 50 series uses a different 4NP process technology. Allo stesso tempo, è importante capire che 4N e 4NP sono solo nomi di marketing. I transistor stessi rimangono di dimensioni pari a 5 nm.

La tecnologia di processo 4NP migliorata consente principalmente una maggiore densità di transistor sul chip e velocità di clock più elevate. Sebbene gli esperti avessero previsto che l'RTX™ 50 avrebbe utilizzato la stessa tecnologia di processo dell'RTX™ 40, si sono sbagliati tecnicamente, anche se non di molto, poiché le dimensioni dei transistor rimangono invariate e TSMC continua a essere il produttore.

Numero di core

Prima del rilascio della serie RTX™ 50, numerose fughe di dati hanno rivelato le caratteristiche di base della GPU. I rapporti iniziali degli insider del luglio 2024 suggerivano che l'ammiraglia sarebbe stata dotata di 24.576 core, 192 core Ray-tracing e 768 core Tensor. Tuttavia, le fughe di notizie successive hanno corretto questi numeri a valori più realistici.

La RTX™ 5090 finale è stata fornita con 21,760 CUDA® cores (rispetto ai 16.384 della RTX™ 4090), 170 Ray-tracing cores e 680 Tensor cores. Questo è in linea con la recente strategia dell'azienda di aumentare le prestazioni non solo attraverso l'aumento del numero di transistor, ma anche attraverso un'ottimizzazione architettonica completa.

Memoria

L'uso della memoria GDDR7 da parte delle nuove GPU non è una sorpresa. Gli esperti del settore avevano previsto questa mossa nel 2024, dopo che i tre principali produttori (Samsung, Micron e SK hynix) avevano presentato in successione i loro prototipi GDDR7. NVIDIA® è stata generosa nella distribuzione della memoria: il modello base RTX™ 5070 presenta 12 GB GDDR7 su un bus 192-bit, mentre i modelli RTX™ 5070 Ti and RTX™ 5080 portano entrambi 16 GB GDDR7 su un bus 256-bit. Il modello di punta RTX™ 5090 è dotato di un enorme 32 GB GDDR7 su un bus 512-bit.

Inizialmente gli esperti avevano previsto che il throughput massimo di questa configurazione di memoria sarebbe stato di 1,5 Tbps. Tuttavia, la realtà ha superato queste aspettative, achieving a throughput of 1,7 Tbps. Questo netto miglioramento va principalmente a vantaggio delle capacità di elaborazione dell'intelligenza artificiale della GPU piuttosto che delle prestazioni di gioco. La combinazione di memoria ad alta capacità e velocità della nuova generazione è particolarmente preziosa per i modelli linguistici e le reti neurali generative di grandi dimensioni.

Tecnologie

Per i giocatori

Il ray-tracing in tempo reale è diventato una delle tecnologie più rivoluzionarie per le GPU, segnando l'inizio della linea RTX™. Per molti consumatori, questa caratteristica è stata un fattore chiave nelle loro decisioni di acquisto. Nelle schede della serie RTX™ 50, la versione 4 del DLSS (Deep Learning Super Sampling) può svolgere un ruolo altrettanto importante. Questa tecnologia aumenta in modo significativo le prestazioni della GPU nei giochi grazie al suo approccio di rendering ibrido dei fotogrammi.

Con DLSS abilitato, invece di renderizzare ogni fotogramma in modo convenzionale, alcuni fotogrammi vengono generati in tempo reale utilizzando l'intelligenza artificiale. Mentre le prime versioni di questa tecnologia potevano solo eseguire l'upscaling dei fotogrammi a risoluzioni più elevate, DLSS 3 ha introdotto una capacità più avanzata: per ogni fotogramma renderizzato in modo convenzionale, può generare un fotogramma aggiuntivo creato dall'intelligenza artificiale.

Il DLSS 4 genererà tre fotogrammi alimentati dall'intelligenza artificiale per ogni fotogramma renderizzato in modo tradizionale. This significantly increases the frame per second (FPS) without putting heavy load on the GPU. L'intelligenza artificiale analizza il movimento degli oggetti e della scena per garantire che i fotogrammi generati corrispondano perfettamente a quelli renderizzati in modo tradizionale.

Ciò solleva una questione importante: come gestire l'input lag? Poiché la generazione dei fotogrammi richiede tempo, ogni iterazione aumenta il tempo di risposta. Un'immagine fluida con una risposta lenta alle azioni del giocatore può influire pesantemente sull'esperienza di gioco. To address this, NVIDIA® has improved their Reflex 2 technology alongside DLSS to minimize latency.

In particolare, nel sistema è stato integrato il Frame Warp. Questa tecnologia riduce la latenza del gioco aggiornando i fotogrammi renderizzati con l'ultimo input del mouse appena prima della visualizzazione. Questo migliora sia la competizione multigiocatore che la reattività del giocatore singolo.

Per i creatori di contenuti

La serie RTX™ 50 non è solo per i giochi. I creatori di contenuti video troveranno un valore significativo in queste nuove GPU. Il modello di punta RTX™ 5090 è dotato di 3 codificatori e 2 decodificatori, rispetto ai 2 codificatori e 1 decodificatore della RTX™ 4090. Questi componenti sono stati migliorati grazie alla collaborazione con i leader del settore: Adobe, Blackmagic Design, ByteDance e Wondershare. As a result, the RTX™ 5090 renders video 60% faster than the RTX™ 4090 and four times faster than the RTX™ 3090.

Oltre ai miglioramenti della velocità, è stata migliorata anche la qualità. The 9th generation NVENC encoder delivers 5% better quality in HEVC and AV1 tasks. The AV1 Ultra Quality mode achieves better data compression while maintaining image quality, reducing file sizes by 5%. Ciò si traduce in un rendering video più rapido su RTX™ 5090 e in una riduzione dei tempi tra l'editing e la produzione.

Conclusione

Guardando indietro di sei mesi, le previsioni e le aspettative degli esperti si sono rivelate eccessivamente ottimistiche. Con l'avvicinarsi della data di uscita, è apparso evidente che le nuove GPU avrebbero offerto molto di più di semplici unità di calcolo aggiuntive. The key innovation would be new optimization and AI technologies enhancing existing frame rendering systems.

Al CES 2025, durante la presentazione della serie GPU 50, è stata svelata una nuova era dell'intelligenza artificiale. Questa visione ritraeva un mondo in cui gli assistenti digitali e i robot gestiscono compiti complessi. Al centro ci sarebbe un ecosistema che combina supercomputer per l'addestramento dell'IA, acceleratori di inferenza a prezzi accessibili per i dispositivi di consumo e software versatile che opera sia a livello locale che nel cloud. Anche se la portata di questo futuro rimane incerta, una cosa è chiara: siamo sulla soglia di trasformare la fantascienza in realtà.

LeaderGPU remains committed to providing reliable access to these cutting-edge technologies. Order your first GPU server today and begin transforming your ideas into reality.

Vedi anche:

Vantaggi e svantaggi della condivisione della GPU

Thu, 23 Jan 2025 13:24:12 +0100

La legge di Moore è rimasta attuale per quasi mezzo secolo. I chip dei processori continuano a contenere un numero sempre maggiore di transistor e le tecnologie progrediscono ogni giorno. Con l'evoluzione della tecnologia, si evolve anche il nostro approccio all'informatica. L'aumento di alcune attività di calcolo ha influenzato in modo significativo lo sviluppo dell'hardware. Per esempio, i dispositivi originariamente progettati per l'elaborazione grafica sono ora strumenti fondamentali e accessibili per le moderne reti neurali.

Anche la gestione delle risorse informatiche si è trasformata. I servizi di massa utilizzano raramente i mainframe, come negli anni Settanta e Ottanta. Preferiscono invece i servizi cloud o la costruzione di infrastrutture proprie. Questo cambiamento ha modificato le richieste dei clienti, che si concentrano su una scalabilità rapida e on-demand e sulla massimizzazione dell'uso delle risorse informatiche allocate.

Le tecnologie di virtualizzazione e containerizzazione sono emerse come soluzioni. Le applicazioni sono ora confezionate in container con tutte le librerie necessarie, semplificando la distribuzione e la scalabilità. Tuttavia, la gestione manuale è diventata impraticabile man mano che il numero di container saliva a migliaia. Orchestratori specializzati come Kubernetes si occupano ora della gestione e della scalabilità. Questi strumenti sono diventati una parte essenziale di qualsiasi infrastruttura IT moderna.

Virtualizzazione dei server

Contemporaneamente, le tecnologie di virtualizzazione si sono evolute, consentendo la creazione di ambienti isolati all'interno di un singolo server fisico. Le macchine virtuali si comportano in modo identico ai normali server fisici, consentendo l'uso di strumenti di gestione standard. A seconda dell'hypervisor, spesso è inclusa un'API specializzata che facilita l'automazione delle procedure di routine.

Tuttavia, questa flessibilità comporta una riduzione della sicurezza. Gli aggressori hanno spostato la loro attenzione dal colpire le singole macchine virtuali allo sfruttare le vulnerabilità dell'hypervisor. Ottenendo il controllo di un hypervisor, gli aggressori possono accedere a tutte le macchine virtuali associate a piacimento. Nonostante i continui miglioramenti della sicurezza, i moderni hypervisor rimangono obiettivi interessanti.

La virtualizzazione tradizionale affronta due questioni fondamentali. Il primo: garantisce l'isolamento delle macchine virtuali l'una dall'altra. Le soluzioni bare-metal evitano questo problema, poiché i clienti affittano interi server fisici sotto il loro controllo. Ma per le macchine virtuali l'isolamento è basato sul software a livello di hypervisor. Un errore di codice o un bug casuale può compromettere questo isolamento, con il rischio di perdita o corruzione dei dati.

Il secondo problema riguarda la gestione delle risorse. Mentre è possibile garantire l'allocazione delle risorse a macchine virtuali specifiche, la gestione di numerose macchine presenta un dilemma. Le risorse possono essere sottoutilizzate, con conseguente riduzione del numero di macchine virtuali per server fisico. Questo scenario non è redditizio per l'infrastruttura e porta inevitabilmente a un aumento dei prezzi.

In alternativa, è possibile utilizzare meccanismi di gestione automatica delle risorse. Sebbene a una macchina virtuale vengano assegnate specifiche caratteristiche dichiarate, in realtà viene fornito solo il minimo richiesto entro questi limiti. Se la macchina ha bisogno di più tempo di processore o di RAM, l'hypervisor cercherà di fornirlo, ma non può garantirlo. Questa situazione è simile all'overbooking degli aerei, quando le compagnie aeree vendono più biglietti di quanti posti siano disponibili.

La logica è identica. Se le statistiche mostrano che circa il 10% dei passeggeri non arriva in tempo per il volo, le compagnie aeree possono vendere il 10% di biglietti in più con un rischio minimo. Se tutti i passeggeri arrivano, alcuni non troveranno posto a bordo. La compagnia aerea dovrà affrontare conseguenze minori sotto forma di risarcimento, ma probabilmente continuerà a seguire questa pratica.

Molti fornitori di infrastrutture adottano una strategia simile. Alcuni sono trasparenti al riguardo, dichiarando di non garantire la disponibilità costante di risorse informatiche ma di offrire prezzi significativamente ridotti. Altri utilizzano meccanismi simili senza pubblicizzarli. Scommettono che non tutti i clienti utilizzeranno costantemente il 100% delle risorse dei loro server e che, anche se alcuni lo faranno, saranno una minoranza. Nel frattempo, le risorse inattive generano profitto.

In questo contesto, le soluzioni bare-metal hanno un vantaggio. Garantiscono che le risorse allocate siano completamente gestite dal cliente e non condivise con altri utenti del fornitore dell'infrastruttura. In questo modo si eliminano gli scenari in cui il carico elevato di un utente di un server vicino influisce negativamente sulle prestazioni.

Virtualizzazione delle GPU

La virtualizzazione classica deve inevitabilmente affrontare la sfida dell'emulazione dei dispositivi fisici. Per ridurre i costi generali, sono state sviluppate tecnologie speciali che consentono alle macchine virtuali di accedere direttamente ai dispositivi fisici del server. Questo approccio funziona bene in molti casi, ma quando viene applicato ai processori grafici, crea limitazioni immediate. Ad esempio, se un server ha 8 GPU installate, solo 8 macchine virtuali possono accedervi.

Per superare questa limitazione è stata inventata la tecnologia vGPU. Essa divide una GPU in più GPU logiche, che possono essere assegnate alle macchine virtuali. Questo permette a ogni macchina virtuale di avere la sua "fetta di torta" e il loro numero totale non è più limitato dal numero di schede video installate nel server.

Le GPU virtuali sono più comunemente utilizzate nella creazione di VDI (Virtual Desktop Infrastructure) in aree in cui le macchine virtuali richiedono l'accelerazione 3D. Ad esempio, una postazione di lavoro virtuale per un designer o un pianificatore comporta tipicamente l'elaborazione grafica. La maggior parte delle applicazioni in questi campi esegue i calcoli sia sul processore centrale che sulla GPU. Questo approccio ibrido aumenta significativamente la produttività e garantisce un uso ottimale delle risorse di elaborazione disponibili.

Tuttavia, questa tecnologia presenta diversi svantaggi. Non è supportata da tutte le GPU ed è disponibile solo nel segmento dei server. Il supporto dipende anche dalla versione installata del sistema operativo e dal driver della GPU. vGPU ha un meccanismo di licenza separato, che aumenta notevolmente i costi operativi. Inoltre, i suoi componenti software possono potenzialmente fungere da vettori di attacco.

Recentemente sono state pubblicate informazioni su otto vulnerabilità che interessano tutti gli utenti di GPU NVIDIA®. Sei vulnerabilità sono state identificate nei driver delle GPU e due nel software vGPU. Questi problemi sono stati rapidamente risolti, ma ciò serve a ricordare che i meccanismi di isolamento in questi sistemi non sono impeccabili. Il monitoraggio costante e l'installazione tempestiva degli aggiornamenti restano i metodi principali per garantire la sicurezza.

Quando si costruisce un'infrastruttura per elaborare dati riservati e sensibili degli utenti, qualsiasi virtualizzazione diventa un potenziale fattore di rischio. In questi casi, un approccio bare-metal può offrire una qualità e una sicurezza migliori.

Conclusioni

La costruzione di un'infrastruttura informatica richiede sempre una valutazione dei rischi. Le domande chiave da considerare sono: I dati dei clienti sono protetti in modo sicuro? Le tecnologie scelte creano ulteriori vettori di attacco? Come si possono isolare ed eliminare le potenziali vulnerabilità? Rispondere a queste domande aiuta a fare scelte informate e a prevenire problemi futuri.

Noi di LeaderGPU siamo giunti a una conclusione chiara: attualmente la tecnologia bare-metal è superiore nel garantire la sicurezza dei dati degli utenti e al tempo stesso costituisce un'ottima base per la creazione di un cloud bare-metal. Questo approccio consente ai nostri clienti di mantenere la flessibilità senza assumersi i rischi aggiuntivi associati alla virtualizzazione delle GPU.

Vedi anche:

Che cos'è la distillazione della conoscenza

Thu, 23 Jan 2025 13:21:29 +0100

I Large Language Models (LLM) sono diventati parte integrante della nostra vita grazie alle loro capacità uniche. Comprendono il contesto e generano testi coerenti ed estesi sulla base di esso. Possono elaborare e rispondere in qualsiasi lingua, tenendo conto delle sfumature culturali di ciascuna.

I LLM eccellono nella risoluzione di problemi complessi, nella programmazione, nella gestione di conversazioni e altro ancora. Questa versatilità deriva dall'elaborazione di grandi quantità di dati di addestramento, da cui il termine "grandi". Questi modelli possono contenere decine o centinaia di miliardi di parametri, il che li rende molto impegnativi per l'uso quotidiano.

L'addestramento è il processo più impegnativo. I modelli di rete neurale imparano elaborando enormi serie di dati, regolando i loro "pesi" interni per formare connessioni stabili tra i neuroni. Queste connessioni memorizzano le conoscenze che la rete neurale addestrata può utilizzare in seguito sui dispositivi finali.

Tuttavia, la maggior parte dei dispositivi finali non dispone della potenza di calcolo necessaria per eseguire questi modelli. Per esempio, l'esecuzione della versione completa di Llama 2 (70B parametri) richiede una GPU con 48 GB di memoria video, hardware che pochi utenti hanno a casa, figuriamoci sui dispositivi mobili.

Di conseguenza, la maggior parte delle reti neurali moderne opera in infrastrutture cloud piuttosto che su dispositivi portatili, che vi accedono tramite API. Tuttavia, i produttori di dispositivi stanno facendo progressi in due modi: dotando i dispositivi di unità di calcolo specializzate come le NPU e sviluppando metodi per migliorare le prestazioni dei modelli di rete neurale compatti.

Ridurre le dimensioni

Tagliare l'eccesso

La quantizzazione è il primo e più efficace metodo per ridurre le dimensioni della rete neurale. I pesi delle reti neurali utilizzano in genere numeri in virgola mobile a 32 bit, ma è possibile ridurli cambiando il formato. L'uso di valori a 8 bit (o addirittura binari in alcuni casi) può ridurre le dimensioni della rete di dieci volte, anche se questo riduce significativamente l'accuratezza delle risposte.

Un altro approccio è la potatura, che rimuove le connessioni non importanti nella rete neurale. Questo processo funziona sia durante l'addestramento sia con le reti completate. Oltre alle semplici connessioni, il pruning può rimuovere neuroni o interi strati. Questa riduzione dei parametri e delle connessioni porta a una riduzione dei requisiti di memoria.

La decomposizione di matrici o tensori è la terza tecnica comune di riduzione delle dimensioni. La scomposizione di una matrice di grandi dimensioni in un prodotto di tre matrici più piccole riduce i parametri totali mantenendo la qualità. Questo può ridurre le dimensioni della rete di decine di volte. La decomposizione tensoriale offre risultati ancora migliori, ma richiede più iperparametri.

Sebbene questi metodi riducano efficacemente le dimensioni, tutti devono affrontare il problema della perdita di qualità. I modelli compressi di grandi dimensioni superano le loro controparti più piccole e non compresse, ma ogni compressione rischia di ridurre l'accuratezza delle risposte. La distillazione della conoscenza rappresenta un interessante tentativo di bilanciare qualità e dimensioni.

Proviamo insieme

La distillazione della conoscenza si spiega meglio con l'analogia tra studente e insegnante. Mentre gli studenti imparano, gli insegnanti insegnano e aggiornano continuamente le loro conoscenze. Quando entrambi si imbattono in nuove conoscenze, l'insegnante è avvantaggiato: può attingere alle sue ampie conoscenze in altri settori, mentre lo studente non ha ancora queste basi.

Questo principio si applica alle reti neurali. Quando si addestrano due reti neurali dello stesso tipo ma di dimensioni diverse su dati identici, la rete più grande di solito ottiene risultati migliori. La sua maggiore capacità di "conoscenza" consente di ottenere risposte più precise rispetto alla sua controparte più piccola. Ciò solleva una possibilità interessante: perché non addestrare la rete più piccola non solo sul set di dati, ma anche sulle uscite più accurate della rete più grande?

Questo processo è la distillazione della conoscenza: una forma di apprendimento supervisionato in cui un modello più piccolo impara a replicare le previsioni di uno più grande. Se da un lato questa tecnica aiuta a compensare la perdita di qualità dovuta alla riduzione delle dimensioni della rete neurale, dall'altro richiede risorse computazionali e tempo di addestramento aggiuntivi.

Software e logica

Chiarite le basi teoriche, esaminiamo il processo da un punto di vista tecnico. Inizieremo con gli strumenti software che possono guidare l'utente attraverso le fasi di formazione e di distillazione della conoscenza.

Python, insieme alla libreria TorchTune dell'ecosistema PyTorch, offre l'approccio più semplice per lo studio e la messa a punto di modelli linguistici di grandi dimensioni. Ecco come funziona l'applicazione:

Vengono caricati due modelli: un modello completo (insegnante) e un modello ridotto (studente). Durante ogni iterazione di addestramento, il modello insegnante genera previsioni ad alta temperatura, mentre il modello studente elabora il set di dati per fare le proprie previsioni.

I valori di output grezzi (logit) di entrambi i modelli vengono valutati attraverso una funzione di perdita (una misura numerica di quanto una previsione si discosta dal valore corretto). Gli aggiustamenti del peso vengono quindi applicati al modello studente attraverso la retropropagazione. Ciò consente al modello più piccolo di apprendere e replicare le previsioni del modello insegnante.

Il file di configurazione principale nel codice dell'applicazione è chiamato ricetta. Questo file memorizza tutti i parametri e le impostazioni della distillazione, rendendo gli esperimenti riproducibili e consentendo ai ricercatori di monitorare l'influenza dei diversi parametri sul risultato finale.

Quando si selezionano i valori dei parametri e il numero di iterazioni, è fondamentale mantenere l'equilibrio. Un modello troppo distillato può perdere la sua capacità di riconoscere i dettagli più sottili e il contesto, passando a risposte predefinite. Anche se un equilibrio perfetto è quasi impossibile da raggiungere, un attento monitoraggio del processo di distillazione può migliorare sostanzialmente la qualità di previsione anche di modelli di reti neurali modesti.

Vale la pena di prestare attenzione anche al monitoraggio durante il processo di addestramento. Questo aiuterà a identificare in tempo i problemi e a correggerli tempestivamente. A tale scopo, è possibile utilizzare lo strumento TensorBoard. Si integra perfettamente nei progetti PyTorch e consente di valutare visivamente molte metriche, come l'accuratezza e le perdite. Inoltre, consente di costruire un grafico del modello, di tenere traccia dell'utilizzo della memoria e del tempo di esecuzione delle operazioni.

Conclusione

La distillazione della conoscenza è un metodo efficace per ottimizzare le reti neurali e migliorare i modelli compatti. Funziona meglio quando è essenziale bilanciare le prestazioni con la qualità delle risposte.

Sebbene la distillazione della conoscenza richieda un attento monitoraggio, i suoi risultati possono essere notevoli. I modelli diventano molto più piccoli, pur mantenendo la qualità della previsione, e funzionano meglio con meno risorse di calcolo.

Se ben pianificata con parametri adeguati, la distillazione della conoscenza è uno strumento fondamentale per creare reti neurali compatte senza sacrificare la qualità.

Vedi anche:

AudioCraft di MetaAI: creare musica per descrizione

Wed, 22 Jan 2025 15:51:35 +0100

Le moderne reti neurali generative stanno diventando sempre più intelligenti. Scrivono storie, dialogano con le persone e creano immagini ultra-realistiche. Ora possono produrre semplici brani musicali senza bisogno di artisti professionisti. Questo futuro è diventato realtà oggi. È previsto, poiché le armonie e i ritmi musicali sono radicati in principi matematici.

Meta ha dimostrato il suo impegno nel mondo del software open-source. Ha reso disponibili al pubblico tre modelli di reti neurali che consentono di creare suoni e musica a partire da descrizioni testuali:

MusicGen - genera musica dal testo.
AudioGen - genera audio dal testo.
EnCodec - compressore audio neurale di alta qualità.

MusicGen è stato addestrato su 20.000 ore di musica. È possibile utilizzarlo localmente tramite i server dedicati di LeaderGPU come piattaforma.

Installazione standard

Aggiornare il repository della cache dei pacchetti:

sudo apt update && sudo apt -y upgrade

Installare il gestore di pacchetti Python, pip, e le librerie ffmpeg:

sudo apt -y install python3-pip ffmpeg

Installare torch 2.0 o più recente usando pip:

pip install 'torch>=2.0'

Il prossimo comando installa automaticamente audiocraft e tutte le dipendenze necessarie:

pip install -U audiocraft

Scriviamo una semplice applicazione Python, utilizzando il modello MusicGen pre-addestrato con 3,3B parametri:

nano generate.py

from audiocraft.models import MusicGen
from audiocraft.data.audio import audio_write
model = MusicGen.get_pretrained("facebook/musicgen-large")
model.set_generation_params(duration=30)  # generate a 30 seconds sample.
descriptions = ["rock solo"]
wav = model.generate(descriptions)  # generates sample.
for idx, one_wav in enumerate(wav):
    # Will save under {idx}.wav, with loudness normalization at -14 db LUFS.
    audio_write(f'{idx}', one_wav.cpu(), model.sample_rate, strategy="loudness")

Eseguire l'applicazione creata:

python3 generate.py

Dopo qualche secondo, il file generato (0.wav) apparirà nella directory.

Caffè Vampir 3

Clonare un repository di progetto:

git clone https://github.com/CoffeeVampir3/audiocraft-webui.git

Aprire la cartella clonata:

cd audiocraft-webui

Eseguire il comando che prepara il sistema e installa tutti i pacchetti necessari:

pip install -r requirements.txt

Eseguire quindi il server Coffee Vampire 3 con il seguente comando:

python3 webui.py

Coffee Vampire 3 utilizza Flask come framework. Per impostazione predefinita, viene eseguito su localhost con la porta 5000. Se si desidera un accesso remoto, utilizzare la funzione di port forwarding nel proprio client SSH. Altrimenti, è possibile organizzare una connessione VPN al server.

Attenzione! Si tratta di un'azione potenzialmente pericolosa; utilizzatela a vostro rischio e pericolo:

nano webui.py

Scorrere fino alla fine e sostituire socketio.run(app) con socketio.run(app, host=’0.0.0.0’, port=5000)

Salvare il file ed eseguire il server con il comando precedente. Questo permette di accedere al server da Internet senza alcuna autenticazione.

Non dimenticate disable AdBlock software, perché può bloccare il lettore musicale sul lato destro della pagina web. Si può iniziare inserendo il prompt e confermando con il pulsante Submit:

Generazione TTS WebUI

Passo 1. Driver

Aggiornare il repository della cache dei pacchetti:

sudo apt update && sudo apt -y upgrade

Installare i driver NVIDIA® utilizzando il programma di installazione automatica o la nostra guida Installare i driver NVIDIA® in Linux:

sudo ubuntu-drivers autoinstall

Riavviare il server:

sudo shutdown -r now

Passo 2. Docker

Il passo successivo è l'installazione di Docker. Installiamo alcuni pacchetti che devono essere aggiunti al repository Docker:

sudo apt -y install apt-transport-https curl gnupg-agent ca-certificates software-properties-common

Scaricare la chiave GPG di Docker e memorizzarla:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Aggiungere il repository:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"

Installare Docker CE (Community Edition) con la CLI e il runtime containerd:

sudo apt -y install docker-ce docker-ce-cli containerd.io

Aggiungere l'utente corrente al gruppo docker:

sudo usermod -aG docker $USER

Applicare le modifiche senza la procedura di logout e login:

newgrp docker

Passo 3. Passaggio della GPU

Abilitiamo il passthrough delle GPU NVIDIA® in Docker. Il comando seguente legge la versione corrente del sistema operativo nella variabile di distribuzione, che può essere utilizzata nel passaggio successivo:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)

Scaricare la chiave GPG del repository NVIDIA® e memorizzarla:

curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -

Scaricare l'elenco dei repository NVIDIA® e memorizzarlo per utilizzarlo nel gestore di pacchetti APT standard:

curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

Aggiornare il repository della cache dei pacchetti e installare il toolkit GPU Passthrough:

sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit

Riavviare il demone Docker:

sudo systemctl restart docker

Passo 4. WebUI

Scaricate l'archivio del repository:

wget https://github.com/rsxdalv/tts-generation-webui/archive/refs/heads/main.zip

Scompattarlo:

unzip main.zip

Aprire la cartella del progetto:

cd tts-generation-webui-main

Avviare la costruzione dell'immagine:

docker build -t rsxdalv/tts-generation-webui .

Eseguire il contenitore creato:

docker compose up -d

Ora è possibile aprire http://[server_ip]:7860, digitare il prompt, selezionare il modello necessario e fare clic sul pulsante Generate:

Il sistema scarica automaticamente il modello selezionato durante la prima generazione. Buon divertimento!

Vedi anche:

Come monitorare l'applicazione LangFlow

Wed, 22 Jan 2025 15:14:55 +0100

Nel nostro articolo sul costruttore di app AI low-code Langflow abbiamo spiegato come iniziare a utilizzare l'ambiente di programmazione visuale di questo costruttore di app AI low-code. Permette a chiunque, anche a chi non ha conoscenze di programmazione, di creare applicazioni alimentate da grandi modelli di reti neurali. Si può trattare di chatbot AI o di applicazioni per l'elaborazione di documenti in grado di analizzare e sintetizzare i contenuti.

Langflow utilizza un approccio a blocchi, in cui gli utenti collegano componenti già pronti per creare l'applicazione desiderata. Tuttavia, spesso si presentano due sfide fondamentali: la risoluzione dei problemi quando le reti neurali si comportano in modo inaspettato e la gestione dei costi. Le reti neurali richiedono notevoli risorse di calcolo, il che rende essenziale monitorare e prevedere le spese per l'infrastruttura.

LangWatch affronta entrambe le sfide. Questo strumento specializzato aiuta gli sviluppatori di Langflow a monitorare le richieste degli utenti, a tenere traccia dei costi e a rilevare le anomalie, ad esempio quando le applicazioni vengono utilizzate in modi non previsti.

Questo strumento è stato originariamente progettato come servizio, ma può essere distribuito su qualsiasi server, anche a livello locale. Si integra con la maggior parte dei fornitori di LLM, siano essi basati su cloud o on-premise. Essendo open source, LangWatch può essere adattato a quasi tutti i progetti: aggiungendo nuove funzionalità o collegandosi ai sistemi interni.

LangWatch consente di impostare avvisi quando determinate metriche superano soglie definite. Questo vi aiuta a rilevare rapidamente aumenti imprevisti dei costi delle richieste o ritardi insoliti nelle risposte. Il rilevamento precoce aiuta a prevenire spese non pianificate e potenziali attacchi al servizio.

Per i ricercatori di reti neurali, questa applicazione consente di monitorare e ottimizzare le richieste più comuni degli utenti. Fornisce inoltre strumenti per valutare la qualità della risposta del modello e apportare le modifiche necessarie.

Avvio rapido

Preparazione del sistema

Come per Langflow, il modo più semplice per eseguire l'applicazione è attraverso un contenitore Docker. Prima di installare LangWatch, è necessario installare Docker Engine sul server. Per prima cosa, aggiornare la cache dei pacchetti e i pacchetti alle loro ultime versioni:

sudo apt update && sudo apt -y upgrade

Installare i pacchetti aggiuntivi richiesti da Docker:

sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Scaricare la chiave GPG per aggiungere il repository ufficiale di Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Aggiungere il repository ad APT utilizzando la chiave scaricata e installata in precedenza:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aggiornare l'elenco dei pacchetti:

sudo apt update

Per assicurarsi che Docker venga installato dal nuovo repository aggiunto e non da quello di sistema, è possibile eseguire il seguente comando:

apt-cache policy docker-ce

Installa motore Docker:

sudo apt install docker-ce

Verificare che Docker sia stato installato correttamente e che il demone corrispondente sia in esecuzione e nello stato active (running):

sudo systemctl status docker

● docker.service - Docker Application Container Engine
    Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset>
    Active: active (running) since Mon 2024-11-18 08:26:35 UTC; 3h 27min ago
TriggeredBy: ● docker.socket
      Docs: https://docs.docker.com
  Main PID: 1842 (dockerd)
     Tasks: 29
    Memory: 1.8G
       CPU: 3min 15.715s
    CGroup: /system.slice/docker.service

Costruire ed eseguire

Con Docker Engine installato e funzionante, è possibile scaricare il repository dell'applicazione LangWatch:

git clone https://github.com/langwatch/langwatch

L'applicazione include un file di configurazione di esempio con variabili di ambiente. Copiare questo file in modo che l'utilità di creazione dell'immagine possa elaborarlo:

cp langwatch/.env.example langwatch/.env

Ora si è pronti per il primo lancio:

sudo docker compose up --build

Il sistema richiederà un momento per scaricare tutti i livelli di contenitore necessari per LangWatch. Una Volta™ completato, verrà visualizzato un messaggio di console che indica che l'applicazione è disponibile all'indirizzo:

http://[LeaderGPU_IP_address]:3000

Navigare a questa pagina nel browser, dove verrà richiesto di creare un account utente:

A differenza di Langflow, questo sistema ha l'autenticazione abilitata per impostazione predefinita. Dopo aver effettuato l'accesso, è necessario configurare il sistema per raccogliere i dati dal server Langflow.

Integrazione con Langflow

Per funzionare, LangWatch ha bisogno di una fonte di dati. Il server è in ascolto sulla porta 3000 e utilizza un'API RESTful, che autentica i dati in arrivo attraverso una chiave API generata automaticamente.

Per abilitare il trasferimento dei dati, è necessario impostare due variabili nei file di configurazione di Langflow: LANGWATCH_ENDPOINT e LANGWATCH_API_KEY. Per prima cosa, stabilite una connessione SSH al vostro server Langflow (che dovrebbe essere offline durante questo processo).

Navigare nella cartella con la configurazione di esempio per Docker:

cd langflow/docker_example

Aprire il file di configurazione per modificarlo:

nano docker-compose.yml

Nella sezione "ambiente:", aggiungere le seguenti variabili (senza parentesi [] o virgolette):

- LANGWATCH_API_KEY= [YOUR_API_KEY]
- LANGWATCH_ENDPOINT=http://[IP_ADDRESS]:3000

Il file YML richiede una formattazione specifica. Seguire queste due regole fondamentali:

Utilizzare spazi (2 o 4) per l'indentazione, mai tabulazioni.
Mantenere una struttura gerarchica corretta con rientri coerenti.

Salvate il file con Ctrl + O e uscite dall'editor con Ctrl + X, Langflow è ora pronto per essere lanciato:

sudo docker compose up

Dopo il lancio, verificate che tutto funzioni correttamente. Create un nuovo progetto o apritene uno esistente, quindi avviate un dialogo attraverso Playground. Langflow invierà automaticamente i dati a LangWatch per il monitoraggio, che potrà essere visualizzato nell'interfaccia web.

Nella sezione di verifica dell'integrazione, alla voce "Sincronizza il primo messaggio" appare un segno di spunta. Questo indica che i dati di Langflow stanno confluendo con successo in LangWatch, confermando che la configurazione è corretta. Esaminiamo ciò che appare nella sezione Messages:

La sezione Messaggi visualizza i dati immessi nell'applicazione, i parametri utilizzati per la generazione della risposta e la risposta stessa della rete neurale. È possibile valutare la qualità della risposta e utilizzare vari filtri per ordinare i dati, anche con centinaia o migliaia di messaggi.

Dopo questa configurazione iniziale, è possibile esplorare sistematicamente le funzionalità dell'applicazione. Nella sezione Evaluations è possibile impostare algoritmi di verifica del dialogo per la moderazione o il riconoscimento dei dati, come ad esempio PII Detection. Questa funzione analizza l'input alla ricerca di informazioni sensibili come numeri di previdenza sociale o numeri di telefono.

L'applicazione offre sia opzioni locali che basate sul cloud attraverso fornitori come Azure o Cloudflare. Per utilizzare le funzioni cloud, è necessario disporre di account presso questi servizi, oltre che dei relativi indirizzi endpoint e chiavi API. Tenete presente che si tratta di fornitori di terze parti, quindi verificate direttamente i costi dei loro servizi.

Per le opzioni locali, l'applicazione dispone di sofisticate funzionalità RAG (Retrieval-augmented generation). È possibile misurare l'accuratezza e la pertinenza dei contenuti generati da RAG e utilizzare le statistiche raccolte per ottimizzare il sistema RAG e ottenere risposte di rete neurale più accurate.

Vedi anche:

Costruttore di app AI a basso codice Langflow

Wed, 22 Jan 2025 15:11:30 +0100

Negli ultimi anni lo sviluppo del software si è evoluto notevolmente. I programmatori moderni hanno ora accesso a centinaia di linguaggi e framework di programmazione. Oltre ai tradizionali approcci imperativi e dichiarativi, sta emergendo un nuovo ed entusiasmante metodo per creare applicazioni. Questo approccio innovativo sfrutta la potenza delle reti neurali, aprendo agli sviluppatori fantastiche possibilità.

Le persone si sono abituate agli assistenti AI negli IDE che aiutano con l'autocompletamento del codice e alle moderne reti neurali che generano facilmente codice per semplici giochi in Python. Tuttavia, stanno emergendo nuovi strumenti ibridi che potrebbero rivoluzionare il panorama dello sviluppo. Uno di questi strumenti è Langflow.

Langflow ha molteplici scopi. Per gli sviluppatori professionisti, offre un migliore controllo su sistemi complessi come le reti neurali. Per coloro che non hanno familiarità con la programmazione, consente di creare applicazioni semplici ma pratiche. Questi obiettivi sono raggiunti con mezzi diversi, che analizzeremo in dettaglio.

Reti neurali

Il concetto di rete neurale può essere semplificato per gli utenti. Immaginate una scatola nera che riceve dati di input e parametri che influenzano il risultato finale. Questa scatola elabora i dati in ingresso utilizzando algoritmi complessi, spesso definiti "magici", e produce dati in uscita che possono essere presentati all'utente.

Il funzionamento interno di questa scatola nera varia in base al progetto della rete neurale e ai dati di addestramento. È fondamentale capire che gli sviluppatori e gli utenti non possono mai ottenere risultati certi al 100%. A differenza della programmazione tradizionale, dove 2 + 2 è sempre uguale a 4, una rete neurale potrebbe dare una risposta con una certezza del 99%, mantenendo sempre un margine di errore.

Il controllo sul processo di "pensiero" di una rete neurale è indiretto. Possiamo regolare solo alcuni parametri, come la "temperatura". Questo parametro determina quanto la rete neurale possa essere creativa o vincolata nel suo approccio. Un valore basso di temperatura limita la rete a un approccio più formale e strutturato ai compiti e alle soluzioni. Al contrario, valori di temperatura elevati concedono alla rete una maggiore libertà, che può portare a fare affidamento su fatti meno affidabili o addirittura alla creazione di informazioni fittizie.

Questo esempio illustra come gli utenti possano influenzare il risultato finale. Per la programmazione tradizionale, questa incertezza rappresenta una sfida significativa: gli errori possono comparire inaspettatamente e i risultati specifici diventano imprevedibili. Tuttavia, questa imprevedibilità è un problema principalmente dei computer, non degli esseri umani che possono adattarsi e interpretare risultati diversi.

Se l'output di una rete neurale è destinato a un essere umano, la formulazione specifica utilizzata per descriverlo è generalmente meno importante. Dato il contesto, le persone possono interpretare correttamente i vari risultati dal punto di vista della macchina. Mentre concetti come "valore positivo", "risultato raggiunto" o "decisione positiva" possono avere più o meno lo stesso significato per una persona, la programmazione tradizionale avrebbe difficoltà a gestire questa flessibilità. Dovrebbe tenere conto di tutte le possibili varianti di risposta, il che è quasi impossibile.

D'altra parte, se l'ulteriore elaborazione viene affidata a un'altra rete neurale, questa può comprendere ed elaborare correttamente il risultato ottenuto. Su questa base, può formulare le proprie conclusioni con un certo grado di sicurezza, come già detto.

Codice basso

La maggior parte dei linguaggi di programmazione prevede la scrittura di codice. I programmatori creano la logica di ogni parte di un'applicazione nella loro mente, quindi la descrivono utilizzando espressioni specifiche del linguaggio. Questo processo forma un algoritmo: una chiara sequenza di azioni che porta a un risultato specifico e predeterminato. È un compito complesso che richiede un notevole sforzo mentale e una profonda conoscenza delle capacità del linguaggio.

Tuttavia, non è necessario reinventare la ruota. Molti problemi affrontati dagli sviluppatori moderni sono già stati risolti in vari modi. Su StackOverflow si possono trovare spesso frammenti di codice pertinenti. La programmazione moderna può essere paragonata all'assemblaggio di un intero con parti di diversi set di costruzione. Il sistema Lego offre un modello di successo, avendo standardizzato diversi set di pezzi per garantire la compatibilità.

Il metodo di programmazione low-code segue un principio simile. I vari pezzi di codice vengono modificati per adattarsi perfettamente l'uno all'altro e vengono presentati agli sviluppatori come blocchi già pronti. Ogni blocco può avere ingressi e uscite di dati. La documentazione specifica il compito che ogni tipo di blocco risolve e il formato in cui accetta o emette i dati.

Collegando questi blocchi in una sequenza specifica, gli sviluppatori possono formare l'algoritmo di un'applicazione e visualizzarne chiaramente la logica operativa. Forse l'esempio più noto di questo metodo di programmazione è il metodo della grafica a tartaruga, comunemente utilizzato in ambito didattico per introdurre i concetti di programmazione e sviluppare il pensiero algoritmico.

L'essenza di questo metodo è semplice: disegnare immagini sullo schermo utilizzando una tartaruga virtuale che lascia una scia mentre striscia sulla tela. Utilizzando blocchi già pronti, come lo spostamento di un determinato numero di pixel, la rotazione ad angoli specifici o il sollevamento e l'abbassamento della penna, gli sviluppatori possono creare programmi che disegnano le immagini desiderate. La creazione di applicazioni utilizzando un costruttore low-code è simile alla grafica delle tartarughe, ma consente agli utenti di risolvere un'ampia gamma di problemi, non solo il disegno su una tela.

Questo metodo è stato implementato al meglio nello strumento di programmazione Node-RED di IBM. È stato sviluppato come mezzo universale per garantire il funzionamento congiunto di diversi dispositivi, servizi online e API. L'equivalente dei frammenti di codice erano i nodi della libreria standard (palette).

Le capacità di Node-RED possono essere ampliate installando componenti aggiuntivi o creando nodi personalizzati che eseguono azioni specifiche sui dati. Gli sviluppatori posizionano i nodi della tavolozza sul desktop e creano relazioni tra di essi. Questo processo crea la logica dell'applicazione, mentre la visualizzazione aiuta a mantenere la chiarezza.

Aggiungendo le reti neurali a questo concetto si ottiene un sistema intrigante. Invece di elaborare i dati con formule matematiche specifiche, è possibile inserirli in una rete neurale e specificare l'output desiderato. Anche se i dati in ingresso possono variare leggermente ogni Volta™, i risultati rimangono adatti all'interpretazione da parte dell'uomo o di altre reti neurali.

Generazione aumentata di recupero (RAG)

L'accuratezza dei dati nei modelli linguistici di grandi dimensioni è un problema urgente. Questi modelli si basano esclusivamente sulla conoscenza acquisita durante l'addestramento, che dipende dalla rilevanza dei set di dati utilizzati. Di conseguenza, i modelli linguistici di grandi dimensioni possono non avere sufficienti dati rilevanti, portando potenzialmente a risultati errati.

Per risolvere questo problema, sono necessari metodi di aggiornamento dei dati. Consentire alle reti neurali di estrarre il contesto da fonti aggiuntive, come i siti web, può migliorare significativamente la qualità delle risposte. È proprio così che funziona la RAG (Retrieval-Augmented Generation). I dati aggiuntivi vengono convertiti in rappresentazioni vettoriali e memorizzati in un database.

In pratica, i modelli di rete neurale possono convertire le richieste degli utenti in rappresentazioni vettoriali e confrontarle con quelle memorizzate nel database. Quando vengono trovati vettori simili, i dati vengono estratti e utilizzati per formare una risposta. I database vettoriali sono sufficientemente veloci per supportare questo schema in tempo reale.

Affinché questo sistema funzioni correttamente, è necessario stabilire un'interazione tra l'utente, il modello di rete neurale, le fonti di dati esterne e il database vettoriale. Langflow semplifica questa configurazione grazie alla sua componente visiva: gli utenti costruiscono semplicemente dei blocchi standard e li "collegano", creando un percorso per il flusso dei dati.

Il primo passo è quello di popolare il database vettoriale con le fonti pertinenti. Queste possono includere file da un computer locale o pagine web da Internet. Ecco un semplice esempio di caricamento dei dati nel database:

Ora che abbiamo un database vettoriale oltre all'LLM addestrato, possiamo incorporarlo nello schema generale. Quando un utente invia una richiesta nella chat, il sistema forma contemporaneamente un prompt e interroga il database dei vettori. Se vengono trovati vettori simili, i dati estratti vengono analizzati e aggiunti come contesto alla richiesta formata. Il sistema invia quindi una richiesta alla rete neurale e invia la risposta ricevuta all'utente nella chat.

Sebbene l'esempio citi servizi cloud come OpenAI e AstraDB, è possibile utilizzare qualsiasi servizio compatibile, compresi quelli distribuiti localmente sui server LeaderGPU. Se non riuscite a trovare l'integrazione di cui avete bisogno nell'elenco dei blocchi disponibili, potete scriverla voi stessi o aggiungerne una creata da qualcun altro.

Avvio rapido

Preparazione del sistema

Il modo più semplice per distribuire Langflow è all'interno di un contenitore Docker. Per configurare il server, iniziare con l'installazione di Docker Engine. Quindi, aggiornate sia la cache dei pacchetti che i pacchetti alle loro ultime versioni:

sudo apt update && sudo apt -y upgrade

Installare i pacchetti aggiuntivi richiesti da Docker:

sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Scaricare la chiave GPG per aggiungere il repository ufficiale di Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Aggiungere il repository ad APT utilizzando la chiave scaricata e installata in precedenza:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aggiornare l'elenco dei pacchetti:

sudo apt update

Per assicurarsi che Docker venga installato dal nuovo repository aggiunto e non da quello di sistema, è possibile eseguire il seguente comando:

apt-cache policy docker-ce

Installa motore Docker:

sudo apt install docker-ce

Verificare che Docker sia stato installato correttamente e che il demone corrispondente sia in esecuzione e nello stato active (running):

sudo systemctl status docker

● docker.service - Docker Application Container Engine
  Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset>
  Active: active (running) since Mon 2024-11-18 08:26:35 UTC; 3h 27min ago
TriggeredBy: ● docker.socket
    Docs: https://docs.docker.com
Main PID: 1842 (dockerd)
   Tasks: 29
  Memory: 1.8G
     CPU: 3min 15.715s
  CGroup: /system.slice/docker.service

Costruire ed eseguire

Tutto è pronto per costruire ed eseguire un contenitore Docker con Langflow. Tuttavia, c'è un'avvertenza: al momento della stesura di questa guida, l'ultima versione (taggata v1.1.0) presenta un errore e non si avvia. Per evitare questo problema, useremo la versione precedente, v1.0.19.post2, che funziona perfettamente subito dopo il download.

L'approccio più semplice è quello di scaricare il repository del progetto da GitHub:

git clone https://github.com/langflow-ai/langflow

Navigare nella cartella contenente la configurazione di deployment di esempio:

cd langflow/docker_example

Ora è necessario fare due cose. Primo, cambiare il tag release, in modo da creare una versione funzionante (al momento della stesura di queste istruzioni). In secondo luogo, aggiungere una semplice autorizzazione, in modo che nessuno possa usare il sistema senza conoscere login e password.

Aprire il file di configurazione:

sudo nano docker-compose.yml

invece della riga seguente:

image: langflowai/langflow:latest

specificare la versione invece del tag latest:

image: langflowai/langflow:v1.0.19.post2

È inoltre necessario aggiungere tre variabili alla sezione environment:

  - LANGFLOW_AUTO_LOGIN=false
  - LANGFLOW_SUPERUSER=admin
  - LANGFLOW_SUPERUSER_PASSWORD=your_secure_password

La prima variabile disabilita l'accesso all'interfaccia web senza autorizzazione. La seconda aggiunge il nome utente che riceverà i diritti di amministratore del sistema. La terza aggiunge la password corrispondente.

Se si intende memorizzare il file docker-compose.yml in un sistema di controllo della versione, evitare di scrivere la password direttamente in questo file. Creare invece un file separato con estensione .env nella stessa directory e memorizzare lì il valore della variabile.

LANGFLOW_SUPERUSER_PASSWORD=your_secure_password

Nel file docker-compose.yml è ora possibile fare riferimento a una variabile invece di specificare direttamente la password:

LANGFLOW_SUPERUSER_PASSWORD=${LANGFLOW_SUPERUSER_PASSWORD}

Per evitare di esporre accidentalmente il file *.env su GitHub, ricordarsi di aggiungerlo a .gitignore. In questo modo la password rimarrà ragionevolmente al sicuro da accessi indesiderati.

Ora non resta che costruire il nostro contenitore ed eseguirlo:

sudo docker compose up

Aprire la pagina web all'indirizzo http://[LeaderGPU_IP_address]:7860 e si vedrà il modulo di autorizzazione:

Una Volta™ inseriti login e password, il sistema concede l'accesso all'interfaccia web dove è possibile creare le proprie applicazioni. Per una guida più approfondita, si consiglia di consultare la documentazione ufficiale. Essa fornisce dettagli su diverse variabili d'ambiente che consentono una facile personalizzazione del sistema in base alle proprie esigenze.

Vedi anche:

Easy Diffusion UI

Wed, 22 Jan 2025 12:13:37 +0100

Easy Diffusion UI è un software open source disponibile per il download su GitHub. Ecco come installarlo su Ubuntu 22.04 LTS. Se avete appena affittato un server, installate i driver della GPU ed estendete la vostra home directory. Quindi, scaricare l'ultima versione di Easy Diffusion UI:

wget https://github.com/cmdr2/stable-diffusion-ui/releases/latest/download/Easy-Diffusion-Linux.zip

Decomprimere l'archivio ZIP scaricato:

unzip Easy-Diffusion-Linux.zip

Cambiare la directory in easy-diffusion:

cd easy-diffusion

Avviare l'installazione:

./start.sh

Si tratta di una raccolta di script che scarica e installa automaticamente tutti i componenti necessari. Scarica anche il modello standard di Diffusione stabile in formato SafeTensors. Una Volta™ completati tutti i download e le installazioni, l'interfaccia utente di Easy Diffusion si avvierà automaticamente.

Utilizzo di

L'articolo precedente, Stable Diffusion WebUI, illustra un metodo per accettare connessioni da Internet pubblico e fornisce una semplice autorizzazione di login e password. In questo caso, vogliamo dimostrare un altro metodo universale per l'inoltro delle porte attraverso una connessione SSH. Utilizziamo PuTTY per stabilire una connessione sicura al server remoto. Potete trovare maggiori informazioni al riguardo nella nostra guida Connettersi a un server Linux.

Per scegliere quali porte inoltrare, aprire Connection > SSH > Tunnels nell'albero delle opzioni a sinistra. Digitare 9000 nel campo Source Port e 127.0.0.1:9000 nel campo Destination. Fare quindi clic sul pulsante Add:

Successivamente, è possibile tornare a Session e salvarlo per un uso successivo. Collegarsi al server remoto come di consueto. Ora, tutti i dati inviati o ricevuti sulla porta 9000 dell'indirizzo di loopback 127.0.0.1 saranno reindirizzati al server remoto. Questo metodo crea un tunnel virtuale sicuro che rimane attivo per tutta la durata della connessione.

Una Volta™ avviata Easy Diffusion UI e attivato il port forwarding, si può aprire un browser web e navigare all'indirizzo http://127.0.0.1:9000. Si consiglia di scaricare e installare modelli personalizzati, come descritto in questo articolo, invece di affidarsi esclusivamente al modello standard per generare le immagini. Non dimenticate di aumentare il numero di passi di inferenza e di regolare la risoluzione dell'immagine desiderata (contrassegnata da asterischi).

Uno dei principali vantaggi dell'interfaccia utente di Easy Diffusion è il supporto di più GPU. Quando si desidera creare un batch di immagini, è possibile scegliere il numero di immagini da creare in parallelo. Ad esempio, se si dispone di una configurazione a doppia GPU:

È possibile visualizzare il carico della GPU durante il processo di generazione dell'immagine. Stabilire un'altra connessione SSH ed eseguire un singolo comando:

watch -n 1 nvidia-smi

Inoltre, Easy Diffusion UI semplifica la creazione dei prompt in quanto fornisce numerosi esempi di modificatori di immagine. È possibile mescolarli per ottenere risultati più accurati:

È una buona idea esplorare PromptBook di OpenArt. Questa guida può migliorare notevolmente le vostre capacità di creazione dei prompt. Con l'interfaccia utente Easy Diffusion, una Volta™ generata l'immagine, è possibile scaricarla, utilizzarla come esempio per la generazione dell'immagine successiva o apportare modifiche con un solo clic:

L'uso più comune del pulsante Upscale è quello di aumentare la risoluzione di un'immagine. La rete neurale generativa utilizza l'immagine originale come base e aggiunge pixel supplementari, interpolando così l'immagine di partenza alle dimensioni desiderate.

Quando si generano i volti, possono sorgere problemi come occhi disallineati, dimensioni sproporzionate o parti malformate. Fortunatamente, questi problemi possono essere risolti utilizzando il pulsante Fix Faces. Inoltre, è possibile utilizzare suggerimenti negativi per evitare che vengano generate facce non corrette.

Disinstallare

Tutti i file, gli script, le librerie e i modelli sono memorizzati in un'unica directory. Se si desidera rimuovere Easy Diffusion UI dal proprio server, è sufficiente eliminare questa directory insieme a tutto il contenuto:

sudo rm -rf easy-diffusion

Vedi anche:

Stable Video Diffusion

Wed, 22 Jan 2025 11:53:04 +0100

Le reti neurali generative possono creare diversi tipi di contenuti. Stable Diffusion è stata creata per generare immagini a partire da descrizioni testuali. Tuttavia, può essere utilizzata anche per creare musica, suoni e persino video. Oggi vi mostreremo come creare brevi video da una singola immagine utilizzando Stable Diffusion con WebUI e ComfyUI.

Installare Stable Diffusion

Iniziamo ad installare Stable Diffusion seguendo la nostra guida passo passo. Dopo l'installazione, interrompere l'esecuzione dello script webui.sh premendo Ctrl + C e chiudere la connessione SSH. Il sistema non consente di installare estensioni con le opzioni --listen (--share) abilitate. Ciò significa che è necessario impostare il port forwarding (7860 e 8189) dal computer locale al server remoto. La prima porta è necessaria per la WebUI e la seconda per ComfyUI.

Ad esempio, in PuTTY, è necessario aprire Connection >> SSH >> Tunnels e aggiungere due nuove porte inoltrate, come mostrato nella seguente schermata:

Ora è possibile ricollegarsi al server remoto ed eseguire nuovamente ./webui.sh.

Aprire questo URL nel browser:

http://127.0.0.1:7860

Navigare fino a Extensions >> Available, quindi fare clic sul pulsante Load from::

Il sistema scaricherà il file JSON con tutte le estensioni disponibili. Digitare ComfyUI nella casella di ricerca e fare clic sul pulsante Install:

La pagina web verrà ricaricata e nel pannello principale verrà visualizzata una nuova scheda ComfyUI. Passare ad essa e fare clic su Install ComfyUI:

Al termine dell'installazione, interrompere nuovamente l'esecuzione dello script webui.sh premendo Ctrl + C.

Installare il modello di diffusione video stabile

Aprire la directory del modello:

cd stable-diffusion-webui/models/Stable-diffusion/

Scaricare il modello completo di Diffusione video stabile:

curl -L https://huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt/resolve/main/svd_xt.safetensors?download=true --output svd_xt.safetensors

Tornare alla directory iniziale:

cd ~/

Ed eseguire nuovamente il servizio Stable Diffusion:

./webui.sh

Scaricare l'esempio del flusso di lavoro Stable Video Diffusion in formato JSON. Cancellare il flusso di lavoro predefinito di ComfyUI premendo Clear, quindi Load l'esempio scaricato:

Assicurarsi di aver selezionato il modello corretto nel nodo Image Only Checkpoint Loader (img2vid model):

Fare clic sul pulsante choose file to upload nel nodo Load Image e selezionare una singola immagine che la rete neurale generativa trasformerà in un video:

Provare a generare un video con tutti i parametri predefiniti facendo clic sul pulsante Queue Prompt:

Al termine del processo, si otterrà il video in formato WEBP nel nodo SaveAnimatedWEBP. Fare clic con il tasto destro del mouse sul video generato e scegliere Save Image:

Ecco il risultato finale GIF.

Risoluzione dei problemi

Se viene visualizzato un messaggio di errore: ModuleNotFoundError: No module named 'utils.json_util'; 'utils' is not a package, seguire i seguenti passaggi:

Rinominare la directory utils in utilities:

mv /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/utils /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/utilities

Modificare custom_node_manager.py:

nano /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/app/custom_node_manager.py

Sostituire questa riga:

from utils.json_util import merge_json_recursive

con:

from utilities.json_util import merge_json_recursive

Salvare il file (Ctrl + O) e uscire dall'editor (Ctrl + X). Quindi modificare main.py:

nano /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/main.py

Sostituire questa riga:

import utils.extra_config

con:

import utilities.extra_config

Salvare il file, uscire dall'editor ed eseguire nuovamente il servizio Stable Diffusion:

./webui.sh

Vedi anche:

PyTorch per Windows

Wed, 22 Jan 2025 11:35:30 +0100

Prima di iniziare l'installazione di PyTorch, è necessario installare l'interprete Python e Microsoft Visual C++ Redistributable. Aprite un browser web e visitate la pagina di download di Python. Trovate l'ultima versione di Python 3 e cliccate sul link:

Quindi scorrere la pagina e fare clic su Windows Installer (64-bit):

Aprire il file scaricato per procedere all'installazione:

Selezionate la casella Add python.exe to PATH e fate clic su Install Now:

Attendere un minuto per il completamento del processo di installazione:

Si può optare per Disable path length limit se si prevede di utilizzare nomi lunghi che potrebbero superare i limiti di MAX_PATH:

Installare MS Visual C++

Successivamente, scaricate Microsoft Visual C++ Redistributable utilizzando questo link e fate clic sul programma di installazione:

È necessario selezionare la casella I agree to the license terms and conditions e fare clic sul pulsante Install:

Dopo qualche secondo, il software verrà installato e sarà possibile accedere al programma di installazione all'indirizzo Close:

Ora tutto è pronto per l'installazione di PyTorch. Fate clic sul pulsante Start e digitate cmd sulla tastiera. Fate clic con il tasto destro del mouse su Command Prompt e selezionate Run as administrator dal menu contestuale:

Installa PyTorch

Eseguite il seguente comando:

pip install torch torchvision

Se si desidera installare una versione specifica di PyTorch, è possibile specificarla durante l'installazione:

pip install torch==1.9.0 torchvision==0.10.0

Una Volta™ completata l'installazione, verifichiamo che PyTorch funzioni correttamente. Eseguite il seguente comando per aprire l'interprete Python:

python

Digitate queste due stringhe, terminando l'immissione con il tasto Enter:

import torch
print(torch.__version__)

Se si ottiene un risultato simile a questo, significa che PyTorch è stato installato correttamente:

2.0.1+cu117

Vedi anche:

PyTorch per Linux

Wed, 22 Jan 2025 10:14:16 +0100

Le moderne distribuzioni Linux dipendono fortemente dalla versione di Python installata. Pertanto, prima di installare PyTorch, si consiglia di creare un ambiente virtuale utilizzando la nostra guida passo passo sulle utilità di sistema di Linux.

Attivare l'ambiente virtuale creato e procedere con l'aggiornamento di pip3:

pip3 install --upgrade pip

Avviare l'installazione di PyTorch:

pip3 install torch torchvision

Se si vuole installare una versione specifica di PyTorch, basta digitare il numero di versione richiesto:

pip3 install torch==1.9.0 torchvision==0.10.0

Al termine dell'installazione, verifichiamo che PyTorch sia stato installato correttamente. Aprite l'interprete Python:

python3

Digitare queste due stringhe, terminando l'immissione con il tasto Invio:

import torch
print(torch.__version__)

Se si ottiene un risultato simile a questo, significa che PyTorch è stato installato correttamente:

2.0.1+cu117

Vedi anche:

Stable Diffusion: Riffusion

Tue, 21 Jan 2025 14:12:29 +0100

Nei nostri precedenti articoli abbiamo esplorato le affascinanti capacità della Diffusione stabile di generare immagini accattivanti. Tuttavia, è importante notare che questa potente rete neurale generativa ha ancora di più da offrire.

Riffusion è un modello di Stable Diffusion per la creazione e l'editing di musica. Con Riffusion è possibile generare uno spettrogramma di un segmento musicale desiderato e trasformarlo senza sforzo in un estratto musicale. Installiamo Riffusion su un server LeaderGPU e proviamolo in azione.

Prerequisiti

Iniziate aggiornando il repository della cache dei pacchetti e i pacchetti installati:

sudo apt update && sudo apt -y upgrade

Non dimenticate di installare i driver NVIDIA® usando il comando autoinstall o manualmente, usando la nostra guida passo-passo:

sudo ubuntu-drivers autoinstall

Riavviare il server:

sudo shutdown -r now

Per creare un ambiente virtuale, gli sviluppatori suggeriscono di utilizzare uno strumento chiamato Anaconda. Si può anche usare venv, di cui abbiamo parlato nel tutorial sulle utilità di sistema di Linux. Scaricare lo script di installazione di Anaconda usando curl:

curl --output anaconda.sh https://repo.anaconda.com/archive/Anaconda3-5.3.1-Linux-x86_64.sh

Renderlo eseguibile:

chmod +x anaconda.sh

Ed eseguire:

./anaconda.sh

Rispondere SI a tutte le domande, tranne l'ultima (installare Microsoft VSCode). Quindi, accedere nuovamente alla console SSH e creare un nuovo ambiente virtuale con Python v3.9:

conda create --name riffusion python=3.9

Attivare il nuovo ambiente virtuale:

conda activate riffusion

Se si desidera utilizzare formati musicali diversi dal wav, è necessario installare anche il set di librerie FFmpeg:

conda install -c conda-forge ffmpeg

Installare Riffusion

Clonare il repository di Riffusion:

git clone https://github.com/riffusion/riffusion.git

Aprire la cartella scaricata:

cd riffusion

Apportiamo alcune modifiche al file dei requisiti. In questo modo si evitano errori di compatibilità con Torch:

nano requirements.txt

Trovare e correggere le versioni dei pacchetti:

diffusers==0.9.0
torchaudio==2.0.1

Salvare le modifiche e procedere con la preparazione di un ambiente virtuale. Il comando seguente installa tutti i pacchetti necessari:

python -m pip install -r requirements.txt

Infine, è possibile aprire un "parco giochi". Si tratta di una semplice interfaccia web che aiuta a conoscere meglio le funzionalità di Riffusion:

python -m riffusion.streamlit.playground

Aprite il vostro browser preferito e inserite l'indirizzo http://[SERVER_IP]:8501/

Prova un'area di gioco

Ora è possibile creare musica utilizzando i messaggi di testo e modificando gli altri parametri:

Inoltre, è possibile eseguire alcune operazioni complesse, come la suddivisione dell'audio in componenti separati. Ad esempio, è possibile estrarre la voce da Bohemian Rhapsody dei Queen:

Ricordate che questo è solo un esempio di come Riffusion può essere utilizzato. Creando la propria applicazione, si possono ottenere risultati molto più accattivanti. I potenti server di LeaderGPU si occuperanno dei calcoli.

Vedi anche:

Stable Diffusion: Generare facce ripetibili

Tue, 21 Jan 2025 13:51:05 +0100

La ripetibilità è l'aspetto più importante quando si creano contenuti grafici con le reti neurali generative. Questo vale indipendentemente dal tipo di contenuto creato, sia esso un personaggio cinematografico o di gioco, un paesaggio o un ambiente scenico. Il problema principale può essere formulato come: "Come posso ripetere il mio risultato?". Ogni Volta™ che si inizia a generare immagini con gli stessi stimoli positivi e negativi, si ottengono risultati diversi. A volte le differenze sono minime e accettabili, ma nella maggior parte dei casi possono rappresentare un problema.

Stable Diffusion viene appreso su un ampio set di dati provenienti dal mondo reale, il che spiega perché la ripetibilità non è un punto di forza di questo modello di rete neurale. Tuttavia, questa regola non si applica alle foto di celebrità. Queste foto si trovano molto più frequentemente nel mondo reale e, quindi, nel set di dati su cui è stato addestrato Stable Diffusion. È possibile utilizzare queste foto come "costante" o "punto di partenza" nel processo di generazione.

Metodo 1. "Agitato, non mescolato"

Naturalmente, non è necessario creare solo immagini di celebrità, ma è possibile utilizzare più prompt pertinenti per ottenere risultati più o meno coerenti. Ad esempio, possiamo prendere due famose cantanti greche: Elena Paparizou e Marina Satti, e ottenere risultati ripetibili:

Model: Realistic Vision v6.0 beta 1

Positive prompts:

Elena Paparizou, Marina Satti, fashion portrait, alone, solo, greek woman in beautiful clothes, natural skin, 8k uhd, high quality, film grain, Canon EOS

Negative prompts:

bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, 2girl, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Funziona con qualsiasi celebrità, poiché Stable Diffusion ha cercato di riprodurre i tratti facciali più evidenti. In questo caso, utilizziamo lo stesso modello e "frulliamo" due star di Hollywood (Dwayne Johnson e Danny Trejo) in un nuovo personaggio sintetico.

Positive prompts:

Dwayne Johnson, Danny Trejo, fashion portrait, alone, solo, 8k uhd, high quality, film grain, Canon EOS

Negative prompts:

bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Ogni Volta™ che si mescolano le stesse celebrità, si ottengono risultati simili. Vediamo un altro metodo per generare personaggi ripetibili.

Metodo 2. Ancoraggio del nome

Le celebrità sono un buon inizio, ma consideriamo altri metodi per ottenere risultati ripetibili. La risposta è abbastanza semplice: possiamo utilizzare più nomi umani. Ogni nazione ha nomi unici, legati a caratteristiche linguistiche. Ad esempio, il nome greco Kostas può essere tradotto con "lavoro" o "sforzo", mentre Nikos significa "Vittoria del popolo". Questi due nomi creano un'immagine unica di una persona generata, aiutando i modelli di rete neurale a comprendere i nostri obiettivi di creazione.

Positive prompts:

Portrait of [Kostas | Nikos] on a white background, greek man, short haircut, beard

Negative prompts:

woman, bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, 2girl, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Generiamo numerose immagini (80-100) per la creazione di ulteriori set di dati. Il prompt principale è stato scelto per fornire immagini convenienti che possono essere facilmente cancellate dallo sfondo. I prompt negativi ci evitano di includere nel set di dati immagini casuali con distorsioni e immagini di donne.

Suggerimento: se si ricevono immagini molto diverse l'una dall'altra, provare a cambiare il parametro CFG Scale da 7,5 a 15. Questo costringerà la rete neurale a cambiare le immagini. Questo costringerà la rete neurale a seguire i suggerimenti in modo più formale.

È possibile selezionare i propri nomi unici con un semplice generatore di nomi, come Behind the Name. Inoltre, è possibile utilizzare la funzione ControlNet per ottenere un maggiore controllo.

Metodo 3. Insegnare l'aspetto

Non possiamo influenzare direttamente il risultato finale, ma osserviamo che alcuni token (come quelli relativi alle immagini di celebrità) hanno un peso maggiore di altri. Ciò significa che possiamo creare il nostro token condizionale "celebrità" creando un prompt appropriato per esso e addestrando ulteriormente il modello su di esso. Questo è il funzionamento di LoRA (Low-Rank Adaptation of Large Language Models). È possibile utilizzare la nostra guida passo-passo per addestrare il proprio modello LoRA sulla base di un set di dati personalizzato.

Dopo aver rimosso lo sfondo, otteniamo ritratti chiari e li utilizziamo per creare un modello LoRA specifico. Questo modello aiuta a replicare un volto con alcune piccole modifiche:

Ora possiamo generare questo personaggio in luoghi diversi, creare storie e collocarlo in vari ruoli: dal giardiniere all'uomo d'affari. Il suo volto sarà sempre riconoscibile e ripetibile:

Questo metodo non è l'ideale, ma funziona perfettamente in diverse situazioni. Non è necessario preparare un set di dati da una persona reale e può essere generato in remoto:

Si può tentare di creare un personaggio virtuale da soli, senza l'assistenza di un designer professionista o di uno specialista di modellazione 3D. Tutto ciò di cui avete bisogno sono GPU veloci, che potete trovare nei server dedicati di LeaderGPU.

Vedi anche:

Stable Diffusion: LoRA selfie

Tue, 21 Jan 2025 13:44:25 +0100

È possibile creare il primo set di dati utilizzando una semplice fotocamera e uno sfondo abbastanza uniforme, come una parete bianca o una tenda oscurante monotona. Per un set di dati di esempio, ho utilizzato una fotocamera mirrorless Olympus OM-D EM5 Mark II con obiettivo 14-42 in kit. Questa fotocamera supporta il controllo remoto da qualsiasi smartphone e una modalità di scatto continuo molto veloce.

Ho montato la fotocamera su un treppiede e ho impostato la priorità di messa a fuoco sul viso. Poi ho selezionato la modalità in cui la fotocamera cattura 10 fotogrammi consecutivi ogni 3 secondi e ho avviato il processo. Durante la ripresa, ho girato lentamente la testa nella direzione selezionata e ho cambiato direzione ogni 10 fotogrammi:

Il risultato è stato di circa 100 fotogrammi con uno sfondo monotono:

Il passo successivo consiste nel rimuovere lo sfondo e lasciare il ritratto su uno sfondo bianco.

Eliminare lo sfondo

È possibile utilizzare la funzione standard di Adobe Photoshop Remove background e l'elaborazione in batch. Memorizziamo le azioni che vogliamo applicare a tutte le immagini di un set di dati. Aprire un'immagine qualsiasi, fare clic sull'icona del triangolo, quindi fare clic sul simbolo +:

Digitare il nome della nuova azione, ad esempio Remove Background e fare clic su Record:

Nella scheda Layers, trovare il simbolo del lucchetto e fare clic su di esso:

Successivamente, fare clic sul pulsante Remove background nel pannello fluttuante:

Fare clic con il tasto destro del mouse su Layer 0 e selezionare Flatten Image:

Tutte le nostre azioni sono state registrate. Fermiamo questo processo:

Ora è possibile chiudere il file aperto senza salvare le modifiche e selezionare File >> Scripts >> Image Processor…

Selezionare le directory di input e output, scegliere l'azione Remove Background creata al punto 4 e fare clic sul pulsante Run:

Si prega di essere pazienti. Adobe Photoshop aprirà tutte le immagini nella directory selezionata, ripeterà le azioni registrate (disattivazione del blocco dei livelli, eliminazione dello sfondo, appiattimento dell'immagine) e le salverà in un'altra directory selezionata. Questo processo può richiedere un paio di minuti, a seconda del numero di immagini.

Al termine del processo, è possibile passare alla fase successiva.

Caricare sul server

Per caricare la directory dataset sul server remoto, utilizzare una delle seguenti guide (adatte al sistema operativo del PC). Ad esempio, posizionatela nella home directory dell'utente predefinito, /home/usergpu:

Pre-installazione

Aggiornare i pacchetti di sistema esistenti:

sudo apt update && sudo apt -y upgrade

Installare due pacchetti aggiuntivi:

sudo apt install -y python3-tk python3.10-venv

Installiamo il CUDA® Toolkit versione 11.8. Scarichiamo il file pin specifico:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin

Il comando seguente colloca il file scaricato nella directory di sistema, controllata dal gestore di pacchetti apt:

sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600

Il prossimo passo è scaricare il repository principale di CUDA:

wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb

Dopodiché, procedere con l'installazione del pacchetto utilizzando l'utility standard dpkg:

sudo dpkg -i cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb

Copiare il portachiavi GPG nella directory di sistema. In questo modo sarà disponibile per l'uso da parte delle utility del sistema operativo, compreso il gestore di pacchetti apt:

sudo cp /var/cuda-repo-ubuntu2204-11-8-local/cuda-*-keyring.gpg /usr/share/keyrings/

Aggiornare i repository della cache del sistema:

sudo apt-get update

Installare il toolkit CUDA® utilizzando apt:

sudo apt-get -y install cuda

Aggiungere CUDA® al PATH. Aprire la configurazione della shell bash:

nano ~/.bashrc

Aggiungere le seguenti righe alla fine del file:

export PATH=/usr/local/cuda/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64\
                         ${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

Salvare il file e riavviare il server:

sudo shutdown -r now

Installare l'allenatore

Copiare il repository del progetto Kohya sul server:

git clone https://github.com/bmaltais/kohya_ss.git

Aprire la cartella scaricata:

cd kohya_ss

Rendere eseguibile lo script di setup:

chmod +x ./setup.sh

Eseguire lo script:

./setup.sh

Verrà visualizzato un messaggio di avviso dall'utilità di accelerazione. Risolviamo il problema. Attivare l'ambiente virtuale del progetto:

source venv/bin/activate

Installare il pacchetto mancante:

pip install scipy

E configurare manualmente l'utilità di accelerazione:

accelerate config

Fare attenzione, perché l'attivazione di un numero dispari di CPU causerà un errore. Ad esempio, se ho 5 GPU, solo 4 possono essere utilizzate con questo software. In caso contrario, si verificherà un errore all'avvio del processo. È possibile verificare immediatamente la nuova configurazione dell'utilità richiamando un test predefinito:

accelerate test

Se tutto è a posto, si riceverà un messaggio come questo:

Test is a success! You are ready for your distributed training!

deactivate

Ora è possibile avviare il server pubblico del trainer con la GUI di Gradio e la semplice autenticazione con login/password (cambiare l'utente/password con la propria):

./gui.sh --share --username user --password password

Riceverete due stringhe:

Running on local URL: http://127.0.0.1:7860
Running on public URL: https://.gradio.live

Aprire il browser web e inserire l'URL pubblico nella barra degli indirizzi. Digitare il nome utente e la password negli appositi campi, quindi fare clic su Login:

Preparare il set di dati

Iniziare creando una nuova cartella in cui memorizzare il modello LoRA addestrato:

mkdir /home/usergpu/myloramodel

Aprire le seguenti schede: Utilities >> Captioning >> BLIP captioning. Riempire gli spazi vuoti come mostrato nell'immagine e fare clic su Caption images:

Trainer scaricherà ed eseguirà un modello di rete neurale specifico (1,6 Gb) che crea messaggi di testo per ogni file di immagine nella directory selezionata. L'esecuzione avviene su una singola GPU e richiede circa un minuto.

Passare alla scheda LoRA >> Tools >> Dataset preparation >> Dreambooth/LoRA folder preparation, riempire gli spazi vuoti e premere in sequenza Prepare training data e Copy info to Folders Tab:

In questo esempio, utilizziamo il nome nikolai come Instance prompt e "persona" come Class prompt. Impostiamo anche /home/usergpu/dataset come Training Images e /home/usergpu/myloramodel come Destination training directory.

Passate nuovamente alla scheda LoRA >> Training >> Folders. Assicurarsi che Image folder, Output folder e Logging folder siano compilati correttamente. Se lo si desidera, è possibile modificare Model output name con il proprio nome. Infine, fare clic sul pulsante Start training:

Il sistema inizierà a scaricare altri file e modelli (~10 GB). Dopodiché, inizierà il processo di addestramento. A seconda della quantità di immagini e delle impostazioni applicate, il processo può durare diverse ore. Una Volta™ completato l'addestramento, è possibile scaricare la directory /home/usergpu/myloramodel sul computer per un uso futuro.

Prova di LoRA

Abbiamo preparato alcuni articoli su Stable Diffusion e i suoi fork. Potete provare a installare Easy Diffusion con la nostra guida Easy Diffusion UI. Dopo che il sistema è stato installato e funziona, è possibile caricare il modello LoRA in formato SafeTensors direttamente su /home/usergpu/easy-diffusion/models/lora

Aggiornare la pagina web di Easy diffusion e selezionare il modello dall'elenco a discesa:

Scriviamo un semplice prompt, portrait of <nikolai> wearing a cowboy hat, e generiamo le prime immagini. In questo caso, abbiamo utilizzato un modello personalizzato di Diffusione stabile scaricato da civitai.com: Realistic Vision v6.0 B1:

È possibile sperimentare con prompt e modelli basati su Stable Diffusion per ottenere risultati migliori. Buon divertimento!

Vedi anche:

Stable Diffusion: Cos'è ControlNet

Tue, 21 Jan 2025 10:42:39 +0100

Un'idea sbagliata comune tra coloro che si avvicinano per la prima Volta™ alle reti neurali generative è che il controllo dell'output finale sia tremendamente impegnativo, soprattutto quando si cerca di alterare l'output attraverso una diversa formulazione dei prompt. Attualmente, esiste una suite di strumenti nota come ControlNet che facilita un controllo relativamente semplice ed efficace sui risultati della generazione.

In questo articolo dimostreremo come manipolare facilmente la posa dei personaggi generati utilizzando immagini preesistenti e "scheletri" personalizzati, con l'aiuto di uno di questi strumenti, OpenPose.

Passo 1. Installare la diffusione stabile

Utilizzate la nostra guida passo passo per installare Stable Diffusion con il modello di base e la WebUI. Questa guida si basa sullo script AUTOMATIC1111.

Passo 2. Installazione dell'estensione ControlNet

Si sconsiglia vivamente di installare l'estensione ControlNet (sd-webui-controlnet) dal repository standard a causa di potenziali problemi di funzionalità. Un problema significativo che abbiamo riscontrato durante la preparazione di questa guida è stato il blocco dell'interfaccia web. Sebbene l'immagine sia stata generata inizialmente con successo, l'interfaccia web diventa poco reattiva quando si genera l'immagine una seconda Volta™. Una soluzione alternativa potrebbe essere quella di installare la stessa estensione da una fonte esterna.

Aprire la WebUI e seguire le schede: Extensions > Install from URL. Incollare questo URL nel campo appropriato:

https://github.com/Mikubill/sd-webui-controlnet

Fare quindi clic sul pulsante Install:

Quando il processo è stato completato con successo, dovrebbe apparire il seguente messaggio:

Installed into /home/usergpu/stable-diffusion-webui/extensions/sd-webui-controlnet. Use Installed tab to restart.

Riavviare l'URL premendo il pulsante Applica e riavvia UI nella scheda Installato:

Dopo il riavvio dell'interfaccia, apparirà il nuovo elemento ControlNet con molte opzioni aggiuntive:

Passo 3. Scaricare OpenPose

Aggiungere la chiave HF

Generiamo e aggiungiamo una chiave SSH da utilizzare in Hugging Face:

cd ~/.ssh && ssh-keygen

Quando la coppia di chiavi è stata generata, è possibile visualizzare la chiave pubblica nell'emulatore di terminale:

cat id_rsa.pub

Copiare tutte le informazioni che iniziano con ssh-rsa e terminano con usergpu@gpuserver, come mostrato nella seguente schermata:

Aprire un browser web, digitare https://huggingface.co/ nella barra degli indirizzi e premere Enter. Accedere al proprio account HF e aprire Impostazioni profilo. Scegliere quindi SSH and GPG Keys e fare clic sul pulsante Add SSH Key:

Compilare Key name e incollare la SSH Public key copiata dal terminale. Salvare la chiave premendo Add key:

Ora il vostro account HF è collegato alla chiave SSH pubblica. La seconda parte (chiave privata) è memorizzata sul server. Il passo successivo consiste nell'installare un'estensione specifica di Git LFS (Large File Storage), utilizzata per scaricare file di grandi dimensioni come i modelli di reti neurali.

Installare Git LFS

Il passo successivo consiste nell'installare un'estensione specifica di Git LFS (Large File Storage), utilizzata per scaricare file di grandi dimensioni come i modelli di reti neurali. Aprite la vostra home directory:

cd ~/

Scaricare ed eseguire lo script di shell. Questo script installa un nuovo repository di terze parti con git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Ora è possibile installarlo utilizzando il gestore di pacchetti standard:

sudo apt-get install git-lfs

Configuriamo git per usare il nostro nickname HF:

git config --global user.name "John"

E collegato all'account di posta elettronica HF:

git config --global user.email "john.doe@example.com"

Scaricare il repository

Si consiglia, se possibile, di utilizzare un disco rigido locale per scaricare e memorizzare i modelli. Per saperne di più, consultare la nostra guida, Partizionamento dei dischi in Linux. Per questo esempio, abbiamo montato un disco SSD sul mountpoint /mnt/fastdisk. Facciamo in modo che sia di proprietà dell'utente predefinito:

sudo chown usergpu:usergpu /mnt/fastdisk

Aprire la directory:

cd /mnt/fastdisk

Clonare il repository ControlNet da HuggingFace. Git-LFS installato in precedenza sostituirà automaticamente i puntatori con i file reali:

git clone git@hf.co:lllyasviel/ControlNet-v1-1

In questo esempio, aggiungiamo solo un modello alla WebUI di Stable Diffusion. Tuttavia, è possibile copiare tutti i modelli disponibili dal repository (~18GB):

cp /mnt/fastdisk/ControlNet-v1-1/control_v11p_sd15_openpose.pth /home/usergpu/stable-diffusion-webui/models/ControlNet/

Passo 4. Eseguire il processo di generazione

Il modello attuale fornito è piuttosto elementare e potrebbe non dare risultati soddisfacenti. Pertanto, si consiglia di sostituirlo con un modello personalizzato. Le linee guida su come farlo sono riportate in questo articolo: Modelli di diffusione stabile: personalizzazione e opzioni. Per questo esempio, abbiamo scaricato RealisticVision v6.0 B1.

Se volete generare la vostra prima immagine usando OpenPose, aprite la scheda ControlNet, scegliete OpenPose, spuntate Enable e Allow Preview. Quindi fare clic su Upload per aggiungere un'immagine contenente la posa desiderata:

È possibile richiedere al sistema di generare un'anteprima della posa facendo clic sul pulsante con l'icona dell'esplosione:

A sinistra viene visualizzata l'immagine originale. A destra, si vede lo "scheletro" che rappresenta la posa riconosciuta dal modello della rete neurale:

Ora è possibile digitare il prompt principale, ad esempio "dancing bear, by Pixar" o "dancing fox, by Pixar" e fare clic sul pulsante Generate. Dopo pochi secondi si otterranno risultati come questo:

Il sistema tenterà di generare una nuova immagine, dato lo "scheletro" ottenuto dall'immagine originale. In alcuni casi, la posa potrebbe non essere accurata, ma questo può essere facilmente corretto modificando manualmente lo "scheletro".

Fase 5. Modifica della posa

Anche se può sembrare una magia, il modello non è perfetto e alcuni errori occasionali possono influire sull'immagine finale. Per evitare problemi durante la generazione dell'immagine, è possibile regolare manualmente lo "scheletro" facendo clic sul pulsante Edit:

Nell'editor fornito, è possibile regolare facilmente la posa trascinando e rilasciando, oppure rimuovere i punti indesiderati con un clic destro. Dopodiché, basta fare clic sul pulsante Send pose to ControlNet e la nuova posa verrà applicata:

Oltre a OpenPose, ControlNet offre una serie di strumenti per personalizzare e perfezionare i risultati. Inoltre, i server dedicati forniti da LeaderGPU garantiscono un processo rapido e conveniente.

Vedi anche:

Fooocus: Ripensare SD e MJ

Tue, 21 Jan 2025 10:36:52 +0100

L'avvento di Stable Diffusion e MidJourney ha rivoluzionato la nostra comprensione del potenziale delle reti neurali generative. Questi strumenti hanno svelato una nuova prospettiva sul processo di creazione delle immagini e sulla misura in cui possiamo manipolarle. L'approccio principale consiste nel fornire al sistema suggerimenti sul risultato desiderato. In sostanza, si evidenziano tre aspetti importanti: oggetto, stile e ambiente.

Sono importanti, ma non indispensabili, anche altri suggerimenti che forniscono istruzioni più specifiche, come la composizione desiderata, il tipo di fotocamera/obiettivo e la colorazione. Più le istruzioni sono complete, più è facile per la rete neurale elaborarle. Il ruolo di un ingegnere di pronto intervento è emerso anche nello spazio professionale. Tuttavia, questo ruolo può essere facilmente sostituito dalle stesse reti neurali generative. Combinando le capacità di creazione di immagini con quelle di creazione di testi, possiamo generare suggerimenti extra per ottenere un risultato ottimale.

Questo è il concetto fondamentale di Fooocus. Integra il modello XL Stable Diffusion e un generatore di prompt basato su GPT2, che arricchisce e dettaglia il semplice prompt. Inoltre, Fooocus è dotato di vari miglioramenti ed estensioni. Queste caratteristiche facilitano la generazione di immagini spettacolari attraverso un'interfaccia semplice, priva di strumenti complessi. Approfondiamo le sue funzionalità e installiamo Fooocus su un server dedicato LeaderGPU.

Prerequisiti

Iniziare con i prerequisiti per l'installazione e riavviare successivamente:

sudo apt update && sudo apt -y upgrade && sudo ubuntu-drivers autoinstall && sudo shutdown -r now

Scaricare lo script di shell che installa Anaconda per la gestione degli ambienti virtuali:

wget https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh

Impostare il flag di esecuzione e fornire l'accesso ai dati:

chmod a+x Anaconda3-2023.09-0-Linux-x86_64.sh

Eseguire lo script di installazione:

./Anaconda3-2023.09-0-Linux-x86_64.sh

Al termine del processo, si consiglia di disconnettere la sessione SSH e di preparare l'inoltro della porta. È necessario inoltrare la porta 7865 dal server remoto a un indirizzo di loopback locale, 127.0.0.1:7865. Per ulteriori informazioni, consultare una delle nostre guide precedenti: Diffusione video stabile. Quindi, ricollegatevi e procedete alla clonazione del repository del progetto su GitHub.

Installare Fooocus

git clone https://github.com/lllyasviel/Fooocus.git

Cambiare la directory in Fooocus:

cd Fooocus

Creare un ambiente virtuale usando Anaconda e la configurazione YAML preparata dall'autore del progetto:

conda env create -f environment.yaml

Cambiamo il nostro ambiente di base con uno appena creato:

conda activate fooocus

Il passo successivo consiste nell'installare le librerie Python:

pip install -r requirements_versions.txt

Ora tutto è pronto per iniziare:

Avvio Fooocus

python entry_with_update.py

L'avvio iniziale potrebbe richiedere un po' di tempo, poiché l'applicazione verifica e scarica tutti i file necessari per il funzionamento. Nel frattempo si consiglia di prendere una tazza di caffè. Una Volta™ completato il processo, aprite il browser e digitate il seguente URL nella barra degli indirizzi:

http://127.0.0.1:7865

Inserite la vostra semplice richiesta e fate clic sul pulsante Generate. Se desiderate un maggiore controllo, spuntate Advanced e selezionate le opzioni necessarie:

La vera magia si svolge dietro le quinte. Nel momento in cui si preme il pulsante Generate, la richiesta di input viene trasferita al modello linguistico GPT2. Questo modello trasforma la vostra breve richiesta in un mix di richieste elaborative positive e negative. Questo mix viene successivamente immesso nel modello Stable Diffusion XL, regolato per emulare lo stile MidJourney. Di conseguenza, anche una breve richiesta può generare risultati impressionanti.

Certo, non c'è alcuna restrizione a scrivere i propri suggerimenti. Tuttavia, dopo diverse iterazioni, risulta evidente che anche in assenza di ciò, il contenuto generato rimane intrigante e vario.

Vedi anche:

Rendering remoto di Blender con Flamenco

Tue, 21 Jan 2025 09:47:24 +0100

Quando il rendering di scene pesanti in Blender inizia a consumare troppo tempo del vostro team, avete due opzioni: aggiornare il computer di ogni membro del team o esternalizzare il rendering a una farm dedicata. Molte aziende offrono soluzioni di rendering già pronte, ma se avete bisogno di un controllo completo sull'infrastruttura, queste soluzioni potrebbero non essere l'opzione più affidabile.

Un approccio alternativo potrebbe essere la creazione di un'infrastruttura ibrida. In questa configurazione, l'archiviazione dei dati e la gestione della farm di rendering rimarrebbero all'interno dell'infrastruttura esistente. L'unico elemento che verrebbe collocato all'esterno sarebbero i server GPU a noleggio sui quali verrebbe eseguito il rendering.

In generale, l'infrastruttura della farm di rendering per Blender si presenta come segue:

Qui abbiamo un nodo centrale Manager che organizza tutti i processi. Riceve i compiti di rendering dagli utenti tramite uno specifico Blender Add-on e sposta tutti i file necessari su Shared Storage. Quindi, Manager distribuisce i compiti a Worker nodes. Questi ricevono un lavoro contenente tutte le informazioni su dove il Worker può trovare i file da renderizzare e cosa fare con i risultati ottenuti. Per implementare questo schema, è possibile utilizzare un'applicazione completamente gratuita e open-source chiamata Flamenco. In questa guida viene mostrato come preparare tutti i nodi, in particolare Manager e Worker.

Il nodo Storage non ha requisiti specifici. Può essere utilizzato con qualsiasi sistema operativo che supporti i protocolli SMB/CIFS o NFS. L'unico requisito è che la directory di archiviazione deve essere montata e accessibile dal sistema operativo. Nella vostra infrastruttura, questa può essere una qualsiasi cartella condivisa accessibile a tutti i nodi.

Ogni nodo ha indirizzi IP diversi e il server Wireguard VPN sarà un punto centrale che li unisce in un'unica rete L2. Questo server, situato sul perimetro esterno, consente di lavorare senza apportare modifiche alla politica NAT esistente.

Per questo esempio, creiamo la seguente configurazione mista:

10.0.0.1 - Wireguard VPN server (server virtuale di qualsiasi fornitore di infrastrutture) con un IP esterno;
10.0.0.2 - Worker node (server dedicato di LeaderGPU) con un IP esterno;
10.0.0.3 - Manager node (server virtuale nella rete dell'ufficio) situato dietro NAT;
10.0.0.4 - Storage node (server virtuale nella rete dell'ufficio) situato dietro NAT;
10.0.0.5 - User node (laptop consumer nella rete dell'ufficio) situato dietro NAT.

Passo 1. Wireguard

Server VPN

È possibile installare e configurare Wireguard manualmente, utilizzando una guida ufficiale e degli esempi. Tuttavia, esiste un'alternativa più semplice: uno script non ufficiale realizzato da un ingegnere informatico di Parigi (Stanislas aka angristan).

Scaricate lo script da GitHub:

wget https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh

Rendetelo eseguibile:

sudo chmod +x wireguard-install.sh

Eseguire:

sudo ./wireguard-install.sh

Seguire le istruzioni e impostare l'intervallo di indirizzi IP 10.0.0.1/24. Il sistema chiederà di creare immediatamente un file di configurazione per il primo client. Secondo il piano, questo client sarà il nodo worker con nome Worker e indirizzo 10.0.0.2. Al termine dello script, nella directory principale apparirà un file di configurazione: /root/wg0-client-Worker.conf.

Eseguire il seguente comando per visualizzare la configurazione:

cat /home/usergpu/wg0-client-Worker.conf

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0

Eseguire nuovamente lo script di installazione per creare un altro client. Aggiungere tutti i client futuri in questo modo e infine verificare che tutti i file di configurazione siano stati creati:

cd ~/

ls -l | grep wg0

-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Manager.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Storage.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-User.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:58 wg0-client-Worker.conf

Clienti VPN

I client VPN comprendono tutti i nodi che devono essere collegati a una singola rete. Nella nostra guida, si tratta del nodo manager, del nodo di archiviazione, del nodo client (se si utilizza Linux) e dei nodi worker. Se il server VPN è in esecuzione su un nodo worker, non è necessario configurarlo come client (questo passaggio può essere saltato).

Aggiornare il repository della cache dei pacchetti, quindi installare i pacchetti Wireguard e CIFS:

sudo apt update && sudo apt -y install wireguard cifs-utils

Elevare i privilegi a superuser:

sudo -i

Aprire la directory di configurazione di Wireguard:

cd /etc/wireguard

Eseguire il comando umask in modo che solo il superutente abbia accesso ai file di questa directory:

umask 077

Generare una chiave privata e salvarla in un file:

wg genkey > private-key

Generare una chiave pubblica utilizzando la chiave privata:

wg pubkey > public-key < private-key

Creare un file di configurazione:

nano /etc/wireguard/wg0.conf

Incollare la propria configurazione, creata per questo client:

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [SERVER_IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0
PersistentKeepalive = 1

Non dimenticare di aggiungere l'opzione PersistentKeepalive = 1 (dove 1 significa 1 secondo) su ogni nodo situato dietro NAT. È possibile scegliere questo periodo in via sperimentale. Il valore consigliato dagli autori di Wireguard è 25. Salvare il file e uscire, usando la scorciatoia CTRL + X e il tasto Y per confermare.

Se si desidera passare il traffico Internet, impostare AllowedIPs su 0.0.0.0/0,::/0

Quindi, effettuare il logout dall'account root:

exit

Avviare la connessione utilizzando systemctl:

sudo systemctl start wg-quick@wg0.service

Verificare che tutto sia a posto e che il servizio sia stato avviato correttamente:

sudo systemctl status wg-quick@wg0.service

● wg-quick@wg0.service - WireGuard via wg-quick(8) for wg0
Loaded: loaded (/lib/systemd/system/wg-quick@.service; enabled; vendor preset: enabled)
Active: active (exited) since Mon 2023-10-23 09:47:53 UTC; 1h 45min ago
  Docs: man:wg-quick(8)
        man:wg(8)
        https://www.wireguard.com/
        https://www.wireguard.com/quickstart/
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg-quick.8
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg.8
Process: 4128 ExecStart=/usr/bin/wg-quick up wg0 (code=exited, status=0/SUCCESS)
Main PID: 4128 (code=exited, status=0/SUCCESS)
  CPU: 76ms

Se si verifica un errore del tipo "resolvconf: comando non trovato" in Ubuntu 22.04, è sufficiente creare un collegamento di simbolo:

sudo ln -s /usr/bin/resolvectl /usr/local/bin/resolvconf

Abilitate il nuovo servizio a connettersi automaticamente durante l'avvio del sistema operativo:

sudo systemctl enable wg-quick@wg0.service

Ora è possibile verificare la connettività inviando pacchetti echo:

ping 10.0.0.1

PING 10.0.0.1 (10.0.0.1) 56(84) bytes of data.
64 bytes from 10.0.0.1: icmp_seq=1 ttl=64 time=145 ms
64 bytes from 10.0.0.1: icmp_seq=2 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=3 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=4 ttl=64 time=72.2 ms
--- 10.0.0.1 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3004ms
rtt min/avg/max/mdev = 71.981/90.230/144.750/31.476 ms

Passo 2. Nodo NAS

Connettersi al server VPN utilizzando la guida del punto 1. Quindi, installare i pacchetti Samba del server e del client:

sudo apt install samba samba-client

Eseguire il backup della configurazione predefinita:

sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak

Creare una directory che verrà utilizzata come condivisione:

sudo mkdir /mnt/share

Creare un nuovo gruppo di utenti che avrà accesso alla nuova condivisione:

sudo groupadd smbusers

Aggiungere un utente esistente al gruppo creato:

sudo usermod -aG smbusers user

Impostare una password per questo utente. Questo è un passo necessario perché la password di sistema e la password di Samba sono entità diverse:

sudo smbpasswd -a $USER

Rimuovere la configurazione predefinita:

sudo rm /etc/samba/smb.conf

e crearne una nuova:

sudo nano /etc/samba/smb.conf

[global]
workgroup = WORKGROUP
security = user
map to guest = bad user
wins support = no
dns proxy = no
[private]
path = /mnt/share
valid users = @smbusers
guest ok = no
browsable = yes
writable = yes

Salvare il file e testare i nuovi parametri:

testparm -s

Riavviare entrambi i servizi Samba:

sudo service smbd restart

sudo service nmbd restart

Infine, dare il permesso di condividere la cartella:

sudo chown user:smbusers /mnt/share

Passo 3. Connessione del client Samba

Tutti i nodi di Flamenco utilizzano una directory condivisa situata in /mnt/flamenco. È necessario montare questa directory su ogni nodo prima di eseguire gli script flamenco-client o flamenco-manager. In questo esempio, utilizziamo un nodo worker ospitato su LeaderGPU con il nome utente usergpu. Si prega di sostituire questi dati con i propri se differiscono.

Creare un file nascosto in cui memorizzare le credenziali della condivisione SMB:

nano /home/usergpu/.smbcredentials

Digitare queste due stringhe:

username=user # your Samba username
password=password # your Samba password

Salvare il file e uscire. Quindi, proteggete il file modificando i permessi di accesso:

sudo chmod 600 /home/usergpu/.smbcredentials

Creare una nuova directory che possa essere usata come punto di montaggio per collegare lo storage remoto:

sudo mkdir /mnt/flamenco

E rendere l'utente proprietario di questa directory:

sudo chown usergpu:users /mnt/flamenco

L'unica cosa che rimane è che la directory di rete venga montata automaticamente:

sudo nano /etc/systemd/system/mnt-flamenco.mount

[Unit]
Description=Mount Remote Storage
[Mount]
What=//10.0.0.4/private
Where=/mnt/flamenco
Type=cifs
Options=mfsymlinks,credentials=/home/usergpu/.smbcredentials,uid=usergpu,gid=users
[Install]
WantedBy=multi-user.target

Aggiungete due righe alla vostra configurazione VPN nella sezione [Interface]:

sudo -i

nano /etc/wireguard/wg0.conf

…
PostUp = ping 10.0.0.4 -c 4 && systemctl start mnt-flamenco.mount
PostDown = systemctl stop mnt-flamenco.mount
…

Riavviare il server:

sudo shutdown -r now

Verificare che i servizi siano caricati e che la directory condivisa sia montata correttamente:

df -h

Filesystem          Size  Used Avail Use% Mounted on
tmpfs                35G  3.3M   35G   1% /run
/dev/sda2            99G   18G   77G  19% /
tmpfs               174G     0  174G   0% /dev/shm
tmpfs               5.0M     0  5.0M   0% /run/lock
tmpfs                35G  8.0K   35G   1% /run/user/1000
//10.0.0.4/private   40G  9.0G   31G  23% /mnt/flamenco

Passo 4. Nodo manager

Impostare una connessione VPN seguendo la guida del passaggio 1. Arrestare il servizio VPN prima di continuare:

sudo systemctl stop wg-quick@wg0.service

Prepariamoci. Il montaggio automatico richiede utility per il protocollo CIFS:

sudo apt -y install cifs-utils

Il prossimo passo importante è l'installazione di Blender. È possibile farlo utilizzando il gestore di pacchetti APT standard, ma molto probabilmente verrà installata una delle versioni più vecchie (meno della v3.6.4). Utilizziamo Snap per installare l'ultima versione:

sudo snap install blender --classic

Controllare la versione installata usando il seguente comando:

blender --version

Blender 4.4.3
build date: 2025-04-29
build time: 15:12:13
build commit date: 2025-04-29
build commit time: 14:09
build hash: 802179c51ccc
build branch: blender-v4.4-release
build platform: Linux
build type: Release
…

Se si riceve un messaggio di errore che indica la mancanza di librerie, è sufficiente installarle. Tutte queste librerie sono incluse nel pacchetto XOrg:

sudo apt -y install xorg

Scaricare l'applicazione:

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Decomprimere l'archivio scaricato:

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Andare alla directory creata:

cd flamenco-3.7-linux-amd64/

E avviare Flamenco per la prima volta:

./flamenco-manager

Aprite il seguente indirizzo nel vostro browser web: http://10.0.0.3:8080/. Fate clic sul pulsante Let's go. Digitare /mnt/flamenco nel campo richiesto, quindi fare clic su Next:

Flamenco cercherà di individuare il file eseguibile di Blender. Se avete installato Blender da Snap, il percorso sarà /snap/bin/blender. Controllate questo punto e fate clic su Next:

Controllate il riepilogo e fate clic su Confirm:

Tornare alla sessione SSH e usare la scorciatoia da tastiera Ctrl + C per interrompere l'applicazione. Il primo avvio genera il file di configurazione flamenco-manager.yaml. Aggiungiamo alcune opzioni alle sezioni variables e blenderArgs:

nano flamenco-manager.yaml

# Configuration file for Flamenco.
# For an explanation of the fields, refer to flamenco-manager-example.yaml
#
# NOTE: this file will be overwritten by Flamenco Manager's web-based configuration system.
#
# This file was written on 2023-10-17 12:41:28 +00:00 by Flamenco 3.7
_meta:
  version: 3
manager_name: Flamenco Manager
database: flamenco-manager.sqlite
listen: :8080
autodiscoverable: true
local_manager_storage_path: ./flamenco-manager-storage
shared_storage_path: /mnt/flamenco
shaman:
  enabled: true
  garbageCollect:
    period: 24h0m0s
    maxAge: 744h0m0s
    extraCheckoutPaths: []
task_timeout: 10m0s
worker_timeout: 1m0s
blocklist_threshold: 3
task_fail_after_softfail_count: 3
variables:
  blender:
    values:
    - platform: linux
      value: blender
    - platform: windows
      value: blender
    - platform: darwin
      value: blender
  storage:
    values:
    is_twoway: true
    values:
    - platform: linux
      value: /mnt/flamenco
    - platform: windows
      value: Z:\
    - platform: darwin
      value: /Volumes/shared/flamenco
  blenderArgs:
    values:
    - platform: all
      value: -b -y -E CYCLES -P gpurender.py

Il primo blocco aggiuntivo descrive ulteriori variabili bidirezionali, necessarie per le farm multipiattaforma. Questo risolve il problema principale degli slash e dei percorsi. In Linux si usa il simbolo della barra in avanti (/) come separatore, mentre in Windows si usa il simbolo del backslash (\). In questo caso, creiamo la regola di sostituzione per tutte le alternative disponibili: Linux, Windows e macOS (Darwin).

Quando si monta una condivisione di rete in Windows, è necessario scegliere una lettera di unità. Ad esempio, il nostro Storage è montato con la lettera Z:. La regola di sostituzione indica al sistema che, per la piattaforma Windows, il percorso /mnt/flamenco sarà situato in Z:\. Per macOS, questo percorso sarà /Volumes/shared/flamenco.

Osservate il secondo blocco aggiunto. Questo indica a Blender di usare il motore di rendering Cycles e chiama un semplice script Python, gpurender.py, quando Blender viene eseguito. Si tratta di un semplice trucco per selezionare la GPU invece della CPU. Non esiste un'opzione standard per farlo direttamente. Non è possibile invocare blender --use-gpu o qualcosa di simile. Tuttavia, è possibile invocare qualsiasi script Python esterno usando l'opzione -P. Questo comando indica a Worker di trovare uno script nella directory locale e di eseguirlo quando il lavoro assegnato richiama l'eseguibile di Blender.

Ora possiamo delegare il controllo dell'applicazione al sottosistema systemd init. Informiamo il sistema sulla posizione della directory di lavoro, sul file eseguibile e sui privilegi dell'utente necessari per il lancio. Creare un nuovo file:

sudo nano /etc/systemd/system/flamenco-manager.service

Compilatelo con le seguenti stringhe:

[Unit]
Description=Flamenco Manager service
[Service]
User=user
WorkingDirectory=/home/user/flamenco-3.7-linux-amd64
ExecStart=/home/user/flamenco-3.7-linux-amd64/flamenco-manager
Restart=always
[Install]
WantedBy=multi-user.target

Salvare il file e uscire dall'editor di testo nano.

sudo systemctl daemon-reload

sudo systemctl start flamenco-manager.service

sudo systemctl status flamenco-manager.service

● flamenco-manager.service - Flamenco Manager service
Loaded: loaded (/etc/systemd/system/flamenco-manager.service; disabled; vendor preset: enabled)
Active: active (running) since Tue 2023-10-17 11:03:50 UTC; 7s ago
Main PID: 3059 (flamenco-manage)
 Tasks: 7 (limit: 4558)
  Memory: 28.6M
     CPU: 240ms
CGroup: /system.slice/flamenco-manager.service
        └─3059 /home/user/flamenco-3.7-linux-amd64/flamenco-manager

Abilitare l'avvio automatico all'avvio del sistema:

sudo systemctl enable flamenco-manager.service

Passo 5. Nodo lavoratore

Connettersi al server VPN utilizzando la guida del passaggio 1 e montare la condivisione del passaggio 3. Arrestare il servizio VPN prima di continuare:

sudo snap install blender --classic

I moderni file *.blend sono compressi con l'algoritmo Zstandard. Per evitare errori, è essenziale incorporare il supporto per questo algoritmo:

sudo apt -y install python3-zstd

Scaricare l'applicazione:

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Decomprimere l'archivio scaricato:

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Navigare nella directory creata:

cd flamenco-3.7-linux-amd64/

Creare uno script aggiuntivo che abiliti il rendering GPU durante l'esecuzione di Flamenco jobs:

nano gpurender.py

import bpy
def enable_gpus(device_type, use_cpus=False):
    preferences = bpy.context.preferences
    cycles_preferences = preferences.addons["cycles"].preferences
    cycles_preferences.refresh_devices()
    devices = cycles_preferences.devices
    if not devices:
        raise RuntimeError("Unsupported device type")
    activated_gpus = []
    for device in devices:
        if device.type == "CPU":
            device.use = use_cpus
        else:
            device.use = True
            activated_gpus.append(device.name)
            print('activated gpu', device.name)
    cycles_preferences.compute_device_type = device_type
    bpy.context.scene.cycles.device = "GPU"
    return activated_gpus
enable_gpus("CUDA")

Salvare il file e uscire. Quindi, creare un servizio separato per eseguire Flamenco da systemd:

sudo nano /etc/systemd/system/flamenco-worker.service

[Unit]
Description=Flamenco Worker service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu/flamenco-3.7-linux-amd64
ExecStart=/home/usergpu/flamenco-3.7-linux-amd64/flamenco-worker
Restart=always
[Install]
WantedBy=multi-user.target

Ricaricare la configurazione e avviare il nuovo servizio:

sudo systemctl daemon-reload

sudo systemctl start flamenco-worker.service

sudo systemctl status flamenco-worker.service

● flamenco-worker.service - Flamenco Worker service
Loaded: loaded (/etc/systemd/system/flamenco-worker.service; enabled; preset: enabled)
Active: active (running) since Tue 2023-10-17 13:56:18 EEST; 47s ago
Main PID: 636 (flamenco-worker)
 Tasks: 5 (limit: 23678)
Memory: 173.9M
   CPU: 302ms
CGroup: /system.slice/flamenco-worker.service
        └─636 /home/user/flamenco-3.7-linux-amd64/flamenco-worker

Attivare l'avvio automatico all'avvio del sistema:

sudo systemctl enable flamenco-worker.service

Passo 6. Nodo utente

Il nodo utente può essere gestito con qualsiasi sistema operativo. In questa guida mostriamo come configurare un nodo con Windows 11 e i 4 componenti necessari:

connessione VPN
Directory remota montata
Blender installato
Componente aggiuntivo Flamenco

Scaricare e installare Wireguard dal sito ufficiale. Creare un nuovo file di testo e incollarvi la configurazione generata per il client al punto 1. Rinominate il file in flamenco.conf e aggiungetelo a Wireguard utilizzando il pulsante Add tunnel:

Collegarsi al server premendo il pulsante Activate:

Montiamo una directory remota. Fare clic con il tasto destro del mouse su This PC e selezionare Map network drive…

Scegliere Z: come lettera di unità, digitare l'indirizzo della condivisione Samba \\10.0.0.4\private e non dimenticare di spuntare Connect using different credentials. Quindi fare clic su Finish. Il sistema chiederà di inserire un nome utente e una password per la condivisione. Successivamente, la directory di rete verrà montata come unità Z:.

Scaricare e installare Blender dal sito ufficiale. Quindi, aprire l'URL http://10.0.0.3:8080/flamenco3-addon.zip e installare il componente aggiuntivo Flamenco. Attivarlo nelle preferenze: Edit > Preferences > Add-ons. Spuntare System: Flamenco 3, inserire l'URL del manager http://10.0.0.3:8080 e fare clic sul pulsante di aggiornamento. Il sistema si collegherà al nodo manager e caricherà automaticamente le impostazioni di archiviazione:

Aprire il file da renderizzare. Nella scheda Scene, scegliere Cycles dall'elenco a discesa Render Engine. Non dimenticate di salvare il file, perché queste impostazioni sono memorizzate direttamente nel file *.blend:

Scorrere verso il basso e trovare la sezione Flamenco 3. Fare clic su Fetch job types per ottenere un elenco dei tipi disponibili. Selezionare Simple Blender Render dall'elenco a discesa e impostare altre opzioni, come il numero di fotogrammi, la dimensione dei pezzi e la cartella di output. Infine, fare clic su Submit to Flamenco:

Il componente aggiuntivo Flamenco crea un nuovo lavoro e carica un file blend sull'archivio condiviso. Il sistema invia il lavoro a un worker disponibile e avvia il processo di rendering:

Se si controlla il carico della GPU con nvtop o utility simili, si vede che tutte le GPU hanno compiti di calcolo:

Il risultato si trova in una directory selezionata nel passaggio precedente. Esempio qui (Ripple Dreams di James Redmond)

Vedere anche:

Fotogrammetria con Meshroom

Tue, 21 Jan 2025 09:38:44 +0100

La fotogrammetria è un metodo per trasformare gli oggetti fisici in modelli digitali tridimensionali che possono essere modificati con un software 3D. Questo processo utilizza in genere dispositivi specializzati chiamati scanner 3D, di due tipi principali: ottici e laser.

Gli scanner ottici utilizzano spesso una o più fotocamere digitali e un'illuminazione speciale per illuminare uniformemente l'oggetto durante la scansione. In questo modo è possibile creare un modello 3D. Gli scanner laser, invece, utilizzano raggi laser. Questi dispositivi emettono più raggi laser e misurano il tempo necessario a ciascun raggio per rimbalzare sull'oggetto. Utilizzando questi dati e le informazioni provenienti dai sensori di posizione, lo scanner calcola la distanza di ciascun punto dell'oggetto. Si crea così una "nuvola di punti" che costituisce la base del modello 3D.

Nuvola di punti

Per costruire la struttura futura di un oggetto, il sistema deve conoscere le coordinate di ogni vertice nello spazio tridimensionale. L'insieme dei vertici è chiamato nuvola di punti. Più vertici ci sono, più dettagliato sarà l'oggetto. La creazione di una nuvola di punti è la prima e una delle fasi più cruciali per ricreare un modello 3D dalle fotografie.

È importante notare che ogni vertice della nuvola di punti è inizialmente non collegato ad altri vertici. Ciò consente un facile filtraggio: mantenere i punti necessari e rimuovere gli altri, prima di iniziare a ricreare la mesh dell'oggetto.

Oggetti della maglia

Un oggetto mesh è un tipo di modello 3D costituito da primitive geometriche triangolari, spesso chiamate mesh o polimeshes. Una Volta™ formati i punti dell'oggetto, l'applicazione può comporre in modo indipendente primitive triangolari a partire da essi. Collegando queste primitive, è possibile creare un modello 3D di qualsiasi forma. In questa fase, il modello non ha colore e rimane non dipinto.

La successiva fase di texturing risolve questo problema.

Texturing

La fase finale consiste nell'applicazione della texture dell'immagine estratta dalle foto all'oggetto mesh preparato. La qualità delle foto scattate e la loro risoluzione giocano un ruolo fondamentale. Se è bassa, il risultato finale non sarà ottimale. Ma se è stato scattato un numero sufficiente di foto di buona qualità, alla fine si otterrà un modello 3D completamente pronto all'uso di un oggetto reale. Di seguito forniremo alcuni consigli utili sulla preparazione delle foto originali.

Impostazioni della fotocamera

Per evitare di rimanere delusi dai primi tentativi di creare un modello 3D da fotografie, considerate queste semplici regole di base. Ciascuna regola aiuterà a prevenire i problemi che di solito si presentano durante la fase di creazione dell'oggetto mesh.

Innanzitutto, non affidatevi alle impostazioni automatiche della fotocamera digitale. Le fotocamere moderne cercano di bilanciare quattro parametri chiave in modo indipendente:

ISO,
bilanciamento del bianco,
velocità dell'otturatore,
apertura.

In modalità automatica, anche lievi variazioni delle condizioni esterne possono far variare queste impostazioni tra i fotogrammi. Queste variazioni possono portare a notevoli incongruenze durante la fase di texturing.

Per mantenere parametri coerenti tra i fotogrammi, utilizzare la modalità Manual (M). L'apertura è un'impostazione cruciale. A seconda dell'obiettivo, si deve puntare a una posizione quasi chiusa. Questo aiuta a ottenere la massima profondità di campo: meno aperta è l'apertura, meglio è. Tuttavia, evitate valori estremi. Se il vostro obiettivo può essere vicino a f/22, otterrete buoni risultati utilizzando valori compresi tra f/11 e f/20.

^{A sinistra f/11, a destra f/22}

La chiusura del diaframma, tuttavia, crea un altro problema: la luce insufficiente. Questo problema può essere affrontato in due modi: aumentando la sensibilità ISO o allungando la velocità dell'otturatore. Entrambi i metodi influiscono sul risultato finale, anche se in modo diverso. Aumentando l'ISO a 6400 si introduce il rumore digitale nell'immagine, quindi è meglio usare i valori più bassi possibili. Per ottenere risultati quasi ideali, è consigliabile impostare l'ISO a 100. Tuttavia, ciò comporta il problema dell'insufficienza del rumore digitale nell'immagine. Tuttavia, ciò significa che il problema dell'illuminazione insufficiente persiste:

^{A sinistra ISO 100, a destra ISO 6400}

Il modo più efficace per aumentare il passaggio di luce attraverso il sensore della fotocamera in condizioni di scarsa illuminazione è allungare la velocità dell'otturatore. Più a lungo l'otturatore rimane aperto, più fotoni colpiscono il sensore, ottenendo una migliore qualità dell'immagine. Tuttavia, questo approccio presenta una sfida: senza un treppiede, una velocità dell'otturatore di 1/50 di secondo o più può sfocare l'immagine. L'uso di un treppiede elimina questo problema.

Il bilanciamento del bianco è l'ultimo parametro fondamentale. È importante disattivare l'impostazione automatica e scegliere un profilo preimpostato (come "Sunny day") o un valore personalizzato in Kelvin. Ad esempio, 5200K è un'impostazione comune. I valori più bassi spostano la tonalità verso il giallo, mentre quelli più alti tendono al blu. Per evitare lunghe correzioni del colore in post-elaborazione, utilizzare lo stesso profilo di bilanciamento del bianco per tutte le foto di una serie.

^{Profili WB. A sinistra "Giorno di sole", a destra "Auto".}

In sintesi, per acquisire foto di alta qualità per la fotogrammetria:

Utilizzare un treppiede quando la luce è insufficiente.
Chiudere l'apertura quasi al minimo.
Impostare l'ISO al valore minimo.
Scegliere una velocità dell'otturatore che dia il risultato desiderato (o utilizzare l'esposimetro integrato nella fotocamera).
Utilizzare la stessa preimpostazione del bilanciamento del bianco.

Scattare le foto

Parliamo di quante foto scattare e da quali angolazioni. Il tipo di oggetto e il suo sfondo influenzano in modo significativo il risultato finale. Gli oggetti senza superfici lucide, trasparenti o riflettenti sono ideali per la fotogrammetria. In pratica, oggetti come finestre e vetri richiedono spesso una correzione in un editor 3D. Tuttavia, la tecnica generale di ripresa rimane la stessa.

Per gli oggetti piccoli posizionati su una superficie, immaginare una sfera intorno all'oggetto. Scattare le foto come se la fotocamera girasse intorno all'oggetto tre volte: una Volta™ dal basso, una Volta™ al centro e una Volta™ dall'alto.

È fondamentale che l'oggetto occupi almeno la metà, preferibilmente i tre quarti di ogni fotogramma. Invece di usare lo zoom, cercate di avvicinarvi fisicamente all'oggetto. Quando si crea un punto nuvola, il software ha bisogno del maggior numero di pixel possibile.

Quando si scatta, ricordarsi che il software combina i fotogrammi in un unico oggetto per ottenere una geometria corretta. È buona norma scattare almeno tre fotogrammi da ogni angolazione. Una Volta™ centrato l'oggetto nell'inquadratura, dividerlo mentalmente in verticale in tre parti uguali. Scattare tre foto, ognuna delle quali si concentra su un terzo dell'oggetto. In questo modo si ottiene la sovrapposizione necessaria all'applicazione per calcolare con precisione la posizione di ciascun punto nello spazio 3D. Dopo aver fotografato l'oggetto da tutti i lati e le angolazioni possibili, si può iniziare a preparare il software.

Installare Meshroom

Meshroom è un'applicazione gratuita e multipiattaforma che esegue in sequenza tutte le fasi di elaborazione, utilizzando le risorse della CPU e della GPU. Anche se può essere eseguito su un normale computer di casa, ogni fase può richiedere molto tempo. Per progetti su larga scala che prevedono la ricostruzione 3D di numerosi oggetti, come la creazione di una scena 3D di grande effetto, il noleggio di un server GPU dedicato potrebbe essere una soluzione pratica.

Consideriamo un server LeaderGPU con la seguente configurazione: 2 x NVIDIA® RTX™ 3090, 2 x Intel® Xeon® Silver 4210 (3.20 GHz), 128GB RAM. Utilizzeremo Windows Server 2022 come sistema operativo. Prima di installare Meshroom, è necessario eseguire alcune operazioni preliminari:

Visitare il sito web ufficiale del progetto per scaricare Meshroom. Decomprimere l'archivio ottenuto per trovare un'applicazione pronta all'uso che non richiede ulteriori installazioni. Avviare Meshroom.exe per iniziare.

Caricare le immagini

La finestra principale dell'applicazione è divisa in due parti: superiore e inferiore. La sezione superiore contiene la Galleria immagini, il Visualizzatore immagini e il Visualizzatore 3D. La sezione inferiore ospita l'editor grafico e il Task Manager. Per iniziare, trascinare e rilasciare le foto acquisite nell'area designata. Sono supportati sia i formati di file compressi (ad esempio, JPG) che quelli RAW. Si consiglia di utilizzare i file RAW perché contengono una quantità di dati significativamente maggiore per ogni fotogramma.

Si noti che per impostazione predefinita è già disponibile una pipeline standard pronta per l'uso, visualizzata in modo schematico nell'Editor grafico. Questo è uno dei controlli più importanti che aiuta a configurare tutti gli aspetti dell'elaborazione delle immagini in ogni fase. È possibile eseguire manualmente ogni fase facendo clic con il pulsante destro del mouse e selezionando Compute dal menu a discesa.

Ma per la prima Volta™, è sufficiente fare clic sul pulsante verde Start e l'applicazione farà tutto per voi. Verrà richiesto di salvare il progetto, in modo da non perdere accidentalmente i risultati del calcolo. Fare clic su Save, specificare un nome e una directory e salvare il progetto:

Successivamente, l'applicazione trasferisce tutte le fasi di elaborazione dall'Editor grafico al Task Manager, che ne gestisce l'esecuzione in un ordine specifico. Per controllare lo stato di ogni fase, selezionare il blocco corrispondente nell'Editor grafico e fare clic sul pulsante Log nell'angolo inferiore destro dello schermo. È anche possibile vedere in tempo reale quale fase è in corso di elaborazione:

Sul lato destro, si può vedere la nuvola di punti costruita. Il risultato finale, generato con la pipeline standard, è disponibile nella directory:

[Your_Project_Path]\MeshroomCache\Texturing\[Random_Symbols]\texturedMesh.obj

Naturalmente, se si fissa prima il percorso di uscita nel nodo finale della pipeline, l'oggetto finirà sul percorso specificato. È quindi possibile importarlo in qualsiasi editor di testo per correggere le superfici, aggiungere fonti di luce e altri effetti prima del rendering.

Integrazione

Anche se il risultato iniziale può sembrare impressionante, spesso richiede un perfezionamento in un editor 3D. Meshroom semplifica questo processo consentendo di importare non solo il modello, ma anche la nuvola di punti e le posizioni della telecamera in editor di terze parti come Houdini o Blender. Nella sezione seguente vedremo come fare.

Houdini

In realtà, Meshroom è un'interfaccia di facile utilizzo per il motore AliceVision, che gestisce tutte le operazioni di calcolo. Questa interfaccia implementa la pipeline e il task manager corrispondenti. Se si utilizza Houdini, è possibile creare la propria pipeline direttamente all'interno dell'applicazione e utilizzarla insieme ad altri strumenti, eliminando la necessità di lanciare Meshroom separatamente.

Per iniziare, è meglio scaricare e installare un launcher dedicato che gestisca gli aggiornamenti e i plugin di Houdini. Quindi, aggiungere il plugin SideFX Labs, che offre numerosi strumenti aggiuntivi, tra cui nodi specifici per AliceVision. Per farlo, fate clic sul pulsante +, quindi selezionate Shelves:

Scorrere l'elenco e selezionare SideFX Labs, quindi fare clic sul pulsante Update Toolset:

Per installare un plugin, procedere come segue: Fare clic sul pulsante Start Launcher, spostarsi nella sezione Labs/Packages del menu di sinistra e selezionare Install packages. Si aprirà una finestra in cui è possibile scegliere i pacchetti da installare:

Scegliete il pacchetto Production Build per la vostra versione di Houdini e fate clic su Install. Successivamente, riavviare l'applicazione per assicurarsi che le icone dei nuovi effetti appaiano in alto:

È fondamentale notare che qui non troverete alcun riferimento ad AliceVision o Meshlab. Questo perché il plugin corrispondente funziona solo all'interno della pipeline del contesto geometrico. Per verificarlo, fare clic sull'icona +, quindi selezionare New Pane Tab Type, e scegliere Network View:

Premere il tasto Tab e aggiungere un nodo Geometry:

Fare doppio clic per aprire il nodo creato e digitare av sulla tastiera. Il sistema visualizzerà immediatamente un elenco di nodi disponibili, a partire dai simboli Labs AV. Questi nodi consentono di controllare il motore AliceVision e di integrarlo nelle proprie pipeline:

Per creare una pipeline adeguata, consultare la documentazione ufficiale del plugin. Inoltre, si consiglia di aggiungere la directory di AliceVision all'elenco delle variabili ambientali nel file houdini.env. Per un'installazione standard che utilizza il launcher, questo file si trova in genere nella directory C:\Users\Administrator\Documents\houdini20.5\

Aprire il file houdini.env con un qualsiasi editor di testo e aggiungere la seguente riga:

ALICEVISION_PATH = [path to alicevision directory in Meshroom folder]

Ad esempio, se avete installato Meshroom nella directory principale dell'unità D:, il vostro percorso potrebbe essere il seguente:

ALICEVISION_PATH = D:\Meshroom\aliceVision

Salvare il file, quindi riavviare l'applicazione Houdini.

Blender

Per gli utenti di Blender, si consiglia il plugin Meshroom2Blender. Pur funzionando in modo diverso dal plugin per Houdini, consente di esportare in Blender le nuvole di punti e le posizioni della telecamera calcolate da Meshroom. Per accedere al codice del plugin, aprire il link nel browser:

https://raw.githubusercontent.com/tibicen/meshroom2blender/master/view3d_point_cloud_visualizer.py

Salvare il codice come view3d_point_cloud_visualizer.py in una cartella comoda. Quindi, aprire Blender e navigare in Edit - Preferences. Da qui, selezionare la scheda Add-ons:

Fare clic sulla freccia verso il basso e selezionare Install from Disk:

Nella nuova finestra aperta, navigare nella directory in cui è stato salvato il plugin. Selezionare il file del plugin e fare clic su Install from Disk button:

Il plugin è ora installato. Si consiglia di riavviare l'applicazione. Dopo il riavvio, verrà visualizzata la voce Point Cloud Visualizer nella modalità di visualizzazione. Il plugin richiede di specificare il percorso di un file con estensione .ply:

Per impostazione predefinita, Meshroom non genera questo tipo di file. Per crearlo, aprire la pipeline e aggiungere il nodo ConvertSfMFormat. Utilizzare il file SfMData dal nodo StructureFromMotion come input. Per l'output, specificare il Images Folder del nodo Texturing.

Il passo finale consiste nello specificare il formato. Fare clic su SfM File Format nel nodo ConvertSfMFormat e selezionare ply dall'elenco a discesa:

Fare clic con il tasto destro del mouse sul nodo creato e selezionare Compute:

Una Volta™ completato il processo, nella directory si troverà il file richiesto:

[Your_Project_Path]\MeshroomCache\ConvertSfMFormat\[Random_Symbols]\sfm.ply

È possibile caricarlo in Blender in due modi: tramite il plugin sopra citato o tramite il processo di importazione standard File - Import - Stanford PLY (.ply):

Per ulteriori informazioni sull'uso di questo plugin, si consiglia di consultare il repository del progetto o una risorsa web specializzata.

Conclusione

La fotogrammetria è un vasto campo di conoscenze, in cui abbiamo cercato di illustrare solo alcune tecniche di base per la conversione di immagini 2D in un modello 3D. È utilizzata in molti settori, dall'architettura alla creazione di giochi per computer.

Dopo aver acquisito la prima esperienza di ripresa di un set di dati e della sua trasformazione coerente in un modello 3D, sarete in grado di migliorare le vostre capacità e di trasferire oggetti fisici in uno spazio virtuale 3D. Ebbene, LeaderGPU vi aiuterà con la potenza di calcolo, riducendo il tempo di calcolo e liberando la vostra postazione di lavoro per altri compiti, spesso più prioritari.

Vedi anche:

Open WebUI: Tutto in uno

Mon, 20 Jan 2025 15:21:46 +0100

Open WebUI è stata originariamente sviluppata per Ollama, di cui abbiamo parlato in uno dei nostri articoli. In precedenza si chiamava Ollama WebUI, ma col tempo l'attenzione si è spostata sull'universalità dell'applicazione e il nome è stato cambiato in Open WebUI. Questo software risolve il problema fondamentale di lavorare comodamente con modelli di reti neurali di grandi dimensioni collocati localmente o su server controllati dall'utente.

Installazione

Il metodo di installazione principale e preferito è quello di distribuire un contenitore Docker. Questo permette di non pensare alla presenza di dipendenze o di altri componenti che garantiscono il corretto funzionamento del software. Tuttavia, è possibile installare Open WebUI clonando il repository del progetto da GitHub e costruendolo dal codice sorgente. In questo articolo prenderemo in considerazione entrambe le opzioni.

Prima di iniziare, assicuratevi che i driver della GPU siano installati sul server. La nostra istruzione Installare i driver NVIDIA® in Linux vi aiuterà a farlo.

Utilizzo di Docker

Se avete appena ordinato un server, vi mancheranno il motore Docker e il set di strumenti necessari per passare le GPU al container. Non consigliamo di installare Docker dal repository standard di Ubuntu, poiché potrebbe essere obsoleto e non supportare tutte le opzioni moderne. Sarebbe meglio utilizzare lo script di installazione pubblicato sul sito ufficiale:

curl -sSL https://get.docker.com/ | sh

Oltre a Docker, è necessario installare NVIDIA® Container Toolkit, quindi attivare il repository Nvidia:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Aggiornare la cache dei pacchetti e installare NVIDIA® Container Toolkit:

sudo apt update && sudo apt -y install nvidia-container-toolkit

Affinché la toolchain funzioni, è necessario riavviare il demone Docker:

sudo systemctl restart docker

Ora è possibile eseguire il contenitore desiderato. Si noti che il comando seguente non isola i contenitori dalla rete dell'host, perché in seguito si potranno attivare altre opzioni, come la generazione di immagini tramite la WebUI di Stable Diffusion. Questo comando scaricherà ed eseguirà automaticamente tutti i livelli dell'immagine:

sudo docker run -d --network=host --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Utilizzo di Git

Ubuntu 22.04

Per prima cosa, è necessario clonare il contenuto del repository:

git clone https://github.com/open-webui/open-webui.git

Aprire la cartella scaricata:

cd open-webui/

Copiare la configurazione di esempio (si può modificare se necessario), che imposterà le variabili d'ambiente per la compilazione:

cp -RPp .env.example .env

Installare il programma di installazione di NVM, che aiuterà a installare la versione richiesta di Node.js sul server:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Successivamente, è necessario chiudere e riaprire la sessione SSH in modo che il comando successivo funzioni correttamente.

Installare Node Package Manager:

sudo apt -y install npm

Installare la versione 22 di Node.js (attuale al momento della stesura di questo articolo):

npm install 22

Installare le dipendenze necessarie per un ulteriore assemblaggio:

npm install

Avviamo la compilazione. Si noti che richiede più di 4 GB di RAM libera:

npm run build

Il frontend è pronto; ora è il momento di preparare il backend. Andare nella cartella con lo stesso nome:

cd ./backend

Installare i pacchetti pip e ffmpeg:

sudo apt -y install python3-pip ffmpeg

Prima dell'installazione, è necessario aggiungere un nuovo percorso alla variabile d'ambiente:

sudo nano ~/.bashrc

Aggiungere la seguente riga alla fine del file:

export PATH="/home/usergpu/.local/bin:$PATH"

Aggiorniamo all'ultima versione:

python3 -m pip install --upgrade pip

Ora è possibile installare le dipendenze:

pip install -r requirements.txt -U

Installare Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Tutto è pronto per lanciare l'applicazione:

bash start.sh

Ubuntu 24.04 / 24.10

Quando installate OpenWebUI su Ubuntu 24.04/24.10, dovrete affrontare una sfida fondamentale: il sistema operativo utilizza Python 3.12 per impostazione predefinita, mentre OpenWebUI supporta solo la versione 3.11. Non è possibile effettuare un semplice downgrade di Python, perché ciò comporterebbe la rottura del sistema operativo. Non è possibile effettuare un semplice downgrade di Python, perché ciò comporterebbe la rottura del sistema operativo. Poiché il pacchetto python3.11 non è disponibile nei repository standard, dovrete creare un ambiente virtuale per utilizzare la versione corretta di Python.

La soluzione migliore è usare il sistema di gestione dei pacchetti Conda. Conda funziona come pip, ma aggiunge il supporto di un ambiente virtuale simile a venv. Poiché sono necessarie solo le funzionalità di base, si utilizzerà Miniconda, una distribuzione leggera. Scaricate l'ultima versione da GitHub:

curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"

Eseguire lo script:

bash Miniforge3-$(uname)-$(uname -m).sh

Creiamo un ambiente virtuale chiamato pyenv e specifichiamo la versione 3.11 di Python:

conda create -n pyenv python=3.11

Attivare l'ambiente creato:

conda activate pyenv

Ora si può procedere con i passaggi standard dell'installazione di OpenWebUI per Ubuntu 22.04. L'ambiente virtuale garantisce che tutti gli script di installazione vengano eseguiti senza conflitti di versione. L'ambiente virtuale garantisce che tutti gli script di installazione vengano eseguiti senza problemi e senza conflitti di versione dei pacchetti.

Modelli

Libreria Ollama

Open WebUI consente di caricare i modelli direttamente dall'interfaccia web, specificando solo il nome nel formato model:size. A tal fine, navigare in http://192.168.88.20:8080/admin/settings e fare clic su Connections. Quindi fare clic sull'icona della chiave inglese di fronte alla stringa http://localhost:11434. Dopo aver consultato i nomi dei modelli presenti nella libreria, inserire il nome e fare clic sull'icona di caricamento:

Il sistema scaricherà automaticamente il modello richiesto, che sarà immediatamente disponibile per l'uso. A seconda delle dimensioni selezionate, il download può richiedere un tempo diverso. Prima di effettuare il download, assicurarsi che ci sia spazio sufficiente sul disco. Per ulteriori informazioni, consultare l'articolo Partizionamento del disco in Linux.

Modelli personalizzati

Se è necessario integrare un modello di rete neurale non presente nella libreria di Ollama, è possibile utilizzare la funzione sperimentale e caricare qualsiasi modello arbitrario in formato GGUF. A tale scopo, accedere a Settings - Admin Settings - Connections e fare clic sull'icona della chiave inglese di fronte a http://localhost:11434. Fare clic su Show nella sezione Experimental. Per impostazione predefinita, è attivata la modalità file, che consente di caricare un file dal computer locale. Facendo clic su File Mode, si passa a URL Mode, che consente di specificare l'URL del file del modello e il server lo scaricherà automaticamente:

RAG

Oltre a un'interfaccia web comoda e funzionale, Open WebUI aiuta a espandere le capacità dei diversi modelli, garantendone l'uso congiunto. Ad esempio, è facile caricare documenti per formare un database vettoriale RAG (Retrieval-augmented generation). Nel processo di generazione di una risposta all'utente, LLM potrà fare affidamento non solo sui dati ottenuti direttamente come risultato dell'addestramento, ma anche su quelli inseriti in un database vettoriale simile.

Documenti

Per impostazione predefinita, Open WebUI scansiona la directory /data/docs alla ricerca di file che possono essere inseriti nello spazio vettoriale del database ed esegue la trasformazione utilizzando il modello integrato all-MiniLM-L6-v2. Questo non è l'unico modello adatto a questo compito, quindi è opportuno provare altre opzioni, ad esempio da questo elenco.

I documenti di testo, privi di tag e altri caratteri speciali, sono i più adatti per RAG. Naturalmente, è possibile caricare i documenti così come sono, ma questo può influire notevolmente sull'accuratezza delle risposte generate. Ad esempio, se si dispone di una base di conoscenza in formato Markdown, si può prima ripulirla dalla formattazione e solo successivamente caricarla in /data/docs.

Ricerca sul Web

Oltre ai documenti locali, il modello di rete neurale può essere istruito a utilizzare qualsiasi sito web come fonte di dati. Questo gli consentirà di rispondere alle domande utilizzando non solo i dati su cui è stato addestrato, ma anche quelli ospitati sui siti web specificati dall'utente.

In realtà, si tratta di un tipo di RAG, che riceve in ingresso pagine HTML e le trasforma in modo speciale, inserendole in un database vettoriale. La ricerca all'interno di tale database sarà molto veloce; pertanto, il modello di rete neurale sarà in grado di generare rapidamente una risposta in base ai risultati ottenuti. Open WebUI supporta diversi motori di ricerca, ma può lavorare solo con uno alla Volta™, che viene specificato nelle impostazioni.

Per includere i risultati della ricerca sul Web nelle risposte della rete neurale, fare clic su + (simbolo più) e far scorrere l'interruttore Ricerca Web:

Generazione di immagini

Il punto forte di Open WebUI è che questo software consente di combinare più reti neurali con compiti diversi per risolvere un singolo problema. Ad esempio, Llama 3.1 è in grado di dialogare perfettamente con l'utente in diverse lingue, ma le sue risposte saranno esclusivamente testuali. Non può generare immagini, quindi non c'è modo di illustrare le sue risposte.

Stable Diffusion, di cui abbiamo spesso scritto, è l'opposto: questa rete neurale genera perfettamente immagini, ma non è in grado di lavorare con i testi. Gli sviluppatori di Open WebUI hanno cercato di combinare i punti di forza di entrambe le reti neurali in un unico dialogo e hanno implementato il seguente schema di lavoro.

Quando si conduce un dialogo in Open WebUI, accanto a ogni risposta della rete neurale appare un pulsante speciale. Facendo clic su di esso, si riceve un'illustrazione di questa risposta direttamente nella chat:

Questo si ottiene chiamando l'API di Stable Diffusion WebUI; al momento sono disponibili una connessione con le versioni di Automatic1111 e una connessione con ComfyUI. È anche possibile generare immagini tramite la rete neurale Dall-E, che però non può essere distribuita localmente: si tratta di un servizio di generazione di immagini a pagamento con codice sorgente chiuso.

Questa funzione funziona solo se, oltre a Open WebUI con Ollama, sul server è installata Stable Diffusion WebUI. Le istruzioni per l'installazione sono disponibili qui. L'unica cosa che vale la pena menzionare è che quando si esegue lo script ./webui.sh, è necessario specificare una chiave aggiuntiva per abilitare l'API:

./webui.sh --listen --api --gradio-auth user:password

Un'altra insidia può essere rappresentata dalla mancanza di memoria video. In questo caso, si possono usare due chiavi utili: --medvram e --lowvram. In questo modo si eviterà l'errore di memoria esaurita all'avvio della generazione.

Vedi anche:

Come funziona Ollama

Mon, 20 Jan 2025 15:16:02 +0100

Ollama è uno strumento per l'esecuzione di modelli di reti neurali di grandi dimensioni a livello locale. L'uso di servizi pubblici è spesso percepito dalle aziende come un potenziale rischio di fuga di dati riservati e sensibili. Per questo motivo, l'implementazione di LLM su un server controllato consente di gestire in modo indipendente i dati presenti su di esso, sfruttando al contempo i punti di forza di LLM.

In questo modo si evita anche la spiacevole situazione di vendor lock-in, in cui qualsiasi servizio pubblico può interrompere unilateralmente la fornitura di servizi. Naturalmente, l'obiettivo iniziale è quello di consentire l'uso delle reti neurali generative in luoghi dove l'accesso a Internet è assente o difficile (ad esempio, in aereo).

L'idea è quella di semplificare l'avvio, il controllo e la messa a punto degli LLM. Invece di complesse istruzioni in più fasi, Ollama consente di eseguire un semplice comando e di ricevere il risultato finale dopo qualche tempo. Il risultato sarà presentato simultaneamente sotto forma di modello di rete neurale locale, con il quale è possibile comunicare utilizzando un'interfaccia web e un'API per una facile integrazione in altre applicazioni.

Per molti sviluppatori, questo è diventato uno strumento molto utile, poiché nella maggior parte dei casi è stato possibile integrare Ollama con l'IDE utilizzato e ricevere raccomandazioni o codice già pronto scritto direttamente mentre si lavora all'applicazione.

Inizialmente Ollama era destinato solo ai computer con sistema operativo macOS, ma in seguito è stato portato su Linux e Windows. È stata rilasciata anche una versione speciale per lavorare in ambienti containerizzati come Docker. Attualmente, funziona ugualmente bene sia sui desktop che su qualsiasi server dedicato con una GPU. Ollama supporta la possibilità di passare da un modello all'altro e massimizza tutte le risorse disponibili. Naturalmente, questi modelli potrebbero non avere le stesse prestazioni su un normale desktop, ma funzionano in modo adeguato.

Come installare Ollama

Ollama può essere installato in due modi: senza usare la containerizzazione, usando uno script di installazione, e come contenitore Docker già pronto. Il primo metodo facilita la gestione dei componenti del sistema e dei modelli installati, ma è meno tollerante ai guasti. Il secondo metodo è più tollerante ai guasti, ma quando lo si utilizza è necessario tenere conto di tutti gli aspetti inerenti ai container: una gestione leggermente più complessa e un approccio diverso all'archiviazione dei dati.

Indipendentemente dal metodo scelto, sono necessari diversi passaggi aggiuntivi per preparare il sistema operativo.

I prerequisiti

Aggiornare il repository della cache dei pacchetti e i pacchetti installati:

sudo apt update && sudo apt -y upgrade

Installare tutti i driver GPU necessari usando la funzione di installazione automatica:

sudo ubuntu-drivers autoinstall

Riavviare il server:

sudo shutdown -r now

Installazione tramite script

Il seguente script rileva l'architettura del sistema operativo corrente e installa la versione appropriata di Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Durante il funzionamento, lo script creerà un utente separato ollama, sotto il quale verrà lanciato il demone corrispondente. Per inciso, lo stesso script funziona bene in WSL2, consentendo l'installazione della versione Linux di Ollama su Windows Server.

Installazione tramite Docker

Esistono vari metodi per installare Docker Engine su un server. Il modo più semplice è quello di utilizzare uno script specifico che installa la versione corrente di Docker. Questo approccio è efficace per Ubuntu Linux, dalla versione 20.04 (LTS) fino all'ultima versione, Ubuntu 24.04 (LTS):

curl -sSL https://get.docker.com/ | sh

Affinché i contenitori Docker interagiscano correttamente con la GPU, è necessario installare un toolkit aggiuntivo. Poiché non è disponibile nei repository di base di Ubuntu, è necessario aggiungere un repository di terze parti utilizzando il seguente comando:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Aggiornare il repository della cache dei pacchetti:

sudo apt update

E installare il pacchetto nvidia-container-toolkit:

sudo apt install nvidia-container-toolkit

Non dimenticare di riavviare il demone docker tramite systemctl:

sudo systemctl restart docker

È il momento di scaricare ed eseguire Ollama con l'interfaccia web Open-WebUI:

sudo docker run -d -p 3000:8080 --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Aprire il browser web e navigare su http://[server-ip]:3000:

Scaricare ed eseguire i modelli

Tramite riga di comando

È sufficiente eseguire il seguente comando:

ollama run llama3

Tramite WebUI

Aprire Settings > Models, digitare il nome del modello necessario, ad esempio llama3 e fare clic sul pulsante con il simbolo di download:

Il modello verrà scaricato e installato automaticamente. Al termine, chiudere la finestra delle impostazioni e selezionare il modello scaricato. A questo punto è possibile iniziare a dialogare con esso:

Integrazione VSCode

Se avete installato Ollama utilizzando lo script di installazione, potete lanciare qualsiasi modello supportato quasi istantaneamente. Nel prossimo esempio, verrà eseguito il modello predefinito previsto dall'estensione Ollama Autocoder (openhermes2.5-mistral:7b-q4_K_M):

ollama run openhermes2.5-mistral:7b-q4_K_M

Per impostazione predefinita, Ollama permette di lavorare attraverso un'API, consentendo solo connessioni dall'host locale. Pertanto, prima di installare e utilizzare l'estensione per Visual Studio Code, è necessario effettuare il port forwarding. In particolare, è necessario inoltrare la porta remota 11434 al computer locale. Un esempio di come farlo è riportato nel nostro articolo sulla WebUI di Easy Diffusion.

Digitare Ollama Autocoder in un campo di ricerca, quindi fare clic su Install:

Dopo aver installato l'estensione, nella tavolozza dei comandi sarà disponibile una nuova voce intitolata Autocomplete with Ollama. Iniziare la codifica e avviare questo comando.

L'estensione si connetterà al server LeaderGPU utilizzando il port forwarding e, in pochi secondi, il codice generato verrà visualizzato sullo schermo:

È possibile assegnare questo comando a un tasto di scelta rapida. Utilizzatelo ogni Volta™ che volete integrare il vostro codice con un frammento generato. Questo è solo un esempio delle estensioni di VSCode disponibili. Il principio del port forwarding da un server remoto a un computer locale consente di configurare un singolo server con un LLM funzionante per un intero team di sviluppatori. Questa garanzia impedisce ad aziende terze o ad hacker di utilizzare il codice inviato.

Vedi anche:

PrivateGPT: AI per i documenti

Mon, 20 Jan 2025 12:01:00 +0100

I modelli linguistici di grandi dimensioni si sono evoluti notevolmente negli ultimi anni e sono diventati strumenti efficaci per molte attività. L'unico problema del loro utilizzo è che la maggior parte dei prodotti basati su questi modelli utilizza servizi già pronti di aziende terze. Questo utilizzo ha il potenziale di far trapelare dati sensibili, per cui molte aziende evitano di caricare documenti interni su servizi LLM pubblici.

Un progetto come PrivateGPT potrebbe essere una soluzione. Inizialmente è stato progettato per un uso completamente locale. Il suo punto di forza è che potete inviare vari documenti come input, e la rete neurale li leggerà per voi e fornirà i propri commenti in risposta alle vostre richieste. Ad esempio, è possibile "dargli in pasto" testi di grandi dimensioni e chiedergli di trarre delle conclusioni in base alle richieste dell'utente. In questo modo è possibile risparmiare notevolmente tempo nella correzione delle bozze.

Questo è particolarmente vero per i settori professionali come la medicina. Ad esempio, un medico può fare una diagnosi e chiedere alla rete neurale di confermarla sulla base della serie di documenti caricati. Ciò consente di ottenere un ulteriore parere indipendente, riducendo così il numero di errori medici. Poiché le richieste e i documenti non lasciano il server, si può essere certi che i dati ricevuti non appaiano di dominio pubblico.

Oggi vi mostreremo come implementare una rete neurale sui server dedicati LeaderGPU con il sistema operativo Ubuntu 22.04 LTS in soli 20 minuti.

Preparazione del sistema

Iniziate aggiornando i pacchetti all'ultima versione:

sudo apt update && sudo apt -y upgrade

A questo punto, installare altri pacchetti, librerie e il driver grafico NVIDIA®. Tutti questi elementi sono necessari per compilare il software ed eseguirlo sulla GPU:

sudo apt -y install build-essential git gcc cmake make openssl libssl-dev libbz2-dev libreadline-dev libsqlite3-dev zlib1g-dev libncursesw5-dev libgdbm-dev libc6-dev zlib1g-dev libsqlite3-dev tk-dev libssl-dev openssl libffi-dev lzma liblzma-dev libbz2-dev

Installazione di CUDA® 12.4

Oltre al driver, è necessario installare il toolkit NVIDIA® CUDA®. Queste istruzioni sono state testate su CUDA® 12.4, ma tutto dovrebbe funzionare anche su CUDA® 12.2. Tuttavia, tenete presente che dovrete indicare la versione installata quando specificate il percorso dei file eseguibili.

Eseguire il seguente comando in sequenza:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin

sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600

wget https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda-repo-ubuntu2204-12-4-local_12.4.0-550.54.14-1_amd64.deb

sudo dpkg -i cuda-repo-ubuntu2204-12-4-local_12.4.0-550.54.14-1_amd64.deb

sudo cp /var/cuda-repo-ubuntu2204-12-4-local/cuda-*-keyring.gpg /usr/share/keyrings/

sudo apt-get update && sudo apt-get -y install cuda-toolkit-12-4

Ulteriori informazioni sull'installazione di CUDA® sono disponibili nella nostra Knowledge Base. A questo punto, riavviare il server:

sudo shutdown -r now

installare PyEnv

È il momento di installare una semplice utility di controllo della versione di Python, chiamata PyEnv. Si tratta di un fork notevolmente migliorato del progetto simile per Ruby (rbenv), configurato per funzionare con Python. Può essere installata con uno script di una riga:

curl https://pyenv.run | bash

Ora, è necessario aggiungere alcune variabili alla fine del file di script, che viene eseguito al momento del login. Le prime tre righe sono responsabili del corretto funzionamento di PyEnv, mentre la quarta è necessaria per Poetry, che sarà installato in seguito:

nano .bashrc

export PYENV_ROOT="$HOME/.pyenv"
[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"
export PATH="/home/usergpu/.local/bin:$PATH"

Applicare le impostazioni effettuate:

source .bashrc

Installare la versione 3.11 di Python:

pyenv install 3.11

Creare un ambiente virtuale per Python 3.11:

pyenv local 3.11

Installazione della poesia

Il prossimo pezzo del puzzle è Poetry. Si tratta di un analogo di pip per la gestione delle dipendenze nei progetti Python. L'autore di Poetry era stanco di avere costantemente a che fare con diversi metodi di configurazione, come setup.cfg, requirements.txt, MANIFEST.ini e altri. Questo è stato il motore per lo sviluppo di un nuovo strumento che utilizza un file pyproject.toml, che memorizza tutte le informazioni di base su un progetto, non solo un elenco di dipendenze.

Installare la poesia:

curl -sSL https://install.python-poetry.org | python3 -

Installazione di PrivateGPT

Ora che tutto è pronto, si può clonare il repository PrivateGPT:

git clone https://github.com/imartinez/privateGPT

Andare al repository scaricato:

cd privateGPT

Eseguire l'installazione delle dipendenze utilizzando Poetry e abilitando i componenti aggiuntivi:

ui - aggiunge un'interfaccia web di gestione basata su Gradio all'applicazione backend;
embedding-huggingface - abilita il supporto per l'incorporazione dei modelli scaricati da HuggingFace;
llms-llama-cpp - aggiunge il supporto per l'inferenza diretta dei modelli in formato GGUF;
vector-stores-qdrant - aggiunge il database vettoriale qdrant.

poetry install --extras "ui embeddings-huggingface llms-llama-cpp vector-stores-qdrant"

Impostare il token di accesso a Hugging Face. Per ulteriori informazioni, leggete questo articolo:

export HF_TOKEN="YOUR_HUGGING_FACE_ACCESS_TOKEN"

Ora, eseguite lo script di installazione, che scaricherà automaticamente il modello e i pesi (Meta Llama 3.1 8B Instruct di default):

poetry run python scripts/setup

Il comando seguente ricompila llms-llama-cpp separatamente per abilitare il supporto NVIDIA® CUDA®, al fine di scaricare i carichi di lavoro sulla GPU:

CUDACXX=/usr/local/cuda-12/bin/nvcc CMAKE_ARGS="-DGGML_CUDA=on -DCMAKE_CUDA_ARCHITECTURES=native" FORCE_CMAKE=1 pip install llama-cpp-python --no-cache-dir --force-reinstall --upgrade

Se si ottiene un errore come nvcc fatal : Unsupported gpu architecture 'compute_' è sufficiente specificare l'architettura esatta della GPU in uso. Ad esempio: DCMAKE_CUDA_ARCHITECTURES=86 per NVIDIA® RTX™ 3090.

L'ultimo passo prima di iniziare è installare il supporto per le chiamate asincrone (async/await):

pip install asyncio

Eseguire PrivateGPT

Esegue PrivateGPT con un solo comando:

make run

Aprite il vostro browser web e andate alla pagina http://[LeaderGPU_server_IP_address]:8001

Vedi anche:

Qwen 2 vs Llama 3

Mon, 20 Jan 2025 11:27:11 +0100

I grandi modelli linguistici (LLM) hanno avuto un impatto significativo sulla nostra vita. Nonostante la comprensione della loro struttura interna, questi modelli rimangono un punto focale per gli scienziati che spesso li paragonano a una "scatola nera". Il risultato finale dipende non solo dalla progettazione del LLM, ma anche dalla sua formazione e dai dati utilizzati per l'addestramento.

Mentre gli scienziati trovano opportunità di ricerca, gli utenti finali sono interessati principalmente a due cose: velocità e qualità. Questi criteri giocano un ruolo fondamentale nel processo di selezione. Per confrontare accuratamente due LLM, è necessario standardizzare molti fattori apparentemente non correlati.

L'apparecchiatura utilizzata per le interferenze e l'ambiente software, compresi il sistema operativo, le versioni dei driver e i pacchetti software, hanno l'impatto più significativo. È essenziale selezionare una versione di LLM che funzioni su diverse apparecchiature e scegliere una metrica di velocità facilmente comprensibile.

Abbiamo scelto come parametro "tokens per secondo" (tokens/s). È importante notare che un token ≠ una parola. L'LLM scompone le parole in componenti più semplici, tipiche di una lingua specifica, denominate token.

La prevedibilità statistica del carattere successivo varia da una lingua all'altra, quindi la tokenizzazione sarà diversa. Ad esempio, in inglese, ogni 75 parole si ricavano circa 100 token. Nelle lingue che utilizzano l'alfabeto cirillico, il numero di token per parola può essere maggiore. Quindi, 75 parole in una lingua cirillica, come il russo, potrebbero equivalere a 120-150 token.

È possibile verificarlo utilizzando lo strumento Tokenizer di OpenAI. Questo strumento mostra in quanti tokens viene suddiviso un frammento di testo, rendendo i "tokens per secondo" un buon indicatore della velocità e delle prestazioni di elaborazione del linguaggio naturale di un LLM.

Ogni test è stato condotto sul sistema operativo Ubuntu 22.04 LTS con i driver NVIDIA® versione 535.183.01 e il toolkit NVIDIA® CUDA® 12.5 installato. Le domande sono state formulate per valutare la qualità e la velocità dell'LLM. La velocità di elaborazione di ogni risposta è stata registrata e contribuirà al valore medio per ogni configurazione testata.

Abbiamo iniziato a testare diverse GPU, dai modelli più recenti a quelli più vecchi. Una condizione fondamentale per il test è stata quella di misurare le prestazioni di una sola GPU, anche se nella configurazione del server erano presenti più GPU. Questo perché le prestazioni di una configurazione con più GPU dipendono da fattori aggiuntivi come la presenza di un'interconnessione ad alta velocità tra di esse (NVLink).

Oltre alla velocità, abbiamo cercato di valutare anche la qualità delle risposte su una scala a 5 punti, dove 5 rappresenta il risultato migliore. Queste informazioni sono fornite solo per una comprensione generale. Ogni Volta™ porremo le stesse domande alla rete neurale e cercheremo di capire quanto accuratamente ognuna di esse comprenda ciò che l'utente vuole da essa.

Qwen 2

Recentemente, un team di sviluppatori di Alibaba Group ha presentato la seconda versione della rete neurale generativa Qwen. Comprende 27 lingue ed è ben ottimizzata per esse. Qwen 2 è disponibile in diverse dimensioni per facilitarne l'implementazione su qualsiasi dispositivo (da sistemi embedded ad alta limitazione di risorse a server dedicati con GPU):

0.5B: adatto per IoT e sistemi embedded;
1.5B: una versione estesa per i sistemi embedded, utilizzata quando le capacità di 0.5B non sono sufficienti;
7B: modello di medie dimensioni, adatto all'elaborazione del linguaggio naturale;
57B: modello di grandi dimensioni ad alte prestazioni, adatto ad applicazioni complesse;
72B: il modello Qwen 2 definitivo, progettato per risolvere i problemi più complessi ed elaborare grandi volumi di dati.

Le versioni 0.5B e 1.5B sono state addestrate su set di dati con una lunghezza di contesto di 32K. Le versioni 7B e 72B erano già state addestrate su un contesto di 128K. Il modello di compromesso 57B è stato addestrato su set di dati con un contesto di 64K. I creatori hanno definito Qwen 2 come un analogo di Llama 3 in grado di risolvere gli stessi problemi, ma molto più velocemente.

Llama 3

La terza versione della rete neurale generativa della famiglia MetaAI Llama è stata introdotta nell'aprile 2024. A differenza di Qwen 2, è stata rilasciata in due sole versioni: 8B e 70B. Questi modelli sono stati posizionati come uno strumento universale per risolvere molti problemi in vari casi. Continuava la tendenza al multilinguismo e alla multimodalità, diventando al contempo più veloce delle versioni precedenti e supportando una maggiore lunghezza del contesto.

I creatori di Llama 3 hanno cercato di perfezionare i modelli per ridurre la percentuale di allucinazioni statistiche e aumentare la varietà delle risposte. Llama 3 è quindi in grado di dare consigli pratici, aiutare a scrivere una lettera commerciale o speculare su un argomento specificato dall'utente. I dataset su cui sono stati addestrati i modelli di Llama 3 avevano una lunghezza del contesto di 128K e più del 5% includeva dati in 30 lingue. Tuttavia, come si legge nel comunicato stampa, le prestazioni di generazione in inglese saranno significativamente superiori a quelle in qualsiasi altra lingua.

Confronto

NVIDIA® RTX™ A6000

Iniziamo le nostre misurazioni di velocità con la GPU NVIDIA® RTX™ A6000, basata sull'architettura Ampere (da non confondere con la NVIDIA® RTX™ A6000 Ada). Questa scheda ha caratteristiche molto modeste, ma allo stesso tempo dispone di 48 GB di VRAM, che le permettono di operare con modelli di reti neurali piuttosto grandi. Purtroppo, la bassa velocità di clock e la larghezza di banda sono le ragioni della bassa velocità di inferenza degli LLM testuali.

Subito dopo il lancio, la rete neurale Qwen 2 ha iniziato a superare le prestazioni di Llama 3. Rispondendo alle stesse domande, la differenza media di velocità è stata del 24% a favore di Qwen 2. La velocità di generazione delle risposte è stata dell'ordine di 11-16 token al secondo. Si tratta di una velocità 2-3 volte superiore rispetto al tentativo di generazione anche su una CPU potente, ma nella nostra valutazione questo è il risultato più modesto.

NVIDIA® RTX™ 3090

Anche la prossima GPU è costruita sull'architettura Ampere, ha una memoria video 2 volte inferiore, ma allo stesso tempo opera a una frequenza superiore (19500 MHz contro 16000 Mhz). Anche la larghezza di banda della memoria video è maggiore (936,2 GB/s contro 768 GB/s). Entrambi questi fattori aumentano notevolmente le prestazioni della RTX™ 3090, anche tenendo conto del fatto che ha 256 core CUDA® in meno.

Qui si vede chiaramente che Qwen 2 è molto più veloce (fino al 23%) di Llama 3 nell'esecuzione degli stessi compiti. Per quanto riguarda la qualità della generazione, il supporto multilingue di Qwen 3 è davvero degno di lode e il modello risponde sempre nella stessa lingua in cui è stata posta la domanda. Con Llama 3, a questo proposito, capita spesso che il modello capisca la domanda stessa, ma preferisca formulare le risposte in inglese.

NVIDIA® RTX™ 4090

Ora la cosa più interessante: vediamo come se la cava la NVIDIA® RTX™ 4090, costruita sull'architettura Ada Lovelace, dal nome della matematica inglese Augusta Ada King, contessa di Lovelace. Ada Lovelace è diventata famosa per essere stata la prima programmatrice nella storia dell'umanità, e all'epoca in cui scrisse il suo primo programma non esisteva un computer assemblato in grado di eseguirlo. Tuttavia, è stato riconosciuto che l'algoritmo descritto da Ada per il calcolo dei numeri di Bernoulli è stato il primo programma al mondo scritto per essere eseguito su un computer.

Il grafico mostra chiaramente che la RTX™ 4090 ha affrontato l'inferenza di entrambi i modelli con una velocità quasi doppia. È interessante notare che in una delle iterazioni Llama 3 è riuscito a superare Qwen 2 dell'1,2%. Tuttavia, tenendo conto delle altre iterazioni, Qwen 2 ha mantenuto la sua leadership, rimanendo più veloce di Llama 3 del 7%. In tutte le iterazioni, la qualità delle risposte di entrambe le reti neurali è stata elevata, con un numero minimo di allucinazioni. L'unico difetto è che in rari casi uno o due caratteri cinesi sono stati mescolati nelle risposte, il che non ha influito in alcun modo sul significato complessivo.

NVIDIA® RTX™ A40

La successiva scheda NVIDIA® RTX™ A40, su cui abbiamo eseguito test simili, è nuovamente costruita sull'architettura Ampere e dispone di 48 GB di memoria video sulla scheda madre. Rispetto alla RTX™ 3090, questa memoria è leggermente più veloce (20000 MHz contro 19500 MHz), ma ha una larghezza di banda inferiore (695,8 GB/s contro 936,2 GB/s). La situazione è compensata dal maggior numero di core CUDA® (10752 contro 10496), che nel complesso permette alla RTX™ A40 di essere leggermente più veloce della RTX™ 3090.

Per quanto riguarda il confronto della velocità dei modelli, anche in questo caso Qwen 2 è superiore a Llama 3 in tutte le iterazioni. Quando viene eseguito su RTX™ A40, la differenza di velocità è di circa il 15% a parità di risposte. In alcuni compiti, Qwen 2 ha fornito informazioni un po' più importanti, mentre Llama 3 è stato il più specifico possibile e ha fornito esempi. Ciononostante, è necessario ricontrollare tutto, poiché a volte entrambi i modelli iniziano a produrre risposte controverse.

NVIDIA® L20

L'ultimo partecipante al nostro test è stato l'NVIDIA® L20. Questa GPU è costruita, come la RTX™ 4090, sull'architettura Ada Lovelace. Si tratta di un modello abbastanza nuovo, presentato nell'autunno del 2023. A bordo ha 48 GB di memoria video e 11776 CUDA® core. La larghezza di banda della memoria è inferiore a quella della RTX™ 4090 (864 GB/s contro 936,2 GB/s), così come la frequenza effettiva. Pertanto, i punteggi di inferenza NVIDIA® L20 di entrambi i modelli saranno più vicini al 3090 che al 4090.

Il test finale non ha riservato sorprese. Qwen 2 è risultato più veloce di Llama 3 in tutte le iterazioni.

Conclusione

Riuniamo tutti i risultati raccolti in un unico grafico. Qwen 2 è risultato più veloce di Llama 3 dal 7% al 24% a seconda della GPU utilizzata. In base a ciò, possiamo concludere chiaramente che se si desidera ottenere inferenze ad alta velocità da modelli come Qwen 2 o Llama 3 su configurazioni a singola GPU, il leader indiscusso sarà la RTX™ 3090. Una possibile alternativa potrebbe essere l'A40 o l'L20. Ma non vale la pena di eseguire l'inferenza di questi modelli su schede Ampere di generazione A6000.

Non abbiamo volutamente menzionato nei test le schede con una quantità inferiore di memoria video, ad esempio la NVIDIA® RTX™ 2080Ti, poiché non è possibile inserirvi i modelli 7B o 8B di cui sopra senza quantizzazione. Il modello Qwen 2 da 1,5B, purtroppo, non ha risposte di alta qualità e non può sostituire completamente il modello 7B.

Vedi anche:

Il proprio Qwen utilizzando HF

Mon, 20 Jan 2025 09:43:46 +0100

I grandi modelli di reti neurali, con le loro straordinarie capacità, sono saldamente radicati nelle nostre vite. Riconoscendo questa opportunità di sviluppo futuro, le grandi aziende hanno iniziato a sviluppare le proprie versioni di questi modelli. Il gigante cinese Alibaba non è rimasto a guardare. Ha creato il proprio modello, QWen (Tongyi Qianwen), che è diventato la base per molti altri modelli di reti neurali.

Prerequisiti

Aggiornare la cache e i pacchetti

Aggiorniamo la cache dei pacchetti e aggiorniamo il sistema operativo prima di iniziare a configurare Qwen. Inoltre, dobbiamo aggiungere Python Installer Packages (PIP), se non è già presente nel sistema. Si noti che per questa guida utilizziamo Ubuntu 22.04 LTS come sistema operativo:

sudo apt update && sudo apt -y upgrade && sudo apt install python3-pip

Installare i driver NVIDIA®

È possibile utilizzare l'utilità automatica inclusa di default nelle distribuzioni Ubuntu:

sudo ubuntu-drivers autoinstall

In alternativa, è possibile installare manualmente i driver NVIDIA® utilizzando la nostra guida passo-passo. Non dimenticate di riavviare il server:

sudo shutdown -r now

Generazione di testo dell'interfaccia web

Clonare il repository

Aprire la cartella di lavoro sull'SSD:

cd /mnt/fastdisk

Clonare il repository del progetto:

git clone https://github.com/oobabooga/text-generation-webui.git

Installare i requisiti

Aprire la cartella scaricata:

cd text-generation-webui

Controllare e installare tutti i componenti mancanti:

pip install -r requirements.txt

Aggiungere la chiave SSH a HF

Prima di iniziare, è necessario impostare il port forwarding (porta remota 7860 a 127.0.0.1:7860) nel proprio client SSH. Per ulteriori informazioni, consultare il seguente articolo: Connettersi al server Linux.

Aggiornare il repository della cache dei pacchetti e i pacchetti installati:

sudo apt update && sudo apt -y upgrade

Generare e aggiungere una chiave SSH da utilizzare in Hugging Face:

cd ~/.ssh && ssh-keygen

Quando la coppia di chiavi è stata generata, è possibile visualizzare la chiave pubblica nell'emulatore di terminale:

cat id_rsa.pub

Copiare tutte le informazioni che iniziano con ssh-rsa e terminano con usergpu@gpuserver come mostrato nella seguente schermata:

Compilare Key name e incollare la SSH Public key copiata dal terminale. Salvare la chiave premendo Add key:

cd ~/

Scaricare ed eseguire lo script di shell. Questo script installa un nuovo repository di terze parti con git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Ora è possibile installarlo utilizzando il gestore di pacchetti standard:

sudo apt-get install git-lfs

Configuriamo git per usare il nostro nickname HF:

git config --global user.name "John"

E collegato all'account di posta elettronica HF:

git config --global user.email "john.doe@example.com"

Scarica il modello

Il passo successivo è scaricare il modello utilizzando la tecnica di clonazione del repository comunemente usata dagli sviluppatori di software. L'unica differenza è che Git-LFS, precedentemente installato, elaborerà automaticamente i file puntatori contrassegnati e scaricherà tutto il contenuto. Aprire la directory necessaria (/mnt/fastdisk nel nostro esempio):

cd /mnt/fastdisk

Questo comando potrebbe richiedere un po' di tempo per essere completato:

git clone git@hf.co:Qwen/Qwen1.5-32B-Chat-GGUF

Eseguire il modello

Eseguire uno script che avvii il server web e specifichi /mnt/fastdisk come directory di lavoro con i modelli. Questo script potrebbe scaricare alcuni componenti aggiuntivi al primo avvio.

./start_linux.sh --model-dir /mnt/fastdisk

Aprire il browser Web e selezionare llama.cpp dall'elenco a discesa Model loader:

Assicurarsi di impostare il parametro n-gpu-layers. È lui il responsabile della percentuale di calcoli che verrà scaricata sulla GPU. Se si lascia il numero a 0, tutti i calcoli verranno eseguiti dalla CPU, il che è piuttosto lento. Una Volta™ impostati tutti i parametri, fare clic sul pulsante Load. Successivamente, passare alla scheda Chat e selezionare Instruct mode. A questo punto, è possibile inserire qualsiasi richiesta e ricevere una risposta:

L'elaborazione verrà eseguita per impostazione predefinita su tutte le GPU disponibili, tenendo conto dei parametri precedentemente specificati:

Vedi anche:

Il proprio Vicuna in Linux

Mon, 20 Jan 2025 09:25:01 +0100

Questo articolo vi guiderà attraverso il processo di implementazione di un'alternativa LLaMA di base su un server LeaderGPU. A questo scopo utilizzeremo il progetto FastChat e il modello Vicuna, disponibile gratuitamente.

Il modello che utilizzeremo è basato sull'architettura LLaMA di Meta, ma è stato ottimizzato per una distribuzione efficiente su hardware consumer. Questa configurazione offre un buon equilibrio tra prestazioni e requisiti di risorse, rendendola adatta sia agli ambienti di test che a quelli di produzione.

Preinstallazione

Prepariamo l'installazione di FastChat aggiornando il repository della cache dei pacchetti:

sudo apt update && sudo apt -y upgrade

Installare automaticamente i driver NVIDIA® utilizzando il seguente comando:

sudo ubuntu-drivers autoinstall

È anche possibile installare questi driver manualmente con la nostra guida passo-passo. Quindi, riavviare il server:

sudo shutdown -r now

Il passo successivo è l'installazione di PIP (Package Installer for Python):

sudo apt install python3-pip

Installare FastChat

Da PyPi

Ci sono due modi possibili per installare FastChat. Si può installare direttamente da PyPi:

pip3 install "fschat[model_worker,webui]"

Da GitHub

In alternativa, è possibile clonare il repository FastChat da GitHub e installarlo:

git clone https://github.com/lm-sys/FastChat.git

cd FastChat

Non dimenticate di aggiornare PIP prima di procedere:

pip3 install --upgrade pip

pip3 install -e ".[model_worker,webui]"

Eseguire FastChat

Primo avvio

Per garantire il successo dell'avvio iniziale, si consiglia di richiamare manualmente FastChat direttamente dalla riga di comando:

python3 -m fastchat.serve.cli --model-path lmsys/vicuna-7b-v1.5

Questa azione recupera e scarica automaticamente il modello designato di vostra scelta, che deve essere specificato utilizzando il parametro --model-path. Il modello 7b rappresenta un modello con 7 miliardi di parametri. È il modello più leggero, adatto alle GPU con 16 GB di memoria video. I collegamenti ai modelli con un numero maggiore di parametri si trovano nel file Readme del progetto.

A questo punto si può scegliere di avviare una conversazione con il chatbot direttamente all'interno dell'interfaccia a riga di comando oppure si può impostare un'interfaccia Web. Essa contiene tre componenti:

Controllore
Lavoratori
Server web Gradio

Impostare i servizi

Trasformiamo ogni componente in un servizio systemd separato. Creare 3 file separati con i seguenti contenuti:

sudo nano /etc/systemd/system/vicuna-controller.service

[Unit]
Description=Vicuna controller service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.controller
Restart=always
[Install]
WantedBy=multi-user.target

sudo nano /etc/systemd/system/vicuna-worker.service

[Unit]
Description=Vicuna worker service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.model_worker --model-path lmsys/vicuna-7b-v1.5
Restart=always
[Install]
WantedBy=multi-user.target

sudo nano /etc/systemd/system/vicuna-webserver.service

[Unit]
Description=Vicuna web server
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.gradio_web_server
Restart=always
[Install]
WantedBy=multi-user.target

Systemd di solito aggiorna il database dei demoni durante il processo di avvio del sistema. Tuttavia, è possibile farlo manualmente utilizzando il seguente comando:

sudo systemctl daemon-reload

Aggiungiamo ora tre nuovi servizi all'avvio e lanciamoli immediatamente usando l'opzione --now:

sudo systemctl enable vicuna-controller.service --now && sudo systemctl enable vicuna-worker.service --now && sudo systemctl enable vicuna-webserver.service --now

Tuttavia, se si tenta di aprire un'interfaccia Web all'indirizzo http://[IP_ADDRESS]:7860, si troverà un'interfaccia completamente inutilizzabile senza modelli disponibili. Per risolvere questo problema, interrompere il servizio di interfaccia Web:

sudo systemctl stop vicuna-webserver.service

Eseguire manualmente il servizio Web:

python3 -m fastchat.serve.gradio_web_server

Aggiungere un'autenticazione

Questa azione richiama un altro script, che registrerà il modello precedentemente scaricato in un database interno di Gradio. Attendere qualche secondo e interrompere il processo utilizzando la scorciatoia Ctrl + C. Ci occuperemo anche della sicurezza e attiveremo un semplice meccanismo di autenticazione per l'accesso all'interfaccia web. Aprite il seguente file se avete installato FastChat da PyPI:

sudo nano /home/usergpu/.local/lib/python3.10/site-packages/fastchat/serve/gradio_web_server.py

oppure

sudo nano /home/usergpu/FastChat/fastchat/serve/gradio_web_server.py

Scorrere fino alla fine. Trovare questa riga:

auth=auth,

Modificatela impostando un nome utente o una password a piacere:

auth=(“username”,”password”),

Salvare il file e uscire, utilizzando la scorciatoia Ctrl + X. Infine, avviare l'interfaccia web:

sudo systemctl start vicuna-webserver.service

Aprite http://[IP_ADDRESS]:7860 nel vostro browser e godetevi FastChat con Vicuna:

Vedi anche:

Il vostro LLaMa 2 in Linux

Mon, 20 Jan 2025 09:13:25 +0100

Passo 1. Preparare il sistema operativo

Aggiornare la cache e i pacchetti

Aggiorniamo la cache dei pacchetti e aggiorniamo il sistema operativo prima di iniziare a configurare LLaMa 2. Si noti che per questa guida utilizziamo Ubuntu 22.04 LTS come sistema operativo:

sudo apt update && sudo apt -y upgrade

Inoltre, dobbiamo aggiungere Python Installer Packages (PIP), se non è già presente nel sistema:

sudo apt install python3-pip

Installare i driver NVIDIA®

È possibile utilizzare l'utilità automatica inclusa di default nelle distribuzioni Ubuntu:

sudo ubuntu-drivers autoinstall

In alternativa, è possibile installare manualmente i driver NVIDIA® utilizzando la nostra guida passo-passo. Non dimenticate di riavviare il server:

sudo shutdown -r now

Passo 2. Ottenere i modelli da MetaAI

Richiesta ufficiale

Aprite il seguente indirizzo nel vostro browser: https://ai.meta.com/resources/models-and-libraries/llama-downloads/

Compilare tutti i campi necessari, leggere il contratto d'uso e fare clic sul pulsante Agree and Continue. Dopo alcuni minuti (ore, giorni), riceverete uno speciale URL di download, che vi autorizza a scaricare i modelli per un periodo di 24 ore.

Clonare il repository

Prima di effettuare il download, verificare lo spazio di archiviazione disponibile:

df -h

Filesystem      Size  Used Avail Use% Mounted on
tmpfs            38G  3.3M   38G   1% /run
/dev/sda2        99G   24G   70G  26% /
tmpfs           189G     0  189G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
/dev/nvme0n1    1.8T   26G  1.7T   2% /mnt/fastdisk
tmpfs            38G  8.0K   38G   1% /run/user/1000

Se i dischi locali sono smontati, seguire le istruzioni riportate in Partizionamento dei dischi in Linux. Questo è importante perché i modelli scaricati possono essere molto grandi e occorre pianificare in anticipo la loro posizione di archiviazione. In questo esempio, abbiamo un SSD locale montato nella directory /mnt/fastdisk. Apriamola:

cd /mnt/fastdisk

Creare una copia del repository originale di LaMa:

git clone https://github.com/facebookresearch/llama

Se si verifica un errore di autorizzazione, è sufficiente concedere i permessi all'utenteergpu:

sudo chown -R usergpu:usergpu /mnt/fastdisk/

Scaricamento tramite script

Aprire la directory scaricata:

cd llama

Eseguire lo script:

./download.sh

Passare l'URL fornito da MetaAI e selezionare tutti i modelli necessari. Si consiglia di scaricare tutti i modelli disponibili per evitare di richiedere nuovamente l'autorizzazione. Tuttavia, se avete bisogno di un modello specifico, scaricate solo quello.

Test rapido tramite l'applicazione di esempio

Per iniziare, possiamo verificare la presenza di eventuali componenti mancanti. Se mancano librerie o applicazioni, il gestore dei pacchetti le installerà automaticamente:

pip install -e .

Il passo successivo consiste nell'aggiungere nuovi file binari al PATH:

export PATH=/home/usergpu/.local/bin:$PATH

Eseguire l'esempio dimostrativo:

torchrun --nproc_per_node 1 /mnt/fastdisk/llama/example_chat_completion.py --ckpt_dir /mnt/fastdisk/llama-2-7b-chat/ --tokenizer_path /mnt/fastdisk/llama/tokenizer.model --max_seq_len 512 --max_batch_size 6

L'applicazione creerà un processo di calcolo sulla prima GPU e simulerà una semplice finestra di dialogo con richieste tipiche, generando le risposte con LaMa 2.

Passo 3. Ottenere llama.cpp

LLaMa C++ è un progetto creato dal fisico e sviluppatore di software bulgaro Georgi Gerganov. Contiene molte utili utility che facilitano il lavoro con questo modello di rete neurale. Tutte le parti di llama.cpp sono software open source e sono distribuite sotto la licenza MIT.

Clonare il repository

Aprire la directory di lavoro sull'SSD:

cd /mnt/fastdisk

Clonare il repository del progetto:

git clone https://github.com/ggerganov/llama.cpp.git

Compilare le applicazioni

Aprire la cartella clonata:

cd llama.cpp

Avviare il processo di compilazione con il seguente comando:

make

Passo 4. Ottenere text-generation-webui

Clonare il repository

Aprire la directory di lavoro sull'SSD:

cd /mnt/fastdisk

Clonare il repository del progetto:

git clone https://github.com/oobabooga/text-generation-webui.git

Installare i requisiti

Aprire la cartella scaricata:

cd text-generation-webui

Controllare e installare tutti i componenti mancanti:

pip install -r requirements.txt

Passo 5. Conversione di PTH in GGUF

Formati comuni

PTH (Python TorcH) - Un formato consolidato. Essenzialmente, è un archivio ZIP standard con un dizionario di stato PyTorch serializzato. Tuttavia, questo formato ha alternative più veloci, come GGML e GGUF.

GGML (Georgi Gerganov’s Machine Learning) - È un formato di file creato da Georgi Gerganov, l'autore di llama.cpp. Si basa su un'omonima libreria, scritta in C++, che ha aumentato in modo significativo le prestazioni dei modelli linguistici di grandi dimensioni. Ora è stato sostituito dal moderno formato GGUF.

GGUF (Georgi Gerganov’s Unified Format) - Un formato di file ampiamente utilizzato per gli LLM, supportato da diverse applicazioni. Offre maggiore flessibilità, scalabilità e compatibilità per la maggior parte dei casi d'uso.

script llama.cpp convert.py

Modifica i parametri del modello prima della conversione:

nano /mnt/fastdisk/llama-2-7b-chat/params.json

Correggere "vocab_size": -1 in "vocab_size": 32000. Salvare il file e uscire. Aprire quindi la cartella llama.cpp:

cd /mnt/fastdisk/llama.cpp

Eseguire lo script che convertirà il modello in formato GGUF:

python3 convert.py /mnt/fastdisk/llama-2-7b-chat/ --vocab-dir /mnt/fastdisk/llama

Se tutti i passaggi precedenti sono corretti, si riceverà un messaggio come questo:

Wrote /mnt/fastdisk/llama-2-7b-chat/ggml-model-f16.gguf

Passo 6. WebUI

Come avviare la WebUI

Aprire la directory:

cd /mnt/fastdisk/text-generation-webui/

Eseguire lo script di avvio con alcuni parametri utili:

--model-dir indica il percorso corretto dei modelli
--share crea un collegamento pubblico temporaneo (se non si vuole inoltrare una porta tramite SSH)
--gradio-auth aggiunge l'autorizzazione con una login e una password (sostituire user:password con la propria)

./start_linux.sh --model-dir /mnt/fastdisk/llama-2-7b-chat/ --share --gradio-auth user:password

Dopo l'avvio, si riceverà un link di condivisione locale e temporaneo per l'accesso:

Running on local URL:  http://127.0.0.1:7860
Running on public URL: https://e9a61c21593a7b251f.gradio.live

Questo link di condivisione scade tra 72 ore.

Caricare il modello

Autorizzate la WebUI utilizzando il nome utente e la password selezionati e seguite questi 5 semplici passaggi:

Passare alla scheda Model.
Selezionare ggml-model-f16.gguf dal menu a discesa.
Scegliere il numero di livelli che si desidera calcolare sulla GPU (n-gpu-layers).
Scegliere il numero di thread da avviare (threads).
Fare clic sul pulsante Load.

Avvio della finestra di dialogo

Cambiare la scheda in Chat, digitare la richiesta e fare clic su Generate:

Vedi anche:

Llama 3 usando Hugging Face

Mon, 20 Jan 2025 09:05:10 +0100

Il 18 aprile 2024 è stato rilasciato Llama 3, il nuovo modello linguistico di MetaAI. Agli utenti sono state presentate due versioni: 8B e 70B. La prima versione contiene più di 15.000 token ed è stata addestrata su dati validi fino a marzo 2023. La seconda versione, più ampia, è stata addestrata su dati validi fino a dicembre 2023.

Fase 1. Preparare il sistema operativo

Aggiornare la cache e i pacchetti

Aggiorniamo la cache dei pacchetti e aggiorniamo il sistema operativo prima di iniziare a configurare LLaMa 3. Si noti che per questa guida utilizziamo Ubuntu 22.04 LTS come sistema operativo:

sudo apt update && sudo apt -y upgrade

Inoltre, dobbiamo aggiungere Python Installer Packages (PIP), se non è già presente nel sistema:

sudo apt install python3-pip

Installare i driver NVIDIA®

È possibile utilizzare l'utilità automatica inclusa di default nelle distribuzioni Ubuntu:

sudo ubuntu-drivers autoinstall

In alternativa, è possibile installare i driver NVIDIA® manualmente. Non dimenticate di riavviare il server:

sudo shutdown -r now

Passo 2. Ottenere il modello

Accedere a Hugging Face utilizzando il proprio nome utente e la propria password. Andare alla pagina corrispondente alla versione di LLM desiderata: Meta-Llama-3-8B o Meta-Llama-3-70B. Al momento della pubblicazione di questo articolo, l'accesso al modello è fornito su base individuale. Compilare un breve modulo e fare clic sul pulsante Submit:

Richiesta di accesso a HF

Riceverete un messaggio che vi informa che la vostra richiesta è stata inoltrata:

L'accesso avverrà dopo 30-40 minuti e sarete avvisati via e-mail.

Aggiungere la chiave SSH a HF

Generare e aggiungere una chiave SSH da utilizzare in Hugging Face:

cd ~/.ssh && ssh-keygen

Quando la coppia di chiavi è stata generata, è possibile visualizzare la chiave pubblica nell'emulatore di terminale:

cat id_rsa.pub

Copiare tutte le informazioni a partire da ssh-rsa e fino a usergpu@gpuserver come mostrato nella seguente schermata:

Aprire le impostazioni del profilo di Hugging Face. Scegliere quindi SSH and GPG Keys e fare clic sul pulsante Aggiungi chiave SSH:

Compilare Key name e incollare SSH Public key copiato dal terminale. Salvare la chiave premendo Add key:

cd ~/

Scaricare ed eseguire lo script di shell. Questo script installa un nuovo repository di terze parti con git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Ora è possibile installarlo utilizzando il gestore di pacchetti standard:

sudo apt-get install git-lfs

Configuriamo git per usare il nostro nickname HF:

git config --global user.name "John"

E collegato all'account di posta elettronica HF:

git config --global user.email "john.doe@example.com"

Scarica il modello

Aprire la directory di destinazione:

cd /mnt/fastdisk

E avviare il download del repository. Per questo esempio abbiamo scelto la versione 8B:

git clone git@hf.co:meta-llama/Meta-Llama-3-8B

Questo processo richiede fino a 5 minuti. È possibile monitorare questo processo eseguendo il seguente comando in un'altra console SSH:

watch -n 0.5 df -h

Qui si vedrà come lo spazio libero sul disco montato si riduce, assicurando che il download procede e che i dati vengono salvati. Lo stato si aggiorna ogni mezzo secondo. Per interrompere manualmente la visualizzazione, premere la scorciatoia Ctrl + C.

In alternativa, è possibile installare btop e monitorare il processo utilizzando questa utility:

sudo apt -y install btop && btop

Per uscire dall'utilità btop, premere il tasto Esc e selezionare Quit.

Passo 3. Eseguire il modello

Aprire la directory:

cd /mnt/fastdisk

Scaricare il repository di Llama 3:

git clone https://github.com/meta-llama/llama3

Cambiare la directory:

cd llama3

Eseguire l'esempio:

torchrun --nproc_per_node 1 example_text_completion.py \
--ckpt_dir /mnt/fastdisk/Meta-Llama-3-8B/original \
--tokenizer_path /mnt/fastdisk/Meta-Llama-3-8B/original/tokenizer.model \
--max_seq_len 128 \
--max_batch_size 4

Ora è possibile utilizzare Llama 3 nelle proprie applicazioni.

Vedi anche:

StarCoder: il vostro assistente di codifica locale

Fri, 17 Jan 2025 14:52:58 +0100

Microsoft CoPilot ha portato una rivoluzione nel campo dello sviluppo software. Questo assistente AI aiuta notevolmente gli sviluppatori a svolgere diverse attività di codifica, semplificando loro la vita. Tuttavia, uno svantaggio è che non si tratta di un'applicazione autonoma, ma di un servizio basato sul cloud. Ciò significa che gli utenti devono accettare i termini e le condizioni del servizio e pagare un abbonamento.

Fortunatamente, il mondo del software open-source offre numerose alternative. Al momento della stesura di questo articolo, la più importante alternativa a CoPilot è StarCoder, sviluppato dal progetto BigCode. StarCoder è un modello di rete neurale esteso con 15,5 miliardi di parametri, addestrato su oltre 80 linguaggi di programmazione.

Questo modello è distribuito su Hugging Face (HF) utilizzando un modello gated sotto l'accordo di licenza BigCode OpenRAIL-M v1. È possibile scaricare e utilizzare questo modello gratuitamente, ma è necessario disporre di un account HF con una chiave SSH collegata. Prima di poterlo scaricare, è necessario eseguire alcuni passaggi aggiuntivi.

Aggiungere la chiave SSH a HF

Prima di iniziare, è necessario impostare il port forwarding (porta remota 7860 a 127.0.0.1:7860) nel proprio client SSH. Ulteriori informazioni sono disponibili nei seguenti articoli:

Aggiornare il repository della cache dei pacchetti e i pacchetti installati:

sudo apt update && sudo apt -y upgrade

Installiamo il gestore dei pacchetti di sistema di Python (PIP):

sudo apt install python3-pip

Generare e aggiungere una chiave SSH da utilizzare in Hugging Face:

cd ~/.ssh && ssh-keygen

Quando la coppia di chiavi è stata generata, è possibile visualizzare la chiave pubblica nell'emulatore di terminale:

cat id_rsa.pub

Copiare tutte le informazioni che iniziano con ssh-rsa e terminano con usergpu@gpuserver come mostrato nella seguente schermata:

Compilare Key name e incollare la SSH Public key copiata dal terminale. Salvare la chiave premendo Add key:

cd ~/

Scaricare ed eseguire lo script di shell. Questo script installa un nuovo repository di terze parti con git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Ora è possibile installarlo utilizzando il gestore di pacchetti standard:

sudo apt-get install git-lfs

Configuriamo git per usare il nostro nickname HF:

git config --global user.name "John"

E collegato all'account di posta elettronica HF:

git config --global user.email "john.doe@example.com"

Scarica il modello

Si noti che StarCoder in formato binario può occupare una quantità significativa di spazio su disco (>75 GB). Non dimenticate di fare riferimento a questo articolo per assicurarvi di utilizzare la partizione montata correttamente.

Tutto è pronto per il download del modello. Aprire la directory di destinazione:

cd /mnt/fastdisk

E avviare il download del repository:

git clone git@hf.co:bigcode/starcoder

Questo processo richiede fino a 15 minuti. Si prega di essere pazienti. È possibile monitorare il processo eseguendo il seguente comando in un'altra console SSH:

watch -n 0.5 df -h

Eseguire il modello completo con la WebUI

Clonare il repository del progetto:

git clone https://github.com/oobabooga/text-generation-webui.git

Aprire la cartella scaricata:

cd text-generation-webui

Eseguire lo script di avvio:

./start_linux.sh --model-dir /mnt/fastdisk

Lo script verificherà la presenza delle dipendenze necessarie sul server. Le dipendenze mancanti saranno installate automaticamente. All'avvio dell'applicazione, aprire il browser Web e digitare il seguente indirizzo:

http://127.0.0.1:7860

Aprire la scheda Model e selezionare il modello scaricato starcoder dall'elenco a discesa. Fare clic sull'elenco Model loader e scegliere Transformers. Impostare il cursore della memoria massima della GPU per ogni GPU installata. Questo è molto importante, poiché impostandolo a 0 si limita l'uso della VRAM e si impedisce il corretto caricamento del modello. È inoltre necessario impostare l'utilizzo massimo della RAM. A questo punto, fare clic sul pulsante Load e attendere il completamento del processo di caricamento:

Passare alla scheda Chat e testare la conversazione con il modello. Si noti che Starcoder non è destinato a dialoghi come ChatGPT. Tuttavia, può essere utile per verificare la presenza di errori nel codice e suggerire soluzioni.

Se volete ottenere un modello di dialogo completo, potete provare altri due modelli: starchat-alpha e starchat-beta. Questi modelli sono stati messi a punto per condurre un dialogo proprio come fa ChatGPT. I comandi seguenti aiutano a scaricare ed eseguire questi modelli:

Per starchat-alpha:

git clone git@hf.co:HuggingFaceH4/starchat-alpha

Per starchat-beta:

git clone git@hf.co:HuggingFaceH4/starchat-beta

La procedura di caricamento è la stessa descritta sopra. Inoltre, è possibile trovare l'implementazione C++ di starcoder, che sarà efficace per l'inferenza della CPU.

Vedere anche:

Modelli di Stable Diffusion: personalizzazione e opzioni

Mon, 25 Nov 2024 13:30:16 +0100

La messa a punto è un modo eccellente per migliorare ogni auto o gadget. Anche le reti neurali generative possono essere messe a punto. Oggi non vogliamo approfondire la struttura della Diffusione Stabile, ma ci proponiamo di ottenere risultati migliori rispetto a una configurazione standard.

Ci sono due modi semplici per farlo: installare modelli personalizzati e utilizzare le opzioni di ottimizzazione standard. In questo articolo scopriremo come installare nuovi modelli in Stable Diffusion e quali opzioni ci permettono di utilizzare l'hardware in modo più efficace.

Se si vogliono condividere immagini divertenti di gatti carini o di cibo dall'aspetto fantastico, di solito le si pubblica su Instagram. Se si sviluppano applicazioni e si vuole rendere il codice disponibile a tutti, lo si pubblica su GitHub. Ma se addestrate un modello grafico di intelligenza artificiale e volete condividerlo, dovreste prestare attenzione a CivitAI. Si tratta di un'enorme piattaforma per condividere conoscenze e risultati con i membri della comunità.

Prima di iniziare il download, è necessario cambiare la directory di lavoro. Tutti i modelli di intelligenza artificiale in Stable Diffusion sono collocati nella directory "models": prima di iniziare il download, è necessario cambiare la directory di lavoro. Tutti i modelli di intelligenza artificiale in Stable Diffusion si trovano nella directory "models":

cd stable-diffusion-webui/models/Stable-diffusion

Verifichiamo quali sono i modelli forniti di default:

ls -a

'Put Stable Diffusion checkpoints here.txt'
v1-5-pruned-emaonly.safetensors

C'è solo un modello con il nome "v1-5-pruned-emaonly" e l'estensione "safetensors". Questo modello è un buon punto di partenza, ma ci sono altri cinque modelli interessanti. Scarichiamoli e confrontiamoli con il modello standard.

Modelli a diffusione stabile

Per mostrare visivamente la differenza tra i due modelli, abbiamo creato dei semplici prompt:

princess, magic, fairy tales, portrait, 85mm, colorful

Per molti modelli, la rappresentazione accurata della geometria e dei tratti del viso può rappresentare una sfida significativa. Per ovviare a questo problema, si possono aggiungere suggerimenti negativi per garantire la generazione di immagini prive di queste caratteristiche:

poorly rendered face, poorly drawn face, poor facial details, poorly drawn hands, poorly rendered hands, low resolution, bad composition, mutated body parts, blurry image, disfigured, oversaturated, bad anatomy, deformed body features

Impostare il valore massimo dei passi di campionamento (150) per ottenere maggiori dettagli nel risultato.

Modello standard

Il modello standard si comporta bene in questi compiti. Tuttavia, alcuni dettagli non sono del tutto accurati. Ad esempio, c'è un problema con gli occhi: sono chiaramente sproporzionati:

Anche il diadema è storto e asimmetrico. Il resto dei dettagli è ben eseguito e corrisponde alle indicazioni fornite. Lo sfondo è sfocato perché abbiamo impostato la richiesta "85 mm". Questa è una lunghezza focale molto usata per i ritratti nella fotografia professionale.

Visione realistica

Questo modello è ottimo per i ritratti. L'immagine appare come se fosse stata scattata con un obiettivo di qualità con la lunghezza focale specificata. Le proporzioni del viso e del corpo sono precise, l'abito si adatta perfettamente e il diadema sulla testa ha un aspetto esteticamente gradevole:

A proposito, l'autore raccomanda di utilizzare il seguente modello per i suggerimenti negativi:

deformed iris, deformed pupils, semi-realistic, cgi, 3d, render, sketch, cartoon, drawing, anime:1.4), text, close up, cropped, out of frame, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck

Ma anche con i nostri suggerimenti piuttosto semplici, il risultato è eccellente.

Scaricate il modello qui: Visione realistica

Deliberato

Un altro modello sorprendente per questi scopi. Anche qui i dettagli sono ben elaborati, ma fate attenzione e controllate il numero di dita. Questo è un problema molto comune con le reti neurali: spesso possono disegnare dita in più o addirittura interi arti.

La creazione di linee visive è una delle tecniche cinematografiche preferite. Così, anche questo modello ha scelto di disegnare una persona sullo sfondo di un sentiero boschivo.

Scaricate il modello qui: Deliberato

Viaggio aperto

Tra le reti neurali generative, Midjourney (MJ) ha ricevuto particolare attenzione. MJ è stato un pioniere in questo campo e viene spesso additato come esempio per gli altri. Le immagini che crea hanno uno stile unico. OpenJourney si ispira allo stile di MJ ed è una Diffusione Stabile opportunamente ottimizzata.

Genera immagini che sembrano un cartone animato. Sono vibranti e luminose. Per ottenere risultati migliori, aggiungete il prompt dello stile mdjrny-v4.

Scaricate il modello qui: OpenJourney

Qualsiasi cosa

Questo modello crea immagini simili a quelle di un artista manga professionista (una persona che disegna fumetti). Così, abbiamo una principessa in stile anime.

Questo modello viene addestrato su immagini con una risoluzione di 768x768. È possibile impostare questa risoluzione per ottenere risultati migliori rispetto allo standard 512x512.

Scaricate il modello qui: Qualsiasi cosa

Azienda Memphis

Questo stile di immagini ha acquisito una popolarità selvaggia nei primi anni 2020 ed è stato ampiamente utilizzato come stile aziendale in diverse aziende high-tech. Nonostante le critiche, si trova spesso nelle presentazioni e nei siti web.

La principessa si è rivelata minimalista, ma piuttosto bella. Particolarmente divertenti sono stati i dettagli che la modella ha inserito sullo sfondo.

Scaricate il modello qui: Memphis aziendale

Opzioni di diffusione stabili

La diffusione stabile consuma molte risorse, per cui sono state sviluppate molte opzioni. La più popolare è --xformers. Questa opzione abilita due meccanismi di ottimizzazione. Il primo riduce il consumo di memoria e il secondo viene utilizzato per aumentare la velocità.

Se si prova ad aggiungere --xformers senza ulteriori passaggi, si otterrà un errore che dice che i pacchetti(torch e torchvision) sono compilati per versioni diverse di CUDA®. Per risolvere questo problema, è necessario entrare nell'ambiente virtuale Python (venv) utilizzato per Stable Diffusion. Successivamente, installare i pacchetti per la versione di CUDA® desiderata (v1.18).

Per prima cosa dobbiamo aggiornare la cache dei pacchetti apt e installare il programma di installazione dei pacchetti per Python (pip). Il passo successivo è attivare Python venv con lo script activate:

source stable-diffusion-webui/venv/bin/activate

Dopo di ciò, il prompt della riga di comando cambia in (venv) username@hostname:~$ Installiamo i pacchetti torch e torchvision con CUDA® 11.8:

pip install torch==2.0.0+cu118 torchvision==0.15.1+cu118 --index-url https://download.pytorch.org/whl/cu118

Questo processo potrebbe richiedere diversi minuti perché i pacchetti sono piuttosto grandi. Avrete giusto il tempo di versarvi un caffè. Infine, è possibile disattivare l'ambiente virtuale e avviare Stable Diffusion con l'opzione --xformers (sostituire [user] e [password] con i propri valori):

deactivate

./webui --xformers --listen --gradio-auth [user]:[password]

L'alternativa più veloce a --xformers è --opt-sdp-no-mem-attention, che consuma più memoria ma funziona un po' più velocemente. È possibile utilizzare questa opzione senza ulteriori passaggi.

Conclusione

Oggi abbiamo esaminato le capacità di Stable Diffusion in combinazione con altri modelli aggiunti e opzioni di ottimizzazione. Ricordiamo che aumentando o diminuendo il numero di passaggi di campionamento, è possibile regolare il livello di dettaglio dell'immagine finale.

Naturalmente, questa è solo una piccola parte di ciò che si può fare con una rete neurale generativa di questo tipo. Quindi ordinate subito un server GPU e iniziate a sperimentare. Molte altre scoperte e opportunità vi attendono. Le schede video potenti e ad alta velocità vi aiuteranno a risparmiare tempo e a generare immagini fantastiche.

Vedi anche:

Stable Diffusion WebUI

Mon, 25 Nov 2024 13:24:45 +0100

Le reti neurali generative sembrano magiche. Rispondono a domande, creano immagini e scrivono persino codice in vari linguaggi di programmazione. Il successo di queste reti è dovuto a due componenti: modelli pre-addestrati e acceleratori hardware. Certo, è possibile utilizzare i core della CPU per questo carico di lavoro, ma sarebbe come una corsa di lumache. La generazione di una piccola immagine può richiedere una quantità di tempo significativa, decine di minuti. La generazione della stessa immagine su una GPU richiederebbe centinaia di volte meno.

Il primo segreto sta nel numero di core. I core delle CPU sono universali e possono gestire istruzioni complesse. Tuttavia, i processori dei server tradizionali hanno un massimo di 64 core. Persino nei sistemi multiprocessore, il numero di core raramente supera i 256. I core delle GPU sono più semplici, ma di conseguenza se ne possono inserire molti di più nel chip. Ad esempio, una NVIDIA® RTX™ 4090 ha 16.384 core.

Il secondo segreto è che il carico di lavoro può essere suddiviso in molti compiti semplici, che possono essere eseguiti in thread paralleli su core GPU dedicati. Questo trucco accelera notevolmente l'elaborazione dei dati. Oggi vedremo come funziona e distribuiremo una rete neurale generativa Stable Diffusion Web UI sull'infrastruttura LeaderGPU. Prendiamo ad esempio un server con una NVIDIA® RTX™ 4090 che ha 16.384 core GPU. Come sistema operativo, abbiamo scelto l"attuale versione LTS di Ubuntu 22.04 e abbiamo scelto l'opzione "Installa i driver NVIDIA® e CUDA® 11.8".

Preparazione del sistema

Prima di iniziare, consideriamo la memoria. Stable Diffusion è un sistema di grandi dimensioni che può occupare fino a 13G sul disco rigido. Il disco virtuale standard in un'installazione di LeaderGPU è di 100G. Il sistema operativo occupa 25G. Se distribuiamo Stable Diffusion senza estendere la partizione home, esauriremo tutta la memoria libera e incontreremo l'errore "No space left on device". È una buona idea estendere la nostra directory home.

Estendere la directory home

Per prima cosa, dobbiamo controllare tutti i dischi disponibili.

sudo fdisk -l

Disk /dev/sda: 447.13 GiB, 480103981056 bytes, 937703088 sectors
Disk model: INTEL SSDSC2KB48
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes

Disk /dev/sdb: 50 GiB, 53687091200 bytes, 104857600 sectors
Disk model: VIRTUAL-DISK
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 9D4C1F0C-D4A7-406E-AECB-BF57E4726437

Poi dobbiamo creare una nuova partizione Linux sul nostro disco SSD fisico, /dev/sda:

sudo fdisk /dev/sda

Premete i seguenti tasti, uno alla volta: g → n → Enter → Enter → Enter → w. Si otterrà così una nuova partizione /dev/sda1 senza filesystem. A questo punto, creare un filesystem ext4 su di essa:

sudo mkfs.ext4 /dev/sda1

Quando il processo è terminato, si passa al passo successivo.

Attenzione! Procedere con la massima cautela. Qualsiasi errore commesso durante la modifica del file fstab può comportare l'impossibilità di avviare normalmente il server e può richiedere il ripristino completo del sistema operativo.

sudo blkid

/dev/sdb2: UUID="6b17e542-0934-4dba-99ca-a00bd260c247" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="70030755-75d8-4339-a4e0-26a97f1d1c5d"
/dev/loop1: TYPE="squashfs"
/dev/sdb1: PARTUUID="63ff1714-bd29-4062-be04-21af32423c0a"
/dev/loop4: TYPE="squashfs"
/dev/loop0: TYPE="squashfs"
/dev/sda1: UUID="fb2ba455-2b8d-4da0-8719-ce327d0026bc" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="6e0108df-b000-5848-8328-b187daf37a4f"
/dev/loop5: TYPE="squashfs"
/dev/loop3: TYPE="squashfs"

Copiare UUID (fb2ba455-2b8d-4da0-8719-ce327d0026bc nell'esempio) della partizione /dev/sda1. Successivamente, si indicherà al sistema di montare automaticamente questa unità con il suo UUID all'avvio:

sudo nano /etc/fstab

Inserire questa riga prima di /swap.img... stringa:

/dev/disk/by-uuid/ /home/usergpu ext4 defaults defaults

Esempio:

# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
#                
# / was on /dev/sdb2 during curtin installation
/dev/disk/by-uuid/6b17e542-0934-4dba-99ca-a00bd260c247 / ext4 defaults,_netdev 0 1
/dev/disk/by-uuid/fb2ba455-2b8d-4da0-8719-ce327d0026bc /home/usergpu ext4 defaults defaults
/swap.img       none    swap    sw      0       0

Uscire con la scorciatoia da tastiera Ctrl + X e confermare il salvataggio del file premendo Enter. Le nuove impostazioni saranno applicate al successivo avvio del sistema. Riavviamo il server:

sudo shutdown -r now

Dopo il riavvio, possiamo controllare tutte le directory montate con il seguente comando:

df -h

Filesystem      Size  Used Avail Use% Mounted on
tmpfs           6.3G  1.7M  6.3G   1% /run
/dev/sdb2        49G   23G   24G  50% /
tmpfs            32G     0   32G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
/dev/sda1       440G   28K  417G   1% /home/usergpu
tmpfs           6.3G  4.0K  6.3G   1% /run/user/1000

Superbo! Ma ora non abbiamo accesso a scrivere qualcosa nella nostra home directory perché è stata modificata dal file di configurazione fstab. È ora di recuperare la proprietà della directory:

sudo chown -R usergpu /home/usergpu

Ottimo lavoro! Passiamo al passo successivo.

Installare i pacchetti di base

Aggiornate la cache del software dai repository ufficiali di Ubuntu e aggiornate alcuni pacchetti:

sudo apt update && sudo apt -y upgrade

Il sistema ha informato che è stato installato un nuovo kernel che sarà operativo dopo il riavvio del sistema. Selezionate due volte OK.

Successivamente, è necessario risolvere le dipendenze, che richiedono una diffusione stabile. Il primo pacchetto aggiunge la funzionalità di ambiente virtuale Python:

sudo apt install python3-venv

Il secondo pacchetto aggiunge un'implementazione della funzione malloc() del linguaggio di programmazione C, personalizzata da Google. Previene l'errore “Cannot locate TCMalloc” e migliora l'utilizzo della memoria della CPU.

sudo apt install -y --no-install-recommends google-perftools

Infine, riavviare nuovamente il server:

sudo shutdown -r now

Diffusione stabile automatica 1111: installare lo script

Il modo più semplice per installare Stable Diffusion con WebUI è utilizzare lo script preconfezionato scritto dall'utente GitHub AUTOMATIC1111. Questo script scarica e configura queste due parti e risolve tutte le dipendenze necessarie.

Scarichiamo lo script:

wget https://raw.githubusercontent.com/AUTOMATIC1111/stable-diffusion-webui/master/webui.sh

Quindi, diamogli accesso ai dati di modifica ed eseguiamolo come programma:

chmod a+x webui.sh

Eseguire lo script scaricato:

./webui.sh

Questo processo può richiedere un paio di minuti. Tutto è pronto per creare immagini perfette con Stable Diffusion.

Risoluzione dei problemi

Se si verifica l'errore "Torch non è in grado di utilizzare la GPU", è possibile risolvere il problema reinstallando il programma tramite apt:

sudo apt -y install nvidia-driver-535

È necessario riavviare il sistema operativo per abilitare il driver:

sudo shutdown -r now

Generare

Lo script di installazione ./webui.sh ha un'altra funzione. Serve contemporaneamente la parte server di Stable Diffusion e la WebUI. Tuttavia, se lo si usa senza argomenti, il server sarà disponibile come demone locale all'indirizzo http://127.0.0.1:7860. Questo problema può essere risolto in due modi: con un port forwarding attraverso un tunnel SSH o consentendo connessioni da IP esterni.

Il secondo modo è più semplice: basta aggiungere l'opzione --listen e ci si può connettere all'interfaccia web all'indirizzo http://[YOUR_LEADERGPU_SERVER_IP_ADDRESS]:7860. Tuttavia, questo è completamente insicuro, poiché ogni utente di Internet avrà accesso. Per evitare un uso non autorizzato, aggiungere l'opzione --gradio-auth accanto al nome utente e alla password, separati da due punti:

./webui.sh --listen --gradio-auth user:password

Lo script scaricherà per la prima Volta™ i modelli di base e le dipendenze necessarie:

Potete godervi il risultato. È sufficiente inserire alcune richieste, separate da virgole, e fare clic sul pulsante Genera. Dopo qualche secondo, verrà visualizzata un'immagine generata dalla rete neurale.

Conclusione

Siamo passati da un server LeaderGPU vuoto con solo un sistema operativo preinstallato a un'istanza pronta con Stable Diffusion e un'interfaccia WebUI. La prossima Volta™ impareremo di più sulla regolazione delle prestazioni del software e su come potenziare correttamente la vostra istanza Stable Diffusion con nuove versioni di driver e pacchetti.

Vedi anche: