Configura un LLM locale su CPU con interfaccia utente di chat in 15 minuti | di Kasper Groes Albin Ludvigsen | Febbraio 2024 | Intelligenza-Artificiale

Questo post del blog mostra come eseguire facilmente un LLM localmente e come configurare una GUI simile a ChatGPT in 4 semplici passaggi.

Grazie alla comunità open source globale, ora è più semplice che mai eseguire modelli LLM (Large Language Model) performanti su laptop consumer o server basati su CPU e interagire facilmente con essi tramite interfacce utente grafiche ben progettate.

Ciò è particolarmente utile per tutte le organizzazioni a cui non è consentito o non è disposto a utilizzare servizi che richiedono l’invio di dati a terzi.

Questo tutorial mostra come configurare un LLM locale con un’interfaccia utente simile a ChatGPT in quattro semplici passaggi. Se è installato il software prerequisito, non saranno necessari più di 15 minuti di lavoro (escluso il tempo di elaborazione del computer utilizzato in alcuni passaggi).

Questo tutorial presuppone che sul tuo computer sia installato quanto segue:

Essere
Docker
Reagire
Python e pacchetti comuni inclusi i trasformatori

Adesso andiamo.

Il primo passo è decidere quale LLM desideri eseguire localmente. Forse hai già un’idea. Altrimenti, per l’inglese, the istruire la versione di Mistral 7b sembra essere la scelta giusta. Per il danese, consiglio Munin-NeuralBeagle anche se è noto per generare token in eccesso (forse perché è una fusione di un modello che non è stato messo a punto dalle istruzioni). Per le altre lingue scandinave, cfr ScandEval valutazione dei modelli generativi scandinavi.

Il passo successivo è quantizzare il modello scelto a meno che tu non abbia selezionato un modello già quantizzato. Se il nome del tuo modello termina con GGUF o GPTQ La quantizzazione è una tecnica che converte i pesi di un modello (i suoi parametri appresi) in un tipo di dati più piccolo dell’originale, ad esempio da fp16 a int4. Ciò fa sì che il modello occupi meno memoria e rende anche più veloce l’esecuzione dell’inferenza, che è una caratteristica interessante se si utilizza la CPU.

Il copione quantize.pynel mio repository local_llm è adattato da Il fantastico taccuino Colab di Maxime Labonne (vedi il suo Corso LLM per altre fantastiche risorse LLM). Puoi usare il suo taccuino o la mia sceneggiatura. Il metodo è stato testato su modelli Mistral e simili.

Per quantizzare, prima clona il mio repository:

git clone https://github.com/KasperGroesLudvigsen/local_llm.git

Adesso cambia ilMODEL_IDvariabile nel quantize.py file per riflettere il modello scelto.

Quindi, nel tuo terminale, esegui lo script:

python quantize.py

Ci vorrà del tempo. Mentre il processo di quantizzazione è in esecuzione, puoi procedere al passaggio successivo.

Eseguiremo il modello con Essere. Ollama è un framework software che racchiude perfettamente un modello in un’API. Ollama si integra facilmente anche con vari front-end, come vedremo nel passaggio successivo.

Per creare un’immagine Ollama del modello, è necessario un cosiddetto file modello che è un file di testo semplice che configura l’immagine Ollama. Se conosci Dockerfiles, i file modello di Ollama ti sembreranno familiari.

Nell’esempio seguente specifichiamo innanzitutto quale LLM utilizzare. Supponiamo che nel repository sia presente una cartella chiamata mistral7b e che la cartella contenga un modello chiamato quantized.gguf. Quindi specifichiamo la finestra di contesto del modello su 8.000 – dimensione massima del contesto di Mistral 7b. Nel Modelfile è inoltre possibile specificare quale modello di prompt utilizzare e i token di arresto.

Salvare il file del modello, ad esempio come Modelfile.txt.

Per ulteriori opzioni di configurazione, vedere GitHub di Ollama.

FROM ./mistral7b/quantized.ggufPARAMETER num_ctx 8000
TEMPLATE """<|im_start|>system {{ .System }}<|im_end|><|im_start|>user {{ .Prompt }}<|im_end|><|im_start|>assistant<|im_end|>"""
PARAMETER stop <|im_end|>
PARAMETER stop <|im_start|>user
PARAMETER stop <|end|>

Ora che hai creato il Modelfile, crea un’immagine Ollama dal Modelfile eseguendolo dal tuo terminale. Anche questa operazione richiederà alcuni istanti:

ollama create choose-a-model-name -f <location of the file e.g. ./Modelfile>'

Al termine del processo di “creazione”, avvia il server Ollama eseguendo questo comando. Ciò esporrà tutti i tuoi modelli Ollama in modo che la GUI possa interagire con essi.

ollama serve

Il passaggio successivo è impostare una GUI per interagire con LLM. Esistono diverse opzioni per questo. In questo tutorial utilizzeremo “Chatbot Ollama”, una GUI molto ordinata che ha un aspetto ChatGPT. “Ollama WebUI” è un’opzione simile. Puoi anche impostare la tua chat GUI con Streamlit.

Eseguendo i due comandi seguenti, clonerai prima il repository GitHub di Chatbot Ollama e quindi installerai le dipendenze React:

git clone https://github.com/ivanfioravanti/chatbot-ollama.git
npm ci

Il passaggio successivo è creare un’immagine Docker dal Dockerfile. Se utilizzi Linux, devi modificare la variabile di ambiente OLLAMA_HOST nel Dockerfile da hhtp://host.docker.internal:11434A http://localhost:11434 .

Ora crea l’immagine Docker ed esegui un contenitore da essa eseguendo questi comandi da un terminale. È necessario restare alla radice del progetto.

docker build -t chatbot-ollama .docker run -p 3000:3000 chatbot-ollama

La GUI è ora in esecuzione all’interno di un contenitore Docker sul tuo computer locale. Nel terminale vedrai l’indirizzo a cui è disponibile la GUI (ad esempio “http://localhost:3000”)

Visita quell’indirizzo nel tuo browser e ora dovresti essere in grado di chattare con LLM tramite l’interfaccia utente di Ollama Chat.

Con questo si conclude questo breve tutorial su come configurare facilmente l’interfaccia utente della chat che ti consente di interagire con un LLM in esecuzione sul tuo computer locale. Facile, vero? Erano necessari solo quattro passaggi: