LeaderGPU® | GPU-oplossingen voor high-performance computing

Qwen3-Coder: een gebroken paradigma

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

We zijn gewend te denken dat open-source modellen qua kwaliteit altijd achterblijven bij hun commerciële tegenhangers. Het lijkt misschien alsof ze uitsluitend worden ontwikkeld door enthousiastelingen die het zich niet kunnen veroorloven om enorme bedragen te investeren in het maken van datasets van hoge kwaliteit en het trainen van modellen op tienduizenden moderne GPU's.

Het is een ander verhaal wanneer grote bedrijven zoals OpenAI, Anthropic of Meta de taak op zich nemen. Zij hebben niet alleen de middelen, maar ook 's werelds beste neurale netwerkspecialisten. Helaas zijn de modellen die ze maken, vooral de laatste versies, closed-source. Ontwikkelaars verklaren dit door te wijzen op de risico's van ongecontroleerd gebruik en de noodzaak om de veiligheid van AI te waarborgen.

Aan de ene kant is hun redenering begrijpelijk: veel ethische vragen zijn nog niet opgelost en de aard van neurale netwerkmodellen laat alleen indirecte invloed toe op de uiteindelijke output. Aan de andere kant is het gesloten houden van modellen en alleen toegang bieden via hun eigen API ook een solide bedrijfsmodel.

Niet alle bedrijven gedragen zich echter zo. Het Franse bedrijf Mistral AI biedt bijvoorbeeld zowel commerciële als open-source modellen aan, zodat onderzoekers en enthousiastelingen ze kunnen gebruiken in hun projecten. Maar er moet speciale aandacht worden besteed aan de prestaties van Chinese bedrijven, waarvan de meeste open-gewicht en open-source modellen bouwen die serieus kunnen concurreren met propriëtaire oplossingen.

DeepSeek, Qwen3 en Kimi K2

De eerste grote doorbraak kwam met DeepSeek-V3. Dit multimodale taalmodel van DeepSeek AI werd ontwikkeld met behulp van de Mixture of Experts (MoE) benadering en indrukwekkende 671B parameters, met 37B meest relevante parameters geactiveerd voor elk token. Het belangrijkste is dat alle componenten (modelgewichten, inferentiecode en trainingspijplijnen) openbaar zijn gemaakt.

Dit maakte het meteen een van de meest aantrekkelijke LLM's voor ontwikkelaars van AI-toepassingen en onderzoekers. De volgende headline-grabber was DeepSeek-R1 - het eerste open-source redeneringsmodel. Op de dag van de release deed het de Amerikaanse aandelenmarkt schudden nadat de ontwikkelaars beweerden dat het trainen van zo'n geavanceerd model slechts $6 miljoen had gekost.

Hoewel de hype rond DeepSeek uiteindelijk afkoelde, waren de volgende releases niet minder belangrijk voor de wereldwijde AI-industrie. We hebben het natuurlijk over Qwen 3. We hebben de functies in detail besproken in onze Nieuw in Qwen 3 review, dus we zullen er hier niet verder op ingaan. Kort daarna verscheen er een andere speler: Kimi K2 van Moonshot AI.

Met zijn MoE architectuur, 1T parameters (32B geactiveerd per token) en open-source code trok Kimi K2 al snel de aandacht van de gemeenschap. Moonshot AI richtte zich niet zozeer op redeneren, maar streefde naar state-of-the-art prestaties op het gebied van wiskunde, programmeren en diepgaande interdisciplinaire kennis.

De troef van Kimi K2 was de optimalisatie voor integratie in AI-agenten. Dit netwerk is letterlijk ontworpen om optimaal gebruik te maken van alle beschikbare hulpmiddelen. Het blinkt uit in taken die niet alleen het schrijven van code vereisen, maar ook iteratief testen in elke ontwikkelingsfase. Het heeft echter ook zwakke punten, die we later zullen bespreken.

Kimi K2 is in alle opzichten een groot taalmodel. Voor het uitvoeren van de volledige versie is ~2 TB VRAM nodig (FP8: ~1 TB). Om voor de hand liggende redenen is dit niet iets wat je thuis kunt doen, en zelfs veel GPU-servers kunnen dit niet aan. Het model heeft ten minste 8 NVIDIA® H200 versnellers nodig. Gekwantiseerde versies kunnen helpen, maar ten koste van de nauwkeurigheid.

Qwen3-coder

Toen Alibaba het succes van Moonshot AI zag, ontwikkelde het zijn eigen Kimi K2-achtige model, maar met belangrijke voordelen die we binnenkort zullen bespreken. Aanvankelijk werd het in twee versies uitgebracht:

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

Een paar dagen later verschenen er kleinere modellen zonder het redeneermechanisme, die veel minder VRAM nodig hadden:

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

Qwen3-Coder is ontworpen voor integratie met ontwikkeltools. Het bevat een speciale parser voor functie-aanroepen (qwen3coder_tool_parser.py, analoog aan OpenAI's functie-aanroepen). Naast het model werd een console-hulpprogramma uitgebracht, dat in staat is om te proeven van codecompilatie tot het opvragen van een kennisbank. Dit idee is niet nieuw, in wezen is het een sterk herwerkte uitbreiding van Anthropic's Gemini code app.

Het model is compatibel met de OpenAI API, waardoor het lokaal of op een externe server kan worden ingezet en kan worden verbonden met de meeste systemen die deze API ondersteunen. Dit omvat zowel kant-en-klare client apps als machine learning bibliotheken. Dit maakt het niet alleen levensvatbaar voor het B2C-segment maar ook voor het B2B-segment en biedt een naadloze drop-in vervanging voor het product van OpenAI zonder wijzigingen in de applicatielogica.

Een van de meest gevraagde functies is de uitgebreide contextlengte. Standaard ondersteunt het 256k tokens, maar het kan worden uitgebreid tot 1M met behulp van het YaRN (Yet another RoPe extensioN) mechanisme. Moderne LLM's worden meestal getraind op korte datasets (2k-8k tokens) en grote contextlengtes kunnen ervoor zorgen dat ze eerdere inhoud uit het oog verliezen.

YaRN is een elegante "truc" die het model laat denken dat het werkt met de gebruikelijke korte reeksen, terwijl het in werkelijkheid veel langere reeksen verwerkt. Het sleutelidee is om de positionele ruimte "uit te rekken" of te "verwijden" met behoud van de wiskundige structuur die het model verwacht. Dit maakt effectieve verwerking van reeksen van tienduizenden tokens mogelijk zonder hertraining of extra geheugen dat nodig is bij traditionele methoden voor contextuitbreiding.

Inference downloaden en uitvoeren

Zorg ervoor dat je CUDA® van tevoren hebt geïnstalleerd, met behulp van de officiële instructies van NVIDIA® of de gids CUDA-toolkit installeren in Linux. Controleer of de benodigde compiler aanwezig is:

nvcc --version

Verwachte uitvoer:

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

Als je krijgt:

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

moet je de CUDA® binaries toevoegen aan $PATH van je systeem.

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

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

Dit is een tijdelijke oplossing. Bewerk voor permanent ~/.bashrc en voeg dezelfde twee regels toe aan het einde.

Bereid nu je systeem voor op het beheren van virtuele omgevingen. Je kunt Python's ingebouwde venv gebruiken of het meer geavanceerde Miniforge. Ervan uitgaande dat Miniforge is geïnstalleerd:

conda create -n venv python=3.10

conda activate venv

Installeer PyTorch met CUDA® ondersteuning die bij je systeem past:

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

Installeer vervolgens de essentiële bibliotheken:

Transformers - De belangrijkste modelbibliotheek van Hugging Face
Accelerate - maakt multi-GPU inferentie mogelijk
HuggingFace Hub - voor het downloaden/uploaden van modellen & datasets
Safetensors - veilig formaat voor modelgewicht
vLLM - aanbevolen inferentie bibliotheek voor Qwen

pip install transformers accelerate huggingface_hub safetensors vllm

Download het model:

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

Inferentie uitvoeren met tensorparallellisme (laag tensors verdelen over GPU's, bijvoorbeeld 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

Hiermee wordt de vLLM OpenAI API Server gestart.

Testen en integratie

cURL

Installeer jq voor het mooi afdrukken van JSON:

sudo apt -y install jq

Test de 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

Om te integreren met Visual Studio Code, installeer de Continue extensie en voeg toe aan 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

Voor een GUI gebaseerde setup met Qwen-Agent (inclusief RAG, MCP en code interpreter):

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

Open de nano editor:

nano script.py

Voorbeeld Python script om Qwen-Agent te starten met een Gradio WebUI:

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()

Voer het script uit:

python script.py

De server zal beschikbaar zijn op: http://127.0.0.1:7860

Je kunt Qwen3-Coder ook integreren in agent frameworks zoals CrewAI voor het automatiseren van complexe taken met toolsets zoals web search of vector database memory.

Zie ook:

CrewAI installeren met GUI

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

De mogelijkheden van neurale netwerkmodellen groeien met de dag. Onderzoekers en commerciële bedrijven investeren steeds meer in het trainen ervan. Maar op zichzelf kunnen deze modellen niet autonoom handelen. Om specifieke taken op te lossen, hebben ze begeleiding nodig: contextuitbreiding en richtingbepaling. Deze aanpak is niet altijd efficiënt, vooral niet voor complexe problemen.

Maar wat als we een neuraal netwerk autonoom zouden laten handelen? En wat als we het veel tools zouden geven om te interageren met de buitenwereld? Dan zou je een AI-agent krijgen die taken kan oplossen door zelfstandig te bepalen welke hulpmiddelen hij moet gebruiken. Klinkt ingewikkeld, maar het werkt heel goed. Maar zelfs voor een gevorderde gebruiker kan het creëren van een AI-agent vanaf nul een niet-triviale taak zijn.

De reden hiervoor is dat de meeste populaire bibliotheken geen grafische gebruikersinterface hebben. Ze vereisen interactie via een programmeertaal zoals Python. Dit verhoogt de instapdrempel drastisch en maakt AI-agenten te complex voor onafhankelijke implementatie. Dit is precies het geval bij CrewAI.

Wat is CrewAI

CrewAI is een zeer populaire en handige bibliotheek, maar heeft standaard geen GUI. Dit zette onafhankelijke ontwikkelaars aan om een onofficiële interface te maken. De open source aard van CrewAI maakte de taak veel gemakkelijker, en al snel bracht de gemeenschap het project CrewAI Studio uit.

Ontwikkelaars en enthousiastelingen kregen meer inzicht in de architectuur van het systeem en konden tools bouwen die op maat gemaakt waren voor specifieke taken. Gewone gebruikers konden AI-agenten maken zonder ook maar één regel code te schrijven. Het werd eenvoudiger om taken toe te wijzen en de toegang tot neurale netwerken en tools te beheren. Het werd ook mogelijk om agents te exporteren en importeren van server naar server en ze te delen met vrienden, collega's of de open source gemeenschap.

Een ander voordeel van CrewAI Studio is de flexibiliteit van de implementatie. Het kan worden geïnstalleerd als een gewone app of als een Docker-container - de voorkeursmethode omdat deze alle benodigde bibliotheken en componenten bevat om het systeem te laten draaien.

Installatie

Update je OS-pakketten en geïnstalleerde apps naar de nieuwste versies:

sudo apt update && sudo apt -y upgrade

Gebruik het script voor automatische installatie van het stuurprogramma of volg onze handleiding Installeer Nvidia-stuurprogramma's in Linux:

sudo ubuntu-drivers autoinstall

Start de server opnieuw op zodat de wijzigingen van kracht worden:

sudo shutdown - r now

Nadat u opnieuw verbinding hebt gemaakt via SSH, installeert u Apache 2 webserverhulpprogramma's, waardoor u toegang krijgt tot de .htpasswd bestandsgenerator die wordt gebruikt voor basisgebruikersauthenticatie:

sudo apt install -y apache2-utils

Installeer Docker Engine met het officiële shellscript:

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

Docker Compose toevoegen aan het systeem:

sudo apt install -y docker-compose

Kloon de repository:

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

Navigeer naar de gedownloade map:

cd CrewAI-Studio

Maak een .htpasswd bestand aan voor de usergpu gebruiker. Je wordt twee keer gevraagd om een wachtwoord in te voeren:

htpasswd -c .htpasswd usergpu

Bewerk nu het container deployment bestand. Standaard zijn er twee containers:

sudo nano docker-compose.yaml

Verwijder de sectie:

ports:
  - "5432:5432"

En voeg de volgende service toe:


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 heeft een config-bestand nodig, dus maak er een aan:

sudo nano nginx.conf

Plak het volgende erin:

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;
    }
  }
}

Alle belangrijke servicevariabelen voor CrewAI zijn gedefinieerd in het bestand .env. Open het bestand .env_example om het te bewerken:

nano .env_example

Voeg de volgende regels toe:

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

En voeg Postgres config toe:

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

Kopieer nu het voorbeeldbestand en hernoem het naar .env zodat het systeem het kan lezen tijdens het uitrollen van de container:

cp .env_example .env

In dit voorbeeld gebruiken we lokale modellen met inferentie afgehandeld door Ollama. We raden onze gids Open WebUI: Alles in één, en voeg tijdens de implementatie -e OLLAMA_HOST=0.0.0.0 toe zodat CrewAI rechtstreeks verbinding kan maken met de Ollama-container. Download het gewenste model (bijvoorbeeld llama3.2:latest) via WebUI of door verbinding te maken met de containerconsole en uit te voeren:

ollama pull llama3.2:latest

Zodra alles is ingesteld, start je de deployment:

sudo docker-compose up -d --build

Als u nu http://[your_server_ip]/ bezoekt, wordt u gevraagd in te loggen. Na correcte invoer verschijnt de CrewAI interface.

Functies

Laten we eens kijken naar de belangrijkste entiteiten die CrewAI gebruikt. Dit zal je helpen te begrijpen hoe je workflows kunt configureren. De centrale entiteit in de Agent, een autonome taakuitvoerder. Elke agent heeft attributen die hem helpen zijn taken uit te voeren:

Role. Een korte taakbeschrijving van 2-3 woorden.
Backstory. Optioneel; helpt het taalmodel te begrijpen hoe de agent zich moet gedragen en op welke ervaringen hij moet vertrouwen.
Goal. Het doel dat de agent moet nastreven.
Allow delegation. Stelt de agent in staat om taken (of delen daarvan) aan anderen te delegeren.
Verbose. Vertelt de agent om gedetailleerde acties te loggen.
LLM Provider and Model. Specificeert het model en de provider om te gebruiken.
Temperature. Bepaalt de creativiteit van het antwoord. Hoger = creatiever.
Max iterations. Aantal pogingen dat de agent moet doen om te slagen, als beveiliging (bijvoorbeeld tegen oneindige lussen).

Agenten werken door iteratief input te analyseren, te redeneren en conclusies te trekken met behulp van beschikbare hulpmiddelen.

Input wordt gedefinieerd door een Task entiteit. Elke taak bevat een beschrijving, een toegewezen agent en optioneel een verwacht resultaat. Taken worden standaard sequentieel uitgevoerd, maar kunnen worden geparallelliseerd met de vlag Async execution.

Autonoom agent werk wordt ondersteund door Tools die real-world interactie mogelijk maakt. CrewAI bevat tools voor het zoeken op het web, het parsen van sites, API-oproepen en bestandsverwerking, die de context verbeteren en agenten helpen doelen te bereiken.

Tot slot is er de Crew entity. Deze verenigt agenten met verschillende rollen in een team om complexe problemen aan te pakken. Ze kunnen met elkaar communiceren, delegeren, beoordelen en corrigeren, en vormen zo een collectieve intelligentie.

Met behulp van

Nu je bekend bent met de entiteiten, laten we een minimale CrewAI workflow bouwen en uitvoeren. In dit voorbeeld volgen we de wereldwijde voortgang in de ontwikkeling van medicijnen tegen kanker.

We gebruiken drie agenten:

Oncology Drug Pipeline Analyst - volgt nieuwe ontwikkelingen van vroege stadia tot klinische proeven.
Regulatory and Approval Watchdog - volgt nieuwe goedkeuringen van medicijnen en wijzigingen in de regelgeving.
Scientific Literature and Innovation Scout - scant wetenschappelijke publicaties en patenten met betrekking tot oncologie.

Open de sectie Agenten en maak de eerste agent aan:

Voor nu gebruiken we het eerder gedownloade llama3.2:latest model, maar in een echt scenario kiest u het model dat het beste bij de taak past. Herhaal het proces voor de overige agents en ga verder met het maken van de taak.

Verzamel alle agenten in een ploeg en wijs hen de voorbereide taak toe:

Activeer de benodigde gereedschappen uit de lijst:

Ga tot slot naar de pagina Kickoff! en klik op Run Crew! Na enkele iteraties zal het systeem een resultaat teruggeven, zoals:

Voordat we afsluiten, controleren we de sectie Import/export. Je workflow of crew kan geëxporteerd worden als JSON om over te zetten naar een andere CrewAI server. Je kunt ook met één klik een Single-Page Application (SPA) maken - perfect voor productie-implementatie:

Conclusie

CrewAI vereenvoudigt het maken van AI-agenten aanzienlijk en maakt integratie in elke applicatie of standalone gebruik mogelijk. De bibliotheek is gebaseerd op het idee van gedistribueerde intelligentie, waarbij elke agent een domeinexpert is en het gecombineerde team beter presteert dan een enkele generalistische agent.

Omdat CrewAI in Python is geschreven, kan het gemakkelijk worden geïntegreerd met ML-platforms en -tools. Het open source karakter maakt uitbreiding door modules van derden mogelijk. Inter-agent communicatie vermindert het tokengebruik door contextverwerking te verdelen.

Hierdoor worden complexe taken sneller en efficiënter uitgevoerd. De lagere instapdrempel van CrewAI Studio vergroot het bereik van AI-agents en multi-agent systemen. En ondersteuning voor lokale modellen zorgt voor betere controle over gevoelige gegevens.

Zie ook:

Nieuw in Qwen 3

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

De wereldwijde AI-race gaat steeds sneller. Onderzoeksinstellingen, privébedrijven en zelfs hele naties strijden nu om het leiderschap op het gebied van AI. In grote lijnen kan deze race in verschillende fasen worden verdeeld. In de eerste fase werd smalle AI gecreëerd. Bestaande neurale netwerkmodellen zoals GPT, MidJourney en AlphaFold laten zien dat deze fase met succes is bereikt.

De volgende stap is de evolutie van AI naar AGI (Artificial General Intelligence). AGI moet menselijke intelligentie evenaren in het oplossen van een breed scala aan taken, van het schrijven van verhalen en het uitvoeren van wetenschappelijke berekeningen tot het begrijpen van sociale situaties en zelfstandig leren. Op het moment van schrijven is dit niveau nog niet bereikt.

Het ultieme stadium in de ontwikkeling van AI wordt ASI (Artificial Super Intelligence) genoemd. Het zou de menselijke vermogens op alle gebieden ver overtreffen. Dit zou het mogelijk maken om technologieën te ontwikkelen die we ons nu nog niet eens kunnen voorstellen en om wereldwijde systemen te beheren met een precisie die de menselijke vermogens te boven gaat. Dit zou echter pas werkelijkheid kunnen worden na tientallen jaren (of zelfs eeuwen) van voortdurende vooruitgang.

Daarom richten de meeste deelnemers aan de AI-race zich op het bereiken van AGI terwijl ze er controle over houden. De ontwikkeling van AGI is nauw verbonden met een groot aantal complexe technische, ethische en juridische uitdagingen. Toch wegen de potentiële beloningen ruimschoots op tegen de kosten en daarom investeren bedrijven als Alibaba Group zwaar in dit gebied.

De release van Qwen 3 markeert een belangrijke mijlpaal, niet alleen voor de neurale netwerken van één bedrijf, maar ook op het wereldtoneel. Vergeleken met zijn voorganger introduceert het model een aantal belangrijke innovaties.

Kenmerken

Qwen 2.5 was voorgetraind op een dataset van 18B tokens, terwijl het nieuwe model die hoeveelheid heeft verdubbeld tot 36B tokens. De grootste dataset heeft de nauwkeurigheid van het basismodel aanzienlijk verbeterd. Interessant is dat het systeem niet alleen is getraind op openbare internetgegevens die zijn verzameld door middel van parsing, maar ook op PDF-documenten. Deze zijn doorgaans goed gestructureerd en bevatten veel kennis, waardoor het model nauwkeurigere antwoorden kan geven en complexe formuleringen beter begrijpt.

Een van de meest veelbelovende richtingen in de ontwikkeling van AI is het bouwen van modellen die kunnen redeneren en die de taakcontext kunnen uitbreiden door middel van een iteratief proces. Aan de ene kant maakt dit uitgebreidere probleemoplossing mogelijk, maar aan de andere kant heeft redeneren de neiging om het proces aanzienlijk te vertragen. Daarom hebben de ontwikkelaars van Qwen 3 twee operationele modi geïntroduceerd:

Thinking mode. Het model bouwt stap voor stap context op voordat het een definitief antwoord geeft. Dit maakt het mogelijk om complexe problemen aan te pakken die diepgaand begrip vereisen.
Non-thinking mode. Het model reageert vrijwel direct, maar kan meer oppervlakkige antwoorden geven zonder diepgaande analyse.

Deze handmatige controle over het gedrag van het model verbetert de gebruikerservaring bij het uitvoeren van veel routinetaken. Het verminderen van het gebruik van de denkmodus verlaagt ook de GPU-belasting aanzienlijk, waardoor meer tokens verwerkt kunnen worden binnen hetzelfde tijdsbestek.

Naast deze binaire keuze is er ook een soft-switching mechanisme. Met dit hybride gedrag kan het model zich aanpassen aan de context met behulp van interne wegingsmechanismen. Als het model een taak moeilijk vindt, zal het automatisch redeneren of zelfs zelfverificatie activeren. Het kan ook reageren op aanwijzingen van de gebruiker zoals "Laten we stap voor stap denken".

Een andere belangrijke verbetering is de uitgebreide meertalige ondersteuning. Waar Qwen 2.5 slechts 29 talen ondersteunde, kan versie 3 nu tekst in 119 talen en dialecten begrijpen en genereren. Dit heeft het volgen van instructies en contextueel begrip sterk verbeterd. Hierdoor kan Qwen 3 nu effectief gebruikt worden in niet-Engelse omgevingen.

Daarnaast is Qwen 3 nu aanzienlijk beter geïntegreerd met MCP servers, waardoor het model tools heeft om dieper in te gaan op het oplossen van problemen en het uitvoeren van acties. Het kan nu communiceren met externe bronnen en complexe processen direct beheren.

Model training

Pre-training

Zo'n grote sprong voorwaarts zou niet mogelijk zijn geweest zonder een meerfasig trainingssysteem. In eerste instantie werd het model voorgetraind op 30B tokens met een contextlengte van 4K, zodat het algemene kennis en basale taalvaardigheden kon opdoen.

Dit werd gevolgd door een verfijningsfase met meer wetenschappelijke en goed gestructureerde gegevens. Tijdens deze fase kreeg het model ook de vaardigheid om effectief toepassingen te schrijven in meerdere programmeertalen.

Tot slot werd het getraind op een dataset van hoge kwaliteit met uitgebreide context. Het resultaat is dat Qwen 3 nu een effectieve contextlengte van 128K tokens ondersteunt, wat neerkomt op ongeveer 350 pagina's getypte tekst, afhankelijk van de taal. Cyrillische talen hebben bijvoorbeeld vaak kortere tokens vanwege de morfologie en het gebruik van voor- en achtervoegsels, etc.

Pijplijn voor redeneren

Het bouwen van redeneerbare modellen is een fascinerend maar arbeidsintensief proces dat verschillende bestaande technieken combineert die gericht zijn op het simuleren van menselijk denken. Gebaseerd op publiek beschikbare informatie, kunnen we aannemen dat de redeneertraining van Qwen 3 uit vier hoofdfasen bestond:

Cold start for long chains of thought. Het model trainen om problemen op te splitsen in meerdere stappen zonder voorafgaande aanpassing. Hierdoor leert het iteratief denken en ontwikkelt het een basislaag van redeneervaardigheden.
Reinforcement learning based on reasoning. In dit stadium hangen beloningen niet alleen af van het uiteindelijke antwoord, maar ook van hoe goed het model logische, interpreteerbare en gestructureerde redeneerketens opbouwt. De afwezigheid van fouten en hallucinaties wordt ook geëvalueerd.
Merging reasoning modes. Mensen vertrouwen typisch op twee denkstijlen: snel (intuïtief) en langzaam (analytisch). Afhankelijk van het type taak moet het neurale model leren om tussen deze stijlen te schakelen en ze te integreren. Dit wordt meestal gedaan met behulp van voorbeelden die beide stijlen combineren of door middel van speciale tokens die aangeven welke stijl moet worden toegepast.
General reinforcement learning. Deze laatste fase lijkt op een zandbakomgeving waarin het model leert om te gaan met hulpmiddelen, taken uit te voeren die uit meerdere stappen bestaan en adaptief gedrag te ontwikkelen. Hier wordt het ook afgestemd op de voorkeuren van de gebruiker.

Conclusie

Qwen 3 is een belangrijke mijlpaal voor Alibaba Group. De kwaliteit van de training en de methodologie maken het een serieuze concurrent voor gevestigde spelers als OpenAI en Anthropic. De verbeteringen ten opzichte van de vorige versie zijn substantieel.

Een bijkomend voordeel is het open-source karakter, waarbij de codebase openbaar beschikbaar is op GitHub onder de Apache 2.0 licentie.

Verdere ontwikkeling van de Qwen modelfamilie zal helpen om de positie in de wereldwijde AI-arena te versterken en de kloof met closed-source commerciële modellen te verkleinen. En alle huidige prestaties zijn, op de een of andere manier, stappen in de richting van de vooruitgang van de mensheid in het bouwen van AGI.

Zie ook:

MCP-server gebaseerd op N8N

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

De ontwikkeling van generatieve neurale netwerken is de afgelopen jaren in een stroomversnelling geraakt. Ze zijn merkbaar sneller en nauwkeuriger geworden in hun reacties en hebben geleerd om te redeneren. Hun mogelijkheden worden echter nog steeds fundamenteel beperkt door hun architectuur. Bijvoorbeeld, elke bestaande LLM op het moment van schrijven heeft een kennis cutoff datum. Dit betekent dat met elke dag die voorbijgaat, de kans groter wordt dat zo'n LLM onjuiste antwoorden geeft, simpelweg omdat het informatie mist over gebeurtenissen die na die datum hebben plaatsgevonden.

Door deze beperking moet het model helemaal opnieuw worden getraind op versere gegevens, wat duur en tijdrovend is. Maar er is een andere manier. Als je het model in staat stelt om met de buitenwereld te communiceren, kan het zelfstandig de informatie vinden en bijwerken die tijdens een gebruikersgesprek wordt gevraagd, zonder dat het opnieuw getraind hoeft te worden.

Dit is ongeveer hoe het RAG-mechanisme (Retrieval Augmented Generation) werkt. Bij het beantwoorden van een vraag bevraagt het model eerst een vooraf voorbereide vectordatabase en als het relevante informatie vindt, verwerkt het deze in de prompt. Door de vectorgegevensbank uit te leggen en bij te werken, kan de kwaliteit van LLM antwoorden dus sterk worden verbeterd.

Maar er is een andere, nog interessantere manier om actuele context in prompts te verwerken. Het heet MCP, wat staat voor Model Context Protocol. Het werd oorspronkelijk ontwikkeld door Anthropic voor zijn Claude-model. Het sleutelmoment kwam toen de broncode voor MCP open-source werd gemaakt, waardoor duizenden AI-onderzoekers aangepaste servers konden bouwen voor verschillende doeleinden.

De essentie van MCP is om een neuraal netwerkmodel toegang te geven tot hulpmiddelen waarmee het zelfstandig zijn kennis kan bijwerken en verschillende acties kan uitvoeren om gegeven taken efficiënt op te lossen. Het model beslist zelf welk gereedschap het gebruikt en of het geschikt is in elke situatie.

Ondersteuning voor MCP verscheen al snel in verschillende IDE's zoals Cursor, maar ook in automatiseringsplatforms zoals N8N. Dit laatste is vooral intuïtief omdat workflows visueel worden gemaakt, waardoor het gemakkelijker te begrijpen is. Binnen N8N kun je verbinding maken met een bestaande MCP-server of je eigen server maken. Bovendien kun je zelfs een directe verbinding binnen één workflow organiseren. Maar laten we stap voor stap te werk gaan.

Een eenvoudige AI-agent maken

Voordat je aan de slag gaat, moet je ervoor zorgen dat aan de belangrijkste vereiste is voldaan: je hebt een LLM klaarstaan voor verbindingen. Dit kan een lokaal draaiend model zijn met Ollama of een externe service zoals OpenAI's ChatGPT. In het eerste geval moet je het lokale Ollama API adres weten (en optioneel de authenticatie), en in het tweede geval heb je een actief OpenAI account nodig met voldoende credits.

Het bouwen van een agent begint met de belangrijkste AI Agent node. Deze moet op zijn minst verbonden zijn met twee andere knooppunten, één om als trigger te fungeren en de andere om verbinding te maken met de LLM. Als je geen trigger opgeeft, maakt het systeem er automatisch een aan en wordt de agent getriggerd zodra hij een bericht ontvangt in de interne chat:

Het enige ontbrekende onderdeel is de LLM. Je kunt bijvoorbeeld onze Open WebUI: Alles in één gids gebruiken om Ollama in te stellen met een webinterface. De enige vereiste wijziging is dat de containers voor N8N en Open WebUI zich op hetzelfde netwerk moeten bevinden. Als de N8N container bijvoorbeeld op een netwerk met de naam web staat, vervang dan in het deployment commando voor Open WebUI --network=host door --network=web.

In sommige gevallen moet je ook handmatig de OLLAMA_HOST omgevingsvariabele instellen, bijvoorbeeld: -e OLLAMA_HOST=0.0.0.0. Dit maakt verbindingen met de Ollama API niet alleen mogelijk vanaf localhost, maar ook vanaf andere containers. Stel dat Ollama wordt ingezet in een container met de naam ollama-webui. Dan zou de basis URL voor verbinden vanuit N8N zijn:

http://open-webui:11434

Vergeet niet om minstens één model te downloaden voordat je de Ollama Chat Model node verbindt. Je kunt dit doen via de webinterface of via de CLI van de container. Het volgende commando zal het Llama 3.1 model met 8 miljard parameters downloaden:

ollama pull llama3.1:8b

Eenmaal gedownload en geïnstalleerd, zal het model automatisch verschijnen in de lijst met beschikbare modellen:

Een minimaal werkende AI Agent workflow ziet er als volgt uit:

In deze vorm kan de agent slechts één model gebruiken en slaat hij geen invoergegevens op of verbetert hij prompts met behulp van externe tools. Het is dus zinvol om ten minste het knooppunt Simple Memory toe te voegen. Voor lichte belastingen is het voldoende om verzoeken en antwoorden op te slaan.

Maar laten we teruggaan naar MCP. Maak om te beginnen een server met het speciale knooppunt MCP Server Trigger:

Dit knooppunt is volledig zelfstandig en heeft geen externe activering nodig. Het wordt alleen geactiveerd door een inkomend extern verzoek naar zijn webhookadres. Standaard zijn er twee URL's: Test URL en Production URL. De eerste wordt gebruikt tijdens de ontwikkeling, terwijl de tweede alleen werkt als de workflow is opgeslagen en geactiveerd.

De trigger is nutteloos op zichzelf, hij heeft verbonden tools nodig. Laten we bijvoorbeeld een van de eenvoudigste gereedschappen aansluiten: een rekenmachine. Deze verwacht een wiskundige uitdrukking als invoer. Knooppunten communiceren met behulp van gewone JSON, dus als de rekenmachine 2 + 2 wil berekenen, moet de invoer zijn:

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

LLM's kunnen eenvoudig zulke JSON genereren uit platte tekst taakbeschrijvingen en deze naar het knooppunt sturen, dat de berekeningen uitvoert en het resultaat terugstuurt. Laten we de MCP-client verbinden met de agent:

Het is de moeite waard om op te merken dat dit knooppunt geen extra verbindingen nodig heeft. Het is voldoende om in de instellingen het eindpuntadres op te geven waar het gegevens van de AI Agent naartoe zal sturen. In ons voorbeeld wijst dit adres naar de container met de naam n8n.

Natuurlijk kun je in dit stadium elk beschikbaar extern MCP serveradres opgeven. Maar voor dit artikel gebruiken we een lokale instantie die binnen N8N draait. Laten we eens kijken hoe de client en server zich gedragen wanneer de AI Agent wordt gevraagd om een eenvoudige wiskundige bewerking uit te voeren:

Na ontvangst van het verzoek zal de AI Agent:

Zoeken in Simple Memory om te zien of de gebruiker dit eerder heeft gevraagd of dat een context kan worden hergebruikt.
De vraag naar de LLM sturen, die de wiskundige uitdrukking correct zal afbreken en de bijbehorende JSON zal voorbereiden.
Stuur de JSON naar het rekenprogramma en ontvang het resultaat.
Gebruik de LLM om het uiteindelijke antwoord te genereren en voeg het resultaat in het antwoord in.
Sla het resultaat op in Simple Memory.
Voer het bericht uit in de chat.

Op dezelfde manier kunnen agents werken met andere tools op de MCP-server. In plaats van Simple Memory kun je geavanceerdere opties gebruiken zoals MongoDB, Postgres, Redis of zelfs zoiets als Zep. Deze vereisen natuurlijk minimaal database-onderhoud, maar de algehele prestaties zullen aanzienlijk toenemen.

Er zijn ook veel meer opties voor de selectie van gereedschappen. Out of the box ondersteunt het knooppunt MCP Server Trigger meer dan 200 tools. Dit kan van alles zijn, van eenvoudige HTTP verzoeken tot voorgebouwde integraties met openbare internetdiensten. Binnen een enkele workflow kun je zowel een server als een client maken. Een belangrijk ding om op te merken: deze knooppunten kunnen niet visueel worden verbonden in de editor, en dat is verwacht gedrag:

In plaats van de standaard trigger kun je andere opties gebruiken, zoals het ontvangen van een bericht via een messenger, het indienen van een website formulier of het uitvoeren volgens een schema. Hiermee kun je workflows opzetten die reageren op gebeurtenissen of routinehandelingen uitvoeren, zoals het dagelijks exporteren van gegevens van Google Ads.

En dat is nog niet alles wat er mogelijk is met AI agents. Je kunt multi-agent systemen bouwen met verschillende neurale netwerkmodellen die samenwerken om taken nauwkeuriger op te lossen, rekening houdend met veel meer beïnvloedende factoren in het proces.

Zie ook:

Hoe installeer ik N8N?

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

AI-agenten in 2025 blijven een van de meest veelbelovende benaderingen voor het oplossen van complexe taken met behulp van grote taalmodellen. Deze agents zijn autonoom en kunnen zelfstandig verschillende tools selecteren om toegewezen taken uit te voeren. Deze aanpak maakt het mogelijk om resultaten te bereiken met minder menselijke betrokkenheid en een hogere kwaliteit. Het opent ook mogelijkheden voor het ontdekken van originelere en effectievere manieren om problemen aan te pakken.

In plaats van alleen een taak te formuleren, geef je het neurale netwerk de opdracht om deze zelfstandig op te lossen, op basis van de middelen die aan het netwerk zijn toegewezen. Maar om dit schema te laten werken, moet er een mechanisme zijn dat neurale netwerkinterfaces verbindt met verschillende tools, of het nu zoeken op het web is of een vector database voor het opslaan van tussenresultaten.

n8n is een automatiseringsplatform dat integratie met verschillende neurale netwerken en openbare diensten ondersteunt. Gebruikers kunnen visueel ontwerpen hoe gegevens worden verwerkt en welk eindresultaat moet worden bereikt. In tegenstelling tot klassieke no-code oplossingen, maakt n8n het mogelijk om willekeurige code op te nemen in elke fase van het proces, wat vooral handig is als ingebouwde functionaliteit niet voldoende is.

Het resultaat is een systeem dat de eenvoud van no-code combineert met de flexibiliteit van traditioneel programmeren. Om het volledig te begrijpen, moet je echter nog wat tijd besteden aan het verkennen en bekijken van workflowvoorbeelden voor een beter begrip. In dit artikel laten we u zien hoe u n8n kunt implementeren op LeaderGPU servers.

De server voorbereiden

Het systeem bijwerken

Werk de pakketlijst bij en upgrade alle geïnstalleerde pakketten:

sudo apt update && sudo apt -y upgrade

Installeer automatisch het aanbevolen NVIDIA® stuurprogramma (eigen) of gebruik onze stap-voor-stap handleiding Installeer Nvidia-stuurprogramma's in Linux:

sudo ubuntu-drivers autoinstall

Start nu de server opnieuw op:

sudo shutdown -r now

Docker installeren

Je kunt het officiële installatiescript gebruiken:

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

Laten we NVIDIA® container toolkit GPG-sleutel en repository toevoegen voor Docker-integratie:

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

Werk de pakketlijst bij en installeer de NVIDIA® container toolkit:

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

Start Docker opnieuw op om de wijzigingen toe te passen en de geïnstalleerde toolkit in te schakelen:

sudo systemctl restart docker

Installeer n8n

Om het systeem gegevens te laten opslaan, moet je een volume aanmaken voordat je de container start:

sudo docker volume create n8n_data

Laten we nu een container starten die poort 5678 zal openen voor externe verbindingen en het aangemaakte n8n_data volume zal mounten in de map /home/node/.n8n in de container:

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

De eerste keer dat je de applicatie start, ben je misschien verbaasd over de volgende foutmelding:

Dit is niet echt een fout, het is meer een waarschuwing over hoe je het systeem goed moet configureren voor toegang. Het probleem is dat het systeem standaard geen TLS/HTTPS-certificaat heeft. Zonder dat is de verbinding niet veilig. Je hebt dus drie opties:

Connect your own certificate. Je kunt dit doen door de paden naar de certificaatbestanden op te geven via omgevingsvariabelen, of door een reverse proxy server te configureren.
Create an SSH tunnel and forward port 5678 naar localhost op de computer waarvandaan je verbinding maakt. Op deze manier krijg je direct een beveiligde persoonlijke verbinding. Niemand anders heeft echter toegang tot de server van buitenaf.
Bypass the warning. Als dit een testserver is die niet bedoeld is voor productiegebruik en je niets geeft om beveiliging, kun je de waarschuwing uitschakelen door de omgevingsvariabele N8N_SECURE_COOKIE in te stellen op FALSE. Dit wordt sterk afgeraden omdat het de server kwetsbaar maakt voor mogelijke aanvallen. Toch kan het acceptabel zijn in specifieke scenario's.

Dit artikel zal elke optie in detail bespreken zodat je de juiste kunt kiezen.

Verbinding maken met de server

Als u nog geen SSL-certificaat hebt, raden wij u aan er een te bestellen bij LeaderSSL. Het kan worden gebruikt voor elke website, online winkel of om de echtheid van een e-mail te verifiëren.

Omgevingsvariabelen gebruiken

De eenvoudigste manier om HTTPS te configureren is door je certificaat te uploaden naar de server en het te specificeren via Docker omgevingsvariabelen. Begin met het aanmaken van een map voor de certificaatbestanden:

mkdir ~/n8n-certs

Je kunt deze bestanden (meestal cert.crt en privkey.key) naar deze directory uploaden met elke methode. Zie voor meer gedetailleerde informatie:

Laten we nu de container starten met één volledig commando:

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

Hier is een uitsplitsing van elk argument:

sudo docker run -d lanceert de Docker-container in daemon (achtergrond) modus
--name n8n kent de naam toe aan de container n8n
-p 5678:5678 stuurt poort 5678 door naar de container
-v n8n_data:/home/node/.n8n creëert en koppelt een volume met de naam n8n_data aan de verborgen directory /home/node/.n8n in de container
-v ~/n8n-certs:/certs koppelt de certificaatmap
-e N8N_PROTOCOL=https dwingt N8N om het HTTPS-protocol te gebruiken
-e N8N_SSL_CERT="/certs/cert.crt" stelt het pad naar het certificaatbestand in
-e N8N_SSL_KEY="/certs/privkey.key" stelt het pad naar de certificaatsleutel in
docker.n8n.io/n8nio/n8n bron van containerafbeelding

Traefik

Een iets complexere maar flexibele opstelling maakt gebruik van de Traefik reverse proxy server om de verbinding met N8N te beveiligen. Het configuratiebestand is gebaseerd op de officiële methode in de documentatie. Installeer eerst het hulpprogramma docker-compose:

sudo apt -y install docker-compose

We implementeren Traefik en N8N samen en ze moeten zich op hetzelfde netwerk bevinden. Maak een netwerk aan met de naam web.

sudo docker network create web

Maak nu een docker-compose.yml bestand om beide containers te definiëren en uit te voeren:

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

Naast het bestand docker-compose.yml maken we nog een bestand aan met de naam .env. Dit bestand zal variabelen bevatten zoals de domeinnaam en het e-mailadres dat wordt gebruikt om een SSL-certificaat aan te vragen bij Let's Encrypt. Als we ooit iets moeten veranderen, zoals de domeinnaam, dan hoeven we dat alleen maar in dit bestand aan te passen en daarna de container opnieuw te maken.

nano .env

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

Implementeer tenslotte beide containers:

sudo docker-compose up -d

Nu is N8N hier beschikbaar: https://n8n.example.com.

Nginx Proxy Manager

In tegenstelling tot Traefik, die geconfigureerd wordt via bestanden, biedt Nginx Proxy Manager een gebruiksvriendelijke webinterface. Het detecteert services echter niet dynamisch, je moet ze handmatig toevoegen. Toch werkt het goed voor statische services zoals N8N.

Maak nog een docker-compose.yml bestand in een aparte directory met de volgende inhoud:

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

Deploy with:

sudo docker-compose up -d

Open dan web-interface bij: http://your_hostname_or_ip:81

Gebruikersnaam: admin@example.com
Wachtwoord: changeme

Je wordt gevraagd om je referenties bij te werken. Open daarna Hosts → Proxy Hosts → Add Proxy Host, voer je domeinnaam in (bijv. n8n.example.com):

Vul de benodigde velden in:

Stel Destination/IP in op n8n.
Stel Port in op 5678.
Kies Request a new SSL certificate with Let’s Encrypt onder het tabblad SSL.
Voer je e-mailadres in en ga akkoord met de voorwaarden.
Klik op Websockets support.
Klik optioneel op Force SSL.

Nadat u op Save hebt gedrukt, wordt het certificaat aangevraagd en geïnstalleerd:

Zodra dit is gebeurd, leidt het openen van je domein naar de N8N-interface.

SSH-tunnel

Als je N8N niet extern toegankelijk hoeft te maken, kun je poort 5678 forwarden via SSH. Dit versleutelt al het verkeer, en N8N zal beschikbaar zijn op http://localhost:5678/.

Opmerking: Deze opstelling werkt niet voor integraties met externe diensten zoals messengers die openbare HTTPS-toegang vereisen.

De eenvoudigste manier om de poort door te sturen is met de populaire SSH-client PuTTY. Eenmaal geïnstalleerd, open SSH → Tunnels en stel Source port - 5678 en Destination - localhost:5678 in. Klik vervolgens op Add.

Ga terug naar Session, voer het IP-adres van je server in en klik op Open. Na authenticatie is de tunnel actief. Open http://localhost:5678 in een browser om toegang te krijgen tot N8N.

Opmerking: De verbinding werkt alleen zolang de SSH-sessie actief is. Het afsluiten van PuTTY zal de tunnel beëindigen.

omzeilen

Deze methode wordt niet aangeraden voor gebruik op openbare netwerken. Als je de container start met de N8N_SECURE_COOKIE=false omgevingsvariabele, zal de waarschuwing verdwijnen en krijg je toegang 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: Dit stelt het beheerpaneel van N8N bloot via onversleutelde HTTP, waardoor het kwetsbaar is voor MITM-aanvallen (Man-In-The-Middle) en een aanvaller mogelijk je server volledig kan overnemen.

Zie ook:

Triton™ Inference Server

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

Zakelijke eisen kunnen verschillen, maar ze hebben allemaal één kernprincipe gemeen: systemen moeten snel werken en de hoogst mogelijke kwaliteit leveren. Als het gaat om neurale netwerkinferentie, is efficiënt gebruik van computermiddelen van cruciaal belang. Onderbenutting of inactiviteit van GPU's leidt direct tot financiële verliezen.

Neem een marktplaats als voorbeeld. Deze platformen hosten talloze producten, elk met meerdere attributen: tekstbeschrijvingen, technische specificaties, categorieën en multimedia-inhoud zoals foto's en video's. Alle inhoud moet gemodereerd worden om eerlijk te blijven. Alle inhoud moet worden gemodereerd om eerlijke voorwaarden te handhaven voor verkopers en om te voorkomen dat verboden goederen of illegale inhoud op het platform verschijnen.

Handmatige moderatie is mogelijk, maar het is traag en inefficiënt. In de huidige competitieve omgeving moeten verkopers hun productaanbod snel uitbreiden: hoe sneller items op de marktplaats verschijnen, hoe groter de kans dat ze ontdekt en gekocht worden. Handmatige moderatie is ook duur en gevoelig voor menselijke fouten, waardoor mogelijk ongepaste inhoud wordt doorgelaten.

Automatische moderatie met behulp van speciaal getrainde neurale netwerken biedt een oplossing. Deze aanpak heeft meerdere voordelen: het vermindert de kosten voor moderatie aanzienlijk en verbetert tegelijkertijd de kwaliteit. Neurale netwerken verwerken inhoud veel sneller dan mensen, waardoor verkopers de moderatiefase sneller kunnen doorlopen, vooral bij grote productvolumes.

De aanpak heeft ook zijn uitdagingen. Het implementeren van geautomatiseerde moderatie vereist het ontwikkelen en trainen van neurale netwerkmodellen, wat zowel geschoold personeel als aanzienlijke computerbronnen vereist. De voordelen worden echter snel duidelijk na de eerste implementatie. Het toevoegen van geautomatiseerde modelimplementatie kan de lopende werkzaamheden aanzienlijk stroomlijnen.

Inferentie

Stel dat we de procedures voor machinaal leren hebben bedacht. De volgende stap is bepalen hoe modelinferentie op een gehuurde server moet worden uitgevoerd. Voor een enkel model kies je meestal een tool die goed werkt met het specifieke framework waarop het gebouwd is. Als je echter te maken hebt met meerdere modellen die in verschillende frameworks zijn gemaakt, heb je twee opties.

Je kunt alle modellen converteren naar één formaat of een tool kiezen die meerdere frameworks ondersteunt. Triton™ Inference Server past perfect bij de tweede benadering. Het ondersteunt de volgende backends:

TensorRT™
TensorRT-LLM
vLLM
Python
PyTorch (LibTorch)
ONNX-runtime
Tensorflow
FIL
DALI

Bovendien kun je elke toepassing als backend gebruiken. Als je bijvoorbeeld nabewerking nodig hebt met een C/C++ toepassing, kun je die naadloos integreren.

Schalen

Triton™ Inference Server beheert computermiddelen efficiënt op een enkele server door meerdere modellen tegelijkertijd uit te voeren en de werklast over GPU's te verdelen.

Installatie gebeurt via een Docker-container. DevOps-technici kunnen de GPU-toewijzing bij het opstarten regelen en ervoor kiezen om alle GPU's te gebruiken of hun aantal te beperken. Hoewel de software niet direct horizontale schaalbaarheid behandelt, kun je hiervoor traditionele loadbalancers zoals HAproxy gebruiken of applicaties in een Kubernetes-cluster implementeren.

Het systeem voorbereiden

Om Triton™ in te stellen op een LeaderGPU server met Ubuntu 22.04, moet je eerst het systeem updaten met dit commando:

sudo apt update && sudo apt -y upgrade

Installeer eerst de NVIDIA® drivers met behulp van het autoinstaller script:

sudo ubuntu-drivers autoinstall

Start de server opnieuw op om de wijzigingen toe te passen:

sudo shutdown -r now

Zodra de server weer online is, installeer je Docker met het volgende installatiescript:

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

Aangezien Docker standaard geen GPU's kan doorgeven aan containers, heb je de NVIDIA® Container Toolkit nodig. Voeg de Nvidia-repository toe door de GPG-sleutel ervan te downloaden en te registreren:

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

Update de packages cache en installeer de toolkit:

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

Start Docker opnieuw op om de nieuwe mogelijkheden in te schakelen:

sudo systemctl restart docker

Het besturingssysteem is nu klaar voor gebruik.

Triton™ inferentieserver installeren

Laten we de projectrepository downloaden:

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

Deze repository bevat vooraf geconfigureerde neurale netwerkvoorbeelden en een downloadscript voor modellen. Navigeer naar de map examples:

cd server/docs/examples

Download de modellen door het volgende script uit te voeren, dat ze opslaat op ~/server/docs/examples/model_repository:

./fetch_models.sh

De architectuur van Triton™ Inference Server vereist dat modellen afzonderlijk worden opgeslagen. Je kunt ze lokaal opslaan in een servermap of op netwerkopslag. Bij het opstarten van de server moet je deze map koppelen aan de container op het koppelpunt /models. Dit dient als opslagplaats voor alle modelversies.

Start de container met dit commando

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

Hier is wat elke parameter doet:

--gpus=all specificeert dat alle beschikbare GPU's worden gebruikt in de server;
--rm vernietigt de container nadat het proces is voltooid of gestopt;
-p8000:8000 stuurt poort 8000 door om HTTP-verzoeken te ontvangen;
-p8001:8001 stuurt poort 8001 door om gRPC verzoeken te ontvangen;
-p8002:8002 stuurt poort 8002 door om metriek op te vragen;
-v ~/server/docs/examples/model_repository:/models stuurt de directory met modellen door;
nvcr.io/nvidia/tritonserver:25.01-py3 adres van de container uit de NGC™ catalogus;
tritonserver --model-repository=/models start de Triton™ Inference Server met de locatie van de models repository op /models.

De uitvoer van het commando toont alle beschikbare modellen in de repository, elk klaar om verzoeken te accepteren:

+----------------------+---------+--------+
| 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  |
+----------------------+---------+--------+

De drie diensten zijn succesvol gestart op poorten 8000, 8001 en 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

Met het hulpprogramma nvtop kunnen we controleren of alle GPU's klaar zijn om de belasting te accepteren:

De client installeren

Om toegang te krijgen tot onze server, moeten we een geschikt verzoek genereren met de client die bij de SDK zit. We kunnen deze SDK downloaden als een Docker-container:

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

Start de container in interactieve modus om toegang te krijgen tot de console:

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

Laten we dit eens testen met het DenseNet-model in ONNX-indeling, met behulp van de INCEPTION-methode voor het voorbewerken en analyseren van afbeeldingen mug.jpg:

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

De client neemt contact op met de server, die een batch aanmaakt en deze verwerkt met behulp van de beschikbare GPU's van de container. Hier is de uitvoer:

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

De repository voorbereiden

Om Triton™ modellen correct te laten beheren, moet je het archief op een specifieke manier voorbereiden. Dit is de mapstructuur:

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

Elk model heeft zijn eigen map nodig met daarin een config.pbtxt configuratiebestand met zijn beschrijving. Hier is een voorbeeld:

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 dit voorbeeld zal een model met de naam Test draaien op de PyTorch backend. De parameter max_batch_size stelt het maximum aantal items in dat gelijktijdig kan worden verwerkt, zodat de belasting van de bronnen efficiënt kan worden verdeeld. Door deze waarde op nul te zetten, wordt batching uitgeschakeld, waardoor het model aanvragen sequentieel verwerkt.

Het model accepteert één invoer en produceert één uitvoer, beide gebruikmakend van het FP32 nummertype. De parameters moeten precies overeenkomen met de vereisten van het model. Voor beeldverwerking is een typische maatspecificatie dims: [ 3, 224, 224 ], waarbij:

3 - aantal kleurkanalen (RGB);
224 - afbeeldingshoogte in pixels;
224 - beeldbreedte in pixels.

De uitvoer dims: [ 1000 ] is een eendimensionale vector van 1000 elementen, die geschikt is voor beeldclassificatietaken. Raadpleeg de documentatie van je model om de juiste dimensionaliteit te bepalen. Als het configuratiebestand onvolledig is, probeert Triton™ ontbrekende parameters automatisch te genereren.

Een aangepast model starten

Laten we de inferentie starten van het gedistilleerde DeepSeek-R1 model dat we eerder bespraken. Eerst maken we de noodzakelijke mappenstructuur aan:

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

Navigeer naar de modeldirectory:

cd ~/model_repository/deepseek

Maak een configuratiebestand config.pbtxt:

nano config.pbtxt

Plak het volgende:

# 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
  }
]

Sla het bestand op door te drukken op Ctrl + O, daarna de editor met Ctrl + X. Navigeer naar de directory 1:

cd 1

Maak een modelconfiguratiebestand model.json met de volgende parameters:

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

Merk op dat de gpu_memory_utilization waarde varieert per GPU en experimenteel bepaald moet worden. Voor deze handleiding gebruiken we 0.9. De directorystructuur binnen ~/model_repository zou er nu als volgt uit moeten zien:

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

Stel voor het gemak de variabele LOCAL_MODEL_REPOSITORY in:

LOCAL_MODEL_REPOSITORY=~/model_repository/

Start de inferentieserver met deze opdracht:

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/

Hier is wat elke parameter doet:

--rm verwijdert de container automatisch na het stoppen;
-it draait de container in interactieve modus met terminaluitvoer;
--net host gebruikt de netwerkstack van de host in plaats van containerisolatie;
--shm-size=2g stelt gedeeld geheugen in op 2 GB;
--ulimit memlock=-1 verwijdert geheugen lock limiet;
--ulimit stack=67108864 stelt stackgrootte in op 64 MB;
--gpus all maakt toegang tot alle GPU's van de server mogelijk;
-v $LOCAL_MODEL_REPOSITORY:/opt/tritonserver/model_repository koppelt de lokale modeldirectory in de container;
nvcr.io/nvidia/tritonserver:25.01-vllm-python-py3 specificeert de container met vLLM backend ondersteuning;
tritonserver --model-repository=model_repository/ start de Triton-inferentieserver met de locatie van de modellenopslagplaats op model_repository.

Test de server door een verzoek te sturen met curl, met een eenvoudige prompt en een antwoordlimiet van 4096 token:

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

De server ontvangt en verwerkt het verzoek met succes.

De interne Triton™ taakplanner handelt alle binnenkomende verzoeken af als de server belast is.

Conclusie

Triton™ Inference Server blinkt uit in het inzetten van machine learning-modellen in productie door verzoeken efficiënt te verdelen over beschikbare GPU's. Dit maximaliseert het gebruik van gehuurde serverresources en verlaagt de kosten van de rekeninfrastructuur. Dit maximaliseert het gebruik van gehuurde serverbronnen en verlaagt de kosten van de computerinfrastructuur. De software werkt met verschillende backends, waaronder vLLM voor grote taalmodellen.

Omdat het wordt geïnstalleerd als een Docker-container, kun je het eenvoudig integreren in elke moderne CI/CD-pijplijn. Probeer het zelf door een server van LeaderGPU te huren.

DeepSeek-R1: toekomst van LLM's

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

Hoewel generatieve neurale netwerken zich snel hebben ontwikkeld, is hun vooruitgang in de afgelopen jaren vrij stabiel gebleven. Dit veranderde met de komst van DeepSeek, een Chinees neuraal netwerk dat niet alleen de aandelenmarkt beïnvloedde maar ook de aandacht trok van ontwikkelaars en onderzoekers wereldwijd. In tegenstelling tot andere grote projecten werd de code van DeepSeek vrijgegeven onder de permissieve MIT-licentie. Deze stap naar open source oogstte lof van de gemeenschap, die gretig de mogelijkheden van het nieuwe model begon te verkennen.

Het meest indrukwekkende aspect was dat het trainen van dit nieuwe neurale netwerk naar verluidt 20 keer minder kostte dan concurrenten met een vergelijkbare kwaliteit. Het model had slechts 55 dagen en 5,6 miljoen dollar nodig om te trainen. Toen DeepSeek werd uitgebracht, veroorzaakte het een van de grootste dalingen op één dag in de geschiedenis van de Amerikaanse aandelenmarkt. Hoewel de markten zich uiteindelijk stabiliseerden, was de impact aanzienlijk.

In dit artikel wordt onderzocht hoe nauwkeurig de koppen in de media de werkelijkheid weerspiegelen en welke LeaderGPU-configuraties geschikt zijn om dit neurale netwerk zelf te installeren.

Architectonische kenmerken

DeepSeek heeft gekozen voor maximale optimalisatie, wat niet verwonderlijk is gezien de exportbeperkingen van China. Door deze beperkingen kan het land de meest geavanceerde GPU-modellen niet officieel gebruiken voor AI-ontwikkeling.

Het model maakt gebruik van MTP-technologie (Multi Token Prediction), die meerdere tokens voorspelt in een enkele inferentiestap in plaats van slechts één. Dit werkt door middel van parallelle token decodering in combinatie met speciale gemaskeerde lagen die autoregressiviteit behouden.

Testen met MTP hebben opmerkelijke resultaten laten zien, waarbij de generatiesnelheden 2-4 keer hoger zijn dan bij traditionele methoden. De uitstekende schaalbaarheid van de technologie maakt het waardevol voor huidige en toekomstige toepassingen voor de verwerking van natuurlijke taal.

Het Multi-Head Latent Attention (MLA) model heeft een verbeterd aandachtsmechanisme. Terwijl het model lange redeneerketens opbouwt, behoudt het in elke fase gerichte aandacht voor de context. Deze verbetering verbetert de verwerking van abstracte concepten en tekstafhankelijkheden.

De belangrijkste eigenschap van MLA is de mogelijkheid om dynamisch aandachtsgewichten aan te passen op verschillende abstractieniveaus. Bij het verwerken van complexe zoekopdrachten bekijkt MLA gegevens vanuit meerdere perspectieven: woordbetekenissen, zinsstructuren en de algehele context. Deze perspectieven vormen verschillende lagen die de uiteindelijke uitvoer beïnvloeden. Om helderheid te behouden, balanceert MLA zorgvuldig de impact van elke laag terwijl het zich blijft concentreren op de primaire taak.

De ontwikkelaars van DeepSeek hebben Mixture of Experts (MoE) technologie in het model verwerkt. Het bevat 256 voorgetrainde neurale netwerken van experts, elk gespecialiseerd voor verschillende taken. Het systeem activeert 8 van deze netwerken voor elke tokeninvoer, waardoor gegevens efficiënt worden verwerkt zonder dat de computerkosten toenemen.

In het volledige model met 671b parameters worden slechts 37b geactiveerd voor elk token. Het model selecteert op intelligente wijze de meest relevante parameters voor het verwerken van elk binnenkomend token. Deze efficiënte optimalisatie bespaart rekenkracht met behoud van hoge prestaties.

Een cruciaal kenmerk van elke neurale netwerkchatbot is de lengte van het contextvenster. Llama 2 heeft een contextlimiet van 4.096 tokens, GPT-3.5 verwerkt 16.284 tokens, terwijl GPT-4 en DeepSeek tot 128.000 tokens kunnen verwerken (ongeveer 100.000 woorden, gelijk aan 300 pagina's getypte tekst).

R - staat voor Redeneren

DeepSeek-R1 heeft een redeneermechanisme dat vergelijkbaar is met OpenAI o1, waardoor het complexe taken efficiënter en nauwkeuriger kan afhandelen. In plaats van direct antwoorden te geven, breidt het model de context uit door stapsgewijze redeneringen in kleine alinea's te genereren. Deze aanpak verbetert het vermogen van het neurale netwerk om complexe gegevensrelaties te identificeren, wat resulteert in uitgebreidere en nauwkeurigere antwoorden.

Wanneer DeepSeek wordt geconfronteerd met een complexe taak, gebruikt het zijn redeneermechanisme om het probleem op te splitsen in componenten en deze afzonderlijk te analyseren. Het model synthetiseert vervolgens deze bevindingen om een gebruikersreactie te genereren. Hoewel dit een ideale benadering lijkt voor neurale netwerken, brengt het aanzienlijke uitdagingen met zich mee.

Alle moderne LLM's delen een zorgwekkende eigenschap - kunstmatige hallucinaties. Wanneer het model een vraag krijgt die het niet kan beantwoorden, kan het, in plaats van zijn beperkingen te erkennen, fictieve antwoorden genereren die worden ondersteund door verzonnen feiten.

Toegepast op een redenerend neuraal netwerk kunnen deze hallucinaties het denkproces in gevaar brengen door conclusies te baseren op fictieve in plaats van feitelijke informatie. Dit kan leiden tot onjuiste conclusies - een uitdaging die onderzoekers en ontwikkelaars van neurale netwerken in de toekomst zullen moeten aangaan.

VRAM-verbruik

Laten we eens kijken hoe we DeepSeek R1 kunnen uitvoeren en testen op een speciale server, waarbij we ons concentreren op de vereisten voor GPU-videogeheugen.

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

De eerste drie opties (1.5b, 7b, 8b) zijn basismodellen die de meeste taken efficiënt aankunnen. Deze modellen draaien probleemloos op elke consumenten-GPU met 6-8 GB videogeheugen. De mid-tier versies (14b en 32b) zijn ideaal voor professionele taken, maar vereisen meer VRAM. De grootste modellen (70b en 671b) vereisen gespecialiseerde GPU's en worden voornamelijk gebruikt voor onderzoek en industriële toepassingen.

Server kiezen

Om u te helpen bij het kiezen van een server voor DeepSeek-inferentie, vindt u hier de ideale LeaderGPU-configuraties voor elke modelgroep:

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

Voor deze groep is elke server met de volgende GPU-typen geschikt. De meeste LeaderGPU-servers zullen deze neurale netwerken zonder problemen uitvoeren. De prestaties zijn voornamelijk afhankelijk van het aantal CUDA® cores. Wij raden servers met meerdere GPU's aan, zoals:

671b

Nu het meest uitdagende geval: hoe voer je inferentie uit op een model met een basisgrootte van 404 GB? Dit betekent dat er ongeveer 470 GB videogeheugen nodig is. LeaderGPU biedt meerdere configuraties met de volgende GPU's die deze belasting aankunnen:

A100
H100

Beide configuraties verwerken de modelbelasting efficiënt en verdelen deze gelijkmatig over meerdere GPU's. Zo ziet een server met 8xH100 er bijvoorbeeld uit na het laden van het deepseek-r1:671b model:

De rekenbelasting wordt dynamisch verdeeld over de GPU's, terwijl snelle NVLink® interconnecties knelpunten in de gegevensuitwisseling voorkomen, waardoor maximale prestaties worden gegarandeerd.

Conclusie

DeepSeek-R1 combineert veel innovatieve technologieën zoals Multi Token Prediction, Multi-Head Latent Attention en Mixture of Experts in één significant model. Deze open-source software laat zien dat LLM's efficiënter kunnen worden ontwikkeld met minder rekenkracht. Het model heeft verschillende versies van kleinere 1,5b tot enorme 671b die gespecialiseerde hardware vereisen met meerdere high-end GPU's die parallel werken.

Door een server van LeaderGPU te huren voor DeepSeek-R1-inferentie, krijgt u een breed scala aan configuraties, betrouwbaarheid en fouttolerantie. Ons technische ondersteuningsteam zal u helpen met eventuele problemen of vragen, terwijl de automatische installatie van het besturingssysteem de implementatietijd verkort.

Kies uw LeaderGPU server en ontdek de mogelijkheden die opengaan bij het gebruik van moderne neurale netwerkmodellen. Als u vragen heeft, aarzel dan niet om ze te stellen in onze chat of e-mail.

Intel Habana Gaudi 2: installeren en testen

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

Voordat je begint met het installeren van de Gaudi 2 accelerators software, is er één belangrijke functie die het vermelden waard is. We zijn gewend aan het feit dat training en inferentie van neurale netwerken kan worden uitgevoerd met behulp van GPU's. Intel Habana Gaudi 2 is echter heel anders dan GPU's en vertegenwoordigt een andere klasse apparaten die uitsluitend zijn ontworpen voor het versnellen van AI-taken.

Veel bekende toepassingen en frameworks zullen niet werken zonder eerst het besturingssysteem voor te bereiden en, in sommige gevallen, zonder een speciale GPU Migration Toolkit. Dit verklaart het grote aantal voorbereidende stappen die we in dit artikel beschrijven. Laten we in volgorde beginnen.

Stap 1. SynapseAI Software Stack installeren

Om aan de slag te gaan met Intel Habana Gaudi 2 versnellers, moet u de SynapseAI stack installeren. Deze bevat een speciale grafiekcompiler die de topologie van het neurale netwerkmodel transformeert om de uitvoering op de Gaudi-architectuur effectief te optimaliseren, API-bibliotheken voor horizontale schaling en een aparte SDK voor het maken van krachtige algoritmen en modellen voor machinaal leren.

Apart vermelden we dat SynapseAI het onderdeel is waarmee je een brug kunt slaan tussen populaire frameworks zoals PyTorch/TensorFlow en de Gaudi 2 AI-versnellers. Hierdoor kun je werken met bekende abstracties, en Gaudi 2 optimaliseert zelfstandig berekeningen Specifieke operatoren waarvoor versnellers geen hardware-ondersteuning hebben, worden uitgevoerd op de CPU.

Om de installatie van individuele SynapseAI componenten te vereenvoudigen, is er een handig shellscript gemaakt. Laten we het downloaden:

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

Maak het bestand uitvoerbaar:

chmod +x habanalabs-installer.sh

Voer het script uit:

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

Volg de aanwijzingen van het systeem tijdens de installatie. Je vindt een gedetailleerd rapport in het logbestand. Hierin kun je zien welke pakketten zijn geïnstalleerd en of de versnellers met succes zijn gevonden en geïnitialiseerd.

Logs hier: /var/log/habana_logs/install-YYYY-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

Net zoals het nvidia-smi hulpprogramma informatie geeft over geïnstalleerde GPU's en draaiende rekenprocessen, heeft SynapseAI een vergelijkbaar programma. Je kunt het draaien om een rapport te krijgen over de huidige staat van de Gaudi 2 AI versnellers:

hl-smi

Stap 2. TensorFlow test

TensorFlow is een van de populairste platforms voor machinaal leren. Met hetzelfde installatiescript kunt u een vooraf gebouwde versie van TensorFlow installeren met ondersteuning voor Gaudi 2-acceleratoren. Laten we beginnen met het installeren van de algemene afhankelijkheden:

./habanalabs-installer.sh install -t dependencies

Vervolgens installeren we de afhankelijkheden voor TensorFlow:

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

Installeer het TensorFlow platform in een virtuele omgeving die geïmplementeerd is met behulp van het Python Virtual Environment (venv) mechanisme:

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

Laten we de gecreëerde virtuele omgeving activeren:

source habanalabs-venv/bin/activate

Maak een eenvoudig Python-codevoorbeeld dat gebruikmaakt van de mogelijkheden van de Gaudi 2-versnellers:

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()

Voer tot slot de toepassing uit:

python3 example.py

Voer het volgende commando uit om de virtuele omgeving af te sluiten:

deactivate

Stap 3. Trainingsarchief klonen

Kloon het archief met de MLperf code:

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

Maak een aparte map die gebruikt zal worden door de Docker container met MLperf:

mkdir -p mlperf

Wijzig de directory:

cd mlperf

Laten we enkele omgevingsvariabelen exporteren:

export MLPERF_DIR=/home/usergpu/mlperf

export SCRATCH_DIR=/home/usergpu/mlperf/scratch

export DATASETS_DIR=/home/usergpu/mlperf/datasets

Maak nieuwe mappen aan met de aangemaakte variabelen:

mkdir -p $MLPERF_DIR/Habana

mkdir -p $SCRATCH_DIR

mkdir -p $DATASETS_DIR

Kopieer de benchmark app naar $MLPERF_DIR/Habana:

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

Exporteer een andere variabele die een link opslaat om de gewenste versie van de Docker-container te downloaden:

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

Stap 4. Docker installeren

Onze instantie draait Ubuntu Linux 22.04 LTS en ondersteunt Docker niet standaard. Dus voordat je containers kunt downloaden en uitvoeren, moet je Docker-ondersteuning installeren. Laten we de pakketcache verversen en een aantal basispakketten installeren die je later nodig hebt:

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

Om Docker te installeren, moet je een digitaal ondertekende projectrepository toevoegen. Download de digitale handtekeningsleutel en voeg deze toe aan de sleutelopslag van het besturingssysteem:

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

Docker kan draaien op platformen met verschillende architecturen. Het volgende commando detecteert de architectuur van je server en voegt de overeenkomstige repository regel toe aan de APT package manager lijst:

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

Werk de pakketcache en het beleid bij en installeer docker-ce (Docker Community Edition):

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

Controleer tot slot of de Docker daemon draait:

sudo systemctl status docker

Stap 5. Docker-container uitvoeren

Laten we de container starten in bevoorrechte modus met behulp van de eerder opgegeven variabelen:

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

Voor het gemak kun je via SSH toegang krijgen tot de terminal in de container:

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

Voer het volgende commando uit om een commandoshell (bash) te openen in de huidige sessie:

sudo docker exec -it mlperf3.0 bash

Stap 6. Een dataset voorbereiden

Om Bert implementatietests uit te voeren vanuit MLperf, hebt u een voorbereide dataset nodig. De optimale methode is om een dataset te genereren van vooraf geladen gegevens. De MLperf-repository bevat een speciaal script, prepare_data.sh, dat een specifieke set pakketten nodig heeft om te functioneren. Laten we naar de volgende directory navigeren:

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

Installeer alle vereiste pakketten met behulp van de vooraf gegenereerde lijst en de pip package manager:

pip install -r requirements.txt

Stel de PYTORCH_BERT_DATA variabele in om het script te instrueren waar de gegevens opgeslagen moeten worden:

export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert

Voer het script uit:

bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATA

De generatieprocedure duurt vrij lang en kan enkele uren in beslag nemen. Wees geduldig en onderbreek het proces niet. Als je van plan bent om de verbinding met de SSH-sessie te verbreken, is het aan te raden om het schermhulpprogramma te gebruiken vlak voordat je de Docker-container start.

Stap 7. De dataset verpakken

De volgende stap is het "knippen" van de dataset in gelijke stukken voor de daaropvolgende lancering van MLperf. Laten we een aparte map maken voor ingepakte gegevens:

mkdir $PYTORCH_BERT_DATA/packed

Voer het verpakkingsscript uit:

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

Stap 8. Voer een test uit

Nu de dataset is voorbereid, is het tijd om de test uit te voeren. Het is echter onmogelijk om dit te doen zonder voorafgaande voorbereiding. De auteurs van de Bert-test hebben een aantal hardgecodeerde waarden in het script laten staan, die de uitvoering van de test zullen verstoren. Hernoem eerst de volgende directory:

mv $PYTORCH_BERT_DATA/packed $PYTORCH_BERT_DATA/packed_data_500_pt

Wijzig de directory:

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

Omdat de GNU Nano editor niet in de container is geïnstalleerd, moet deze apart worden geïnstalleerd. Als alternatief kunt u de ingebouwde Vi editor gebruiken:

apt update && apt -y install nano

Bewerk nu het testscript:

nano launch_bert_pytorch.sh

Zoek de eerste regel:

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

Vervang door het volgende:

DATA_ROOT=/root/datasets/pytorch_bert

Zoek de tweede regel:

INPUT_DIR=$DATA_ROOT/packed

Vervang door het volgende:

INPUT_DIR=$DATA_ROOT/packed_data_500_pt

Sla het bestand op en sluit af.

De testcode bevat een begrenzingsfunctie die ervoor zorgt dat de gradiënt bepaalde waarden niet overschrijdt, waardoor potentiële exponentiële groei wordt voorkomen. Om ons onbekende redenen is deze functie afwezig in de PyTorch-versie die wordt gebruikt in de container, waardoor de test abnormaal eindigt tijdens de opwarmfase.

Een mogelijke oplossing is om deze functie tijdelijk te verwijderen uit de code in het fastddp.py bestand. Open hiervoor het bestand:

nano ../PyTorch/fastddp.py

Zoek en becommentarieer de volgende drie regels code met behulp van het # (shebang symbool) zodat ze er als volgt uitzien:

#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))

Sla ook het bestand op en sluit af. Verander de map:

cd ../HLS-Gaudi2-PT

Voer tot slot het script uit. Het zal ongeveer 20 minuten duren om te voltooien:

./launch_bert_pytorch.sh

Zie ook:

NVIDIA® RTX™ 50: verwachtingen en realiteit

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.

Laten we eerst eens kijken naar de line-up. De RTX™ 40-serie werd gelanceerd met 6 modellen, variërend van de RTX™ 4060 tot de RTX™ 4090. Hoewel velen een soortgelijke reeks verwachtten voor de RTX™ 50-serie, gebeurde dat niet. In plaats daarvan omvat de RTX™ 50-serie slechts 4 modellen: RTX™ 5070, RTX™ 5070 Ti, RTX™ 5080 en RTX™ 5090. Mogelijk zien we in de toekomst zowel de RTX™ 5050 als RTX5060, maar er zijn nog geen officiële bronnen die deze grafische kaarten hebben geverifieerd.

Technologisch proces

De wet van Moore, de empirische observatie dat "het aantal transistors in een geïntegreerd circuit ongeveer elke twee jaar verdubbelt", wordt vaak gezegd dat deze niet langer relevant is voor de prestaties van chips. Sinds 2022 heeft Jensen Huang de wet van Moore herhaaldelijk doodverklaard. In plaats daarvan stelde hij een nieuw concept voor dat de nadruk legt op de gelijktijdige ontwikkeling van architectuur, microchips, softwarebibliotheken en algoritmen.

Samen zorgt deze verschuiving ervoor dat we ons kunnen richten op de algehele systeemprestaties in plaats van alleen op het aantal transistors. Het concept van computerefficiëntie heeft geleid tot voortdurende discussies in de technische gemeenschap. Hoewel de meningen over dit onderwerp uiteenlopen, wordt de industrie duidelijk geconfronteerd met zowel fysieke als economische barrières voor verdere miniaturisatie.

Laten we eens kijken naar de nieuwe generatie GPU-procestechnologie. De presentatie vermeldde dit niet specifiek, maar alle kaarten van de vorige generatie waren gebouwd op het 4N-proces. The RTX™ 50 series uses a different 4NP process technology. Tegelijkertijd is het belangrijk om te begrijpen dat 4N en 4NP slechts marketingnamen zijn. De transistors zelf blijven 5 nm groot.

De verbeterde 4NP procestechnologie maakt vooral een hogere transistordichtheid op de chip en hogere kloksnelheden mogelijk. Hoewel experts voorspelden dat de RTX™ 50 dezelfde procestechnologie zou gebruiken als de RTX™ 40, hadden ze het technisch gezien mis, zij het niet veel, aangezien de transistorgrootte ongewijzigd blijft en TSMC de fabrikant blijft.

Aantal kernen

Voorafgaand aan de release van de RTX™ 50-serie onthulden talrijke datalekken de basiskenmerken van de GPU. Eerste insiderrapporten uit juli 2024 suggereerden dat het vlaggenschip 24.576 cores zou hebben, 192 Ray-tracing cores en 768 Tensor cores. Latere lekken hebben deze getallen echter aangepast naar meer realistische waarden.

De uiteindelijke RTX™ 5090 werd geleverd met 21,760 CUDA® cores (tegenover 16.384 van de RTX™ 4090), 170 Ray-tracing cores en 680 Tensor cores. Dit komt overeen met de recente strategie van het bedrijf om de prestaties te verbeteren, niet alleen door het aantal transistors te verhogen, maar door de architectuur uitgebreid te optimaliseren.

Geheugen

Het gebruik van GDDR7-geheugen door de nieuwe GPU's kwam niet als een verrassing. Industrie-experts hadden deze stap in 2024 voorspeld nadat de drie grootste fabrikanten (Samsung, Micron en SK hynix) hun GDDR7-prototypes na elkaar hadden getoond. NVIDIA® was gul met geheugenverdeling: het basismodel RTX™ 5070 heeft 12 GB GDDR7 op een 192-bit bus, terwijl de RTX™ 5070 Ti and RTX™ 5080 beide 16 GB GDDR7 op een 256-bit bus hebben. Aan de bovenkant wordt het vlaggenschip RTX™ 5090 geleverd met een enorme 32 GB GDDR7 op een 512-bit bus.

Experts voorspelden aanvankelijk dat de maximale doorvoer van deze geheugenconfiguratie 1,5 Tbps zou zijn. De werkelijkheid overtrof deze verwachtingen echter, achieving a throughput of 1,7 Tbps. Deze drastische verbetering komt vooral ten goede aan de AI-verwerkingsmogelijkheden van de GPU en niet zozeer aan de gamingprestaties. De combinatie van hoge capaciteit en snel geheugen van de nieuwe generatie is vooral waardevol voor grote taalmodellen en generatieve neurale netwerken.

Technologieën

Voor gamers

Real-time ray tracing is een van de meest revolutionaire GPU-technologieën geworden en markeert het begin van de RTX-lijn. Voor veel consumenten is deze functie een belangrijke factor geweest in hun aankoopbeslissing. In de RTX™ 50-serie kaarten kan DLSS (Deep Learning Super Sampling) versie 4 een even belangrijke rol spelen. Deze technologie verhoogt de GPU-prestaties in games aanzienlijk door de hybride frame rendering aanpak.

Als DLSS is ingeschakeld, wordt in plaats van elk frame conventioneel te renderen, een aantal frames in realtime gegenereerd met behulp van AI. Vroege versies van deze technologie konden frames alleen opschalen naar hogere resoluties, maar DLSS 3 introduceerde een geavanceerdere mogelijkheid: voor elk conventioneel gerenderd frame kan het een extra door AI gemaakt frame genereren.

DLSS 4 genereert drie AI-frames voor elk traditioneel gerenderd frame. This significantly increases the frame per second (FPS) without putting heavy load on the GPU. De AI analyseert object- en scènebewegingen om ervoor te zorgen dat de gegenereerde frames goed overeenkomen met conventioneel gerenderde frames.

Dit roept een belangrijke vraag op: hoe gaan we om met input lag? Omdat het genereren van frames tijd kost, draagt elke iteratie bij aan de reactietijd. Een vloeiend beeld met een trage reactie op acties van spelers kan de spelervaring ernstig beïnvloeden. To address this, NVIDIA® has improved their Reflex 2 technology alongside DLSS to minimize latency.

Daarom is Frame Warp in het systeem geïntegreerd. Deze technologie vermindert de latentie van games door gerenderde frames vlak voor weergave bij te werken met de laatste muisinvoer. Het verbetert zowel de multiplayer-competitie als de reactiesnelheid van de singleplayer.

Voor makers van content

De RTX™ 50-serie is niet alleen voor gaming. Makers van videocontent zullen aanzienlijke waarde vinden in deze nieuwe GPU's. Het vlaggenschip, de RTX™ 5090, is uitgerust met 3 encoders en 2 decoders, vergeleken met de 2 encoders en 1 decoder van de RTX™ 4090. Deze componenten zijn verbeterd door samenwerking met marktleiders: Adobe, Blackmagic Design, ByteDance en Wondershare. As a result, the RTX™ 5090 renders video 60% faster than the RTX™ 4090 and four times faster than the RTX™ 3090.

Naast ruwe snelheidsverbeteringen is ook de kwaliteit verbeterd. 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%. Dit betekent snellere videoweergave op de RTX™ 5090 en kortere tijd tussen montage en productie.

Conclusie

Als we zes maanden terugkijken, zijn de voorspellingen en verwachtingen van de experts te optimistisch gebleken. Naarmate de releasedatum naderde, werd het duidelijk dat de nieuwe GPU's meer zouden bieden dan alleen extra rekeneenheden. The key innovation would be new optimization and AI technologies enhancing existing frame rendering systems.

Op CES 2025 werd tijdens de presentatie van de GPU 50-serie een nieuw AI-tijdperk onthuld. Deze visie schetste een wereld waarin digitale assistenten en robots complexe taken uitvoeren. De kern zou bestaan uit een ecosysteem dat supercomputers voor AI-training combineert met betaalbare inferentieversnellers voor consumentenapparaten en veelzijdige software die zowel lokaal als in de cloud werkt. Hoewel de volledige omvang van deze toekomst onzeker blijft, is één ding duidelijk: we staan op de drempel om science fiction werkelijkheid te laten worden.

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.

Zie ook:

Voordelen en nadelen van GPU delen

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

De Wet van Moore is al bijna een halve eeuw relevant. Processorchips blijven meer transistors bevatten en technologieën gaan dagelijks vooruit. Naarmate de technologie zich ontwikkelt, verandert ook onze benadering van computergebruik. De opkomst van bepaalde computertaken heeft de ontwikkeling van hardware aanzienlijk beïnvloed. Apparaten die oorspronkelijk ontworpen waren voor grafische verwerking zijn nu bijvoorbeeld belangrijke, betaalbare hulpmiddelen voor moderne neurale netwerken.

Het beheer van computermiddelen is ook veranderd. Massadiensten gebruiken nu zelden nog mainframes, zoals in de jaren 1970 en 1980. In plaats daarvan geven ze de voorkeur aan clouddiensten of het bouwen van hun eigen infrastructuur. Deze verschuiving heeft de eisen van de klant veranderd, met een focus op snel, on-demand schalen en het maximaliseren van het gebruik van toegewezen computerbronnen.

Virtualisatie- en containerisatietechnologieën zijn als oplossingen naar voren gekomen. Applicaties worden nu verpakt in containers met alle benodigde bibliotheken, wat het uitrollen en schalen vereenvoudigt. Handmatig beheer werd echter onpraktisch toen het aantal containers in de duizenden steeg. Gespecialiseerde orchestrators zoals Kubernetes zorgen nu voor effectief beheer en schaling. Deze tools zijn een essentieel onderdeel geworden van elke moderne IT-infrastructuur.

Servervirtualisatie

Tegelijkertijd ontwikkelden virtualisatietechnologieën zich, waardoor het mogelijk werd om geïsoleerde omgevingen te creëren binnen een enkele fysieke server. Virtuele machines gedragen zich identiek aan gewone fysieke servers, waardoor het gebruik van standaard beheertools mogelijk is. Afhankelijk van de hypervisor wordt vaak een gespecialiseerde API meegeleverd, die het automatiseren van routineprocedures vergemakkelijkt.

Deze flexibiliteit gaat echter gepaard met verminderde beveiliging. Aanvallers hebben hun focus verlegd van het aanvallen van individuele virtuele machines naar het uitbuiten van zwakke plekken in de hypervisor. Door de controle over een hypervisor te krijgen, kunnen aanvallers naar believen toegang krijgen tot alle gekoppelde virtuele machines. Ondanks voortdurende verbeteringen in de beveiliging blijven moderne hypervisors aantrekkelijke doelwitten.

Traditionele virtualisatie pakt twee belangrijke problemen aan. Eerste probleem: het zorgt voor de isolatie van virtuele machines van elkaar. Bare-metal oplossingen omzeilen dit probleem omdat klanten volledige fysieke servers onder hun beheer huren. Maar voor virtuele machines is isolatie softwaregebaseerd op het niveau van de hypervisor. Een fout in de code of een willekeurige bug kan deze isolatie in gevaar brengen, waardoor gegevens kunnen uitlekken of beschadigd raken.

Het tweede probleem betreft resource management. Hoewel het mogelijk is om de toewijzing van resources aan specifieke virtuele machines te garanderen, vormt het beheer van een groot aantal machines een dilemma. Resources kunnen onderbenut raken, wat resulteert in minder virtuele machines per fysieke server. Dit scenario is onrendabel voor de infrastructuur en leidt onvermijdelijk tot prijsverhogingen.

Als alternatief kun je mechanismen voor automatisch resourcebeheer gebruiken. Hoewel een virtuele machine specifieke gedeclareerde karakteristieken krijgt toegewezen, wordt in feite alleen het vereiste minimum geleverd binnen deze limieten. Als de machine meer processortijd of RAM nodig heeft, zal de hypervisor proberen dit te leveren, maar kan dit niet garanderen. Deze situatie is vergelijkbaar met het overboeken van vliegtuigen, waarbij luchtvaartmaatschappijen meer tickets verkopen dan er stoelen beschikbaar zijn.

De logica is identiek. Als statistieken aantonen dat ongeveer 10% van de passagiers niet op tijd komt voor hun vlucht, kunnen luchtvaartmaatschappijen 10% meer tickets verkopen met een minimaal risico. Als alle passagiers komen, zullen sommige passagiers niet aan boord passen. De luchtvaartmaatschappij zal kleine gevolgen ondervinden in de vorm van compensatie, maar zal waarschijnlijk doorgaan met deze praktijk.

Veel infrastructuuraanbieders hanteren een vergelijkbare strategie. Sommigen zijn er transparant over en geven aan dat ze geen constante beschikbaarheid van computermiddelen garanderen, maar wel aanzienlijk lagere prijzen bieden. Anderen gebruiken soortgelijke mechanismen zonder er reclame voor te maken. Ze gokken erop dat niet alle klanten consequent 100% van hun serverresources zullen gebruiken, en zelfs als sommigen dat doen, zullen ze in de minderheid zijn. Ondertussen genereren ongebruikte bronnen winst.

In deze context hebben bare-metal oplossingen een voordeel. Ze garanderen dat toegewezen resources volledig worden beheerd door de klant en niet worden gedeeld met andere gebruikers van de infrastructuurleverancier. Dit elimineert scenario's waarbij een hoge belasting door een gebruiker van een naburige server de prestaties negatief beïnvloedt.

GPU-virtualisatie

Klassieke virtualisatie wordt onvermijdelijk geconfronteerd met de uitdaging van het emuleren van fysieke apparaten. Om de overheadkosten te beperken, zijn er speciale technologieën ontwikkeld waarmee virtuele machines rechtstreeks toegang hebben tot de fysieke apparaten van de server. Deze aanpak werkt in veel gevallen goed, maar wanneer deze wordt toegepast op grafische processors, levert dit direct beperkingen op. Als een server bijvoorbeeld 8 GPU's heeft geïnstalleerd, hebben slechts 8 virtuele machines toegang.

Om deze beperking te omzeilen werd de vGPU-technologie uitgevonden. Deze verdeelt een GPU in meerdere logische GPU's, die vervolgens kunnen worden toegewezen aan virtuele machines. Hierdoor kan elke virtuele machine zijn "stukje taart" krijgen en is hun totale aantal niet langer beperkt door het aantal videokaarten dat in de server is geïnstalleerd.

Virtuele GPU's worden het meest gebruikt bij het bouwen van VDI (Virtual Desktop Infrastructure) in gebieden waar virtuele machines 3D-versnelling nodig hebben. Bij een virtuele werkplek voor een ontwerper of planner gaat het bijvoorbeeld meestal om grafische verwerking. De meeste toepassingen op deze gebieden voeren berekeningen uit op zowel de centrale processor als de GPU. Deze hybride aanpak verhoogt de productiviteit aanzienlijk en zorgt voor een optimaal gebruik van de beschikbare computerbronnen.

Deze technologie heeft echter een aantal nadelen. Het wordt niet ondersteund door alle GPU's en is alleen beschikbaar in het serversegment. De ondersteuning is ook afhankelijk van de geïnstalleerde versie van het besturingssysteem en de GPU-driver. vGPU heeft een apart licentiemechanisme, wat de operationele kosten aanzienlijk verhoogt. Bovendien kunnen de softwarecomponenten mogelijk dienen als aanvalsvector.

Onlangs werd informatie gepubliceerd over acht kwetsbaarheden die alle gebruikers van NVIDIA® GPU's treffen. Zes kwetsbaarheden werden vastgesteld in GPU-stuurprogramma's en twee in de vGPU-software. Deze problemen werden snel verholpen, maar het herinnert ons eraan dat isolatiemechanismen in dergelijke systemen niet feilloos zijn. Constante bewaking en tijdige installatie van updates blijven de belangrijkste manieren om de veiligheid te garanderen.

Bij het bouwen van infrastructuur om vertrouwelijke en gevoelige gebruikersgegevens te verwerken, wordt elke virtualisatie een potentiële risicofactor. In dergelijke gevallen kan een bare-metal aanpak een betere kwaliteit en beveiliging bieden.

Conclusie

Het bouwen van een computerinfrastructuur vereist altijd een risicobeoordeling. Belangrijke vragen om te overwegen zijn onder andere: Zijn klantgegevens veilig beschermd? Creëren de gekozen technologieën extra aanvalsvectoren? Hoe kunnen potentiële kwetsbaarheden worden geïsoleerd en geëlimineerd? Het beantwoorden van deze vragen helpt om weloverwogen keuzes te maken en toekomstige problemen te voorkomen.

Bij LeaderGPU zijn we tot een duidelijke conclusie gekomen: op dit moment is bare-metal technologie superieur in het waarborgen van de veiligheid van gebruikersgegevens, terwijl het dient als een uitstekende basis voor het bouwen van een bare-metal cloud. Deze aanpak stelt onze klanten in staat om flexibiliteit te behouden zonder de extra risico's van GPU-virtualisatie.

Zie ook:

Wat is kennisdistillatie

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

Grote taalmodellen (LLM's) zijn door hun unieke mogelijkheden een integraal onderdeel van ons leven geworden. Ze begrijpen context en genereren op basis daarvan samenhangende, uitgebreide teksten. Ze kunnen elke taal verwerken en erop reageren, rekening houdend met de culturele nuances van elke taal.

LLM's blinken uit in complexe problemen oplossen, programmeren, gesprekken voeren en nog veel meer. Deze veelzijdigheid komt voort uit het verwerken van enorme hoeveelheden trainingsgegevens, vandaar de term "groot". Deze modellen kunnen tientallen of honderden miljarden parameters bevatten, waardoor ze veel resources vereisen voor dagelijks gebruik.

Training is het meest veeleisende proces. Neurale netwerkmodellen leren door enorme datasets te verwerken en hun interne "gewichten" aan te passen om stabiele verbindingen tussen neuronen te vormen. Deze verbindingen slaan kennis op die het getrainde neurale netwerk later kan gebruiken op eindapparaten.

De meeste eindapparaten beschikken echter niet over de nodige rekenkracht om deze modellen uit te voeren. Voor het uitvoeren van de volledige versie van Llama 2 (70B parameters) is bijvoorbeeld een GPU met 48 GB videogeheugen nodig, hardware die maar weinig gebruikers thuis hebben, laat staan op mobiele apparaten.

Daarom werken de meeste moderne neurale netwerken in een cloud-infrastructuur in plaats van op draagbare apparaten, die via API's toegang hebben tot deze netwerken. Toch boeken fabrikanten op twee manieren vooruitgang: ze rusten apparaten uit met gespecialiseerde rekeneenheden zoals NPU's en ontwikkelen methoden om de prestaties van compacte neurale netwerkmodellen te verbeteren.

De omvang verkleinen

Het teveel wegsnijden

Quantisatie is de eerste en meest effectieve methode om de grootte van het neurale netwerk te verkleinen. Gewichten van neurale netwerken gebruiken meestal 32-bits drijvendekomma getallen, maar we kunnen ze verkleinen door dit formaat te wijzigen. Het gebruik van 8-bits waarden (of zelfs binaire waarden in sommige gevallen) kan de grootte van het netwerk vertienvoudigen, hoewel dit de nauwkeurigheid van de antwoorden aanzienlijk vermindert.

Pruning is een andere aanpak, waarbij onbelangrijke verbindingen in het neurale netwerk worden verwijderd. Dit proces werkt zowel tijdens de training als bij voltooide netwerken. Naast alleen verbindingen kan snoeien ook neuronen of hele lagen verwijderen. Deze vermindering in parameters en verbindingen leidt tot een lager geheugengebruik.

Matrix- of tensordecompositie is de derde veelgebruikte techniek om de grootte te reduceren. Het opsplitsen van een grote matrix in een product van drie kleinere matrices vermindert het totaal aantal parameters met behoud van kwaliteit. Dit kan de grootte van het netwerk tientallen keren verkleinen. Tensor decompositie biedt nog betere resultaten, maar vereist meer hyperparameters.

Hoewel deze methoden effectief de grootte verkleinen, hebben ze allemaal te maken met kwaliteitsverlies. Grote gecomprimeerde modellen presteren beter dan hun kleinere, niet-gecomprimeerde tegenhangers, maar bij elke compressie bestaat het risico dat de antwoordnauwkeurigheid afneemt. Kennisdistillatie is een interessante poging om een balans te vinden tussen kwaliteit en grootte.

Laten we het samen proberen

Kennisdistillatie kan het best worden uitgelegd aan de hand van de analogie van een leerling en een leraar. Terwijl studenten leren, geven docenten les en werken ze hun bestaande kennis voortdurend bij. Wanneer beiden op nieuwe kennis stuiten, heeft de leraar een voordeel, hij kan putten uit zijn brede kennis van andere gebieden, terwijl de student deze basis nog niet heeft.

Dit principe is van toepassing op neurale netwerken. Wanneer twee neurale netwerken van hetzelfde type maar van verschillende grootte op identieke gegevens worden getraind, presteert het grotere netwerk meestal beter. Zijn grotere capaciteit voor "kennis" maakt nauwkeurigere reacties mogelijk dan zijn kleinere tegenhanger. Dit roept een interessante mogelijkheid op: waarom trainen we het kleinere netwerk niet niet alleen op de dataset, maar ook op de nauwkeurigere uitkomsten van het grotere netwerk?

Dit proces is kennisdistillatie: een vorm van supervised learning waarbij een kleiner model leert om de voorspellingen van een groter model te repliceren. Hoewel deze techniek helpt om het kwaliteitsverlies door het verkleinen van het neurale netwerk te compenseren, vereist het wel extra rekenkracht en trainingstijd.

Software en logica

Nu de theoretische basis duidelijk is, kunnen we het proces vanuit een technisch perspectief bekijken. We beginnen met softwaretools die je door de training en kennisdistillatie kunnen leiden.

Python, samen met de TorchTune bibliotheek van het PyTorch ecosysteem, biedt de eenvoudigste aanpak voor het bestuderen en fine-tunen van grote taalmodellen. Dit is hoe de toepassing werkt:

Er worden twee modellen geladen: een volledig model (leraar) en een gereduceerd model (leerling). Tijdens elke trainings iteratie genereert het teacher model hoge temperatuur voorspellingen terwijl het student model de dataset verwerkt om zijn eigen voorspellingen te doen.

De ruwe uitvoerwaarden (logits) van beide modellen worden geëvalueerd met behulp van een verliesfunctie (een numerieke maat voor hoeveel een voorspelling afwijkt van de juiste waarde). Gewichtsaanpassingen worden dan toegepast op het leerlingmodel door middel van backpropagatie. Hierdoor kan het kleinere model leren en de voorspellingen van het leraarmodel repliceren.

Het primaire configuratiebestand in de applicatiecode wordt een recept genoemd. In dit bestand worden alle distillatieparameters en instellingen opgeslagen, waardoor experimenten reproduceerbaar worden en onderzoekers kunnen bijhouden hoe verschillende parameters het uiteindelijke resultaat beïnvloeden.

Bij het selecteren van parameterwaarden en iteratietellingen is het behouden van evenwicht cruciaal. Een model dat te veel gedistilleerd heeft, kan zijn vermogen verliezen om subtiele details en context te herkennen, waardoor het terugvalt op standaard reacties. Hoewel een perfecte balans bijna onmogelijk te bereiken is, kan het zorgvuldig bewaken van het destillatieproces de voorspellingskwaliteit van zelfs bescheiden neurale netwerkmodellen aanzienlijk verbeteren.

Het is ook de moeite waard om aandacht te besteden aan monitoring tijdens het trainingsproces. Dit zal helpen om problemen op tijd te identificeren en onmiddellijk te corrigeren. Hiervoor kun je de tool TensorBoard gebruiken. Het integreert naadloos in PyTorch-projecten en stelt je in staat om veel metrieken visueel te evalueren, zoals nauwkeurigheid en verliezen. Bovendien kun je er een modeldiagram mee maken en het geheugengebruik en de uitvoeringstijd van bewerkingen mee bijhouden.

Conclusie

Kennisdistillatie is een effectieve methode voor het optimaliseren van neurale netwerken om compacte modellen te verbeteren. Het werkt het beste wanneer het balanceren van prestaties met antwoordkwaliteit essentieel is.

Hoewel kennisdestillatie zorgvuldig toezicht vereist, kunnen de resultaten opmerkelijk zijn. Modellen worden veel kleiner met behoud van voorspellingskwaliteit en ze presteren beter met minder rekenkracht.

Als kennisdestillatie goed wordt gepland met de juiste parameters, is het een belangrijk hulpmiddel om compacte neurale netwerken te maken zonder aan kwaliteit in te boeten.

Zie ook:

AudioCraft van MetaAI: muziek maken op basis van beschrijving

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

Moderne generatieve neurale netwerken worden steeds slimmer. Ze schrijven verhalen, voeren gesprekken met mensen en creëren ultrarealistische beelden. Nu kunnen ze eenvoudige muziektracks produceren zonder dat daar professionele artiesten voor nodig zijn. Deze toekomst is vandaag werkelijkheid geworden. Dat was te verwachten, want muzikale harmonieën en ritmes zijn geworteld in wiskundige principes.

Meta heeft zijn toewijding aan de wereld van open-source software aangetoond. Ze hebben drie neurale netwerkmodellen openbaar gemaakt waarmee geluiden en muziek kunnen worden gemaakt van tekstbeschrijvingen:

MusicGen - genereert muziek uit tekst.
AudioGen - genereert audio uit tekst.
EnCodec - neurale audiocompressor van hoge kwaliteit.

MusicGen is getraind op 20.000 uur muziek. U kunt het lokaal gebruiken via speciale LeaderGPU-servers als platform.

Standaard installatie

Update de pakket cache repository:

sudo apt update && sudo apt -y upgrade

Installeer de Python pakketbeheerder, pip, en de ffmpeg bibliotheken:

sudo apt -y install python3-pip ffmpeg

Installeer torch 2.0 of nieuwer met pip:

pip install 'torch>=2.0'

De volgende opdracht installeert automatisch audiocraft en alle benodigde afhankelijkheden:

pip install -U audiocraft

Laten we een eenvoudige Python app schrijven, die gebruik maakt van het grote voorgetrainde MusicGen model met 3,3B parameters:

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")

De gemaakte app uitvoeren:

python3 generate.py

Na een paar seconden verschijnt het gegenereerde bestand (0.wav) in de map.

Koffie Vampir 3

Kloon een projectrepository:

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

Open de gekloonde map:

cd audiocraft-webui

Voer het commando uit dat je systeem voorbereidt en alle benodigde pakketten installeert:

pip install -r requirements.txt

Start vervolgens de Coffee Vampire 3 server met het volgende commando:

python3 webui.py

Coffee Vampire 3 gebruikt Flask als framework. Standaard draait het op localhost met poort 5000. Als je toegang op afstand wilt, gebruik dan de poort doorstuurfunctie in je SSH-client. Anders kun je een VPN-verbinding met de server organiseren.

Let op! Dit is een potentieel gevaarlijke actie; gebruik op eigen risico:

nano webui.py

Scroll naar beneden en vervang socketio.run(app) door socketio.run(app, host=’0.0.0.0’, port=5000)

Sla het bestand op en start de server met het bovenstaande commando. Dit geeft toegang tot de server vanaf het openbare internet zonder enige authenticatie.

Vergeet niet disable AdBlock software te gebruiken, omdat dit de muziekspeler aan de rechterkant van de webpagina kan blokkeren. Je kunt beginnen door de prompt in te voeren en te bevestigen met de knop Submit:

TTS-generatie WebUI

Stap 1. Stuurprogramma's

Werk de pakketcache-repository bij:

sudo apt update && sudo apt -y upgrade

Installeer Nvidia-stuurprogramma's met het automatische installatieprogramma of met onze gids Nvidia-stuurprogramma's installeren in Linux:

sudo ubuntu-drivers autoinstall

Start de server opnieuw op:

sudo shutdown -r now

Stap 2. Docker

De volgende stap is het installeren van Docker. Laten we enkele pakketten installeren die moeten worden toegevoegd aan de Docker-repository:

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

Download de Docker GPG-sleutel en sla deze op:

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

Voeg de repository toe:

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

Installeer Docker CE (Community Edition) met CLI en de containerd runtime:

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

Voeg de huidige gebruiker toe aan de docker groep:

sudo usermod -aG docker $USER

Wijzigingen toepassen zonder uit- en aanmeldprocedure:

newgrp docker

Stap 3. GPU passthrough

Laten we NVIDIA® GPU's passthrough inschakelen in Docker. Het volgende commando leest de huidige OS-versie in de distributievariabele, die we in de volgende stap kunnen gebruiken:

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

Download de GPG-sleutel van de Nvidia-repository en sla deze op:

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

Download de lijst met Nvidia-repositories en sla deze op voor gebruik in de standaard APT-pakketbeheerder:

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

Werk de pakketcache-repository bij en installeer de GPU passthrough toolkit:

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

Start de Docker-daemon opnieuw:

sudo systemctl restart docker

Stap 4. WebUI

Download het archief van het archief:

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

Uitpakken:

unzip main.zip

Open de map van het project:

cd tts-generation-webui-main

Start het bouwen van de image:

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

Voer de aangemaakte container uit:

docker compose up -d

Nu kun je http://[server_ip]:7860 openen, je prompt intypen, het benodigde model selecteren en op de knop Generate klikken:

Het systeem downloadt automatisch het geselecteerde model tijdens de eerste generatie. Veel plezier!

Zie ook:

Hoe de LangFlow-toepassing monitoren

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

In ons artikel Low-code AI app builder Langflow hebben we onderzocht hoe je aan de slag kunt met de visuele programmeeromgeving van deze low-code AI app builder. Hiermee kan iedereen, zelfs mensen zonder programmeerkennis, toepassingen bouwen die worden aangedreven door grote neurale netwerkmodellen. Dit kunnen AI chatbots zijn of toepassingen voor documentverwerking die inhoud kunnen analyseren en samenvatten.

Langflow gebruikt een bouwsteenbenadering waarbij gebruikers vooraf gemaakte componenten met elkaar verbinden om hun gewenste toepassing te creëren. Er zijn echter twee belangrijke uitdagingen: het oplossen van problemen wanneer neurale netwerken zich onverwacht gedragen en het beheren van de kosten. Neurale netwerken vereisen aanzienlijke rekenkracht, waardoor het essentieel is om de infrastructuurkosten te bewaken en te voorspellen.

LangWatch pakt beide uitdagingen aan. Deze gespecialiseerde tool helpt Langflow ontwikkelaars om verzoeken van gebruikers te monitoren, kosten bij te houden en afwijkingen te detecteren, zoals wanneer toepassingen op onbedoelde manieren worden gebruikt.

Deze tool is oorspronkelijk ontworpen als een service, maar kan op elke server worden ingezet, ook lokaal. Het integreert met de meeste LLM-providers, zowel in de cloud als op locatie. Omdat LangWatch open source is, kan het aan bijna elk project worden aangepast: nieuwe functies toevoegen of verbinding maken met interne systemen.

Met LangWatch kun je waarschuwingen instellen wanneer specifieke statistieken bepaalde drempelwaarden overschrijden. Dit helpt u om onverwachte stijgingen in aanvraagkosten of ongewone responsvertragingen snel te detecteren. Vroegtijdige detectie helpt ongeplande uitgaven en potentiële serviceaanvallen voorkomen.

Voor onderzoekers van neurale netwerken maakt deze toepassing zowel monitoring als optimalisatie van veelvoorkomende gebruikersverzoeken mogelijk. Het biedt ook tools om de kwaliteit van modelreacties te evalueren en waar nodig aanpassingen te doen.

Snel aan de slag

Systeem voorbereiden

Net als bij Langflow is de eenvoudigste manier om de applicatie te draaien een Docker-container. Voordat je LangWatch installeert, moet je Docker Engine op je server installeren. Werk eerst je pakketcache en de pakketten bij naar de nieuwste versies:

sudo apt update && sudo apt -y upgrade

Installeer extra pakketten die Docker nodig heeft:

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

Download de GPG-sleutel om de officiële Docker-repository toe te voegen:

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

Voeg de repository toe aan APT met de sleutel die je eerder hebt gedownload en geïnstalleerd:

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

Vernieuw de pakketlijst:

sudo apt update

Om ervoor te zorgen dat Docker wordt geïnstalleerd vanuit de nieuw toegevoegde repository en niet vanuit de systeemrepository, kun je het volgende commando uitvoeren:

apt-cache policy docker-ce

Docker Engine installeren:

sudo apt install docker-ce

Controleer of Docker met succes is geïnstalleerd en of de bijbehorende daemon draait en de status active (running) heeft:

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

Bouwen en uitvoeren

Als Docker Engine is geïnstalleerd en draait, kun je de LangWatch-toepassingsrepository downloaden:

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

De applicatie bevat een voorbeeldconfiguratiebestand met omgevingsvariabelen. Kopieer dit bestand zodat het image build hulpprogramma het kan verwerken:

cp langwatch/.env.example langwatch/.env

Nu ben je klaar voor de eerste lancering:

sudo docker compose up --build

Het systeem neemt even de tijd om alle benodigde containerlagen voor LangWatch te downloaden. Zodra dit is voltooid, ziet u een consolebericht dat aangeeft dat de applicatie beschikbaar is op:

http://[LeaderGPU_IP_address]:3000

Navigeer naar deze pagina in uw browser, waar u wordt gevraagd om een gebruikersaccount aan te maken:

In tegenstelling tot Langflow heeft dit systeem standaard verificatie ingeschakeld. Na het inloggen moet u het systeem configureren om gegevens van uw Langflow server te verzamelen.

Langflow integratie

LangWatch heeft een gegevensbron nodig om te functioneren. De server luistert op poort 3000 en gebruikt een RESTful API, die inkomende gegevens authenticeert via een automatisch gegenereerde API-sleutel.

Om gegevensoverdracht mogelijk te maken, moet je twee variabelen instellen in de Langflow configuratiebestanden: LANGWATCH_ENDPOINT en LANGWATCH_API_KEY. Maak eerst een SSH-verbinding met je Langflow server (die offline moet zijn tijdens dit proces).

Navigeer naar de map met de voorbeeldconfiguratie voor Docker:

cd langflow/docker_example

Open het configuratiebestand om het te bewerken:

nano docker-compose.yml

Voeg in het gedeelte "omgeving:" de volgende variabelen toe (zonder haakjes [] of aanhalingstekens):

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

Het YML-bestand vereist een specifieke opmaak. Volg deze twee belangrijke regels:

Gebruik spaties (2 of 4) voor inspringen, nooit tabs.
Zorg voor een goede hiërarchische structuur met consistente inspringing.

Sla het bestand op met Ctrl + O en sluit de editor af met Ctrl + X, Langflow is nu klaar om te starten:

sudo docker compose up

Controleer na het starten of alles naar behoren werkt. Maak een nieuw project of open een bestaand project en start een dialoog via Playground. Langflow stuurt automatisch gegevens naar LangWatch voor monitoring, die u in de webinterface kunt bekijken.

In de sectie Integratieverificatie verschijnt een vinkje bij het item "Synchroniseer uw eerste bericht". Dit geeft aan dat de gegevens van Langflow met succes naar LangWatch stromen, wat bevestigt dat de instelling correct is. Laten we eens kijken wat er verschijnt in de sectie Messages:

Het gedeelte Berichten geeft de gegevens weer die in de toepassing zijn ingevoerd, de parameters die zijn gebruikt voor het genereren van reacties en de reactie van het neurale netwerk zelf. Je kunt de kwaliteit van de respons evalueren en verschillende filters gebruiken om de gegevens te sorteren, zelfs met honderden of duizenden berichten.

Na deze eerste installatie kunt u de functies van de toepassing systematisch verkennen. In het gedeelte Evaluations kun je algoritmen voor dialoogverificatie instellen voor dialoogmoderatie of gegevensherkenning, zoals PII Detection. Deze functie scant invoer op gevoelige informatie zoals sofi-nummers of telefoonnummers.

De applicatie biedt zowel lokale als cloud-gebaseerde opties via providers zoals Azure of Cloudflare. Om cloudfuncties te gebruiken, heb je een account nodig bij deze services, samen met hun eindpuntadressen en API-sleutels. Houd er rekening mee dat dit providers van derden zijn, dus controleer direct hun servicekosten.

Voor lokale opties beschikt de applicatie over geavanceerde RAG-mogelijkheden (Retrieval-augmented generation). Je kunt de nauwkeurigheid en relevantie van RAG-gegenereerde inhoud meten en de verzamelde statistieken gebruiken om het RAG-systeem te optimaliseren voor nauwkeurigere neurale netwerkreacties.

Zie ook:

Low-code AI-app bouwer Langflow

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

Softwareontwikkeling heeft de laatste jaren een enorme ontwikkeling doorgemaakt. Moderne programmeurs hebben nu toegang tot honderden programmeertalen en frameworks. Naast de traditionele imperatieve en declaratieve benaderingen is er een nieuwe en opwindende methode voor het maken van toepassingen in opkomst. Deze innovatieve aanpak maakt gebruik van de kracht van neurale netwerken en biedt ontwikkelaars fantastische mogelijkheden.

Mensen zijn gewend geraakt aan AI-assistenten in IDE's die helpen met het automatisch aanvullen van code en moderne neurale netwerken die eenvoudig code genereren voor eenvoudige Python-spelletjes. Er zijn echter nieuwe hybride tools in opkomst die een revolutie teweeg kunnen brengen in het ontwikkellandschap. Eén zo'n hulpmiddel is Langflow.

Langflow dient meerdere doelen. Voor professionele ontwikkelaars biedt het betere controle over complexe systemen zoals neurale netwerken. Voor degenen die niet bekend zijn met programmeren, kunnen er eenvoudige maar praktische toepassingen mee worden gemaakt. Deze doelen worden op verschillende manieren bereikt, die we in meer detail zullen bespreken.

Neurale netwerken

Het concept van een neuraal netwerk kan worden vereenvoudigd voor gebruikers. Stel je een zwarte doos voor die invoergegevens en parameters ontvangt die het uiteindelijke resultaat beïnvloeden. Deze doos verwerkt de invoer met behulp van complexe algoritmen, vaak "magie" genoemd, en produceert uitvoergegevens die aan de gebruiker kunnen worden gepresenteerd.

De innerlijke werking van deze zwarte doos varieert op basis van het ontwerp en de trainingsgegevens van het neurale netwerk. Het is cruciaal om te begrijpen dat ontwikkelaars en gebruikers nooit 100% zekerheid in resultaten kunnen bereiken. In tegenstelling tot traditioneel programmeren waarbij 2 + 2 altijd gelijk is aan 4, kan een neuraal netwerk dit antwoord met 99% zekerheid geven, waarbij er altijd een foutmarge is.

De controle over het "denkproces" van een neuraal netwerk is indirect. We kunnen alleen bepaalde parameters aanpassen, zoals de "temperatuur". Deze parameter bepaalt hoe creatief of beperkt het neurale netwerk kan zijn in zijn benadering. Een lage temperatuurwaarde beperkt het netwerk tot een meer formele, gestructureerde benadering van taken en oplossingen. Omgekeerd geven hoge temperatuurwaarden het netwerk meer vrijheid, wat mogelijk leidt tot het vertrouwen op minder betrouwbare feiten of zelfs het creëren van fictieve informatie.

Dit voorbeeld illustreert hoe gebruikers de uiteindelijke output kunnen beïnvloeden. Voor traditionele programmering vormt deze onzekerheid een grote uitdaging - fouten kunnen onverwacht verschijnen en specifieke resultaten worden onvoorspelbaar. Deze onvoorspelbaarheid is echter vooral een probleem voor computers, niet voor mensen die zich kunnen aanpassen aan wisselende output en deze kunnen interpreteren.

Als de output van een neuraal netwerk bedoeld is voor een mens, is de specifieke formulering die gebruikt wordt om het te beschrijven over het algemeen minder belangrijk. Gegeven de context kunnen mensen verschillende resultaten correct interpreteren vanuit het perspectief van de machine. Hoewel begrippen als "positieve waarde", "bereikt resultaat" of "positieve beslissing" voor een mens ongeveer hetzelfde kunnen betekenen, zou traditionele programmering moeite hebben met deze flexibiliteit. Het zou rekening moeten houden met alle mogelijke antwoordvariaties, wat bijna onmogelijk is.

Aan de andere kant, als de verdere verwerking wordt uitbesteed aan een ander neuraal netwerk, kan het het verkregen resultaat correct begrijpen en verwerken. Op basis hiervan kan het dan zijn eigen conclusie vormen met een zekere mate van vertrouwen, zoals eerder vermeld.

Low-code

De meeste programmeertalen bevatten code. Programmeurs creëren de logica voor elk onderdeel van een toepassing in hun hoofd en beschrijven deze vervolgens met taalspecifieke uitdrukkingen. Dit proces vormt een algoritme: een duidelijke opeenvolging van acties die leiden tot een specifiek, vooraf bepaald resultaat. Het is een complexe taak die een aanzienlijke mentale inspanning en een grondig begrip van de mogelijkheden van de taal vereist.

Het is echter niet nodig om het wiel opnieuw uit te vinden. Veel problemen waar moderne ontwikkelaars mee te maken hebben, zijn al op verschillende manieren opgelost. Relevante stukjes code zijn vaak te vinden op StackOverflow. Modern programmeren kan worden vergeleken met het in elkaar zetten van een geheel uit onderdelen van verschillende bouwsets. Het Lego-systeem biedt een succesvol model, waarbij verschillende sets onderdelen gestandaardiseerd zijn om compatibiliteit te garanderen.

De low-code programmeermethode volgt een vergelijkbaar principe. Verschillende stukken code worden aangepast zodat ze naadloos in elkaar passen en worden aan ontwikkelaars gepresenteerd als kant-en-klare blokken. Elk blok kan data-ingangen en -uitgangen hebben. Documentatie specificeert de taak die elk bloktype oplost en het formaat waarin het gegevens accepteert of uitvoert.

Door deze blokken in een specifieke volgorde met elkaar te verbinden, kunnen ontwikkelaars het algoritme van een toepassing vormen en de operationele logica ervan duidelijk visualiseren. Misschien wel het bekendste voorbeeld van deze programmeermethode is de turtle graphics methode, die vaak gebruikt wordt in educatieve omgevingen om programmeerconcepten te introduceren en algoritmisch denken te ontwikkelen.

De essentie van deze methode is eenvoudig: afbeeldingen op het scherm tekenen met behulp van een virtuele schildpad die een spoor achterlaat terwijl hij over het canvas kruipt. Door gebruik te maken van kant-en-klare blokken, zoals het verplaatsen van een ingesteld aantal pixels, het draaien onder specifieke hoeken of het omhoog en omlaag bewegen van de pen, kunnen ontwikkelaars programma's maken die de gewenste afbeeldingen tekenen. Het maken van toepassingen met behulp van een low-code constructor is vergelijkbaar met schildpad afbeeldingen, maar het stelt gebruikers in staat om een breed scala aan problemen op te lossen, niet alleen het tekenen op een canvas.

Deze methode werd het best geïmplementeerd in IBM's Node-RED programmeertool. Het werd ontwikkeld als een universeel middel om de gezamenlijke werking van verschillende apparaten, online services en API's te garanderen. Het equivalent van code snippets waren nodes uit de standaard bibliotheek (palette).

De mogelijkheden van Node-RED kunnen worden uitgebreid door add-ons te installeren of aangepaste nodes te maken die specifieke gegevensacties uitvoeren. Ontwikkelaars plaatsen knooppunten uit het palet op het bureaublad en bouwen relaties tussen deze knooppunten. Dit proces creëert de logica van de toepassing, waarbij de visualisatie helpt om duidelijkheid te behouden.

De toevoeging van neurale netwerken aan dit concept levert een intrigerend systeem op. In plaats van gegevens te verwerken met specifieke wiskundige formules, kun je ze invoeren in een neuraal netwerk en de gewenste uitvoer specificeren. Hoewel de invoergegevens elke keer iets kunnen verschillen, blijven de resultaten geschikt voor interpretatie door mensen of andere neurale netwerken.

Retrieval Augmented Generation (RAG)

De nauwkeurigheid van gegevens in grote taalmodellen is een dringende zorg. Deze modellen vertrouwen uitsluitend op kennis die is opgedaan tijdens de training, die afhankelijk is van de relevantie van de gebruikte datasets. Bijgevolg kunnen grote taalmodellen onvoldoende relevante gegevens hebben, wat mogelijk leidt tot onjuiste resultaten.

Om dit probleem aan te pakken, zijn methoden voor het updaten van gegevens nodig. Door neurale netwerken context te laten halen uit aanvullende bronnen, zoals websites, kan de kwaliteit van antwoorden aanzienlijk worden verbeterd. Dit is precies hoe RAG (Retrieval-Augmented Generation) werkt. Aanvullende gegevens worden omgezet in vectorrepresentaties en opgeslagen in een database.

In de praktijk kunnen neurale netwerkmodellen verzoeken van gebruikers omzetten in vectorrepresentaties en deze vergelijken met de vectoren die zijn opgeslagen in de database. Als er vergelijkbare vectoren worden gevonden, worden de gegevens geëxtraheerd en gebruikt bij het vormen van een antwoord. Vectordatabases zijn snel genoeg om dit schema in realtime te ondersteunen.

Om dit systeem goed te laten functioneren, moet er interactie zijn tussen de gebruiker, het neurale netwerkmodel, externe gegevensbronnen en de vectordatabase. Langflow vereenvoudigt deze opzet met zijn visuele component - gebruikers bouwen gewoon standaardblokken en "koppelen" ze, waardoor een pad voor gegevensstroom ontstaat.

De eerste stap is het vullen van de vector database met relevante bronnen. Dit kunnen bestanden zijn van een lokale computer of webpagina's van het internet. Hier is een eenvoudig voorbeeld van het laden van gegevens in de database:

Nu we een vectordatabase hebben naast de getrainde LLM, kunnen we deze opnemen in het algemene schema. Wanneer een gebruiker een verzoek indient in de chat, wordt tegelijkertijd een prompt gevormd en de vectordatabase bevraagd. Als er vergelijkbare vectoren worden gevonden, worden de geëxtraheerde gegevens verwerkt en als context toegevoegd aan de gevormde prompt. Het systeem stuurt vervolgens een verzoek naar het neurale netwerk en stuurt het ontvangen antwoord naar de gebruiker in de chat.

Hoewel in het voorbeeld clouddiensten zoals OpenAI en AstraDB worden genoemd, kun je elke compatibele dienst gebruiken, inclusief diensten die lokaal op de servers van LeaderGPU zijn geïnstalleerd. Als u de integratie die u nodig hebt niet kunt vinden in de lijst met beschikbare blokken, kunt u deze zelf schrijven of er een toevoegen die door iemand anders is gemaakt.

Snel aan de slag

Systeem voorbereiden

De eenvoudigste manier om Langflow te implementeren is in een Docker container. Om de server op te zetten, begin je met het installeren van Docker Engine. Werk vervolgens zowel de pakketcache als de pakketten bij naar de nieuwste versies:

sudo apt update && sudo apt -y upgrade

Installeer extra pakketten die Docker nodig heeft:

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

Download de GPG-sleutel om de officiële Docker-repository toe te voegen:

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

Voeg de repository toe aan APT met de sleutel die je eerder hebt gedownload en geïnstalleerd:

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

Vernieuw de pakketlijst:

sudo apt update

Om ervoor te zorgen dat Docker wordt geïnstalleerd vanuit de nieuw toegevoegde repository en niet vanuit de systeemrepository, kun je het volgende commando uitvoeren:

apt-cache policy docker-ce

Docker Engine installeren:

sudo apt install docker-ce

Controleer of Docker met succes is geïnstalleerd en of de bijbehorende daemon draait en de status active (running) heeft:

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

Bouwen en uitvoeren

Alles is klaar om een Docker container met Langflow te bouwen en te draaien. Er is echter één voorbehoud: op het moment van schrijven van deze handleiding heeft de nieuwste versie (getagd v1.1.0) een fout en start niet op. Om dit probleem te voorkomen, gebruiken we de vorige versie, v1.0.19.post2, die direct na het downloaden vlekkeloos werkt.

De eenvoudigste aanpak is om de project repository te downloaden van GitHub:

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

Navigeer naar de map met de voorbeeld deployment configuratie:

cd langflow/docker_example

Nu moet je twee dingen doen. Ten eerste, verander de release tag zodat een werkende versie (op het moment van schrijven van deze instructie) is gebouwd. Ten tweede, voeg eenvoudige authorisatie toe zodat niemand het systeem kan gebruiken zonder de login en het wachtwoord te kennen.

Open het configuratiebestand:

sudo nano docker-compose.yml

in plaats van de volgende regel:

image: langflowai/langflow:latest

geef de versie op in plaats van de tag latest:

image: langflowai/langflow:v1.0.19.post2

Je moet ook drie variabelen toevoegen aan de sectie environment:

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

De eerste variabele schakelt toegang tot de webinterface zonder autorisatie uit. De tweede voegt de gebruikersnaam toe die systeembeheerdersrechten krijgt. De derde voegt het bijbehorende wachtwoord toe.

Als u van plan bent om het bestand docker-compose.yml op te slaan in een versiebeheersysteem, schrijf het wachtwoord dan niet rechtstreeks in dit bestand. Maak in plaats daarvan een apart bestand met een .env extensie in dezelfde map en sla de variabele waarde daar op.

LANGFLOW_SUPERUSER_PASSWORD=your_secure_password

In het bestand docker-compose.yml kun je nu verwijzen naar een variabele in plaats van direct een wachtwoord op te geven:

LANGFLOW_SUPERUSER_PASSWORD=${LANGFLOW_SUPERUSER_PASSWORD}

Om te voorkomen dat je per ongeluk het *.env bestand op GitHub blootgeeft, vergeet niet om het toe te voegen aan .gitignore. Dit zal je wachtwoord redelijk veilig houden van ongewenste toegang.

Nu hoeven we alleen nog maar onze container te bouwen en uit te voeren:

sudo docker compose up

Open de webpagina op http://[LeaderGPU_IP_address]:7860, en je ziet het autorisatieformulier:

Zodra je je login en wachtwoord hebt ingevoerd, geeft het systeem toegang tot de webinterface waar je je eigen applicaties kunt maken. Voor meer gedetailleerde begeleiding raden we aan om de officiële documentatie te raadplegen. Deze bevat details over verschillende omgevingsvariabelen die het mogelijk maken om het systeem eenvoudig aan te passen aan jouw behoeften.

Zie ook:

Easy Diffusion UI

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

Easy Diffusion UI is open source software die je kunt downloaden op GitHub. Hier lees je hoe je het installeert op Ubuntu 22.04 LTS. Als je net een server hebt gehuurd, installeer dan de GPU-stuurprogramma's en breid je homedirectory uit. Download vervolgens de nieuwste versie van Easy Diffusion UI:

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

Pak het gedownloade ZIP-bestand uit:

unzip Easy-Diffusion-Linux.zip

Wijzig de map in easy-diffusion:

cd easy-diffusion

Start de installatie:

./start.sh

Dit is een scriptverzameling die automatisch alle benodigde componenten downloadt en installeert. Het downloadt ook het standaard Stable Diffusion-model in SafeTensors-formaat. Zodra alle downloads en installaties zijn voltooid, wordt de gebruikersinterface van Easy Diffusion automatisch gestart.

Gebruik

Het vorige artikel, Stable Diffusion WebUI, schetst een methode om verbindingen van het publieke internet te aanvaarden en voorziet in eenvoudige login en wachtwoordautorisatie. In dit geval willen we een andere universele methode demonstreren voor het doorsturen van poorten via een SSH-verbinding. We gebruiken PuTTY om een beveiligde verbinding op te zetten met de externe server. Je kunt hier meer informatie over vinden in onze gids Verbinding maken met een Linux server.

Om te kiezen welke poorten u wilt doorsturen, opent u Connection > SSH > Tunnels in de linker optiestructuur. Typ 9000 in het veld Source Port en 127.0.0.1:9000 in het veld Destination. Klik vervolgens op de knop Add:

Daarna kun je terugkeren naar Session en het opslaan voor later gebruik. Maak zoals gewoonlijk verbinding met de externe server. Nu worden alle gegevens die je verstuurt of ontvangt op poort 9000 op het loopback adres 127.0.0.1 omgeleid naar de externe server. Deze methode creëert een virtuele beveiligde tunnel die bestaat zolang de verbinding bestaat.

Zodra Easy Diffusion UI opstart en port forwarding is ingeschakeld, kunt u een webbrowser openen en naar het adres http://127.0.0.1:9000 navigeren. We raden aan om aangepaste modellen te downloaden en te installeren, zoals beschreven in dit artikel, in plaats van alleen te vertrouwen op het standaardmodel om afbeeldingen te genereren. Vergeet niet het aantal inferentiestappen te verhogen en de gewenste beeldresolutie aan te passen (aangegeven met sterretjes).

Een van de grote voordelen van de Easy Diffusion UI is de ondersteuning voor meerdere GPU's. Als u een batch afbeeldingen wilt maken, kunt u kiezen hoeveel afbeeldingen parallel worden gemaakt. Als u bijvoorbeeld een configuratie met twee GPU's hebt:

Je kunt de belasting van de GPU weergeven tijdens het genereren van de image. Maak een andere SSH-verbinding en voer een enkel commando uit:

watch -n 1 nvidia-smi

Bovendien vereenvoudigt Easy Diffusion UI het maken van prompts omdat het talloze voorbeelden van beeldmodifiers biedt. U kunt ze mengen om nauwkeurigere resultaten te krijgen:

Het is een goed idee om PromptBook van OpenArt te verkennen. Deze gids kan je vaardigheden om prompts te maken aanzienlijk verbeteren. Met de Easy Diffusion UI kun je, zodra de afbeelding is gegenereerd, deze downloaden, gebruiken als voorbeeld voor het genereren van de volgende afbeelding, of wijzigingen aanbrengen met slechts één klik:

Het meest gebruikte gebruik van de Upscale knop is om de resolutie van een afbeelding te verhogen. Het generatieve neurale netwerk gebruikt de originele afbeelding als basis en voegt extra pixels toe, waardoor de bronafbeelding wordt geïnterpoleerd naar de gewenste grootte.

Bij het genereren van gezichten kunnen problemen ontstaan zoals verkeerd uitgelijnde ogen, onevenredige afmetingen of misvormde delen. Gelukkig kunnen deze problemen worden opgelost met de knop Fix Faces. Daarnaast kunnen negatieve aanwijzingen worden gebruikt om te voorkomen dat er onjuiste gezichten worden gegenereerd.

verwijderen

Alle bestanden, scripts, bibliotheken en modellen worden opgeslagen in een enkele map. Als u Easy Diffusion UI van uw server wilt verwijderen, verwijdert u gewoon deze map samen met alle inhoud:

sudo rm -rf easy-diffusion

Zie ook:

Stable Video Diffusion

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

Generatieve neurale netwerken kunnen verschillende soorten inhoud creëren. Stable Diffusion is gemaakt om afbeeldingen te genereren uit tekstbeschrijvingen. Het kan echter ook worden gebruikt om muziek, geluiden en zelfs video's te maken. Vandaag laten we zien hoe je korte video's kunt maken van een enkele afbeelding met behulp van Stable Diffusion met WebUI en ComfyUI.

Stable Diffusion installeren

Laten we beginnen met het installeren van Stable Diffusion met behulp van onze stap-voor-stap handleiding. Onderbreek na de installatie de uitvoering van het webui.sh script door op Ctrl + C te drukken en sluit de SSH-verbinding. Het systeem staat niet toe dat u extensies installeert met de ingeschakelde --listen (--share) opties. Dit betekent dat je port forwarding (7860 en 8189) moet instellen van je lokale machine naar de remote server. De eerste poort is nodig voor WebUI en de tweede voor ComfyUI.

In PuTTY moet je bijvoorbeeld Connection >> SSH >> Tunnels openen en twee nieuwe doorgestuurde poorten toevoegen zoals in de volgende schermafbeelding:

Nu kunt u opnieuw verbinding maken met de externe server en ./webui.sh opnieuw uitvoeren.

Open deze URL in uw browser:

http://127.0.0.1:7860

Navigeer naar Extensions >> Available en klik vervolgens op de knop Load from::

Het systeem zal het JSON-bestand downloaden met alle beschikbare extensies. Typ ComfyUI in het zoekinvoervak en klik op de knop Install:

De webpagina wordt opnieuw geladen en je krijgt een nieuw tabblad ComfyUI in het hoofdpaneel. Ga daarheen en klik op Install ComfyUI:

Als de installatie voltooid is, onderbreek dan opnieuw de uitvoering van het webui.sh script door op Ctrl + C te drukken.

Stabiel videoverspreidingsmodel installeren

Open de map van het model:

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

Download het volledige Stable Video Diffusion-model:

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

Terug naar de homedirectory:

cd ~/

En start de Stable Diffusion service opnieuw:

./webui.sh

Download het voorbeeld van de Stable Video Diffusion-workflow in JSON-formaat. Wis de standaardworkflow van ComfyUI door te drukken op Clear en vervolgens op Load het gedownloade voorbeeld:

Zorg ervoor dat u het juiste model hebt geselecteerd in het knooppunt Image Only Checkpoint Loader (img2vid model):

Klik op de knop choose file to upload in het knooppunt Load Image en selecteer een enkele afbeelding die het generatieve neurale netwerk moet transformeren in een video:

Probeer een video te genereren met alle standaardparameters door op de knop Queue Prompt te klikken:

Nadat het proces is voltooid, krijg je je video in WEBP-indeling in het knooppunt SaveAnimatedWEBP. Klik met de rechtermuisknop op de gegenereerde video en kies Save Image:

Hier is het uiteindelijke resultaat GIF.

Problemen oplossen

Als je een foutmelding krijgt: ModuleNotFoundError: No module named 'utils.json_util'; 'utils' is not a package, volg dan deze stappen:

Hernoem de map utils naar utilities:

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

Bewerk custom_node_manager.py:

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

Vervang deze regel:

from utils.json_util import merge_json_recursive

met:

from utilities.json_util import merge_json_recursive

Sla het bestand op (Ctrl + O) en sluit de editor af (Ctrl + X). Bewerk vervolgens main.py:

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

Vervang deze regel:

import utils.extra_config

met:

import utilities.extra_config

Sla het bestand op, sluit de editor af en start de Stable Diffusion-service opnieuw:

./webui.sh

Zie ook:

PyTorch voor Windows

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

Voordat u begint met de installatie van PyTorch, moet u de Python-interpreter en Microsoft Visual C++ Redistributable installeren. Open een webbrowser en navigeer naar de downloadpagina van Python. Zoek de nieuwste Python 3 versie en klik op de link:

Scroll vervolgens naar beneden en klik op Windows Installer (64-bit):

Open het gedownloade bestand om verder te gaan met de installatie:

Vink het vakje voor Add python.exe to PATH aan en klik op Install Now:

Wacht een minuut tot het installatieproces is voltooid:

U kunt optioneel Disable path length limit als u van plan bent lange namen te gebruiken die de limieten van MAX_PATH zouden kunnen overschrijden:

MS Visual C++ installeren

Download vervolgens Microsoft Visual C++ Redistributable via deze link en klik op het installatieprogramma:

U moet het vakje I agree to the license terms and conditions aanvinken en op de knop Install klikken:

Na enkele seconden wordt deze software geïnstalleerd en kunt u het installatieprogramma Close gebruiken:

Nu is alles klaar voor de installatie van PyTorch. Klik op de Start knop en typ cmd op het toetsenbord. Klik met de rechtermuisknop op Command Prompt en selecteer Run as administrator in het contextmenu:

PyTorch installeren

Voer het volgende commando uit:

pip install torch torchvision

Als u een specifieke versie van PyTorch wilt installeren, kunt u deze tijdens de installatie opgeven:

pip install torch==1.9.0 torchvision==0.10.0

Als de installatie is voltooid, laten we controleren of PyTorch goed werkt. Voer het volgende commando uit om de Python-interpreter te openen:

python

Typ deze twee strings en eindig uw invoer met de toets Enter:

import torch
print(torch.__version__)

Als u een resultaat als dit krijgt, betekent dit dat PyTorch correct is geïnstalleerd:

2.0.1+cu117

Zie ook:

PyTorch voor Linux

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

Moderne Linux-distributies zijn sterk afhankelijk van de geïnstalleerde versie van Python. Daarom raden we aan om, voordat je PyTorch installeert, een virtuele omgeving aan te maken met behulp van onze stap-voor-stap handleiding Linux systeemhulpprogramma's.

Activeer de aangemaakte venv en ga verder met de pip3 upgrade:

pip3 install --upgrade pip

Start de PyTorch installatie:

pip3 install torch torchvision

Als u een specifieke versie van PyTorch wilt installeren, typ dan het gewenste versienummer in:

pip3 install torch==1.9.0 torchvision==0.10.0

Als de installatie is voltooid, laten we controleren of PyTorch correct is geïnstalleerd. Open de Python-interpreter:

python3

Typ deze twee strings en eindig uw invoer met de Enter-toets:

import torch
print(torch.__version__)

Als u een resultaat als dit krijgt, betekent dit dat PyTorch correct is geïnstalleerd:

2.0.1+cu117

Zie ook:

Stable Diffusion: Riffusion

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

In onze vorige artikelen hebben we de fascinerende mogelijkheden van Stable Diffusion voor het genereren van boeiende afbeeldingen onderzocht. Het is echter belangrijk om op te merken dat dit krachtige generatieve neurale netwerk nog meer te bieden heeft.

Riffusion is een Stable Diffusion-model voor het maken en bewerken van muziek. Met Riffusion kun je een spectrogram genereren van een gewenst muzieksegment en dit moeiteloos omzetten in een muziekfragment. Laten we Riffusion installeren op een LeaderGPU server en het in actie proberen.

Vereisten

Begin met het bijwerken van de pakketcache repository en geïnstalleerde pakketten:

sudo apt update && sudo apt -y upgrade

Vergeet niet de Nvidia-stuurprogramma's te installeren met de opdracht autoinstall of handmatig met behulp van onze stapsgewijze handleiding:

sudo ubuntu-drivers autoinstall

Start de server opnieuw op:

sudo shutdown -r now

Om een virtuele omgeving te creëren, raden ontwikkelaars aan om het hulpprogramma Anaconda te gebruiken. Je kunt ook venv gebruiken, dat we hebben besproken in de tutorial over Linux systeemhulpprogramma's. Download het installatiescript van Anaconda met behulp van curl:

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

Maak het uitvoerbaar:

chmod +x anaconda.sh

En uitvoeren:

./anaconda.sh

Antwoord JA op alle vragen, behalve de laatste (installeer Microsoft VSCode). Log dan opnieuw in op de SSH-console en maak een nieuwe virtuele omgeving met Python v3.9:

conda create --name riffusion python=3.9

Activeer de nieuwe virtuele omgeving:

conda activate riffusion

Als je andere muziekformaten dan wav wilt gebruiken, moet je ook de FFmpeg-bibliotheekset installeren:

conda install -c conda-forge ffmpeg

Riffusion installeren

Kloon de Riffusion opslagplaats:

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

Open de gedownloade map:

cd riffusion

Laten we enkele wijzigingen aanbrengen in het bestand met vereisten. Dit voorkomt fouten met compatibiliteit met torch:

nano requirements.txt

Pakketversies zoeken en herstellen:

diffusers==0.9.0
torchaudio==2.0.1

Sla de wijzigingen op en ga verder met het voorbereiden van een virtuele omgeving. Het volgende commando installeert alle benodigde pakketten:

python -m pip install -r requirements.txt

Tot slot kunt u een "speeltuin" openen. Dit is een eenvoudige webinterface waarmee je meer kunt leren over de functies van Riffusion:

python -m riffusion.streamlit.playground

Open uw favoriete browser en voer het adres in http://[SERVER_IP]:8501/

Test een speelplaats

Nu kun je muziek maken met behulp van tekstprompts en door de andere parameters te wijzigen:

Je kunt ook wat lastige dingen doen, zoals audio opsplitsen in afzonderlijke componenten. Je kunt bijvoorbeeld de zang uit Bohemian rhapsody van Queen halen:

Onthoud dat dit slechts een enkel voorbeeld is van hoe Riffusion gebruikt kan worden. Door je eigen toepassing te maken, kun je veel boeiendere resultaten bereiken. Krachtige servers van LeaderGPU zorgen voor de berekeningen.

Zie ook:

Stable Diffusion: Herhaalbare gezichten genereren

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

Herhaalbaarheid is het belangrijkste aspect bij het maken van grafische inhoud met generatieve neurale netwerken. Dit geldt ongeacht het type content dat je maakt, of het nu een film- of gamekarakter, landschap of scèneomgeving is. Het belangrijkste probleem kan worden geformuleerd als: "Hoe kan ik mijn resultaat herhalen?". Telkens als je beelden begint te genereren met dezelfde positieve en negatieve aanwijzingen, krijg je verschillende resultaten. Soms zijn de verschillen klein en acceptabel, maar in de meeste gevallen kunnen ze een probleem vormen.

Stable Diffusion is geleerd op een grote dataset uit de echte wereld, wat verklaart waarom herhaalbaarheid geen sterk punt is van dit neurale netwerkmodel. Deze regel geldt echter niet voor foto's van beroemdheden. Deze foto's komen veel vaker voor in de echte wereld en dus ook in de dataset waarop Stable Diffusion is getraind. Je kunt deze foto's gebruiken als een "constante" of een "startpunt" in het generatieproces.

Methode 1. "Geschud, niet geroerd

Je hoeft natuurlijk niet alleen afbeeldingen van beroemdheden te maken, maar je kunt meerdere relevante aanwijzingen gebruiken om min of meer consistente resultaten te krijgen. We kunnen bijvoorbeeld twee beroemde Griekse zangeressen nemen: Elena Paparizou en Marina Satti, en herhaalbare resultaten krijgen:

Model: Realistische visie 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

Het werkt met alle beroemdheden, omdat Stable Diffusion probeerde de meest prominente gelaatstrekken te reproduceren. Hier gebruiken we hetzelfde model en "schudden" we twee Hollywoodsterren (Dwayne Johnson en Danny Trejo) tot één nieuw synthetisch personage.

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

Elke keer dat je dezelfde beroemdheden mengt, krijg je soortgelijke resultaten. Laten we eens kijken naar een andere methode om herhaalbare karakters te genereren.

Methode 2. Naam anker

Beroemdheden zijn een goed begin, maar laten we eens kijken naar andere methoden om herhaalbare resultaten te krijgen. Het antwoord is heel eenvoudig: we kunnen meerdere menselijke namen gebruiken. Elk land heeft unieke namen, gerelateerd aan taalkundige kenmerken. De Griekse naam Kostas kan bijvoorbeeld vertaald worden naar "arbeid" of "inspanning", terwijl Nikos "Overwinning van het volk" betekent. Deze twee namen creëren een uniek beeld van een gegenereerd persoon, wat neurale netwerkmodellen helpt bij het begrijpen van onze creatiedoelen.

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

Laten we een groot aantal afbeeldingen (80-100) genereren om verdere datasets te maken. De belangrijkste prompt werd gekozen om handige afbeeldingen te leveren die gemakkelijk van de achtergrond kunnen worden verwijderd. Negatieve prompts beschermen ons tegen het opnemen van willekeurige afbeeldingen met vervormingen in de dataset, evenals afbeeldingen van vrouwen.

Tip: als je erg verschillende afbeeldingen ontvangt, probeer dan de parameter CFG Scale te veranderen van 7,5 naar 15. Dit dwingt het neurale netwerk om de afbeeldingen te vergelijken. Dit zal het neurale netwerk dwingen om de aanwijzingen formeler te volgen.

Je kunt je eigen unieke namen kiezen met een eenvoudige naamgenerator, zoals Behind the Name. Je kunt ook de ControlNet functie gebruiken om meer controle te krijgen.

Methode 3. Uiterlijk aanleren

We kunnen het eindresultaat niet direct beïnvloeden, maar we zien dat sommige tokens (zoals tokens met afbeeldingen van beroemdheden) zwaarder wegen dan andere. Dit betekent dat we ons voorwaardelijke "beroemdheid" token kunnen creëren door er een passende prompt voor te maken en het model hierop verder te trainen. Dit is hoe LoRA (Low-Rank Adaptation of Large Language Models) werkt. Je kunt onze stapsgewijze handleiding gebruiken om je eigen LoRA-model te trainen op basis van een zelfgemaakte dataset.

Nadat we de achtergrond hebben verwijderd, verkrijgen we duidelijke portretten en gebruiken die om een specifiek LoRA-model te maken. Dit model helpt om een gezicht na te bootsen met een paar kleine veranderingen:

Nu kunnen we dit personage op verschillende locaties genereren, verhalen creëren en hem in verschillende rollen plaatsen: van tuinman tot zakenman. Zijn gezicht zal consistent herkenbaar en herhaalbaar zijn:

Deze methode is niet ideaal, maar werkt perfect in verschillende situaties. Je hoeft geen dataset van een echt persoon voor te bereiden en het kan op afstand worden gegenereerd:

Je kunt proberen om zelf zo'n virtueel personage te maken, zonder de hulp van een professionele ontwerper of 3D-modelleringsspecialist. Alles wat u nodig hebt zijn snelle GPU's, die u kunt vinden in dedicated servers van LeaderGPU.

Zie ook:

Stable Diffusion: LoRA selfie

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

Je kunt je eerste dataset maken met een eenvoudige camera en een vrij uniforme achtergrond, zoals een witte muur of een monotoon verduisteringsgordijn. Voor een voorbeeld dataset heb ik een spiegelloze camera Olympus OM-D EM5 Mark II met 14-42 kitlenzen gebruikt. Deze camera ondersteunt afstandsbediening vanaf elke smartphone en een zeer snelle continue opnamemodus.

Ik heb de camera op een statief gemonteerd en de scherpstelprioriteit ingesteld op gezicht. Daarna selecteerde ik de modus waarin de camera elke 3 seconden 10 frames achter elkaar vastlegt en startte het proces. Tijdens het fotograferen draaide ik mijn hoofd langzaam in de geselecteerde richting en veranderde na elke 10 beelden van richting:

Het resultaat was ongeveer 100 frames met een monotone achtergrond:

De volgende stap is om de achtergrond te verwijderen en het portret op een witte achtergrond te laten staan.

Achtergrond verwijderen

Je kunt de standaard Adobe Photoshop Remove background functie en batchverwerking gebruiken. Laten we acties opslaan die we op elke foto in een dataset willen toepassen. Open een willekeurige afbeelding, klik op het driehoekpictogram en vervolgens op het + symbool:

Typ de naam van de nieuwe actie, bijvoorbeeld Remove Background en klik op Record:

Zoek op het tabblad Layers het slotsymbool en klik erop:

Klik vervolgens op de knop Remove background op het zwevende paneel:

Klik met de rechtermuisknop op Layer 0 en selecteer Flatten Image:

Al onze acties zijn opgenomen. Laten we dit proces stoppen:

Nu kunt u het geopende bestand sluiten zonder de wijzigingen op te slaan en selecteert u File >> Scripts >> Image Processor…

Selecteer de invoer- en uitvoermappen, kies de gemaakte Remove Background actie in stap 4 en klik op Run:

Wees geduldig. Adobe Photoshop zal elke afbeelding in de geselecteerde map openen, de opgenomen acties herhalen (laagvergrendeling uitschakelen, achtergrond verwijderen, afbeelding afvlakken) en opslaan in een andere geselecteerde map. Dit proces kan een paar minuten duren, afhankelijk van het aantal afbeeldingen.

Als het proces is voltooid, kun je naar de volgende stap gaan.

Uploaden naar server

Gebruik een van de volgende gidsen (aangepast aan het besturingssysteem van je pc) om de map dataset te uploaden naar de externe server. Plaats deze bijvoorbeeld in de homedirectory van de standaardgebruiker, /home/usergpu:

Pre-installatie

Werk bestaande systeempakketten bij:

sudo apt update && sudo apt -y upgrade

Installeer twee extra pakketten:

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

Laten we de CUDA® Toolkit versie 11.8 installeren. Laten we het specifieke pinbestand downloaden:

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

Het volgende commando plaatst het gedownloade bestand in de systeemdirectory, die wordt beheerd door de apt package manager:

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

De volgende stap is het downloaden van de CUDA® repository:

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

Ga daarna verder met de pakketinstallatie met het standaard hulpprogramma dpkg:

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

Kopieer de GPG-sleutelring naar de systeemdirectory. Dit maakt het beschikbaar voor gebruik door besturingssysteemprogramma's, inclusief de apt package manager:

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

Update systeem cache repositories:

sudo apt-get update

Installeer de CUDA® toolkit met apt:

sudo apt-get -y install cuda

Voeg CUDA® toe aan PATH. Open de bash shell config:

nano ~/.bashrc

Voeg de volgende regels toe aan het einde van het bestand:

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

Sla het bestand op en start de server opnieuw op:

sudo shutdown -r now

Trainer installeren

Kopieer de repository van het Kohya project naar de server:

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

Open de gedownloade map:

cd kohya_ss

Maak het installatiescript uitvoerbaar:

chmod +x ./setup.sh

Voer het script uit:

./setup.sh

Je krijgt een waarschuwing van het versnellingshulpprogramma. Laten we het probleem oplossen. Activeer de virtuele omgeving van het project:

source venv/bin/activate

Installeer het ontbrekende pakket:

pip install scipy

En configureer het versnellingshulpprogramma handmatig:

accelerate config

Wees voorzichtig, want het activeren van een oneven aantal CPU's zal een fout veroorzaken. Als ik bijvoorbeeld 5 GPU's heb, kunnen er maar 4 worden gebruikt met deze software. Anders zal er een fout optreden wanneer het proces start. Je kunt de nieuwe configuratie van het hulpprogramma onmiddellijk controleren door een standaardtest aan te roepen:

accelerate test

Als alles in orde is, krijg je een bericht als dit:

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

deactivate

Nu kun je de publieke server van de trainer starten met Gradio GUI en eenvoudige login/wachtwoord authenticatie (verander de gebruiker/wachtwoord in je eigen):

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

Je ontvangt twee strings:

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

Open je webbrowser en voer de openbare URL in de adresbalk in. Typ je gebruikersnaam en wachtwoord in de daarvoor bestemde velden en klik op Aanmelden:

Bereid de dataset voor

Maak eerst een nieuwe map aan waarin je het getrainde LoRA-model opslaat:

mkdir /home/usergpu/myloramodel

Open de volgende tabbladen: Utilities >> Captioning >> BLIP captioning. Vul de openingen in zoals aangegeven in de afbeelding en klik op Caption images:

Trainer zal een specifiek neuraal netwerkmodel (1,6 Gb) downloaden en uitvoeren dat tekstaanwijzingen maakt voor elk afbeeldingsbestand in de geselecteerde map. Het wordt uitgevoerd op een enkele GPU en duurt ongeveer een minuut.

Ga naar LoRA >> Tools >> Dataset preparation >> Dreambooth/LoRA folder preparation, vul de gaten in en druk achtereenvolgens op Prepare training data en Copy info to Folders Tab:

In dit voorbeeld gebruiken we de naam nikolai als een Instance prompt en "person" als een Class prompt. We stellen ook /home/usergpu/dataset in als een Training Images en /home/usergpu/myloramodel als een Destination training directory.

Ga opnieuw naar het tabblad LoRA >> Training >> Folders. Controleer of de Image folder, Output folder en Logging folder correct zijn ingevuld. Indien gewenst kunt u de Model output name wijzigen in uw eigen. Klik ten slotte op de knop Start training:

Het systeem zal beginnen met het downloaden van extra bestanden en modellen (~10 GB). Daarna begint het trainingsproces. Afhankelijk van de hoeveelheid afbeeldingen en de toegepaste instellingen kan dit enkele uren duren. Zodra de training is voltooid, kun je de map /home/usergpu/myloramodel downloaden naar je computer voor toekomstig gebruik.

Test je LoRA

We hebben enkele artikelen voorbereid over Stable Diffusion en zijn forks. Je kunt proberen om Easy Diffusion te installeren met onze gids Easy Diffusion UI. Nadat het systeem is geïnstalleerd en draait, kun je je LoRA-model in SafeTensors-formaat rechtstreeks uploaden naar /home/usergpu/easy-diffusion/models/lora

Werk de webpagina van Easy Diffusion bij en selecteer uw model in de vervolgkeuzelijst:

Laten we een eenvoudige prompt schrijven, portrait of <nikolai> wearing a cowboy hat, en onze eerste afbeeldingen genereren. Hier hebben we een aangepast Stable Diffusion-model gebruikt dat we hebben gedownload van civitai.com: Realistic Vision v6.0 B1:

Je kunt experimenteren met aanwijzingen en modellen op basis van Stable Diffusion om betere resultaten te krijgen. Veel plezier!

Zie ook:

Stable Diffusion: Wat is ControlNet

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

Een veel voorkomende misvatting bij mensen die voor het eerst in aanraking komen met generatieve neurale netwerken is dat het een enorme uitdaging is om de uiteindelijke output te controleren, vooral wanneer geprobeerd wordt om de output te veranderen door middel van verschillende prompt frasering. Op dit moment bestaat er een verzameling gereedschappen die bekend staat als ControlNet om relatief eenvoudige en effectieve controle over de generatieresultaten mogelijk te maken.

In dit artikel laten we zien hoe je eenvoudig de houding van gegenereerde personages kunt manipuleren met behulp van bestaande afbeeldingen en aangepaste "skeletten", met behulp van een van deze tools, OpenPose.

Stap 1. Stabiele diffusie installeren

Gebruik onze stapsgewijze handleiding om Stable Diffusion met het basismodel en de WebUI te installeren. Deze handleiding is gebaseerd op het AUTOMATIC1111 script.

Stap 2. ControlNet uitbreiding installeren

We raden ten zeerste af om de ControlNet-extensie (sd-webui-controlnet) uit de standaard repository te installeren vanwege mogelijke functionaliteitsproblemen. Een belangrijk probleem dat we tegenkwamen tijdens de voorbereiding van deze handleiding was het bevriezen van de webinterface. Hoewel de image in eerste instantie succesvol is gegenereerd, reageert de WebUI niet meer als de image een tweede keer wordt gegenereerd. Een alternatieve oplossing zou zijn om dezelfde extensie van een externe bron te installeren.

Open WebUI en volg de tabbladen: Extensions > Install from URL. Plak deze URL in het juiste veld:

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

Klik vervolgens op de knop Install:

Wanneer het proces met succes is voltooid, zou het volgende bericht moeten verschijnen:

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

Laten we de URL opnieuw starten door op de knop Apply and restart UI te drukken op het tabblad Installed:

Na het herstarten van de interface verschijnt het nieuwe ControlNet-element met veel extra opties:

Stap 3. OpenPose downloaden

HF-sleutel toevoegen

Laten we een SSH-sleutel genereren en toevoegen die u kunt gebruiken in Hugging Face:

cd ~/.ssh && ssh-keygen

Wanneer het sleutelpaar is gegenereerd, kun je de publieke sleutel weergeven in de terminal emulator:

cat id_rsa.pub

Kopieer alle informatie beginnend bij ssh-rsa en eindigend met usergpu@gpuserver, zoals weergegeven in de volgende schermafbeelding:

Open een webbrowser, typ https://huggingface.co/ in de adresbalk en druk op Enter. Log in op je HF-account en open Profielinstellingen. Kies dan SSH and GPG Keys en klik op de knop Add SSH Key:

Vul de Key name in en plak de gekopieerde SSH Public key van de terminal. Sla de sleutel op door op Add key te drukken:

Nu is je HF-account gekoppeld aan de publieke SSH-sleutel. Het tweede deel (privésleutel) wordt opgeslagen op de server. De volgende stap is het installeren van een specifieke Git LFS (Large File Storage) extensie, die gebruikt wordt voor het downloaden van grote bestanden zoals neurale netwerkmodellen.

Git LFS installeren

De volgende stap is het installeren van een specifieke Git LFS (Large File Storage) extensie, die gebruikt wordt voor het downloaden van grote bestanden zoals neurale netwerkmodellen. Open je home directory:

cd ~/

Download het shellscript en voer het uit. Dit script installeert een nieuwe repository van derden met git-lfs:

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

Nu kun je het installeren met de standaard pakketbeheerder:

sudo apt-get install git-lfs

Laten we git configureren om onze HF nickname te gebruiken:

git config --global user.name "John"

En gekoppeld aan het HF e-mailaccount:

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

Het archief downloaden

We raden aan om, indien mogelijk, een lokale harde schijf te gebruiken om modellen te downloaden en op te slaan. Je kunt hier meer over leren in onze gids Schijfpartitionering in Linux. Voor dit voorbeeld hebben we een SSD-schijf gekoppeld aan het koppelpunt /mnt/fastdisk. Laten we het eigendom maken van de standaard gebruiker:

sudo chown usergpu:usergpu /mnt/fastdisk

Open de directory:

cd /mnt/fastdisk

Kloon de ControlNet repository van HuggingFace. Eerder geïnstalleerde Git-LFS zal automatisch verwijzingen vervangen door echte bestanden:

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

In dit voorbeeld voegen we slechts één model toe aan Stable Diffusion WebUI. Je kunt echter alle beschikbare modellen uit het archief kopiëren (~18GB):

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

Stap 4. Genereren uitvoeren

Het huidige model is vrij eenvoudig en levert mogelijk geen bevredigende resultaten op. Daarom stellen we voor om het te vervangen door een aangepast model. Richtlijnen om dit te doen zijn te vinden in dit artikel: Stabiele verspreidingsmodellen: aanpassingen en opties. Voor dit voorbeeld hebben we RealisticVision v6.0 B1 gedownload.

Als u uw eerste afbeelding wilt genereren met OpenPose, open dan het tabblad ControlNet, kies OpenPose, vink Enable en Allow Preview aan. Klik vervolgens op Upload om een afbeelding met de gewenste pose toe te voegen:

Je kunt het systeem vragen een voorbeeld van de pose te genereren door op de knop met het explosiepictogram te klikken:

Links wordt de originele afbeelding weergegeven. Rechts zie je het "skelet" dat de pose voorstelt zoals herkend door het neurale netwerkmodel:

Nu kun je de hoofdprompt intypen, bijvoorbeeld "dancing bear, by Pixar" of "dancing fox, by Pixar" en op de knop Generate klikken. Na een paar seconden krijg je resultaten zoals deze:

Het systeem zal proberen een nieuwe afbeelding te genereren, gegeven het "skelet" verkregen van de originele afbeelding. In sommige gevallen is de houding niet nauwkeurig, maar dit kan eenvoudig worden gecorrigeerd door het "skelet" handmatig te bewerken.

Stap 5. Houding wijzigen

Hoewel het magisch lijkt, is het model niet perfect en kunnen incidentele fouten invloed hebben op de uiteindelijke afbeelding. Om problemen tijdens het genereren van de afbeelding te voorkomen, heb je de optie om het "skelet" handmatig aan te passen door op de knop Edit te klikken:

In de meegeleverde editor kun je eenvoudig de pose aanpassen door te slepen en neerzetten, of ongewenste punten verwijderen met een rechtermuisklik. Klik daarna gewoon op de knop Send pose to ControlNet en de nieuwe pose wordt toegepast:

Naast OpenPose biedt ControlNet een groot aantal tools om je resultaten aan te passen en te perfectioneren. Bovendien zorgen de speciale servers van LeaderGPU voor een snel en handig proces.

Zie ook:

Fooocus: Heroverweging van SD en MJ

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

De komst van Stable Diffusion en MidJourney heeft een revolutie teweeggebracht in ons begrip van de mogelijkheden van generatieve neurale netwerken. Deze gereedschappen hebben een nieuw perspectief onthuld op het proces van beeldcreatie en de mate waarin we het kunnen manipuleren. De primaire benadering bestaat uit het geven van aanwijzingen aan het systeem over het gewenste resultaat. In wezen benadrukken we drie belangrijke aspecten: object, stijl en omgeving.

Extra aanwijzingen die meer specifieke instructies geven, zoals de gewenste compositie, het type camera/lens en de inkleuring, zijn ook belangrijk, maar niet onmisbaar. Hoe uitgebreider de instructies, hoe gemakkelijker het neurale netwerk ze kan verwerken. In de professionele ruimte is zelfs de rol van een prompt engineer ontstaan. Deze rol kan echter gemakkelijk worden vervangen door dezelfde generatieve neurale netwerken. Door vaardigheden in het maken van afbeeldingen te combineren met het maken van tekst, kunnen we extra aanwijzingen genereren om een optimaal resultaat te bereiken.

Dit is het fundamentele concept van Fooocus. Het integreert het XL Stable Diffusion-model en een GPT2-gebaseerde promptgenerator, die je eenvoudige prompt verrijkt en gedetailleerd maakt. Bovendien is Fooocus uitgerust met diverse verbeteringen en uitbreidingen. Deze functies maken het mogelijk om spectaculaire afbeeldingen te genereren via een eenvoudige interface, zonder ingewikkelde tools. Laten we ons verdiepen in de functionaliteit en Fooocus installeren op een LeaderGPU dedicated server.

Vereisten

Begin met de installatievereisten en start daarna opnieuw op:

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

Download het shellscript dat Anaconda installeert voor het beheren van virtuele omgevingen:

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

Stel de uitvoeringsvlag in en geef gegevenstoegang:

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

Voer het installatiescript uit:

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

Nadat het proces is voltooid, raden we je aan om de SSH-sessie te verbreken en je voor te bereiden op het doorsturen van de poort. Je moet poort 7865 van de externe server doorsturen naar een lokaal loopback adres, 127.0.0.1:7865. Raadpleeg voor meer informatie een van onze eerdere gidsen: Stable Video Diffusion. Maak dan opnieuw verbinding en ga verder met het klonen van de repository van het project op GitHub.

Fooocus installeren

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

Wijzig de map naar Fooocus:

cd Fooocus

Creëer een virtuele omgeving met behulp van Anaconda en de YAML-config voorbereid door de auteur van het project:

conda env create -f environment.yaml

Laten we onze basisomgeving veranderen in een nieuw gemaakte omgeving:

conda activate fooocus

De volgende stap is het installeren van Python-bibliotheken:

pip install -r requirements_versions.txt

Nu is alles klaar om te beginnen:

Fooocus start

python entry_with_update.py

Het opstarten kan even duren omdat de applicatie alle benodigde bestanden controleert en downloadt. Misschien wilt u ondertussen een kopje koffie drinken. Zodra het proces is voltooid, opent u uw browser en typt u de volgende URL in de adresbalk:

http://127.0.0.1:7865

Voer je eenvoudige prompt in en klik op de knop Generate. Als je meer controle wilt, vink dan Advanced aan en selecteer de benodigde opties:

De echte magie ontvouwt zich achter de schermen. Zodra je op de knop Generate klikt, wordt je ingevoerde prompt doorgestuurd naar het op GPT2 gebaseerde taalmodel. Dit model zet je korte prompt om in een mix van elaboratieve positieve en negatieve prompts. Deze mix wordt vervolgens ingevoerd in het Stable Diffusion XL-model, dat is afgestemd op de MidJourney-stijl. Het resultaat is dat zelfs een korte prompt indrukwekkende resultaten kan opleveren.

Natuurlijk is er geen beperking voor het schrijven van je eigen prompts. Maar na meerdere iteraties wordt het duidelijk dat zelfs zonder deze beperking de gegenereerde inhoud intrigerend en divers blijft.

Zie ook:

Blender op afstand renderen met Flamenco

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

Wanneer het renderen van zware scènes in Blender te veel van de tijd van je team begint te vergen, heb je twee opties: of de computer van elk teamlid upgraden of rendering uitbesteden aan een speciale renderfarm. Veel bedrijven bieden kant-en-klare renderoplossingen, maar als je volledige controle over de infrastructuur nodig hebt, zijn deze oplossingen misschien niet de meest betrouwbare optie.

Een alternatieve aanpak is het creëren van een hybride infrastructuur. In deze opzet houdt u uw gegevensopslag en rendering farm management binnen uw bestaande infrastructuur. Het enige element dat zich daarbuiten zou bevinden, zijn de gehuurde GPU-servers waarop de rendering wordt uitgevoerd.

In het algemeen ziet de rendering farm infrastructuur voor Blender er als volgt uit:

Hier hebben we een centrale Manager node die alle processen organiseert. Het ontvangt rendertaken van gebruikers via een specifieke Blender Add-on en verplaatst alle benodigde bestanden naar Shared Storage. Vervolgens verdeelt de Manager de taken naar Worker nodes. Zij ontvangen een job die alle informatie bevat over waar de Worker bestanden kan vinden om te renderen en wat te doen met de verkregen resultaten. Om dit schema te implementeren kun je gebruik maken van een volledig vrije en open-source applicatie genaamd Flamenco. In deze handleiding laten we zien hoe je alle knooppunten kunt voorbereiden, vooral de Manager en Worker.

Het knooppunt Storage heeft geen specifieke vereisten. Het kan gebruikt worden met elk besturingssysteem dat SMB/CIFS of NFS protocollen ondersteunt. De enige vereiste is dat de opslagmap gemount en toegankelijk moet zijn voor het besturingssysteem. In jouw infrastructuur kan dit elke gedeelde map zijn die toegankelijk is voor alle knooppunten.

Elk knooppunt heeft verschillende IP-adressen en de Wireguard VPN server wordt een centraal punt dat ze samenbrengt in één L2-netwerk. Met deze server, die zich op de externe perimeter bevindt, kun je werken zonder wijzigingen aan te brengen in het bestaande NAT-beleid.

Voor dit voorbeeld maken we de volgende gemengde configuratie:

10.0.0.1 - Wireguard VPN server (virtuele server van een willekeurige infrastructuurprovider) met een extern IP;
10.0.0.2 - Worker node (dedicated server van LeaderGPU) met een extern IP;
10.0.0.3 - Manager node (virtuele server in het kantoornetwerk) achter NAT;
10.0.0.4 - Storage node (virtuele server in het kantoornetwerk) achter NAT;
10.0.0.5 - User node (consumentenlaptop in het kantoornetwerk) achter NAT.

Stap 1. Draadbeschermer

VPN-server

U kunt Wireguard handmatig installeren en configureren met behulp van een officiële handleiding en voorbeelden. Er is echter een eenvoudiger alternatief: een onofficieel script van software engineer uit Parijs (Stanislas aka angristan).

Download het script van GitHub:

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

Maak het uitvoerbaar:

sudo chmod +x wireguard-install.sh

Uitvoeren:

sudo ./wireguard-install.sh

Volg de instructies en stel het IP-adresbereik in 10.0.0.1/24. Het systeem zal je vragen om onmiddellijk een configuratiebestand aan te maken voor de eerste client. Volgens het plan zal deze client het werkknooppunt zijn met de naam Worker en het adres 10.0.0.2. Wanneer het script is voltooid, verschijnt er een configuratiebestand in de hoofdmap: /root/wg0-client-Worker.conf.

Voer het volgende commando uit om deze configuratie te bekijken:

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

Voer het installatiescript opnieuw uit om nog een client aan te maken. Voeg op deze manier alle toekomstige clients toe en tot slot kun je controleren of alle configuratiebestanden zijn aangemaakt:

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

VPN-clients

VPN-clients omvatten alle knooppunten die verbonden moeten worden met een enkel netwerk. In onze handleiding verwijst dit naar het beheerknooppunt, opslagknooppunt, clientknooppunt (als Linux wordt gebruikt) en worker knooppunten. Als de VPN-server op een worker node draait, hoeft deze niet als client te worden geconfigureerd (deze stap kan worden overgeslagen).

Werk de pakketcache-repository bij en installeer vervolgens Wireguard en CIFS-ondersteuningspakketten:

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

Verhoog rechten naar superuser:

sudo -i

Open de Wireguard configuratiemap:

cd /etc/wireguard

Voer het commando umask uit zodat alleen de superuser toegang heeft tot de bestanden in deze directory:

umask 077

Genereer een privésleutel en sla deze op in een bestand:

wg genkey > private-key

Genereer een openbare sleutel met behulp van de privésleutel:

wg pubkey > public-key < private-key

Maak een configuratiebestand:

nano /etc/wireguard/wg0.conf

Plak je eigen configuratie, gemaakt voor deze 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

Vergeet niet de optie PersistentKeepalive = 1 toe te voegen (waarbij 1 staat voor 1 seconde) op elk knooppunt dat zich achter NAT bevindt. U kunt deze periode experimenteel kiezen. De aanbevolen waarde door de auteurs van Wireguard is 25. Sla het bestand op en sluit het af met de sneltoets CTRL + X en de toets Y om te bevestigen.

Als je internetverkeer wilt doorlaten, stel dan AllowedIPs in op 0.0.0.0/0,::/0

Log vervolgens uit met het root-account:

exit

Start de verbinding met systemctl:

sudo systemctl start wg-quick@wg0.service

Controleer of alles in orde is en de service succesvol is gestart:

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

Als je een foutmelding tegenkomt zoals "resolvconf: opdracht niet gevonden" in Ubuntu 22.04, maak dan gewoon een symboolkoppeling:

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

Schakel de nieuwe service in om automatisch verbinding te maken terwijl het besturingssysteem opstart:

sudo systemctl enable wg-quick@wg0.service

Nu kun je de connectiviteit controleren door echopakketten te versturen:

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

Stap 2. NAS-knooppunt

Maak verbinding met de VPN-server met behulp van de handleiding uit stap 1. Installeer vervolgens de Samba-pakketten voor de server en client:

sudo apt install samba samba-client

Maak een back-up van je standaardconfiguratie:

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

Maak een map aan die zal worden gebruikt als share:

sudo mkdir /mnt/share

Maak een nieuwe gebruikersgroep aan die toegang krijgt tot de nieuwe share:

sudo groupadd smbusers

Voeg een bestaande gebruiker toe aan de aangemaakte groep:

sudo usermod -aG smbusers user

Stel een wachtwoord in voor deze gebruiker. Dit is een noodzakelijke stap omdat het systeemwachtwoord en het Samba-wachtwoord verschillende entiteiten zijn:

sudo smbpasswd -a $USER

Verwijder de standaardconfiguratie:

sudo rm /etc/samba/smb.conf

En maak een nieuwe:

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

Sla het bestand op en test de nieuwe parameters:

testparm -s

Start beide Samba-services opnieuw op:

sudo service smbd restart

sudo service nmbd restart

Geef tot slot de toestemming om de map te delen:

sudo chown user:smbusers /mnt/share

Stap 3. Samba client-verbinding

Alle knooppunten in Flamenco gebruiken een gedeelde map op /mnt/flamenco. U moet deze map op elk knooppunt mounten voordat u de flamenco-client of flamenco-manager scripts uitvoert. In dit voorbeeld gebruiken we een worker node gehost op LeaderGPU met de gebruikersnaam usergpu. Vervang deze gegevens door uw eigen gegevens als ze afwijken.

Maak een verborgen bestand aan waarin u de referenties van SMB-shares kunt opslaan:

nano /home/usergpu/.smbcredentials

Typ deze twee strings:

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

Sla dit bestand op en sluit af. Beveilig dit bestand vervolgens door de toegangsrechten te wijzigen:

sudo chmod 600 /home/usergpu/.smbcredentials

Maak een nieuwe map aan die kan worden gebruikt als koppelpunt voor de externe opslag:

sudo mkdir /mnt/flamenco

En maak de gebruiker eigenaar van deze map:

sudo chown usergpu:users /mnt/flamenco

Het enige wat overblijft is om de netwerkdirectory automatisch te laten mounten:

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

Voeg twee regels toe aan je VPN-configuratie in de sectie [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
…

Herstart de server:

sudo shutdown -r now

Controleer of de services zijn geladen en of de gedeelde map is gemount:

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

Stap 4. Beheerknooppunt

Zet een VPN-verbinding op met behulp van de handleiding uit stap 1. Stop de VPN-service voordat u verdergaat:

sudo systemctl stop wg-quick@wg0.service

Laten we ons voorbereiden. Automatisch mounten vereist hulpprogramma's voor het CIFS-protocol:

sudo apt -y install cifs-utils

De volgende belangrijke stap is het installeren van Blender. Je kunt dit doen met de standaard APT pakketbeheerder, maar dit zal waarschijnlijk een van de oudere versies installeren (minder dan v3.6.4). Laten we Snap gebruiken om de nieuwste versie te installeren:

sudo snap install blender --classic

Controleer de geïnstalleerde versie met het volgende commando:

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
…

Als je een foutmelding krijgt die aangeeft dat er bibliotheken ontbreken, installeer ze dan gewoon. Al deze bibliotheken zijn opgenomen in het XOrg-pakket:

sudo apt -y install xorg

Download de toepassing:

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

Pak het gedownloade archief uit:

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

Ga naar de aangemaakte map:

cd flamenco-3.7-linux-amd64/

En start Flamenco voor de eerste keer:

./flamenco-manager

Open het volgende adres in je webbrowser: http://10.0.0.3:8080/. Klik op de knop Let's go. Typ /mnt/flamenco in het verplichte veld en klik vervolgens op Next:

Flamenco zal proberen het Blender uitvoerbare bestand te lokaliseren. Als je Blender hebt geïnstalleerd vanaf Snap, zal het pad /snap/bin/blender zijn. Controleer dit punt en klik op Next:

Controleer de samenvatting en klik op Confirm:

Ga terug naar de SSH-sessie en gebruik de sneltoets Ctrl + C om de toepassing te onderbreken. De eerste start genereert het configuratiebestand flamenco-manager.yaml. Laten we wat opties toevoegen aan de secties variables en 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

Het eerste extra blok beschrijft extra tweerichtingsvariabelen, die nodig zijn voor multiplatform farms. Dit lost het belangrijkste probleem op met slashes en paden. In Linux gebruiken we het forward slash symbool (/) als scheidingsteken, maar in Windows gebruiken we het backslash symbool (^). Hier maken we de vervangingsregel voor alle beschikbare alternatieven: Linux, Windows en macOS (Darwin).

Wanneer je een netwerkshare koppelt in Windows, moet je een stationsletter kiezen. Onze Storage is bijvoorbeeld gekoppeld met de letter Z:. De vervangingsregel vertelt het systeem dat voor het Windows-platform het pad /mnt/flamenco zich op Z:\ bevindt. Voor macOS zal dit pad /Volumes/shared/flamenco zijn.

Kijk naar het tweede toegevoegde blok. Dit instrueert Blender om Cycles rendering engine te gebruiken en roept een eenvoudig Python script, gpurender.py, aan wanneer Blender wordt uitgevoerd. Dit is een eenvoudige truc om de GPU te selecteren in plaats van de CPU. Er is geen standaard optie om dit direct te doen. Je kunt niet blender --use-gpu of iets dergelijks aanroepen. Je kunt echter wel een extern Python script aanroepen met de -P optie. Dit commando instrueert de Worker om een script te vinden in de lokale directory en het uit te voeren wanneer de toegewezen job de Blender executable aanroept.

Nu kunnen we de controle over de applicatie delegeren aan het systemd init subsysteem. Laten we het systeem informeren over de locatie van de werkmap, het uitvoerbare bestand en de gebruikersrechten die nodig zijn voor het starten. Maak een nieuw bestand:

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

Vul het met de volgende strings:

[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

Sla het bestand op en sluit de nano-teksteditor af.

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

Schakel automatisch starten in wanneer het systeem opstart:

sudo systemctl enable flamenco-manager.service

Stap 5. Werkerknooppunt

Maak verbinding met de VPN-server met behulp van de handleiding uit stap 1 en koppel de share uit stap 3. Stop de VPN-service voordat u verdergaat:

sudo snap install blender --classic

Moderne *.blend bestanden worden gecomprimeerd met het Zstandard algoritme. Om fouten te voorkomen is het essentieel om ondersteuning voor dit algoritme op te nemen:

sudo apt -y install python3-zstd

Download de toepassing:

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

Pak het gedownloade archief uit:

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

Navigeer naar de aangemaakte map:

cd flamenco-3.7-linux-amd64/

Maak een extra script dat GPU rendering inschakelt wanneer Flamenco jobs draait:

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")

Sla het bestand op en sluit af. Maak vervolgens een aparte service om Flamenco uit te voeren vanuit 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

Herlaad de configuratie en start de nieuwe service:

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

Automatische start inschakelen wanneer het systeem opstart:

sudo systemctl enable flamenco-worker.service

Stap 6. Gebruikersknooppunt

Gebruikersknooppunten kunnen met elk besturingssysteem worden beheerd. In deze handleiding laten we zien hoe je een knooppunt instelt met Windows 11 en 4 benodigde componenten:

VPN-verbinding
Gemonteerde map op afstand
Blender geïnstalleerd
Flamenco add-on

Download en installeer Wireguard van de officiële website. Maak een nieuw tekstbestand aan en plak daarin de configuratie die in stap 1 voor de client is gegenereerd. Hernoem het bestand naar flamenco.conf en voeg het toe in Wireguard met de knop Add tunnel:

Maak verbinding met uw server door op de knop Activate te drukken:

Koppel een externe map. Klik met de rechtermuisknop op This PC en selecteer Map network drive…

Kies Z: als stationsletter, typ het Samba share adres \\10.0.0.4\private en vergeet niet Connect using different credentials aan te vinken. Klik vervolgens op Finish. Het systeem zal je vragen om een gebruikersnaam en wachtwoord voor de share in te voeren. Daarna wordt de netwerkmap gemount als het Z: station.

Download en installeer Blender van de officiële website. Open vervolgens de URL http://10.0.0.3:8080/flamenco3-addon.zip en installeer de Flamenco add-on. Activeer het in voorkeuren: Edit > Preferences > Add-ons. Vink System: Flamenco 3 aan, voer de Manager URL http://10.0.0.3:8080 in en klik op de refresh knop. Het systeem zal verbinding maken met het beheerdersknooppunt en de opslaginstellingen automatisch laden:

Open het bestand dat je moet renderen. Kies Cycles op het tabblad Scene in de vervolgkeuzelijst Render Engine. Vergeet niet het bestand op te slaan, want deze instellingen worden direct opgeslagen in het *.blend bestand:

Scroll naar beneden en vind de Flamenco 3 sectie. Klik op Fetch job types voor een lijst met beschikbare types. Selecteer Simple Blender Render in de vervolgkeuzelijst en stel andere opties in, zoals het aantal frames, de grootte van de chunk en de uitvoermap. Klik ten slotte op Submit to Flamenco:

De Flamenco add-on maakt een nieuwe taak aan en uploadt een blendbestand naar gedeelde opslag. Het systeem stuurt de taak naar een beschikbare worker en start het renderproces:

Als je de belasting van de GPU's controleert met nvtop of soortgelijke hulpprogramma's, zie je dat alle GPU's compute taken hebben:

Je vindt het resultaat in een map die je in de vorige stap hebt geselecteerd. Voorbeeld hier (Ripple Dreams door James Redmond)

Zie ook:

Fotogrammetrie met Meshroom

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

Fotogrammetrie is een methode om fysieke objecten om te zetten in driedimensionale digitale modellen die bewerkt kunnen worden met 3D-software. Dit proces maakt meestal gebruik van gespecialiseerde apparaten die 3D-scanners worden genoemd en er zijn twee hoofdtypen: optisch en laser.

Optische scanners gebruiken vaak een of meer digitale camera's en speciale verlichting om het object gelijkmatig te belichten tijdens het scannen. Hierdoor kan een 3D-model worden gemaakt. Laserscanners daarentegen maken gebruik van laserstralen. Deze apparaten zenden meerdere laserstralen uit en meten de tijd die elke straal nodig heeft om terug te kaatsen van het object. Aan de hand van deze gegevens, samen met informatie van positiesensoren, berekent de scanner de afstand tot elk punt op het object. Dit creëert een "puntenwolk" die de basis vormt van het 3D-model.

Puntenwolk

Om het toekomstige raamwerk van een object op te bouwen, moet het systeem de coördinaten van elk hoekpunt in de driedimensionale ruimte kennen. De verzameling hoekpunten wordt een puntenwolk genoemd. Hoe meer hoekpunten er zijn, hoe gedetailleerder het object zal zijn. Het maken van een puntenwolk is de eerste en een van de meest cruciale stappen bij het recreëren van een 3D-model van foto's.

Het is belangrijk om te weten dat elk hoekpunt in de puntenwolk in eerste instantie niet verbonden is met andere hoekpunten. Dit maakt filteren eenvoudig: de noodzakelijke punten behouden en de rest verwijderen, voordat u begint met het opnieuw maken van de mesh van het object.

Mesh-objecten

Een mesh-object is een type 3D-model dat bestaat uit driehoekige geometrische primitieven, vaak meshes of polymeshes genoemd. Zodra objectpunten gevormd zijn, kan de toepassing hieruit onafhankelijk driehoekige primitieven samenstellen. Door deze primitieven te verbinden, is het mogelijk om een 3D-model van bijna elke vorm te maken. In dit stadium heeft het model geen kleur en blijft het ongeverfd.

De volgende textureringsfase pakt dit probleem aan.

Structureren

De laatste stap is het aanbrengen van de uit de foto's geëxtraheerde beeldtextuur op het voorbereide mesh-object. De kwaliteit van de genomen foto's en hun resolutie spelen hier een belangrijke rol. Als die laag is, zal het eindresultaat er niet op zijn best uitzien. Maar als er voldoende foto's van goede kwaliteit zijn gemaakt, krijg je bij de uitvoer een volledig gebruiksklaar 3D-model van een echt object. Hieronder geven we een aantal handige tips voor het voorbereiden van de originele foto's.

Camera-instellingen

Om teleurstellingen te voorkomen bij uw eerste pogingen om een 3D-model te maken van foto's, moet u deze eenvoudige basisregels in acht nemen. Elke regel helpt problemen te voorkomen die meestal optreden tijdens het maken van het mesh-object.

Ten eerste, vertrouw niet op de automatische instellingen van uw digitale camera. Moderne camera's proberen vier belangrijke parameters onafhankelijk van elkaar te balanceren:

ISO,
witbalans,
sluitertijd,
diafragma.

In de automatische modus kunnen zelfs kleine veranderingen in externe omstandigheden ervoor zorgen dat deze instellingen variëren tussen frames. Deze variaties kunnen leiden tot merkbare inconsistenties tijdens het textureren.

Gebruik de modus Manual (M) om consistente parameters tussen frames te behouden. Het diafragma is hier een cruciale instelling. Afhankelijk van je lens moet je streven naar een stand waarbij het diafragma bijna gesloten is. Dit helpt om maximale scherptediepte te bereiken: hoe minder open het diafragma, hoe beter. Vermijd echter extreme waarden. Als je lens dicht bij f/22 kan staan, krijg je goede resultaten met waarden tussen f/11 en f/20.

^{Links f/11, rechts f/22}

Het sluiten van het diafragma creëert echter een ander probleem: onvoldoende licht. Dit kan op twee manieren worden aangepakt: door de ISO-gevoeligheid te verhogen of de sluitertijd te verlengen. Beide methoden hebben invloed op het eindresultaat, zij het op verschillende manieren. Het verhogen van de ISO tot 6400 introduceert digitale ruis in de foto, dus je kunt het beste de laagst mogelijke waarden gebruiken. Voor bijna ideale resultaten is het verstandig om de ISO op 100 in te stellen. Dit betekent echter dat het probleem van onvoldoende belichting blijft bestaan:

^{Links ISO 100, rechts ISO 6400}

De meest effectieve manier om meer licht door de camerasensor te laten stromen bij weinig licht is door de sluitertijd te verlengen. Hoe langer de sluiter open blijft, hoe meer fotonen de sensor raken, wat resulteert in een betere beeldkwaliteit. Deze aanpak brengt echter een uitdaging met zich mee: zonder statief kan een sluitertijd van 1/50 seconde of langer het beeld onscherp maken. Met een statief is dit probleem verleden tijd.

Witbalans is de laatste cruciale parameter. Het is belangrijk om de automatische instelling uit te schakelen en een voorgeprogrammeerd profiel te kiezen (zoals "Zonnige dag") of een aangepaste waarde in Kelvin. 5200K is bijvoorbeeld een veelgebruikte instelling. Lagere waarden verschuiven de tint naar geel, terwijl hogere waarden naar blauw neigen. Om tijdrovende kleurcorrecties in de nabewerking te voorkomen, gebruik je hetzelfde witbalansprofiel voor alle foto's in een serie.

^{WB-profielen. Links "Zonnige dag", rechts "Auto".}

Kortom, om foto's van hoge kwaliteit te maken voor fotogrammetrie:

Gebruik een statief bij onvoldoende licht.
Sluit het diafragma bijna tot het minimum.
Stel de ISO in op de minimale waarde.
Kies een sluitertijd die je het gewenste resultaat geeft (of gebruik de ingebouwde belichtingsmeter van je camera).
Gebruik dezelfde voorkeuze witbalans.

Foto's maken

Laten we het hebben over hoeveel foto's je moet nemen en vanuit welke hoeken. Het type object en de achtergrond hebben een grote invloed op het eindresultaat. Objecten zonder glimmende, transparante of reflecterende oppervlakken zijn ideaal voor fotogrammetrie. In de praktijk moeten objecten zoals ramen en glas later vaak worden gecorrigeerd in een 3D-editor. De algemene opnametechniek blijft echter hetzelfde.

Stel je voor kleine objecten op een oppervlak een bol voor rond het object. Neem foto's alsof je camera drie keer rond het object cirkelt: een keer van onderaf, een keer in het midden en een keer van bovenaf.

Het is cruciaal dat het object minstens de helft en bij voorkeur driekwart van elk beeld inneemt. Probeer in plaats van in te zoomen fysiek dichter bij het object te komen. Bij het maken van een wolkenpunt heeft de software zoveel mogelijk pixels nodig.

Denk er bij het fotograferen aan dat de software frames combineert tot één object voor een correcte geometrie. Maak als regel minstens drie frames vanuit elke hoek. Zodra je het object in het frame hebt gecentreerd, verdeel je het mentaal verticaal in drie gelijke delen. Neem drie foto's, elk gericht op een derde van het object. Dit zorgt voor de nodige overlap zodat de toepassing de locatie van elk punt in de 3D-ruimte nauwkeurig kan berekenen. Nadat je het object van alle mogelijke kanten en hoeken hebt gefotografeerd, kun je beginnen met het voorbereiden van de software.

Meshroom installeren

Meshroom is een gratis, cross-platform toepassing die alle verwerkingsstappen sequentieel uitvoert, gebruikmakend van CPU en GPU bronnen. Hoewel het op een standaard thuiscomputer kan draaien, kan elke stap tijdrovend zijn. Voor grootschalige projecten met 3D-reconstructie van een groot aantal objecten, zoals het maken van een indrukwekkende 3D-scène, kan het huren van een speciale GPU-server een praktische oplossing zijn.

Laten we eens kijken naar een LeaderGPU server met de volgende configuratie: 2 x NVIDIA® RTX™ 3090, 2 x Intel® Xeon® Silver 4210 (3.20 GHz), 128GB RAM. We gebruiken Windows Server 2022 als besturingssysteem. Voordat je Meshroom installeert, moet je enkele voorbereidende stappen uitvoeren:

Bezoek de officiële website van het project om Meshroom te downloaden. Pak het resulterende archief uit om een gebruiksklare toepassing te vinden die geen extra installatie vereist. Start Meshroom.exe om te beginnen.

Afbeeldingen uploaden

Het hoofdvenster van de toepassing is verdeeld in twee delen: boven en onder. Het bovenste deel bevat de afbeeldingsgalerij, de afbeeldingsviewer en de 3D-viewer. Het onderste deel bevat de Graph editor en Task Manager. Om te beginnen sleep je je vastgelegde foto's naar het aangewezen gebied. Zowel gecomprimeerde (bijvoorbeeld JPG) als RAW-bestandsformaten worden ondersteund. Het wordt aanbevolen om RAW-bestanden te gebruiken omdat deze aanzienlijk meer gegevens bevatten voor elk frame.

Houd er rekening mee dat je standaard al een kant-en-klare standaard pijplijn hebt, die schematisch wordt weergegeven in de Graph Editor. Dit is een van de belangrijkste besturingselementen waarmee je alle aspecten van de beeldverwerking in elke fase kunt configureren. Je kunt elke stap handmatig uitvoeren door met de rechtermuisknop te klikken en Compute te selecteren in het vervolgkeuzemenu.

Maar voor de eerste keer kun je gewoon op de groene knop Start klikken en de toepassing zal alles voor je doen. Het vraagt je om het project op te slaan, zodat je de resultaten van de berekening niet per ongeluk kwijtraakt. Klik op Save, geef een naam en map op en sla het project op:

Vervolgens brengt de toepassing alle verwerkingsfasen over van de Graph Editor naar de Task Manager, die ze in een specifieke volgorde uitvoert. Om de status van elke stap te controleren, selecteer je het corresponderende blok in de Graph Editor en klik je op de knop Log in de rechterbenedenhoek van het scherm. Je kunt ook in realtime zien welke stap momenteel wordt verwerkt:

Aan de rechterkant zie je de puntenwolk die je hebt opgebouwd. Het eindresultaat, gegenereerd met de standaard pijplijn, is beschikbaar in de map:

[Your_Project_Path]\MeshroomCache\Texturing\[Random_Symbols]\texturedMesh.obj

Als je van tevoren het uitvoerpad vastlegt in het laatste knooppunt van de pijplijn, komt het object natuurlijk terecht op het pad dat je hebt opgegeven. Vervolgens kun je het importeren in elke teksteditor om oppervlakken te corrigeren, lichtbronnen en andere effecten toe te voegen voor het renderen.

Integratie

Hoewel het eerste resultaat er indrukwekkend uitziet, moet het vaak worden verfijnd in een 3D-editor. Meshroom vereenvoudigt dit proces doordat je niet alleen het model, maar ook de puntenwolk en cameraposities kunt importeren in editors van derden, zoals Houdini of Blender. In de volgende sectie bekijken we hoe u dat doet.

Houdini

In feite is Meshroom een gebruiksvriendelijke interface voor de AliceVision engine, die alle berekeningsgerelateerde operaties afhandelt. Deze interface implementeert de bijbehorende pijplijn en taakmanager. Als je Houdini gebruikt, kun je je eigen pijplijn direct in de toepassing maken en deze naast andere gereedschappen gebruiken, zodat je Meshroom niet apart hoeft te starten.

Om te beginnen kunt u het beste een speciale launcher downloaden en installeren die Houdini updates en plugins beheert. Voeg vervolgens de SideFX Labs plugin toe, die talloze extra tools biedt, waaronder specifieke nodes voor AliceVision. Klik hiervoor op de knop + en selecteer vervolgens Shelves:

Scroll naar beneden in de lijst en selecteer SideFX Labs, klik vervolgens op de knop Update Toolset:

Volg deze stappen om een plugin te installeren: Klik op de knop Start Launcher, navigeer naar de sectie Labs/Packages in het linkermenu en selecteer Install packages. Dit opent een venster waarin je pakketten kunt kiezen om te installeren:

Kies de Production Build voor jouw versie van Houdini en klik op Install. Start daarna de toepassing opnieuw op om ervoor te zorgen dat de nieuwe effectpictogrammen bovenaan verschijnen:

Het is cruciaal om op te merken dat je hier geen vermelding vindt van AliceVision of Meshlab. Dit komt omdat de corresponderende plugin alleen werkt binnen de geometrie context pijplijn. Om dit te controleren, klikt u op het pictogram +, selecteert u vervolgens New Pane Tab Type en kiest u Network View:

Druk op de toets Tab en voeg een knooppunt Geometry toe:

Dubbelklik om het gemaakte knooppunt te openen en typ av op uw toetsenbord. Het systeem toont direct een lijst met beschikbare knooppunten die beginnen met de Labs AV-symbolen. Met deze knooppunten kunt u de AliceVision engine besturen en integreren in uw eigen pijplijnen:

Raadpleeg de officiële documentatie van de plugin om een goede pijplijn te maken. Overweeg daarnaast om de AliceVision directory toe te voegen aan de lijst met omgevingsvariabelen in het houdini.env bestand. Voor een standaardinstallatie met de launcher, bevindt dit bestand zich meestal in de map C:\Users\Administrator\Documents\houdini20.5\

Open het houdini.env bestand met een tekstverwerker en voeg de volgende regel toe:

ALICEVISION_PATH = [path to alicevision directory in Meshroom folder]

Bijvoorbeeld, als je Meshroom hebt geïnstalleerd in de root directory van de D: drive, dan zou je pad er als volgt uit kunnen zien:

ALICEVISION_PATH = D:\Meshroom\aliceVision

Sla het bestand op en start de Houdini-toepassing opnieuw.

Blender

Voor Blender gebruikers raden we de Meshroom2Blender plugin aan. Hoewel deze anders werkt dan de Houdini plugin, kun je hiermee puntwolken en cameraposities berekend door Meshroom exporteren naar Blender. Open de link in uw browser om toegang te krijgen tot de plugincode:

https://raw.githubusercontent.com/tibicen/meshroom2blender/master/view3d_point_cloud_visualizer.py

Sla de code op als view3d_point_cloud_visualizer.py in een handige map. Open vervolgens Blender en navigeer naar Edit - Preferences. Selecteer daar de tab Add-ons:

Klik op de pijl omlaag en selecteer Install from Disk:

Navigeer in het nieuw geopende venster naar de map waar je de plugin hebt opgeslagen. Selecteer het plugin-bestand en klik op Install from Disk button:

De plugin is nu geïnstalleerd. Het wordt aanbevolen om de toepassing opnieuw op te starten. Na het herstarten zie je het item Point Cloud Visualizer in de weergavemodus. De plugin vereist dat je het pad naar een bestand met de extensie .ply opgeeft:

Standaard genereert Meshroom dit type bestand niet. Om het aan te maken, open de pijplijn en voeg de ConvertSfMFormat node toe. Gebruik de SfMData van de StructureFromMotion node als invoer. Geef voor de uitvoer de Images Folder van het knooppunt Texturing op.

De laatste stap is het opgeven van het formaat. Klik op SfM File Format in het knooppunt ConvertSfMFormat en selecteer ply in de vervolgkeuzelijst:

Klik met de rechtermuisknop op het gemaakte knooppunt en selecteer Compute:

Zodra het proces is voltooid, vind je het vereiste bestand in de directory:

[Your_Project_Path]\MeshroomCache\ConvertSfMFormat\[Random_Symbols]\sfm.ply

Je kunt het op twee manieren in Blender laden: via de eerder genoemde plugin of via het standaard importproces File - Import - Stanford PLY (.ply):

Voor meer informatie over het gebruik van deze plugin, raden we je aan de project repository of een gespecialiseerde webbron te raadplegen.

Conclusie

Fotogrammetrie is een groot kennisgebied, waarbij we hebben geprobeerd om slechts enkele basistechnieken te vertellen voor het omzetten van 2D afbeeldingen in een 3D model. Dit wordt in veel industrieën gebruikt, van architectuur tot het maken van computerspellen.

Nadat u de eerste ervaring hebt opgedaan met het fotograferen van een dataset en de consistente transformatie ervan in een 3D-model, kunt u uw vaardigheden verbeteren en fysieke objecten overbrengen naar een virtuele 3D-ruimte. Welnu, LeaderGPU zal u helpen met rekenkracht, het verminderen van de rekentijd en het vrijmaken van uw werkstation voor andere, vaak meer prioritaire taken.

Zie ook:

Open WebUI: Alles in één

Mon, 20 Jan 2025 15:21:46 +0100

Open WebUI is oorspronkelijk ontwikkeld voor Ollama, waarover we in een van onze artikelen hebben gesproken. Voorheen heette het Ollama WebUI, maar na verloop van tijd verschoof de focus naar universaliteit van toepassing en werd de naam veranderd in Open WebUI. Deze software lost het sleutelprobleem op van handig werken met grote neurale netwerkmodellen die lokaal of op door de gebruiker beheerde servers worden geplaatst.

Installatie

De belangrijkste en meest geprefereerde installatiemethode is het implementeren van een Docker-container. Hierdoor hoef je niet na te denken over de aanwezigheid van afhankelijkheden of andere componenten die zorgen voor de juiste werking van de software. Je kunt Open WebUI echter ook installeren door de projectrepository van GitHub te klonen en het vanaf de broncode te bouwen. In dit artikel bekijken we beide opties.

Voordat je begint, moet je ervoor zorgen dat de GPU-stuurprogramma's op de server zijn geïnstalleerd. Onze instructie Nvidia-stuurprogramma's installeren in Linux helpt je hierbij.

Docker gebruiken

Als je net een server hebt besteld, dan ontbreken de Docker Engine zelf en de nodige tools om GPU's aan de container door te geven. We raden niet aan Docker te installeren vanuit de standaard Ubuntu repository, omdat deze mogelijk verouderd is en niet alle moderne opties ondersteunt. Het is beter om het installatiescript te gebruiken dat op de officiële website staat:

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

Naast Docker moet je ook de NVIDIA® Container Toolkit installeren, dus schakel de Nvidia-repository in:

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

Werk je pakketcache bij en installeer NVIDIA® Container Toolkit:

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

Om de toolchain te laten werken, moet je de Docker-daemon herstarten:

sudo systemctl restart docker

Nu kun je de gewenste container uitvoeren. Merk op dat het volgende commando de containers niet isoleert van het hostnetwerk, omdat u later extra opties kunt inschakelen, zoals het genereren van images met de Stable Diffusion WebUI. Dit commando zal automatisch alle lagen van het image downloaden en uitvoeren:

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

Git gebruiken

Ubuntu 22.04

Eerst moet je de inhoud van het archief klonen:

git clone https://github.com/open-webui/open-webui.git

Open de gedownloade map:

cd open-webui/

Kopieer de voorbeeldconfiguratie (je kunt deze indien nodig aanpassen), die de omgevingsvariabelen voor het bouwen instelt:

cp -RPp .env.example .env

Installeer de NVM installer, die je zal helpen om de vereiste versie van Node.js op de server te installeren:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Daarna moet je de SSH-sessie sluiten en opnieuw openen zodat het volgende commando correct werkt.

Installeer Node Package Manager:

sudo apt -y install npm

Installeer Node.js versie 22 (actueel op het moment van schrijven van dit artikel):

npm install 22

Installeer de afhankelijkheden die nodig zijn voor verdere assemblage:

npm install

Laten we de build starten. Houd er rekening mee dat er meer dan 4 GB vrij RAM-geheugen nodig is:

npm run build

De voorkant is klaar; nu is het tijd om de achterkant voor te bereiden. Ga naar de map met dezelfde naam:

cd ./backend

Installeer pip en ffmpeg pakketten:

sudo apt -y install python3-pip ffmpeg

Voor de installatie moet je een nieuw pad toevoegen aan de omgevingsvariabele:

sudo nano ~/.bashrc

Voeg de volgende regel toe aan het einde van het bestand:

export PATH="/home/usergpu/.local/bin:$PATH"

Laten we het bijwerken naar de nieuwste versie:

python3 -m pip install --upgrade pip

Nu kun je de afhankelijkheden installeren:

pip install -r requirements.txt -U

Installeer Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Alles is klaar om de toepassing te starten:

bash start.sh

Ubuntu 24.04 / 24.10

Bij het installeren van OpenWebUI op Ubuntu 24.04/24.10 wordt u geconfronteerd met een belangrijke uitdaging: het besturingssysteem gebruikt standaard Python 3.12, terwijl OpenWebUI alleen versie 3.11 ondersteunt. U kunt Python niet eenvoudigweg downgraden, want dan zou het besturingssysteem kapot gaan. Aangezien het python3.11 pakket niet beschikbaar is in de standaard repositories, moet u een virtuele omgeving maken om de juiste Python versie te gebruiken.

De beste oplossing is om het Conda pakketbeheersysteem te gebruiken. Conda werkt als pip, maar voegt ondersteuning voor virtuele omgevingen toe, vergelijkbaar met venv. Omdat je alleen basisfunctionaliteit nodig hebt, gebruik je Miniconda, een lichtgewicht distributie. Download de nieuwste versie van GitHub:

curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"

Voer het script uit:

bash Miniforge3-$(uname)-$(uname -m).sh

Laten we een virtuele omgeving aanmaken met de naam pyenv en de Python versie 3.11 specificeren:

conda create -n pyenv python=3.11

Activeer de aangemaakte omgeving:

conda activate pyenv

Nu kunt u doorgaan met de standaard OpenWebUI installatiestappen voor Ubuntu 22.04. De virtuele omgeving zorgt ervoor dat alle installatiescripts soepel verlopen zonder conflicten met pakketversies.

Modellen

Ollama bibliotheek

Met Open WebUI kunt u modellen rechtstreeks uploaden vanuit de webinterface, waarbij u alleen de naam hoeft op te geven in het formaat model:size. Navigeer hiervoor naar http://192.168.88.20:8080/admin/settings en klik op Connections. Klik vervolgens op het moersleutelpictogram tegenover de http://localhost:11434 string. Nadat u de namen van de modellen in de bibliotheek hebt bekeken, voert u de naam in en klikt u op het uploadpictogram:

Daarna zal het systeem automatisch het gewenste model downloaden en zal het onmiddellijk beschikbaar worden voor gebruik. Afhankelijk van de geselecteerde grootte kan het downloaden een andere hoeveelheid tijd in beslag nemen. Controleer voor het downloaden of er voldoende ruimte is op de schijf. Zie voor meer informatie het artikel Schijfpartitionering in Linux.

Aangepaste modellen

Als je een neuraal netwerkmodel moet integreren dat niet in de Ollama-bibliotheek zit, kun je de experimenteerfunctie gebruiken en een willekeurig model in GGUF-formaat laden. Ga hiervoor naar Settings - Admin Settings - Connections en klik op het moersleutelpictogram tegenover http://localhost:11434. Klik op Show in de sectie Experimental. Standaard is de bestandsmodus geactiveerd, waarmee je een bestand van je lokale computer kunt laden. Als je op File Mode klikt, verandert dit in URL Mode, waarmee je de URL van het modelbestand kunt opgeven, waarna de server het automatisch downloadt:

RAG

Naast een handige en functionele webinterface helpt Open WebUI om de mogelijkheden van verschillende modellen uit te breiden, zodat ze samen kunnen worden gebruikt. Het is bijvoorbeeld eenvoudig om documenten te uploaden om een RAG (Retrieval-augmented generation) vectordatabase te vormen. Bij het genereren van een antwoord aan de gebruiker zal LLM niet alleen kunnen vertrouwen op gegevens die direct als resultaat van de training zijn verkregen, maar ook op gegevens die in een vergelijkbare vectordatabase zijn geplaatst.

Documenten

Open WebUI scant standaard de map /data/docs op bestanden die in de vectorruimte van de database kunnen worden geplaatst en voert de transformatie uit met behulp van het ingebouwde all-MiniLM-L6-v2 model. Dit is niet het enige model dat geschikt is voor deze taak, dus het is zinvol om andere opties te proberen, bijvoorbeeld uit deze lijst.

Tekstdocumenten zonder tags en andere speciale tekens zijn het meest geschikt voor RAG. Natuurlijk kun je documenten uploaden zoals ze zijn, maar dit kan de nauwkeurigheid van de gegenereerde antwoorden sterk beïnvloeden. Als je bijvoorbeeld een kennisbank in Markdown-indeling hebt, kun je deze eerst opmaken en pas daarna uploaden naar /data/docs.

Zoeken op het web

Naast lokale documenten kan het neurale netwerkmodel ook de opdracht krijgen om websites te gebruiken als gegevensbron. Hierdoor kan het vragen beantwoorden door niet alleen de gegevens te gebruiken waarop het getraind is, maar ook gegevens die gehost worden op websites die door de gebruiker gespecificeerd zijn.

In feite is dit een soort RAG, die HTML-pagina's als invoer ontvangt en ze vervolgens op een speciale manier transformeert en in een vectorgegevensbank plaatst. Het doorzoeken van zo'n database gaat erg snel; daarom kan het neurale netwerkmodel snel een antwoord genereren op basis van de resultaten. Open WebUI ondersteunt verschillende zoekmachines, maar kan er maar met één tegelijk werken, wat wordt aangegeven in de instellingen.

Om webzoekresultaten op te nemen in neurale netwerkreacties, klikt u op + (plusteken) en verschuift u de schakelaar Web Search:

Afbeelding genereren

Het hoogtepunt van Open WebUI is dat je met deze software meerdere neurale netwerken met verschillende taken kunt combineren om een enkel probleem op te lossen. Llama 3.1 voert bijvoorbeeld perfect een dialoog met de gebruiker in verschillende talen, maar zijn antwoorden zijn uitsluitend tekst. Het kan geen afbeeldingen genereren, dus er is geen manier om zijn antwoorden te illustreren.

Stable Diffusion, waar we vaak over schreven, is het tegenovergestelde: dit neurale netwerk genereert perfect afbeeldingen, maar kan helemaal niet met teksten werken. De ontwikkelaars van Open WebUI probeerden de sterke punten van beide neurale netwerken te combineren in één dialoog en implementeerden het volgende werkschema.

Als je een dialoog voert in Open WebUI, verschijnt er een speciale knop naast elk neuraal netwerkantwoord. Door erop te klikken, krijg je een illustratie van dit antwoord direct in de chat:

Dit wordt bereikt door de Stable Diffusion WebUI API aan te roepen, en op dit moment zijn een verbinding met versies van Automatic1111 en een verbinding met ComfyUI beschikbaar. U kunt ook afbeeldingen genereren via het Dall-E neurale netwerk, maar dit kan niet lokaal worden ingezet - dit is een betaalde dienst voor het genereren van afbeeldingen met gesloten broncode.

Deze functie werkt alleen als naast Open WebUI met Ollama ook Stable Diffusion WebUI op de server is geïnstalleerd. U kunt de installatie-instructies hier vinden. Het enige dat het vermelden waard is, is dat wanneer u het script ./webui.sh uitvoert, u een extra sleutel moet opgeven om de API in te schakelen:

./webui.sh --listen --api --gradio-auth user:password

Een andere valkuil kan ontstaan door een gebrek aan videogeheugen. Als je dit tegenkomt, kun je twee handige sleutels gebruiken: --medvram en --lowvram. Dit voorkomt de foutmelding Out-of-memory bij het starten van de generatie.

Zie ook:

Hoe werkt Ollama

Mon, 20 Jan 2025 15:16:02 +0100

Ollama is een hulpmiddel om grote neurale netwerkmodellen lokaal uit te voeren. Het gebruik van openbare diensten wordt door bedrijven vaak gezien als een potentieel risico voor het lekken van vertrouwelijke en gevoelige gegevens. Door LLM op een gecontroleerde server te implementeren, kunt u de gegevens die erop staan onafhankelijk beheren terwijl u gebruik maakt van de sterke punten van LLM.

Dit helpt ook om de onaangename situatie van vendor lock-in te voorkomen, waarbij elke openbare dienst eenzijdig kan stoppen met het leveren van services. Natuurlijk is het initiële doel om het gebruik van generatieve neurale netwerken mogelijk te maken op locaties waar internettoegang afwezig of moeilijk is (bijvoorbeeld in een vliegtuig).

Het idee was om de lancering, besturing en fijnafstelling van LLM's te vereenvoudigen. In plaats van complexe instructies in meerdere stappen, kun je met Ollama één simpel commando uitvoeren en na enige tijd het eindresultaat ontvangen. Het wordt tegelijkertijd gepresenteerd in de vorm van een lokaal neuraal netwerkmodel, waarmee je kunt communiceren via een webinterface en API voor eenvoudige integratie in andere toepassingen.

Voor veel ontwikkelaars werd dit een zeer nuttig hulpmiddel, omdat het in de meeste gevallen mogelijk was om Ollama te integreren met de gebruikte IDE en aanbevelingen of kant-en-klare code te ontvangen die direct geschreven werd terwijl er aan de applicatie werd gewerkt.

Ollama was oorspronkelijk alleen bedoeld voor computers met het besturingssysteem macOS, maar werd later geport naar Linux en Windows. Er is ook een speciale versie uitgebracht voor het werken in gecontaineriseerde omgevingen zoals Docker. Op dit moment werkt het even goed op desktops als op elke dedicated server met een GPU. Ollama ondersteunt de mogelijkheid om out-of-the-box te schakelen tussen verschillende modellen en maximaliseert alle beschikbare bronnen. Natuurlijk presteren deze modellen misschien niet zo goed op een gewone desktop, maar ze functioneren heel adequaat.

Hoe installeer ik Ollama

Ollama kan op twee manieren worden geïnstalleerd: zonder gebruik te maken van containerisatie, met behulp van een installatiescript, en als een kant-en-klare Docker-container. De eerste methode maakt het makkelijker om de componenten van het geïnstalleerde systeem en modellen te beheren, maar is minder fouttolerant. De tweede methode is fouttoleranter, maar als je deze gebruikt, moet je rekening houden met alle aspecten die inherent zijn aan containers: iets complexer beheer en een andere benadering van gegevensopslag.

Ongeacht de gekozen methode zijn er een aantal extra stappen nodig om het besturingssysteem voor te bereiden.

Voorwaarden

Update de pakketcache repository en geïnstalleerde pakketten:

sudo apt update && sudo apt -y upgrade

Installeer alle benodigde GPU-stuurprogramma's met behulp van de auto-installatiefunctie:

sudo ubuntu-drivers autoinstall

Start de server opnieuw op:

sudo shutdown -r now

Installatie via script

Het volgende script detecteert de huidige architectuur van het besturingssysteem en installeert de juiste versie van Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Tijdens het gebruik maakt het script een aparte ollama gebruiker aan, waaronder de bijbehorende daemon wordt gestart. Overigens werkt hetzelfde script ook goed in WSL2, waardoor de Linux-versie van Ollama op Windows Server kan worden geïnstalleerd.

Installatie via Docker

Er zijn verschillende methodes om Docker Engine op een server te installeren. De eenvoudigste manier is om een specifiek script te gebruiken dat de huidige Docker-versie installeert. Deze aanpak is effectief voor Ubuntu Linux, vanaf versie 20.04 (LTS) tot de nieuwste versie, Ubuntu 24.04 (LTS):

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

Om Docker-containers goed te laten samenwerken met de GPU, moet een extra toolkit worden geïnstalleerd. Omdat deze niet beschikbaar is in de standaard Ubuntu-repositories, moet je eerst een repository van derden toevoegen met het volgende commando:

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

Update de pakketcache repository:

sudo apt update

En installeer het pakket nvidia-container-toolkit:

sudo apt install nvidia-container-toolkit

Vergeet niet om de docker daemon opnieuw te starten via systemctl:

sudo systemctl restart docker

Het is tijd om Ollama te downloaden en uit te voeren met de Open-WebUI webinterface:

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

Open de webbrowser en navigeer naar http://[server-ip]:3000:

De modellen downloaden en uitvoeren

Via de opdrachtregel

Voer gewoon het volgende commando uit:

ollama run llama3

Via WebUI

Open Settings > Models, typ de naam van het benodigde model, bijvoorbeeld llama3 en klik op de knop met het downloadsymbool:

Het model wordt automatisch gedownload en geïnstalleerd. Zodra dit voltooid is, sluit u het instellingenvenster en selecteert u het gedownloade model. Hierna kunt u er een dialoog mee beginnen:

VSCode integratie

Als je Ollama hebt geïnstalleerd met behulp van het installatiescript, kun je vrijwel direct alle ondersteunde modellen starten. In het volgende voorbeeld zullen we het standaardmodel uitvoeren dat wordt verwacht door de Ollama Autocoder-extensie (openhermes2.5-mistral:7b-q4_K_M):

ollama run openhermes2.5-mistral:7b-q4_K_M

Standaard staat Ollama het werken via een API toe, waarbij alleen verbindingen vanaf de lokale host worden toegestaan. Daarom is voor het installeren en gebruiken van de uitbreiding voor Visual Studio Code, port forwarding vereist. Specifiek moet je poort 11434 doorsturen naar je lokale computer. U kunt een voorbeeld vinden in ons artikel over Easy Diffusion WebUI.

Typ Ollama Autocoder in een zoekveld en klik dan op Install:

Na het installeren van de extensie zal een nieuw item met de titel Autocomplete with Ollama beschikbaar zijn in het opdrachtenpalet. Begin met coderen en start deze opdracht.

De extensie zal verbinding maken met de LeaderGPU server via port forwarding en binnen enkele seconden zal de gegenereerde code op uw scherm verschijnen:

U kunt dit commando toewijzen aan een sneltoets. Gebruik het wanneer u uw code wilt aanvullen met een gegenereerd fragment. Dit is slechts één voorbeeld van de beschikbare VSCode-uitbreidingen. Het principe van port forwarding van een externe server naar een lokale computer maakt het mogelijk om een enkele server op te zetten met een draaiende LLM voor een heel ontwikkelteam. Deze zekerheid voorkomt dat derden of hackers de verzonden code kunnen gebruiken.

Zie ook:

PrivateGPT: AI voor documenten

Mon, 20 Jan 2025 12:01:00 +0100

Grote taalmodellen hebben zich de afgelopen jaren sterk ontwikkeld en zijn effectieve hulpmiddelen geworden voor veel taken. Het enige probleem met het gebruik ervan is dat de meeste producten op basis van deze modellen gebruikmaken van kant-en-klare diensten van externe bedrijven. Dit gebruik kan gevoelige gegevens lekken, dus veel bedrijven vermijden het uploaden van interne documenten naar openbare LLM-services.

Een project als PrivateGPT zou een oplossing kunnen zijn. Het is in eerste instantie ontworpen voor volledig lokaal gebruik. De kracht is dat je verschillende documenten kunt invoeren en dat het neurale netwerk ze voor je leest en zelf commentaar geeft op jouw verzoeken. Je kunt het bijvoorbeeld grote teksten "voeren" en het vragen om conclusies te trekken op basis van het verzoek van de gebruiker. Hierdoor kun je aanzienlijk tijd besparen op proeflezen.

Dit geldt vooral voor professionele gebieden zoals geneeskunde. Een arts kan bijvoorbeeld een diagnose stellen en het neurale netwerk vragen deze te bevestigen op basis van de geüploade reeks documenten. Dit maakt het mogelijk om een extra onafhankelijke mening te krijgen, waardoor het aantal medische fouten vermindert. Aangezien verzoeken en documenten de server niet verlaten, kan men er zeker van zijn dat de ontvangen gegevens niet in het publieke domein verschijnen.

Vandaag laten we je zien hoe je in slechts 20 minuten een neuraal netwerk kunt implementeren op speciale LeaderGPU-servers met het Ubuntu 22.04 LTS-besturingssysteem.

Systeem voorbereiden

Begin met het bijwerken van uw pakketten naar de nieuwste versie:

sudo apt update && sudo apt -y upgrade

Installeer nu extra pakketten, bibliotheken en het grafische stuurprogramma van NVIDIA®. Deze zijn allemaal nodig om de software succesvol te bouwen en uit te voeren op de 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

CUDA® 12.4 installeren

Naast het stuurprogramma moet je ook de NVIDIA® CUDA® toolkit installeren. Deze instructies zijn getest op CUDA® 12.4, maar alles zou ook moeten werken op CUDA® 12.2. Houd er wel rekening mee dat je de geïnstalleerde versie moet aangeven wanneer je het pad naar de uitvoerbare bestanden opgeeft.

Voer achtereenvolgens het volgende commando uit:

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

Meer informatie over het installeren van CUDA® is te vinden in onze Kennisbank. Start nu de server opnieuw op:

sudo shutdown -r now

PyEnv installeren

Het is tijd om een eenvoudig Python-hulpprogramma voor versiebeheer te installeren, PyEnv genaamd. Dit is een aanzienlijk verbeterde fork van het vergelijkbare project voor Ruby (rbenv), geconfigureerd om met Python te werken. Het kan worden geïnstalleerd met een éénregelig script:

curl https://pyenv.run | bash

Nu moet je enkele variabelen toevoegen aan het einde van het scriptbestand, dat wordt uitgevoerd bij het inloggen. De eerste drie regels zijn verantwoordelijk voor de juiste werking van PyEnv en de vierde is nodig voor Poetry, dat later wordt geïnstalleerd:

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"

Pas de gemaakte instellingen toe:

source .bashrc

Installeer Python versie 3.11:

pyenv install 3.11

Maak een virtuele omgeving voor Python 3.11:

pyenv local 3.11

Poëzie installeren

Het volgende stukje van de puzzel is Poetry. Dit is een analogon van pip voor het beheren van afhankelijkheden in Python-projecten. De auteur van Poetry was het beu om constant om te gaan met verschillende configuratiemethodes, zoals setup.cfg, requirements.txt, MANIFEST.ini, en andere. Dit werd de drijfveer voor de ontwikkeling van een nieuwe tool die gebruik maakt van een pyproject.toml bestand, dat alle basisinformatie over een project opslaat, niet alleen een lijst met afhankelijkheden.

Poëzie installeren:

curl -sSL https://install.python-poetry.org | python3 -

PrivateGPT installeren

Nu alles klaar is, kun je de PrivateGPT repository klonen:

git clone https://github.com/imartinez/privateGPT

Ga naar de gedownloade repository:

cd privateGPT

Voer de installatie van afhankelijkheden uit met Poetry terwijl je extra componenten inschakelt:

ui - voegt een op Gradio gebaseerde beheer-webinterface toe aan de back-end applicatie;
embedding-huggingface - biedt ondersteuning voor het insluiten van modellen die zijn gedownload van HuggingFace;
llms-llama-cpp - voegt ondersteuning toe voor directe inferentie van modellen in GGUF-formaat;
vector-stores-qdrant - voegt de qdrant vector database toe.

poetry install --extras "ui embeddings-huggingface llms-llama-cpp vector-stores-qdrant"

Stel uw Hugging Face toegangstoken in. Lees dit artikel voor meer informatie:

export HF_TOKEN="YOUR_HUGGING_FACE_ACCESS_TOKEN"

Voer nu het installatiescript uit, dat automatisch het model en de gewichten downloadt (standaard Meta Llama 3.1 8B Instruct):

poetry run python scripts/setup

Het volgende commando hercompileert llms-llama-cpp afzonderlijk om NVIDIA® CUDA-ondersteuning in te schakelen, om workloads naar de GPU te verplaatsen:

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

Als je een foutmelding krijgt zoals nvcc fatal : Unsupported gpu architecture 'compute_', geef dan de exacte architectuur op van de GPU die je gebruikt. Bijvoorbeeld: DCMAKE_CUDA_ARCHITECTURES=86 voor NVIDIA® RTX™ 3090.

De laatste stap voordat je begint is het installeren van ondersteuning voor asynchrone aanroepen (async/await):

pip install asyncio

PrivateGPT uitvoeren

Voer PrivateGPT uit met een enkel commando:

make run

Open uw webbrowser en ga naar de pagina http://[LeaderGPU_server_IP_address]:8001

Zie ook:

Qwen 2 vs Llama 3

Mon, 20 Jan 2025 11:27:11 +0100

Grote taalmodellen (LLM's) hebben ons leven aanzienlijk beïnvloed. Ondanks dat we hun interne structuur begrijpen, blijven deze modellen een aandachtspunt voor wetenschappers die ze vaak vergelijken met een "zwarte doos". Het uiteindelijke resultaat hangt niet alleen af van het ontwerp van de LLM, maar ook van de training en de gegevens die voor de training zijn gebruikt.

Terwijl wetenschappers op zoek gaan naar onderzoeksmogelijkheden, zijn eindgebruikers vooral geïnteresseerd in twee dingen: snelheid en kwaliteit. Deze criteria spelen een cruciale rol in het selectieproces. Om twee LLM's nauwkeurig met elkaar te vergelijken, moeten veel schijnbaar ongerelateerde factoren worden gestandaardiseerd.

De apparatuur die wordt gebruikt voor interferentie en de softwareomgeving, inclusief het besturingssysteem, driverversies en softwarepakketten, hebben de grootste invloed. Het is essentieel om een LLM-versie te kiezen die op verschillende apparatuur werkt en een snelheidsmeting te kiezen die gemakkelijk te begrijpen is.

We hebben gekozen voor 'tokens per seconde' (tokens/s) als deze metriek. Het is belangrijk om te weten dat een token ≠ een woord is. De LLM splitst woorden op in eenvoudigere componenten, typisch voor een specifieke taal, die tokens worden genoemd.

De statistische voorspelbaarheid van het volgende teken verschilt per taal, dus de tokenisatie zal verschillen. In het Engels worden bijvoorbeeld ongeveer 100 tokens afgeleid uit elke 75 woorden. In talen die het cyrillische alfabet gebruiken, kan het aantal tokens per woord hoger zijn. Dus 75 woorden in een cyrillische taal, zoals Russisch, kunnen gelijkstaan aan 120-150 tokens.

Je kunt dit controleren met het gereedschap Tokenizer van OpenAI. Deze laat zien in hoeveel tokens een tekstfragment is opgedeeld, waardoor 'tokens per seconde' een goede indicator is voor de snelheid en prestaties van een LLM op het gebied van natuurlijke taalverwerking.

Elke test werd uitgevoerd op het Ubuntu 22.04 LTS besturingssysteem met NVIDIA® drivers versie 535.183.01 en de NVIDIA® CUDA® 12.5 Toolkit geïnstalleerd. Er werden vragen geformuleerd om de kwaliteit en snelheid van de LLM te beoordelen. De verwerkingssnelheid van elk antwoord werd geregistreerd en zal bijdragen aan de gemiddelde waarde voor elke geteste configuratie.

We begonnen met het testen van verschillende GPU's, van de nieuwste modellen tot de oudere. Een cruciale voorwaarde voor de test was dat we de prestaties van slechts één GPU maten, zelfs als er meerdere aanwezig waren in de serverconfiguratie. De prestaties van een configuratie met meerdere GPU's zijn namelijk afhankelijk van extra factoren, zoals de aanwezigheid van een snelle interconnect tussen de GPU's (NVLink).

Naast snelheid hebben we ook geprobeerd de kwaliteit van de antwoorden te evalueren op een 5-puntsschaal, waarbij 5 staat voor het beste resultaat. Deze informatie wordt hier alleen gegeven voor algemeen begrip. Elke keer stellen we dezelfde vragen aan het neurale netwerk en proberen we te achterhalen hoe nauwkeurig elk netwerk begrijpt wat de gebruiker wil.

Qwen 2

Onlangs presenteerde een team ontwikkelaars van Alibaba Group de tweede versie van hun generatieve neurale netwerk Qwen. Het begrijpt 27 talen en is er goed voor geoptimaliseerd. Qwen 2 wordt geleverd in verschillende groottes, zodat het eenvoudig kan worden ingezet op elk apparaat (van embedded systemen met veel bronnen tot een speciale server met GPU's):

0.5B: geschikt voor IoT en embedded systemen;
1,5B: een uitgebreide versie voor ingebedde systemen, gebruikt waar de mogelijkheden van 0,5B niet voldoende zijn;
7B: middelgroot model, zeer geschikt voor natuurlijke taalverwerking;
57B: groot model met hoge prestaties, geschikt voor veeleisende toepassingen;
72B: het ultieme Qwen 2 model, ontworpen om de meest complexe problemen op te lossen en grote hoeveelheden data te verwerken.

Versies 0.5B en 1.5B werden getraind op datasets met een contextlengte van 32K. Versies 7B en 72B waren al getraind op de 128K context. Het compromismodel 57B werd getraind op datasets met een contextlengte van 64K. De makers positioneren Qwen 2 als een analogon van Llama 3 die dezelfde problemen kan oplossen, maar dan veel sneller.

Llama 3

De derde versie van het generatieve neurale netwerk van de MetaAI Llama familie werd geïntroduceerd in april 2024. Het werd, in tegenstelling tot Qwen 2, in slechts twee versies uitgebracht: 8B en 70B. Deze modellen werden gepositioneerd als een universeel hulpmiddel voor het oplossen van veel problemen in verschillende gevallen. Het zette de trend naar meertaligheid en multimodaliteit voort, terwijl het tegelijkertijd sneller werd dan de vorige versies en een langere contextlengte ondersteunde.

De makers van Llama 3 probeerden de modellen te verfijnen om het percentage statistische hallucinaties te verminderen en de variatie in antwoorden te vergroten. Llama 3 is dus heel goed in staat om praktisch advies te geven, te helpen bij het schrijven van een zakelijke brief of te speculeren over een door de gebruiker gespecificeerd onderwerp. De datasets waarop Llama 3 modellen werden getraind hadden een contextlengte van 128K en meer dan 5% bevatte gegevens in 30 talen. Echter, zoals vermeld in het persbericht, zullen de generatieprestaties in het Engels significant hoger zijn dan in elke andere taal.

Vergelijking

NVIDIA® RTX™ A6000

Laten we onze snelheidsmetingen beginnen met de NVIDIA® RTX™ A6000 GPU, gebaseerd op de Ampere architectuur (niet te verwarren met de NVIDIA® RTX™ A6000 Ada). Deze kaart heeft zeer bescheiden eigenschappen, maar heeft tegelijkertijd 48 GB VRAM, waardoor het met redelijk grote neurale netwerkmodellen kan werken. Helaas zijn de lage kloksnelheid en bandbreedte de redenen voor de lage inferentiesnelheid van tekst LLM's.

Onmiddellijk na de lancering begon het Qwen 2 neurale netwerk beter te presteren dan Llama 3. Bij het beantwoorden van dezelfde vragen was het gemiddelde snelheidsverschil 24% in het voordeel van Qwen 2. De snelheid waarmee antwoorden werden gegenereerd lag in het bereik van 11-16 tokens per seconde. Dit is 2-3 keer sneller dan wanneer je zelfs op een krachtige CPU probeert te genereren, maar in onze beoordeling is dit het meest bescheiden resultaat.

NVIDIA® RTX™ 3090

De volgende GPU is ook gebouwd op de Ampere-architectuur, heeft 2 keer minder videogeheugen, maar werkt tegelijkertijd op een hogere frequentie (19500 MHz versus 16000 Mhz). De bandbreedte van het videogeheugen is ook hoger (936,2 GB/s tegenover 768 GB/s). Beide factoren verhogen de prestaties van de RTX™ 3090 aanzienlijk, zelfs als we rekening houden met het feit dat deze 256 CUDA-kernen minder heeft.

Hier kun je duidelijk zien dat Qwen 2 veel sneller is (tot 23%) dan Llama 3 bij het uitvoeren van dezelfde taken. Wat betreft de kwaliteit van het genereren, is de meertalige ondersteuning van Qwen 3 echt een pluim waard, en het model antwoordt altijd in dezelfde taal als waarin de vraag is gesteld. Met Llama 3 komt het in dit opzicht vaak voor dat het model de vraag zelf begrijpt, maar er de voorkeur aan geeft antwoorden in het Engels te formuleren.

NVIDIA® RTX™ 4090

Nu het meest interessante: laten we eens kijken hoe de NVIDIA® RTX™ 4090, gebouwd op de Ada Lovelace-architectuur, genoemd naar de Engelse wiskundige Augusta Ada King, gravin van Lovelace, dezelfde taak aankan. Ze werd beroemd omdat ze de eerste programmeur in de geschiedenis van de mensheid was, en op het moment dat ze haar eerste programma schreef was er nog geen computer die het kon uitvoeren. Wel werd erkend dat het algoritme dat Ada beschreef voor het berekenen van Bernoulli getallen het eerste programma ter wereld was dat geschreven werd om op een computer te spelen.

De grafiek laat duidelijk zien dat de RTX™ 4090 de inferentie van beide modellen bijna twee keer zo snel uitvoerde. Het is interessant dat in een van de iteraties Llama 3 erin slaagde om Qwen 2 met 1,2% te overtreffen. Rekening houdend met de andere iteraties behield Qwen 2 echter zijn leiderschap en bleef 7% sneller dan Llama 3. In alle iteraties was de kwaliteit van de antwoorden van beide neurale netwerken hoog met een minimaal aantal hallucinaties. Het enige defect is dat in zeldzame gevallen een of twee Chinese karakters werden gemengd in de antwoorden, wat op geen enkele manier de algehele betekenis beïnvloedde.

NVIDIA® RTX™ A40

De volgende NVIDIA® RTX™ A40-kaart, waarop we vergelijkbare tests uitvoerden, is opnieuw gebouwd op de Ampere-architectuur en heeft 48 GB videogeheugen op het moederbord. Vergeleken met de RTX™ 3090 is dit geheugen iets sneller (20000 MHz versus 19500 MHz), maar heeft het een lagere bandbreedte (695,8 GB/s versus 936,2 GB/s). Deze situatie wordt gecompenseerd door het grotere aantal CUDA-kernen (10752 tegenover 10496), waardoor de RTX™ A40 over het geheel genomen iets sneller presteert dan de RTX™ 3090.

Wat betreft het vergelijken van de snelheid van modellen, hier ligt Qwen 2 ook voor op Llama 3 in alle iteraties. Bij het draaien op RTX™ A40 is het verschil in snelheid ongeveer 15% met dezelfde antwoorden. Bij sommige opgaven gaf Qwen 2 iets meer belangrijke informatie, terwijl Llama 3 zo specifiek mogelijk was en voorbeelden gaf. Desondanks moet alles dubbel gecontroleerd worden, omdat beide modellen soms controversiële antwoorden geven.

NVIDIA® L20

De laatste deelnemer aan onze tests was de NVIDIA® L20. Deze GPU is net als de RTX™ 4090 gebouwd op de Ada Lovelace-architectuur. Dit is een vrij nieuw model, gepresenteerd in de herfst van 2023. Hij heeft 48 GB videogeheugen en 11776 CUDA-kernen aan boord. De geheugenbandbreedte is lager dan die van de RTX™ 4090 (864 GB/s tegenover 936,2 GB/s), net als de effectieve frequentie. Dus de NVIDIA® L20 inferentiescores van beide modellen zullen dichter bij 3090 liggen dan bij 4090.

De laatste test leverde geen verrassingen op. Qwen 2 bleek in alle iteraties sneller dan Llama 3.

Conclusie

Laten we alle verzamelde resultaten samenvoegen in één grafiek. Qwen 2 was 7% tot 24% sneller dan Llama 3, afhankelijk van de gebruikte GPU. Op basis hiervan kunnen we duidelijk concluderen dat als je hogesnelheidsinferenties nodig hebt van modellen zoals Qwen 2 of Llama 3 op single-GPU configuraties, de RTX™ 3090 de onbetwiste leider is. Een mogelijk alternatief zou de A40 of L20 kunnen zijn. Maar het is niet de moeite waard om de inferentie van deze modellen uit te voeren op A6000-generatie Ampere-kaarten.

We hebben met opzet kaarten met een kleinere hoeveelheid videogeheugen, bijvoorbeeld NVIDIA® RTX™ 2080Ti, niet genoemd in de tests, omdat het daar niet mogelijk is om de bovengenoemde 7B of 8B modellen in te passen zonder kwantisatie. Welnu, het 1,5B model Qwen 2 heeft helaas geen antwoorden van hoge kwaliteit en kan niet dienen als volledige vervanging voor 7B.

Zie ook:

Je eigen Qwen met HF

Mon, 20 Jan 2025 09:43:46 +0100

Grote neurale netwerkmodellen, met hun buitengewone capaciteiten, zijn stevig verankerd in ons leven. Grote bedrijven zagen dit als een kans voor toekomstige ontwikkeling en begonnen hun eigen versies van deze modellen te ontwikkelen. De Chinese reus Alibaba bleef niet aan de zijlijn staan. Zij creëerden hun eigen model, QWen (Tongyi Qianwen), dat de basis werd voor vele andere neurale netwerkmodellen.

Vereisten

Cache en pakketten bijwerken

Laten we de pakketcache bijwerken en je besturingssysteem upgraden voordat je begint met het instellen van Qwen. Ook moeten we Python Installer Packages (PIP) toevoegen, als het nog niet aanwezig is in het systeem. Voor deze handleiding gebruiken we Ubuntu 22.04 LTS als besturingssysteem:

sudo apt update && sudo apt -y upgrade && sudo apt install python3-pip

Nvidia-stuurprogramma's installeren

Je kunt het geautomatiseerde hulpprogramma gebruiken dat standaard wordt meegeleverd met Ubuntu-distributies:

sudo ubuntu-drivers autoinstall

Je kunt de Nvidia-stuurprogramma's ook handmatig installeren met behulp van onze stapsgewijze handleiding. Vergeet niet de server opnieuw op te starten:

sudo shutdown -r now

Tekstgeneratie web UI

Kloon het archief

Open de werkmap op de SSD:

cd /mnt/fastdisk

Kloon de repository van het project:

git clone https://github.com/oobabooga/text-generation-webui.git

Vereisten installeren

Open de gedownloade map:

cd text-generation-webui

Controleer en installeer alle ontbrekende onderdelen:

pip install -r requirements.txt

SSH-sleutel toevoegen aan HF

Voordat je begint, moet je port forwarding instellen (remote poort 7860 naar 127.0.0.1:7860) in je SSH-client. Meer informatie vind je in het volgende artikel: Verbinding maken met Linux server.

Update de pakketcache repository en geïnstalleerde pakketten:

sudo apt update && sudo apt -y upgrade

Genereer en voeg een SSH-sleutel toe die je kunt gebruiken in Hugging Face:

cd ~/.ssh && ssh-keygen

Wanneer het sleutelpaar is gegenereerd, kun je de publieke sleutel weergeven in de terminal emulator:

cat id_rsa.pub

Kopieer alle informatie beginnend bij ssh-rsa en eindigend met usergpu@gpuserver zoals weergegeven in de volgende schermafbeelding:

Vul de Key name in en plak de gekopieerde SSH Public key van de terminal. Sla de sleutel op door op Add key te drukken:

cd ~/

Download en voer het shell script uit. Dit script installeert een nieuwe repository van derden met git-lfs:

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

Nu kun je het installeren met de standaard pakketbeheerder:

sudo apt-get install git-lfs

Laten we git configureren om onze HF nickname te gebruiken:

git config --global user.name "John"

En gekoppeld aan het HF e-mail account:

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

Het model downloaden

De volgende stap is het downloaden van het model met behulp van de repository cloning techniek die vaak gebruikt wordt door software ontwikkelaars. Het enige verschil is dat de eerder geïnstalleerde Git-LFS automatisch de gemarkeerde aanwijzingsbestanden zal verwerken en alle inhoud zal downloaden. Open de benodigde map (/mnt/fastdisk in ons voorbeeld):

cd /mnt/fastdisk

Dit commando kan even duren:

git clone git@hf.co:Qwen/Qwen1.5-32B-Chat-GGUF

Het model uitvoeren

Voer een script uit dat de webserver start en /mnt/fastdisk specificeert als de werkmap met modellen. Dit script kan enkele extra componenten downloaden bij de eerste start.

./start_linux.sh --model-dir /mnt/fastdisk

Open uw webbrowser en selecteer llama.cpp in de vervolgkeuzelijst Model loader:

Zorg ervoor dat je de parameter n-gpu-layers instelt. Hij bepaalt welk percentage van de berekeningen wordt overgeheveld naar de GPU. Als je het getal op 0 laat staan, dan worden alle berekeningen uitgevoerd op de CPU, wat vrij traag is. Zodra alle parameters zijn ingesteld, klik je op de knop Load. Ga daarna naar het tabblad Chat en selecteer Instruct mode. Nu kun je een willekeurige prompt invoeren en een antwoord ontvangen:

Verwerking wordt standaard uitgevoerd op alle beschikbare GPU's, rekening houdend met de eerder opgegeven parameters:

Zie ook:

Je eigen Vicuna in Linux

Mon, 20 Jan 2025 09:25:01 +0100

Dit artikel leidt je door het proces van het implementeren van een basis LLaMA alternatief op een LeaderGPU server. We gebruiken hiervoor het FastChat project en het vrij beschikbare Vicuna model.

Het model dat we zullen gebruiken is gebaseerd op Meta's LLaMA architectuur, maar is geoptimaliseerd voor efficiënte inzet op consumenten hardware. Deze opzet biedt een goede balans tussen prestaties en benodigde bronnen, waardoor het geschikt is voor zowel test- als productieomgevingen.

Voorinstallatie

Laten we de installatie van FastChat voorbereiden door de pakket cache repository bij te werken:

sudo apt update && sudo apt -y upgrade

Installeer Nvidia-stuurprogramma's automatisch met het volgende commando:

sudo ubuntu-drivers autoinstall

Je kunt deze stuurprogramma's ook handmatig installeren met onze stapsgewijze handleiding. Start de server vervolgens opnieuw op:

sudo shutdown -r now

De volgende stap is het installeren van PIP (Package Installer for Python):

sudo apt install python3-pip

FastChat installeren

Van PyPi

Er zijn twee mogelijke manieren om FastChat te installeren. U kunt het rechtstreeks vanuit PyPi installeren:

pip3 install "fschat[model_worker,webui]"

Van GitHub

Als alternatief kun je de FastChat repository van GitHub clonen en installeren:

git clone https://github.com/lm-sys/FastChat.git

cd FastChat

Vergeet niet om PIP te upgraden voordat je verder gaat:

pip3 install --upgrade pip

pip3 install -e ".[model_worker,webui]"

FastChat uitvoeren

Eerste start

Om zeker te zijn van een succesvolle eerste start, is het aan te raden om FastChat handmatig direct vanaf de commandoregel aan te roepen:

python3 -m fastchat.serve.cli --model-path lmsys/vicuna-7b-v1.5

Deze actie haalt automatisch het aangewezen model van jouw keuze op en downloadt het, wat gespecificeerd moet worden met de --model-path parameter. De 7b staat voor een model met 7 miljard parameters. Dit is het lichtste model, geschikt voor GPU's met 16 GB videogeheugen. Links naar modellen met een groter aantal parameters zijn te vinden in het Readme-bestand van het project.

Nu heb je de optie om een gesprek aan te gaan met de chatbot direct binnen de opdrachtregelinterface of je kunt een webinterface instellen. Deze bevat drie componenten:

Controller
Werkers
Gradio webserver

Diensten instellen

Laten we van elke component een aparte systemd service maken. Maak 3 aparte bestanden met de volgende inhoud:

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 werkt zijn daemons database meestal bij tijdens het opstartproces van het systeem. Je kunt dit echter ook handmatig doen met het volgende commando:

sudo systemctl daemon-reload

Laten we nu drie nieuwe services toevoegen aan het opstarten en ze onmiddellijk starten met de optie --now:

sudo systemctl enable vicuna-controller.service --now && sudo systemctl enable vicuna-worker.service --now && sudo systemctl enable vicuna-webserver.service --now

Als je echter een webinterface probeert te openen op http://[IP_ADDRESS]:7860, krijg je een volledig onbruikbare interface zonder beschikbare modellen. U kunt dit probleem oplossen door de webinterface-service te stoppen:

sudo systemctl stop vicuna-webserver.service

Voer de webinterface handmatig uit:

python3 -m fastchat.serve.gradio_web_server

Een verificatie toevoegen

Deze actie roept een ander script aan, dat het eerder gedownloade model zal registreren in een interne database van Gradio. Wacht een paar seconden en onderbreek het proces met de snelkoppeling Ctrl + C. We zorgen ook voor de beveiliging en activeren een eenvoudig authenticatiemechanisme voor toegang tot de webinterface. Open het volgende bestand als je FastChat hebt geïnstalleerd vanuit PyPI:

sudo nano /home/usergpu/.local/lib/python3.10/site-packages/fastchat/serve/gradio_web_server.py

sudo nano /home/usergpu/FastChat/fastchat/serve/gradio_web_server.py

Scroll naar beneden naar het einde. Zoek deze regel:

auth=auth,

Wijzig deze door een gebruikersnaam of wachtwoord in te stellen:

auth=(“username”,”password”),

Sla het bestand op en sluit het af met de snelkoppeling Ctrl + X. Start tot slot de webinterface:

sudo systemctl start vicuna-webserver.service

Open http://[IP_ADDRESS]:7860 in je browser en geniet van FastChat met Vicuna:

Zie ook:

Je eigen LLaMa 2 in Linux

Mon, 20 Jan 2025 09:13:25 +0100

Stap 1. Besturingssysteem voorbereiden

Cache en pakketten bijwerken

Laten we de pakketcache bijwerken en je besturingssysteem upgraden voordat je begint met het instellen van LLaMa 2. Houd er rekening mee dat we voor deze gids Ubuntu 22.04 LTS als besturingssysteem gebruiken:

sudo apt update && sudo apt -y upgrade

Ook moeten we Python Installer Packages (PIP) toevoegen, als het nog niet aanwezig is in het systeem:

sudo apt install python3-pip

Nvidia-stuurprogramma's installeren

Je kunt het geautomatiseerde hulpprogramma gebruiken dat standaard in Ubuntu-distributies zit:

sudo ubuntu-drivers autoinstall

Je kunt de Nvidia-stuurprogramma's ook handmatig installeren met behulp van onze stapsgewijze handleiding. Vergeet niet de server opnieuw op te starten:

sudo shutdown -r now

Stap 2. Modellen ophalen bij MetaAI

Officieel verzoek

Open het volgende adres in je browser: https://ai.meta.com/resources/models-and-libraries/llama-downloads/

Vul alle noodzakelijke velden in, lees de gebruikersovereenkomst en klik op de knop Agree and Continue. Na een paar minuten (uren, dagen) ontvang je een speciale download-URL, die je toestemming geeft om modellen voor een periode van 24 uur te downloaden.

Het archief klonen

Controleer voor het downloaden de beschikbare opslagruimte:

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

Als je niet-gemounte lokale schijven hebt, volg dan de instructies in Schijfpartitionering in Linux. Dit is belangrijk omdat de gedownloade modellen erg groot kunnen zijn en je hun opslaglocatie van tevoren moet plannen. In dit voorbeeld hebben we een lokale SSD aangekoppeld in de map /mnt/fastdisk. Laten we deze openen:

cd /mnt/fastdisk

Maak een kopie van het oorspronkelijke LLaMa archief:

git clone https://github.com/facebookresearch/llama

Als je een toestemmingsfout tegenkomt, verleen dan gewoon toestemmingen aan de gebruikerergpu:

sudo chown -R usergpu:usergpu /mnt/fastdisk/

Downloaden via script

Open de gedownloade map:

cd llama

Voer het script uit:

./download.sh

Plak de URL van MetaAI en selecteer alle benodigde modellen. We raden aan alle beschikbare modellen te downloaden om te voorkomen dat je opnieuw om toestemming moet vragen. Als je echter een specifiek model nodig hebt, download dan alleen dat model.

Snelle test via voorbeeld app

Om te beginnen kunnen we controleren of er componenten ontbreken. Als er bibliotheken of toepassingen ontbreken, zal de pakketbeheerder deze automatisch installeren:

pip install -e .

De volgende stap is het toevoegen van nieuwe binaries aan het PATH:

export PATH=/home/usergpu/.local/bin:$PATH

Voer het demovoorbeeld uit:

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

De toepassing maakt een rekenproces aan op de eerste GPU en simuleert een eenvoudige dialoog met typische verzoeken, waarbij antwoorden worden gegenereerd met behulp van LLaMa 2.

Stap 3. Haal llama.cpp op

LLaMa C++ is een project gemaakt door de Bulgaarse natuurkundige en softwareontwikkelaar Georgi Gerganov. Het heeft veel nuttige hulpprogramma's die het werken met dit neurale netwerkmodel eenvoudiger maken. Alle onderdelen van llama.cpp zijn open source software en worden gedistribueerd onder de MIT-licentie.

Kloon de repository

Open de werkmap op de SSD:

cd /mnt/fastdisk

Kloon de repository van het project:

git clone https://github.com/ggerganov/llama.cpp.git

Apps compileren

Open de gekloonde map:

cd llama.cpp

Start het compilatieproces met de volgende opdracht:

make

Stap 4. Tekst-generatie-webui ophalen

Kloon de repository

Open de werkmap op de SSD:

cd /mnt/fastdisk

Kloon de repository van het project:

git clone https://github.com/oobabooga/text-generation-webui.git

Vereisten installeren

Open de gedownloade map:

cd text-generation-webui

Controleer en installeer alle ontbrekende onderdelen:

pip install -r requirements.txt

Stap 5. PTH omzetten naar GGUF

Algemene formaten

PTH (Python TorcH) - Een geconsolideerd formaat. In wezen is het een standaard ZIP-archief met een geserialiseerde PyTorch-statuswoordenboek. Dit formaat heeft echter snellere alternatieven zoals GGML en GGUF.

GGML (Georgi Gerganov’s Machine Learning) - Dit is een bestandsformaat gemaakt door Georgi Gerganov, de auteur van llama.cpp. Het is gebaseerd op een gelijknamige bibliotheek, geschreven in C++, die de prestaties van grote taalmodellen aanzienlijk heeft verbeterd. Het is nu vervangen door het moderne GGUF formaat.

GGUF (Georgi Gerganov’s Unified Format) - Een veelgebruikt bestandsformaat voor LLM's, ondersteund door verschillende toepassingen. Het biedt verbeterde flexibiliteit, schaalbaarheid en compatibiliteit voor de meeste gebruikssituaties.

script llama.cpp converteren.py

Bewerk de parameters van het model voordat het wordt geconverteerd:

nano /mnt/fastdisk/llama-2-7b-chat/params.json

Corrigeer "vocab_size": -1 naar "vocab_size": 32000. Sla het bestand op en sluit af. Open vervolgens de map llama.cpp:

cd /mnt/fastdisk/llama.cpp

Voer het script uit dat het model zal converteren naar GGUF formaat:

python3 convert.py /mnt/fastdisk/llama-2-7b-chat/ --vocab-dir /mnt/fastdisk/llama

Als alle voorgaande stappen juist zijn, krijg je een bericht als dit:

Wrote /mnt/fastdisk/llama-2-7b-chat/ggml-model-f16.gguf

Stap 6. WebUI

WebUI starten

Open de map:

cd /mnt/fastdisk/text-generation-webui/

Voer het startscript uit met enkele nuttige parameters:

--model-dir geeft het juiste pad naar de modellen aan
--share creëert een tijdelijke publieke link (als je geen poort wilt doorsturen via SSH)
--gradio-auth voegt autorisatie toe met een login en wachtwoord (vervang user:wachtwoord door je eigen)

./start_linux.sh --model-dir /mnt/fastdisk/llama-2-7b-chat/ --share --gradio-auth user:password

Na een succesvolle lancering ontvang je een lokale en tijdelijke share link voor toegang:

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

Deze share link verloopt over 72 uur.

Het model laden

Autoriseer in de WebUI met de geselecteerde gebruikersnaam en wachtwoord en volg deze 5 eenvoudige stappen:

Navigeer naar het tabblad Model.
Selecteer ggml-model-f16.gguf in het vervolgkeuzemenu.
Kies hoeveel lagen je wilt berekenen op de GPU (n-gpu-layers).
Kies hoeveel threads je wilt starten (threads).
Klik op de knop Load.

Het dialoogvenster starten

Verander de tab in Chat, typ je vraag en klik op Generate:

Zie ook:

Llama 3 met Hugging Face

Mon, 20 Jan 2025 09:05:10 +0100

Op 18 april 2024 werd het nieuwste grote taalmodel van MetaAI, Llama 3, uitgebracht. Er werden twee versies aan gebruikers gepresenteerd: 8B en 70B. De eerste versie bevat meer dan 15K tokens en werd getraind op gegevens die geldig waren tot maart 2023. De tweede, grotere versie is getraind op gegevens die geldig zijn tot december 2023.

Stap 1. Besturingssysteem voorbereiden

Cache en pakketten bijwerken

Laten we de pakketcache bijwerken en je besturingssysteem upgraden voordat je begint met het instellen van LLaMa 3. Houd er rekening mee dat we voor deze gids Ubuntu 22.04 LTS als besturingssysteem gebruiken:

sudo apt update && sudo apt -y upgrade

Ook moeten we Python Installer Packages (PIP) toevoegen, als het nog niet aanwezig is in het systeem:

sudo apt install python3-pip

Nvidia-stuurprogramma's installeren

Je kunt het geautomatiseerde hulpprogramma gebruiken dat standaard in Ubuntu-distributies zit:

sudo ubuntu-drivers autoinstall

Je kunt de Nvidia-stuurprogramma's ook handmatig installeren. Vergeet niet de server opnieuw op te starten:

sudo shutdown -r now

Stap 2. Het model ophalen

Log in op Hugging Face met uw gebruikersnaam en wachtwoord. Ga naar de pagina die bij de gewenste LLM-versie hoort: Meta-Llama-3-8B of Meta-Llama-3-70B. Op het moment van publicatie van dit artikel wordt toegang tot het model op individuele basis verleend. Vul een kort formulier in en klik op de knop Submit:

Toegang aanvragen bij HF

Vervolgens ontvang je een bericht dat je verzoek is ingediend:

Na 30-40 minuten krijg je toegang en ontvang je hierover bericht via e-mail.

SSH-sleutel toevoegen aan HF

Genereer en voeg een SSH-sleutel toe die je kunt gebruiken in Hugging Face:

cd ~/.ssh && ssh-keygen

Wanneer het sleutelpaar is gegenereerd, kun je de publieke sleutel weergeven in de terminal emulator:

cat id_rsa.pub

Kopieer alle informatie beginnend bij ssh-rsa en eindigend bij usergpu@gpuserver zoals weergegeven in de volgende schermafbeelding:

Open Hugging Face Profielinstellingen. Kies vervolgens SSH and GPG Keys en klik op de knop SSH-sleutel toevoegen:

Vul de Key name in en plak de gekopieerde SSH Public key van de terminal. Sla de sleutel op door op Add key te drukken:

cd ~/

Download en voer het shell script uit. Dit script installeert een nieuwe repository van derden met git-lfs:

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

Nu kun je het installeren met de standaard pakketbeheerder:

sudo apt-get install git-lfs

Laten we git configureren om onze HF nickname te gebruiken:

git config --global user.name "John"

En gekoppeld aan het HF e-mail account:

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

Het model downloaden

Open de doelmap:

cd /mnt/fastdisk

En begin met het downloaden van de repository. Voor dit voorbeeld kiezen we versie 8B:

git clone git@hf.co:meta-llama/Meta-Llama-3-8B

Dit proces duurt maximaal 5 minuten. Je kunt dit controleren door het volgende commando in een andere SSH-console uit te voeren:

watch -n 0.5 df -h

Hier zie je hoe de vrije schijfruimte op de gemounte schijf afneemt, wat ervoor zorgt dat de download vordert en de gegevens worden opgeslagen. De status wordt elke halve seconde vernieuwd. Om het bekijken handmatig te stoppen, druk je op de sneltoets Ctrl + C.

Je kunt ook btop installeren en het proces volgen met dit hulpprogramma:

sudo apt -y install btop && btop

Om het hulpprogramma btop af te sluiten, druk je op de toets Esc en selecteer je Quit.

Stap 3. Het model uitvoeren

Open de map:

cd /mnt/fastdisk

Download de Llama 3 repository:

git clone https://github.com/meta-llama/llama3

Wijzig de map:

cd llama3

Voer het voorbeeld uit:

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

Nu kun je Llama 3 gebruiken in je applicaties.

Zie ook:

StarCoder: uw lokale codeerhulp

Fri, 17 Jan 2025 14:52:58 +0100

Microsoft CoPilot heeft een revolutie teweeggebracht op het gebied van softwareontwikkeling. Deze AI-assistent helpt ontwikkelaars enorm met verschillende coderingstaken, waardoor hun leven eenvoudiger wordt. Een nadeel is echter dat het geen standalone applicatie is, maar een cloud-gebaseerde service. Dit betekent dat gebruikers akkoord moeten gaan met de servicevoorwaarden en moeten betalen voor een abonnement.

Gelukkig biedt de wereld van open-source software ons tal van alternatieven. Op het moment van schrijven van dit artikel is het meest opvallende alternatief voor CoPilot StarCoder, ontwikkeld door het BigCode project. StarCoder is een uitgebreid neuraal netwerkmodel met 15,5B parameters, getraind op meer dan 80 programmeertalen.

Dit model wordt gedistribueerd op Hugging Face (HF) met een gated model onder de BigCode OpenRAIL-M v1 licentieovereenkomst. Je kunt dit model gratis downloaden en gebruiken, maar je moet wel een HF-account hebben met een gekoppelde SSH-sleutel. Voordat je kunt downloaden, zijn er een paar extra stappen die je moet nemen.

SSH-sleutel toevoegen aan HF

Voordat je begint, moet je port forwarding (externe poort 7860 naar 127.0.0.1:7860) instellen in je SSH-client. Aanvullende informatie is te vinden in de volgende artikelen:

Werk de pakketcache-repository en geïnstalleerde pakketten bij:

sudo apt update && sudo apt -y upgrade

Laten we de systeempakketbeheerder van Python (PIP) installeren:

sudo apt install python3-pip

Genereer en voeg een SSH-sleutel toe die je kunt gebruiken in Hugging Face:

cd ~/.ssh && ssh-keygen

Wanneer het sleutelpaar is gegenereerd, kun je de publieke sleutel weergeven in de terminal emulator:

cat id_rsa.pub

Kopieer alle informatie beginnend bij ssh-rsa en eindigend met usergpu@gpuserver zoals weergegeven in de volgende schermafbeelding:

Vul de Key name in en plak de gekopieerde SSH Public key van de terminal. Sla de sleutel op door op Add key te drukken:

cd ~/

Download en voer het shell script uit. Dit script installeert een nieuwe repository van derden met git-lfs:

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

Nu kun je het installeren met de standaard pakketbeheerder:

sudo apt-get install git-lfs

Laten we git configureren om onze HF nickname te gebruiken:

git config --global user.name "John"

En gekoppeld aan het HF e-mailaccount:

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

Het model downloaden

Houd er rekening mee dat StarCoder in binair formaat een aanzienlijke hoeveelheid schijfruimte in beslag kan nemen (>75 GB). Vergeet niet dit artikel te raadplegen om er zeker van te zijn dat je de juiste partitie gebruikt.

Alles is klaar voor het downloaden van het model. Open de doelmap:

cd /mnt/fastdisk

En begin met het downloaden van de repository:

git clone git@hf.co:bigcode/starcoder

Dit proces duurt maximaal 15 minuten. Wees geduldig. Je kunt dit controleren door het volgende commando in een andere SSH-console uit te voeren:

watch -n 0.5 df -h

Het volledige model uitvoeren met WebUI

Kloon de repository van het project:

git clone https://github.com/oobabooga/text-generation-webui.git

Open de gedownloade map:

cd text-generation-webui

Voer het startscript uit:

./start_linux.sh --model-dir /mnt/fastdisk

Het script controleert of de nodige afhankelijkheden op de server aanwezig zijn. Eventuele ontbrekende afhankelijkheden worden automatisch geïnstalleerd. Wanneer de toepassing start, opent u uw webbrowser en typt u het volgende adres in:

http://127.0.0.1:7860

Open het tabblad Model en selecteer het gedownloade model starcoder in de vervolgkeuzelijst. Klik op de lijst Model loader en kies Transformers. Stel de maximale GPU-geheugenschuif in voor elke geïnstalleerde GPU. Dit is heel belangrijk, want als je deze op 0 zet, wordt het gebruik van VRAM beperkt en kan het model niet correct laden. Je moet ook het maximale RAM-gebruik instellen. Klik nu op de knop Load en wacht tot het laden is voltooid:

Ga naar het tabblad Chat en test de conversatie met het model. Houd er rekening mee dat Starcoder niet bedoeld is voor dialogen zoals ChatGPT. Het kan echter wel handig zijn om code te controleren op fouten en oplossingen aan te dragen.

Als je een volwaardig dialoogmodel wilt, kun je twee andere modellen proberen: starchat-alpha en starchat-beta. Deze modellen zijn verfijnd om een dialoog te voeren zoals ChatGPT dat doet. De volgende commando's helpen om deze modellen te downloaden en uit te voeren:

Voor starchat-alpha:

git clone git@hf.co:HuggingFaceH4/starchat-alpha

Voor starchat-beta:

git clone git@hf.co:HuggingFaceH4/starchat-beta

De laadprocedure is hetzelfde als hierboven beschreven. Je kunt ook de C++ implementatie van starcoder vinden, die effectief zal zijn voor CPU-inferentie.

Zie ook:

Stable Diffusion modellen: aanpassingen en opties

Mon, 25 Nov 2024 13:30:16 +0100

Tuning is een uitstekende manier om elke auto of gadget te verbeteren. Generatieve neurale netwerken kunnen ook worden getuned. Vandaag willen we niet diep ingaan op de structuur van Stable Diffusion, maar we streven naar betere resultaten dan een standaard opstelling.

Er zijn twee eenvoudige manieren om dit te doen: aangepaste modellen installeren en standaard optimalisatieopties gebruiken. In dit artikel leren we hoe we nieuwe modellen in Stable Diffusion kunnen installeren en met welke opties we hardware effectiever kunnen gebruiken.

Als je grappige foto's van schattige katten of lekker eten wilt delen, post je ze meestal op Instagram. Als je applicaties ontwikkelt en de code voor iedereen beschikbaar wilt maken, post je die op GitHub. Maar als je een grafisch AI-model traint en dat wilt delen, moet je eens kijken naar CivitAI. Dit is een enorm platform om kennis en resultaten te delen met communityleden.

Voordat u begint met downloaden, moet u de werkdirectory wijzigen. Alle AI modellen in Stable Diffusion staan in de "models" map:Voordat u begint met downloaden, moet u de werkmap veranderen. Alle AI-modellen in Stable Diffusion staan in de map "models":

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

Laten we eens kijken welke modellen standaard aanwezig zijn:

ls -a

'Put Stable Diffusion checkpoints here.txt'
v1-5-pruned-emaonly.safetensors

Er is slechts één model met de naam "v1-5-pruned-emaonly" en de extensie "safetensors". Dit model is een goed uitgangspunt, maar we hebben vijf interessantere modellen. Laten we ze downloaden en vergelijken met het standaardmodel.

Stabiele diffusie-aanwijzingen

Om het verschil visueel te laten zien, hebben we eenvoudige aanwijzingen bedacht:

princess, magic, fairy tales, portrait, 85mm, colorful

Voor veel modellen kan het een grote uitdaging zijn om geometrie en gezichtskenmerken nauwkeurig weer te geven. Om dit aan te pakken, kunt u negatieve aanwijzingen toevoegen om ervoor te zorgen dat afbeeldingen zonder deze kenmerken worden gegenereerd:

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

Stel de maximale waarde van bemonsteringsstappen in (150) om meer details in het resultaat te krijgen.

Standaardmodel

Het standaardmodel presteert goed in dergelijke taken. Sommige details zijn echter niet helemaal nauwkeurig. Er is bijvoorbeeld een probleem met de ogen: ze zijn duidelijk uit verhouding:

Als je naar de diadeem kijkt, is deze ook scheef en asymmetrisch. De rest van de details zijn goed uitgevoerd en komen overeen met de gegeven aanwijzingen. De achtergrond is wazig omdat we "85mm" hebben ingesteld. Dit is een veelgebruikte brandpuntsafstand voor portretten in professionele fotografie.

Realistische visie

Dit model is geweldig voor portretten. Het beeld ziet eruit alsof het is genomen met een kwaliteitsobjectief met de opgegeven brandpuntsafstand. De verhoudingen van het gezicht en lichaam zijn nauwkeurig, de jurk past perfect en de diadeem op het hoofd ziet er esthetisch uit:

De auteur raadt trouwens aan om het volgende sjabloon te gebruiken voor negatieve aanwijzingen:

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

Maar zelfs met onze vrij eenvoudige aanwijzingen is het resultaat uitstekend.

Download het model hier: Realistische visie

Bewust

Nog een geweldig model voor dergelijke doeleinden. De details zijn ook hier goed uitgewerkt, maar wees voorzichtig en let op het aantal vingers. Dit is een veel voorkomend probleem bij neurale netwerken: ze kunnen vaak extra vingers of zelfs hele ledematen tekenen.

Het creëren van visuele lijnen is een van de favoriete filmtechnieken. Zo koos dit model er ook voor om een persoon te tekenen tegen de achtergrond van een bospad.

Download het model hier: Bewust

OpenJourney

Onder generatieve neurale netwerken heeft Midjourney (MJ) speciale aandacht gekregen. MJ was een pionier op dit gebied en wordt vaak als voorbeeld voor anderen gebruikt. De beelden die het creëert hebben een unieke stijl. OpenJourney is geïnspireerd door de MJ-stijl en is een geschikt afgestemde Stable Diffusion.

gegenereerde afbeeldingen die eruitzien als een tekenfilm. Ze zijn levendig en helder. Voeg voor betere resultaten de stijlprompt mdjrny-v4 toe.

Download het model hier: OpenJourney

Alles

Dit model maakt beelden die lijken op die van een professionele mangatekenaar (iemand die strips tekent). We hebben dus een prinses in anime-stijl.

Dit model is getraind op afbeeldingen met een resolutie van 768x768. Je kunt deze resolutie instellen om betere resultaten te krijgen dan standaard 512x512.

Download het model hier: Alles

Zakelijk Memphis

Deze beeldstijl werd wild populair in de vroege jaren 2020 en werd veel gebruikt als bedrijfsstijl in verschillende hightechbedrijven. Ondanks kritiek is deze stijl vaak terug te vinden in presentaties en websites.

De prinses bleek minimalistisch, maar best mooi. Vooral grappig waren de details die het model op de achtergrond plaatste.

Download het model hier: Bedrijfsmemphis

Stabiele verspreidingsopties

Stable Diffusion verbruikt veel bronnen, dus zijn er veel opties voor ontwikkeld. De populairste is --xformers. Deze optie maakt twee optimalisatiemechanismen mogelijk. De eerste vermindert het geheugengebruik en de tweede wordt gebruikt om de snelheid te verhogen.

Als je --xformers probeert toe te voegen zonder aanvullende stappen, krijg je een foutmelding dat de pakketten(torch en torchvision) zijn gecompileerd voor verschillende versies van CUDA®. Om dit op te lossen, moeten we naar de virtuele Python-omgeving (venv) gaan die wordt gebruikt voor Stable Diffusion. Installeer daarna de pakketten voor de gewenste versie van CUDA® (v1.18).

Eerst moeten we apt packages cache updaten en package installer voor Python (pip) installeren. De volgende stap is het activeren van Python venv met het script activate:

source stable-diffusion-webui/venv/bin/activate

Daarna verandert de opdrachtprompt in (venv) username@hostname:~$ Laten we de pakketten torch en torchvision met CUDA® 11.8 installeren:

pip install torch==2.0.0+cu118 torchvision==0.15.1+cu118 --index-url https://download.pytorch.org/whl/cu118

Dit proces kan enkele minuten duren omdat de pakketten vrij groot zijn. Je hebt net genoeg tijd om wat koffie in te schenken. Tot slot kunt u de virtuele omgeving deactiveren en Stable Diffusion starten met de optie --xformers (vervang [user] en [password] door uw eigen waarden):

deactivate

./webui --xformers --listen --gradio-auth [user]:[password]

Het snellere alternatief voor --xformers is --opt-sdp-no-mem-attention. Het verbruikt meer geheugen maar werkt iets sneller. U kunt deze optie zonder extra stappen gebruiken.

Conclusie

Vandaag hebben we de mogelijkheden van Stabiele Verspreiding onderzocht in combinatie met andere toegevoegde modellen en optimalisatieopties. Onthoud dat u het detailniveau in de uiteindelijke afbeelding kunt aanpassen door het aantal bemonsteringsstappen te verhogen of verlagen.

Natuurlijk is dit maar een klein deel van wat je met zo'n generatief neuraal netwerk kunt doen. Bestel dus nu een GPU-server en begin te experimenteren. Er liggen nog veel meer ontdekkingen en mogelijkheden op je te wachten. Snelle en krachtige videokaarten zullen je helpen tijd te besparen en gave beelden te genereren.

Zie ook:

Stable Diffusion WebUI

Mon, 25 Nov 2024 13:24:45 +0100

Generatieve neurale netwerken lijken magisch. Ze beantwoorden vragen, maken afbeeldingen en schrijven zelfs code in verschillende programmeertalen. Het succes van deze netwerken heeft twee componenten: voorgetrainde modellen en hardwareversnellers. Het is zeker mogelijk om CPU-kernen te gebruiken voor deze werklast, maar dat zou een slakkenrace zijn. Het genereren van één kleine afbeelding kan een aanzienlijke hoeveelheid tijd in beslag nemen - tientallen minuten. Het genereren van dezelfde afbeelding op een GPU zou honderden keren minder tijd kosten.

Het eerste geheim zit hem in het aantal cores. CPU cores zijn universeel en kunnen complexe instructies aan. Conventionele serverprocessors hebben echter maximaal 64 cores. Zelfs in multiprocessorsystemen is het aantal kernen zelden groter dan 256. GPU-kernen zijn eenvoudiger, maar daardoor passen er veel meer op de chip. Een NVIDIA® RTX™ 4090 heeft bijvoorbeeld 16.384 kernen.

Het tweede geheim is dat de werklast kan worden opgedeeld in veel eenvoudige taken, die in parallelle threads kunnen worden uitgevoerd op speciale GPU-kernen. Deze truc versnelt de gegevensverwerking aanzienlijk. Vandaag zullen we zien hoe het werkt en een generatief neuraal netwerk Stable Diffusion Web UI inzetten op de LeaderGPU-infrastructuur. Neem bijvoorbeeld een server met een NVIDIA® RTX™ 4090 die 16.384 GPU-kernen heeft. Als besturingssysteem hebben we de huidige LTS-release Ubuntu 22.04 gekozen en de optie "Nvidia-stuurprogramma's en CUDA® 11.8 installeren".

Systeem voorbereiden

Voordat we beginnen, moeten we even stilstaan bij het geheugen. Stable Diffusion is een groot systeem dat tot 13G op uw harde schijf in beslag kan nemen. De standaard virtuele schijf in een LeaderGPU-installatie is 100G. Het besturingssysteem neemt 25G in beslag. Als we Stable Diffusion installeren zonder de home-partitie uit te breiden, zullen we al het vrije geheugen opgebruiken en een foutmelding krijgen: "No space left on device". Het is een goed idee om onze homedirectory uit te breiden.

Thuismap uitbreiden

Eerst moeten we alle beschikbare schijven controleren.

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

Daarna moeten we een nieuwe Linux-partitie aanmaken op onze fysieke SSD-schijf, /dev/sda:

sudo fdisk /dev/sda

Druk één voor één op de volgende toetsen: g → n → Enter → Enter → Enter → w. Dit resulteert in een nieuwe /dev/sda1 partitie zonder bestandssysteem. Maak er nu een ext4 bestandssysteem op aan:

sudo mkfs.ext4 /dev/sda1

Als het proces klaar is, gaan we naar de volgende stap.

Waarschuwing! Ga zeer voorzichtig te werk bij de volgende stap. Elke fout tijdens het wijzigen van het fstab-bestand kan ertoe leiden dat je server niet meer normaal kan opstarten en kan een volledige reset van het besturingssysteem vereisen.

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"

Kopieer UUID (fb2ba455-2b8d-4da0-8719-ce327d0026bc in het voorbeeld) van de /dev/sda1 partitie. Vervolgens zullen we het systeem instrueren om deze schijf automatisch te mounten met zijn UUID tijdens het opstarten:

sudo nano /etc/fstab

Voer deze regel in vóór /swap.img... string:

/dev/disk/by-uuid/ /home/usergpu ext4 defaults defaults

Voorbeeld:

# /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

Sluit af met de sneltoets Ctrl + X en bevestig het opslaan van het bestand door op Enter te drukken. De nieuwe instellingen worden toegepast bij de volgende systeemstart. Laten we de server opnieuw opstarten:

sudo shutdown -r now

Na het herstarten kunnen we alle gemounte mappen controleren met het volgende commando:

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

Geweldig! Maar nu hebben we geen toegang om iets in onze thuismap te schrijven, omdat deze is gewijzigd door het configuratiebestand fstab. Het is tijd om het eigendom van de map terug te eisen:

sudo chown -R usergpu /home/usergpu

Goed gedaan! Laten we naar de volgende stap gaan.

Basispakketten installeren

Update de software cache van de officiële Ubuntu repositories en upgrade enkele pakketten:

sudo apt update && sudo apt -y upgrade

Het systeem heeft gemeld dat er een nieuwe kernel is geïnstalleerd en deze zal operationeel zijn na het opnieuw opstarten van het systeem. Selecteer twee keer OK.

Vervolgens moeten we de afhankelijkheden oplossen, waarvoor Stable Diffusion nodig is. Het eerste pakket voegt de functionaliteit van de Python virtuele omgeving toe:

sudo apt install python3-venv

Het tweede pakket voegt een implementatie toe van de malloc() functie van de programmeertaal C, aangepast door Google. Het voorkomt “Cannot locate TCMalloc” fout en verbetert het CPU geheugengebruik.

sudo apt install -y --no-install-recommends google-perftools

Start ten slotte de server opnieuw op:

sudo shutdown -r now

Stabiele verspreiding automatisch 1111: installeer script

De eenvoudigste manier om Stable Diffusion met WebUI te installeren is door het vooraf gemaakte script te gebruiken dat geschreven is door GitHub gebruiker AUTOMATIC1111. Dit script downloadt en installeert deze twee onderdelen terwijl het alle benodigde afhankelijkheden oplost.

Laten we het script downloaden:

wget https://raw.githubusercontent.com/AUTOMATIC1111/stable-diffusion-webui/master/webui.sh

Geef het vervolgens toegang tot wijzigingsgegevens en voer het uit als een programma:

chmod a+x webui.sh

Het gedownloade script uitvoeren:

./webui.sh

Dit proces kan een paar minuten duren. Alles is klaar om perfecte beelden te maken met Stable Diffusion.

Problemen oplossen

Als je de foutmelding "Torch is not able to use GPU" tegenkomt, kun je dit oplossen door opnieuw te installeren via apt:

sudo apt -y install nvidia-driver-535

Je moet het besturingssysteem opnieuw opstarten om het stuurprogramma in te schakelen:

sudo shutdown -r now

genereren

Het installatiescript ./webui.sh heeft nog een andere functie. Het bedient tegelijkertijd het servergedeelte van Stable Diffusion en WebUI. Als u het echter zonder argumenten gebruikt, zal de server beschikbaar zijn als een lokale daemon op http://127.0.0.1:7860. Dit kan op twee manieren worden opgelost: poort doorsturen via een SSH-tunnel of verbindingen vanaf externe IP's toestaan.

De tweede manier is eenvoudiger: voeg de optie --listen toe en je kunt verbinding maken met de webinterface op http://[YOUR_LEADERGPU_SERVER_IP_ADDRESS]:7860. Dit is echter volledig onveilig, omdat iedere internetgebruiker toegang heeft. Om ongeautoriseerd gebruik te voorkomen, voegt u de optie --gradio-auth toe naast de gebruikersnaam en het wachtwoord, gescheiden door een dubbele punt:

./webui.sh --listen --gradio-auth user:password

Dit voegt een inlogpagina toe aan je WebUI instance.Het script zal voor de eerste keer basismodellen en vereiste afhankelijkheden downloaden:

Je kunt genieten van het resultaat. Voer een paar prompts in, scheid ze door komma's en klik op de knop Generate. Na een paar seconden wordt een afbeelding weergegeven die door het neurale netwerk is gegenereerd.

Conclusie

We zijn helemaal gekomen van een lege LeaderGPU server met alleen een voorgeïnstalleerd besturingssysteem tot een kant-en-klare instantie met Stable Diffusion en een WebUI interface. De volgende keer zullen we meer leren over het afstellen van softwareprestaties en hoe u uw Stable Diffusion instance op de juiste manier kunt uitbreiden met nieuwe versies van stuurprogramma's en pakketten.

Zie ook: