Bild vom Autor

# Einführung

Erinnern Sie sich noch daran, dass für die Erstellung einer Full-Stack-Anwendung teure Cloud-Credit, kostspielige API-Schlüssel und ein Crew von Ingenieuren erforderlich waren? Diese Zeiten sind offiziell vorbei. Bis 2026 können Entwickler eine produktionsreife Anwendung nur mit kostenlosen Instruments erstellen, bereitstellen und skalieren große Sprachmodelle (LLMs), die seine Intelligenz antreiben.

Die Landschaft hat sich dramatisch verändert. Open-Supply-Modelle fordern mittlerweile ihre kommerziellen Gegenstücke heraus. Kostenlose KI-Codierungsassistenten haben sich von einfachen Autovervollständigungstools zu vollständigen Coding-Agenten entwickelt, die ganze Funktionen entwerfen können. Und was vielleicht am wichtigsten ist: Sie können hochmoderne Modelle lokal oder über großzügige kostenlose Kontingente betreiben, ohne einen Cent auszugeben.

In diesem umfassenden Artikel werden wir eine reale Anwendung erstellen – eine Zusammenfassung von KI-Besprechungsnotizen. Benutzer laden Sprachaufzeichnungen hoch und unsere App transkribiert sie, extrahiert wichtige Punkte und Aktionselemente und zeigt alles in einem übersichtlichen Dashboard an – und das alles mit völlig kostenlosen Instruments.

Ganz gleich, ob Sie Scholar, Bootcamp-Absolvent oder erfahrener Entwickler sind, der eine Idee prototypisieren möchte, dieses Tutorial zeigt Ihnen, wie Sie die besten verfügbaren kostenlosen KI-Instruments nutzen können. Beginnen Sie damit, zu verstehen, warum kostenlose LLMs heute so intestine funktionieren.

# Verstehen, warum kostenlose große Sprachmodelle jetzt funktionieren

Noch vor zwei Jahren bedeutete die Entwicklung einer KI-gestützten App, dass man ein Funds für OpenAI-API-Credit einplanen oder teure GPU-Instanzen mieten musste. Die Wirtschaftslage hat sich grundlegend verändert.

Die Kluft zwischen kommerziellen und Open-Supply-LLMs ist nahezu verschwunden. Fashions mögen GLM-4.7-Flash von Zhipu AI zeigen, dass Open-Supply eine Leistung auf dem neuesten Stand der Technik erzielen und gleichzeitig völlig kostenlos genutzt werden kann. Ähnlich, LFM2-2.6B-Transkript wurde speziell für die Zusammenfassung von Besprechungen entwickelt und läuft vollständig auf dem Gerät mit Qualität auf Cloud-Ebene.

Für Sie bedeutet das, dass Sie nicht mehr an einen einzigen Anbieter gebunden sind. Wenn ein Modell für Ihren Anwendungsfall nicht funktioniert, können Sie zu einem anderen wechseln, ohne Ihre Infrastruktur zu ändern.

// Treten Sie der Self-Hosted-Bewegung bei

Es gibt eine wachsende Präferenz für lokale KI, die Modelle auf Ihrer eigenen {Hardware} ausführt, anstatt Daten an die Cloud zu senden. Dabei geht es nicht nur um die Kosten; es geht um Privatsphäre, Latenz und Kontrolle. Mit Werkzeugen wie Ollama Und LM Studiokönnen Sie leistungsstarke Modelle auf einem Laptop computer ausführen.

// Einführung des „Deliver Your Personal Key“-Modells

Es ist eine neue Kategorie von Instruments entstanden: Open-Supply-Anwendungen, die kostenlos sind, aber die Bereitstellung eigener API-Schlüssel erfordern. Das gibt Ihnen höchste Flexibilität. Sie können Googles verwenden Gemini-API (das täglich Hunderte von kostenlosen Anfragen bietet) oder vollständig lokale Modelle ohne laufende Kosten betreiben.

# Wählen Sie Ihren kostenlosen Stack für künstliche Intelligenz

Um die besten kostenlosen Optionen für jede Komponente unserer Anwendung aufzuschlüsseln, müssen Instruments ausgewählt werden, die Leistung und Benutzerfreundlichkeit in Einklang bringen.

// Transkriptionsebenen: Speech-to-Textual content

Für die Konvertierung von Audio in Textual content verfügen wir über hervorragende kostenlose Speech-to-Textual content-Instruments (STT).

Für unser Projekt werden wir verwenden Flüsterndas Sie lokal oder über kostenlos gehostete Optionen ausführen können. Es unterstützt über 100 Sprachen und erstellt hochwertige Transkripte.

// Zusammenfassung und Analyse: Das große Sprachmodell

Hier haben Sie die größte Auswahl. Alle unten aufgeführten Optionen sind völlig kostenlos:

Für unsere Besprechungszusammenfassung, die LFM2-2.6B-Transkript Modell ist besonders interessant; Es wurde buchstäblich für genau diesen Anwendungsfall trainiert und läuft mit weniger als 3 GB RAM.

// Beschleunigte Entwicklung: Codierungsassistenten für künstliche Intelligenz

Bevor wir eine einzige Codezeile schreiben, denken Sie über die Instruments nach, die uns helfen, innerhalb der integrierten Entwicklungsumgebung (IDE) effizienter zu bauen:

Unsere Empfehlung: Für dieses Projekt werden wir Codeium wegen seines unbegrenzten kostenlosen Kontingents und seiner Geschwindigkeit verwenden und Proceed als Backup behalten, wenn wir zwischen verschiedenen LLM-Anbietern wechseln müssen.

// Überprüfung des traditionellen kostenlosen Stacks

• Frontend: Reagieren (kostenlos und Open-Supply)
• Backend: FastAPI (Python, kostenlos)
• Datenbank: SQLite (dateibasiert, kein Server erforderlich)
• Einsatz: Vercel (großzügiges kostenloses Kontingent) + Machen (für Backend)

# Überprüfung des Projektplans

Definieren des Bewerbungsworkflows:

1. Der Benutzer lädt eine Audiodatei hoch (Besprechungsaufzeichnung, Sprachnotiz, Vortrag).
2. Das Backend empfängt die Datei und übergibt sie zur Transkription an Whisper
3. Der transkribierte Textual content wird zur Zusammenfassung an ein LLM gesendet
4. Das LLM extrahiert wichtige Diskussionspunkte, Aktionspunkte und Entscheidungen
5. Die Ergebnisse werden in SQLite gespeichert
6. Der Benutzer sieht ein übersichtliches Dashboard mit Transkript, Zusammenfassung und Aktionselementen

Professionelles Flussdiagramm mit sieben aufeinanderfolgenden Schritten | Bild vom Autor

// Voraussetzungen

• Python 3.9+ installiert
• Node.js und npm installiert
• Grundlegende Vertrautheit mit Python und React
• Ein Code-Editor (VS-Code empfohlen)

// Schritt 1: Einrichten des Backends mit FastAPI

Erstellen Sie zunächst unser Projektverzeichnis und richten Sie eine virtuelle Umgebung ein:

mkdir meeting-summarizer
cd meeting-summarizer
python -m venv venv

Aktivieren Sie die virtuelle Umgebung:

# On Home windows 
venvScriptsactivate

# On Linux/macOS
supply venv/bin/activate

Installieren Sie die erforderlichen Pakete:

pip set up fastapi uvicorn python-multipart openai-whisper transformers torch openai

Erstellen Sie nun die fundamental.py Datei für unsere FastAPI-Anwendung und fügen Sie diesen Code hinzu:

from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import whisper
import sqlite3
import json
import os
from datetime import datetime

app = FastAPI()

# Allow CORS for React frontend
app.add_middleware(
    CORSMiddleware,
    allow_origins=("http://localhost:3000"),
    allow_methods=("*"),
    allow_headers=("*"),
)

# Initialize Whisper mannequin - utilizing "tiny" for quicker CPU processing
print("Loading Whisper mannequin (tiny)...")
mannequin = whisper.load_model("tiny")
print("Whisper mannequin loaded!")

# Database setup
def init_db():
    conn = sqlite3.join('conferences.db')
    c = conn.cursor()
    c.execute('''CREATE TABLE IF NOT EXISTS conferences
                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
                  filename TEXT,
                  transcript TEXT,
                  abstract TEXT,
                  action_items TEXT,
                  created_at TIMESTAMP)''')
    conn.commit()
    conn.shut()

init_db()

async def summarize_with_llm(transcript: str) -> dict:
    """Placeholder for LLM summarization logic"""
    # This can be carried out in Step 2
    return {"abstract": "Abstract pending...", "action_items": ()}

@app.publish("/add")
async def upload_audio(file: UploadFile = File(...)):
    file_path = f"temp_{file.filename}"
    with open(file_path, "wb") as buffer:
        content material = await file.learn()
        buffer.write(content material)
    
    attempt:
        # Step 1: Transcribe with Whisper
        outcome = mannequin.transcribe(file_path, fp16=False)
        transcript = outcome("textual content")
        
        # Step 2: Summarize (To be stuffed in Step 2)
        summary_result = await summarize_with_llm(transcript)
        
        # Step 3: Save to database
        conn = sqlite3.join('conferences.db')
        c = conn.cursor()
        c.execute(
            "INSERT INTO conferences (filename, transcript, abstract, action_items, created_at) VALUES (?, ?, ?, ?, ?)",
            (file.filename, transcript, summary_result("abstract"),
             json.dumps(summary_result("action_items")), datetime.now())
        )
        conn.commit()
        meeting_id = c.lastrowid
        conn.shut()
        
        os.take away(file_path)
        return {
            "id": meeting_id,
            "transcript": transcript,
            "abstract": summary_result("abstract"),
            "action_items": summary_result("action_items")
        }
    besides Exception as e:
        if os.path.exists(file_path):
            os.take away(file_path)
        elevate HTTPException(status_code=500, element=str(e))

// Schritt 2: Integration des kostenlosen großen Sprachmodells

Lassen Sie uns nun das implementieren summarize_with_llm() Funktion. Wir zeigen zwei Ansätze:

Choice A: Verwendung der GLM-4.7-Flash-API (Cloud, kostenlos)

from openai import OpenAI

async def summarize_with_llm(transcript: str) -> dict:
    shopper = OpenAI(api_key="YOUR_FREE_ZHIPU_KEY", base_url="https://open.bigmodel.cn/api/paas/v4/")
    
    response = shopper.chat.completions.create(
        mannequin="glm-4-flash",
        messages=(
            {"function": "system", "content material": "Summarize the next assembly transcript and extract motion gadgets in JSON format."},
            {"function": "person", "content material": transcript}
        ),
        response_format={"sort": "json_object"}
    )
    
    return json.masses(response.decisions(0).message.content material)

Choice B: Verwendung des lokalen LFM2-2.6B-Transkripts (lokal, völlig kostenlos)

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

async def summarize_with_llm_local(transcript):
    model_name = "LiquidAI/LFM2-2.6B-Transcript"
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    mannequin = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.float16,
        device_map="auto"
    )
    
    immediate = f"Analyze this transcript and supply a abstract and motion gadgets:nn{transcript}"
    inputs = tokenizer(immediate, return_tensors="pt").to(mannequin.system)
    
    with torch.no_grad():
        outputs = mannequin.generate(**inputs, max_new_tokens=500)
    
    return tokenizer.decode(outputs(0), skip_special_tokens=True)

// Schritt 3: Erstellen des React-Frontends

Erstellen Sie ein einfaches React-Frontend, um mit unserer API zu interagieren. Erstellen Sie in einem neuen Terminal eine React-App:

npx create-react-app frontend
cd frontend
npm set up axios

Ersetzen Sie den Inhalt von src/App.js mit:

import React, { useState } from 'react';
import axios from 'axios';
import './App.css';

perform App() {
  const (file, setFile) = useState(null);
  const (importing, setUploading) = useState(false);
  const (outcome, setResult) = useState(null);
  const (error, setError) = useState('');

  const handleUpload = async () => {
    if (!file) { setError('Please choose a file'); return; }
    setUploading(true);
    const formData = new FormData();
    formData.append('file', file);

    attempt {
      const response = await axios.publish('http://localhost:8000/add', formData);
      setResult(response.information);
    } catch (err)  err.message));
     lastly { setUploading(false); }
  };

  return (
    <div className="App">
      <header className="App-header"><h1>AI Assembly Summarizer</h1></header>
      <fundamental className="container">
        <div className="upload-section">
          <enter sort="file" onChange={(e) => setFile(e.goal.information(0))} disabled={importing} />
          <button onClick={handleUpload} disabled= importing>
            {importing ? 'Processing...' : 'Analyze'}
          </button>
          {error && <p className="error">{error}</p>}
        </div>
        {outcome && (
          <div className="outcomes">
            <h4>Abstract</h4><p>{outcome.abstract}</p>
            <h4>Motion Gadgets</h4>
            <ul>{outcome.action_items.map((it, i) => <li key={i}>{it}</li>)}</ul>
          </div>
        )}
      </fundamental>
    </div>
  );
}

export default App;

// Schritt 4: Ausführen der Anwendung

• Starten Sie das Backend: Führen Sie im Hauptverzeichnis bei aktiver virtueller Umgebung Folgendes aus uvicorn fundamental:app --reload
• Starten Sie das Frontend: Führen Sie in einem neuen Terminal im Frontend-Verzeichnis Folgendes aus npm begin
• Offen http://localhost:3000 in Ihrem Browser und laden Sie eine Take a look at-Audiodatei hoch

Dashboard-Oberfläche mit zusammenfassenden Ergebnissen | Bild vom Autor

# Kostenlose Bereitstellung der Anwendung

Sobald Ihre App lokal funktioniert, ist es an der Zeit, sie weltweit bereitzustellen – immer noch kostenlos. Machen bietet ein großzügiges kostenloses Kontingent für Webdienste. Schieben Sie Ihren Code in ein GitHub-Repository, erstellen Sie einen neuen Webdienst auf Render und verwenden Sie diese Einstellungen:

• Umgebung: Python 3
• Construct-Befehl: pip set up -r necessities.txt
• Startbefehl: uvicorn fundamental:app --host 0.0.0.0 --port $PORT

Erstellen Sie eine necessities.txt Datei:

fastapi
uvicorn
python-multipart
openai-whisper
transformers
torch
openai

Notiz: Whisper und Transformers benötigen viel Speicherplatz. Wenn Sie an die Grenzen des kostenlosen Kontingents stoßen, sollten Sie stattdessen die Verwendung einer Cloud-API für die Transkription in Betracht ziehen.

// Bereitstellen des Frontends auf Vercel

Vercel ist der einfachste Weg, React-Apps bereitzustellen:

• Installieren Sie die Vercel-CLI: npm i -g vercel
• Führen Sie in Ihrem Frontend-Verzeichnis Folgendes aus: vercel
• Aktualisieren Sie Ihre API-URL in App.js um auf Ihr Render-Backend zu verweisen

// Erkundung lokaler Bereitstellungsalternativen

Wenn Sie Cloud-Internet hosting vollständig vermeiden möchten, können Sie sowohl Frontend als auch Backend auf einem lokalen Server bereitstellen, indem Sie Instruments wie verwenden ngrok um Ihren lokalen Server vorübergehend verfügbar zu machen.

# Abschluss

Wir haben gerade eine produktionsreife KI-Anwendung mit ausschließlich kostenlosen Instruments erstellt. Fassen wir zusammen, was wir erreicht haben:

• Transkription: Verwendet Whisper von OpenAI (kostenlos, Open Supply)
• Zusammenfassung: Leveraged GLM-4.7-Flash oder LFM2-2.6B (beide völlig kostenlos)
• Backend: Mit FastAPI erstellt (kostenlos)
• Frontend: Erstellt mit React (kostenlos)
• Datenbank: Gebrauchtes SQLite (kostenlos)
• Bereitstellung: Bereitstellung auf Vercel und Render (kostenlose Stufen)
• Entwicklung: Beschleunigt mit kostenlosen KI-Codierungsassistenten wie Codeium

Die Landschaft für die kostenlose KI-Entwicklung warfare noch nie so vielversprechend. Open-Supply-Modelle konkurrieren mittlerweile mit kommerziellen Angeboten. Lokale KI-Instruments geben uns Privatsphäre und Kontrolle. Und großzügige kostenlose Stufen von Anbietern wie Google und Zhipu AI ermöglichen uns Prototypen ohne finanzielles Risiko.

Shittu Olumid ist ein Software program-Ingenieur und technischer Autor, der sich leidenschaftlich dafür einsetzt, modernste Technologien zu nutzen, um fesselnde Erzählungen zu erschaffen, mit einem scharfen Blick fürs Element und einem Gespür für die Vereinfachung komplexer Konzepte. Sie können Shittu auch auf finden Twitter.

Bild vom Herausgeber

# Einführung

ChatGPT, Claude, Zwillinge. Sie kennen die Namen. Aber hier ist eine Frage: Was wäre, wenn Sie stattdessen Ihr eigenes Modell ausführen würden? Es klingt ehrgeizig. Das ist es nicht. Sie können ein funktionierendes bereitstellen großes Sprachmodell (LLM) in weniger als 10 Minuten, ohne einen Greenback auszugeben.

Dieser Artikel schlüsselt es auf. Zunächst ermitteln wir, was Sie tatsächlich benötigen. Dann schauen wir uns die tatsächlichen Kosten an. Schließlich werden wir TinyLlama kostenlos auf Hugging Face bereitstellen.

Bevor Sie Ihr Modell auf den Markt bringen, haben Sie wahrscheinlich viele Fragen im Kopf. Welche Aufgaben erwarte ich zum Beispiel von meinem Modell?

Versuchen wir, diese Frage zu beantworten. Wenn Sie einen Bot für 50 Benutzer benötigen, benötigen Sie GPT-5 nicht. Oder wenn Sie eine Stimmungsanalyse für mehr als 1.200 Tweets professional Tag planen, benötigen Sie möglicherweise kein Modell mit 50 Milliarden Parametern.

Schauen wir uns zunächst einige beliebte Anwendungsfälle und die Modelle an, die diese Aufgaben ausführen können.

Wie Sie sehen, haben wir das Modell an die Aufgabe angepasst. Dies sollten Sie tun, bevor Sie beginnen.

# Aufschlüsselung der tatsächlichen Kosten für die Durchführung eines LLM

Nachdem Sie nun wissen, was Sie brauchen, möchte ich Ihnen zeigen, wie viel es kostet. Beim Hosten eines Fashions geht es nicht nur um das Mannequin; Es geht auch darum, wo dieses Modell ausgeführt wird, wie häufig es ausgeführt wird und wie viele Personen damit interagieren. Lassen Sie uns die tatsächlichen Kosten entschlüsseln.

// Computing: Die höchsten Kosten, die Ihnen entstehen werden

Wenn Sie a ausführen Zentraleinheit (CPU) 24/7 an Amazon Net Providers (AWS) EC2, das würde etwa 36 $ professional Monat kosten. Wenn Sie jedoch a ausführen Grafikverarbeitungseinheit (GPU)-Instanz würde es etwa 380 US-Greenback professional Monat kosten – mehr als das Zehnfache der Kosten. Seien Sie additionally vorsichtig bei der Berechnung der Kosten Ihres großen Sprachmodells, denn dies ist der Hauptkostenfaktor.

(Bei den Berechnungen handelt es sich um Näherungswerte. Den tatsächlichen Preis finden Sie hier: AWS EC2-Preise).

// Lagerung: Geringe Kosten, es sei denn, Ihr Modell ist riesig

Berechnen wir grob den Speicherplatz. Ein 7B-Modell (7 Milliarden Parameter) benötigt etwa 14 Gigabyte (GB). Die Kosten für Cloud-Speicher liegen bei etwa 0,023 $ professional GB und Monat. Der Unterschied zwischen einem 1-GB-Modell und einem 14-GB-Modell beträgt additionally nur etwa 0,30 $ professional Monat. Die Speicherkosten können vernachlässigbar sein, wenn Sie nicht vorhaben, ein 300-B-Parametermodell zu hosten.

// Bandbreite: Günstig, bis Sie skalieren

Bandbreite ist wichtig, wenn Ihre Daten verschoben werden, und wenn andere Ihr Modell verwenden, werden Ihre Daten verschoben. AWS berechnet nach dem ersten GB 0,09 $ professional GB, es handelt sich additionally um ein paar Cent. Aber wenn Sie auf Millionen von Anfragen skalieren, sollten Sie auch dies sorgfältig kalkulieren.

(Bei den Berechnungen handelt es sich um Näherungswerte. Den tatsächlichen Preis finden Sie hier: Preise für AWS-Datenübertragungen).

// Kostenlose Internet hosting-Optionen, die Sie noch heute nutzen können

Gesichtsräume umarmen ermöglicht das kostenlose Hosten kleiner Modelle mit CPU. Machen Und Eisenbahn Bieten Sie kostenlose Stufen an, die für Demos mit geringem Datenverkehr geeignet sind. Wenn Sie experimentieren oder einen Proof-of-Idea erstellen, können Sie ziemlich weit kommen, ohne einen Cent auszugeben.

# Wählen Sie ein Modell, das Sie tatsächlich ausführen können

Jetzt kennen wir die Kosten, aber welches Modell sollten Sie verwenden? Natürlich hat jedes Modell seine Vor- und Nachteile. Wenn Sie beispielsweise ein 100-Milliarden-Parameter-Modell auf Ihren Laptop computer herunterladen, funktioniert es garantiert nicht, es sei denn, Sie verfügen über eine erstklassige, speziell gebaute Workstation.

Sehen wir uns die verschiedenen Modelle an, die auf Hugging Face verfügbar sind, damit Sie sie kostenlos ausführen können, wie wir es im nächsten Abschnitt tun werden.

TinyLlama: Dieses Modell erfordert keine Einrichtung und läuft mit der kostenlosen CPU-Stufe von Hugging Face. Es ist für einfache Konversationsaufgaben, die Beantwortung einfacher Fragen und die Texterstellung konzipiert.

Es kann verwendet werden, um schnell Chatbots zu erstellen und zu testen, schnelle Automatisierungsexperimente durchzuführen oder interne Frage-Antwort-Systeme zum Testen zu erstellen, bevor es zu einer Infrastrukturinvestition wird.

DestillierenGPT-2: Es ist außerdem schnell und leicht. Dies macht es perfekt zum Umarmen von Gesichtsräumen. Geeignet zum Vervollständigen von Texten, für sehr einfache Klassifizierungsaufgaben oder für kurze Antworten. Geeignet, um zu verstehen, wie LLMs ohne Ressourcenbeschränkungen funktionieren.

Phi-2: Ein kleines, von Microsoft entwickeltes Modell, das sich als sehr effektiv erweist. Es läuft immer noch auf der kostenlosen Stufe von Hugging Face, bietet jedoch verbesserte Argumentation und Codegenerierung. Nutzen Sie es für die Abfragegenerierung in natürlicher Sprache in SQL, die einfache Vervollständigung von Python-Code oder die Stimmungsanalyse von Kundenbewertungen.

Flan-T5-Klein: Dies ist das Anweisungs-Tuning-Modell von Google. Geschaffen, um auf Befehle zu reagieren und Antworten zu geben. Nützlich für die Generierung, wenn Sie deterministische Ausgaben auf kostenlosem Internet hosting wünschen, z. B. Zusammenfassung, Übersetzung oder Beantwortung von Fragen.

# Stellen Sie TinyLlama in 5 Minuten bereit

Lassen Sie uns TinyLlama erstellen und bereitstellen, indem wir Hugging Face Areas kostenlos verwenden. Keine Kreditkarte, kein AWS-Konto, keine Docker-Probleme. Nur ein funktionierender Chatbot, den Sie mit einem Hyperlink teilen können.

// Schritt 1: Gehen Sie zu „Gesichtsräume umarmen“.

Gehen Sie zu Huggingface.co/areas und klicken Sie auf „Neuer Bereich“, wie im Screenshot unten.

Benennen Sie den Raum nach Ihren Wünschen und fügen Sie eine kurze Beschreibung hinzu.

Die anderen Einstellungen können Sie unverändert lassen.

Klicken Sie auf „Bereich erstellen“.

// Schritt 2: Schreiben Sie die app.py

Klicken Sie nun im Bildschirm unten auf „App.py erstellen“.

Fügen Sie den folgenden Code in diese app.py ein.

Dieser Code lädt TinyLlama (mit den bei Hugging Face verfügbaren Construct-Dateien), verpackt es in eine Chat-Funktion und verwendet Gradio um eine Weboberfläche zu erstellen. Der chat() Die Methode formatiert Ihre Nachricht korrekt, generiert eine Antwort (bis zu maximal 100 Token) und gibt nur die Antwort des Modells (ohne Wiederholungen) auf die von Ihnen gestellte Frage zurück.

Hier ist die Seite, auf der Sie lernen können, wie Sie Code für jedes Hugging Face-Modell schreiben.

Schauen wir uns den Code an.

import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
tokenizer = AutoTokenizer.from_pretrained(model_name)
mannequin = AutoModelForCausalLM.from_pretrained(model_name)

def chat(message, historical past):
    # Put together the immediate in Chat format
    immediate = f"<|consumer|>n{message}n<|assistant|>n"
    
    inputs = tokenizer(immediate, return_tensors="pt")
    outputs = mannequin.generate(
        **inputs, 
        max_new_tokens=100,  
        temperature=0.7,
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id
    )
    response = tokenizer.decode(outputs(0)(inputs('input_ids').form(1):), skip_special_tokens=True)
    return response

demo = gr.ChatInterface(chat)
demo.launch()

Klicken Sie nach dem Einfügen des Codes auf „Neue Datei in die Hauptdatei übertragen“. Bitte sehen Sie sich den folgenden Screenshot als Beispiel an.

Hugging Face erkennt es automatisch, installiert Abhängigkeiten und stellt Ihre App bereit.

Erstellen Sie in dieser Zeit eine necessities.txt Datei oder Sie erhalten eine Fehlermeldung wie diese.

// Schritt 3: Erstellen Sie die Datei „Necessities.txt“.

Klicken Sie oben rechts auf dem Bildschirm auf „Dateien“.

Klicken Sie hier auf „Neue Datei erstellen“, wie im Screenshot unten.

Benennen Sie die Datei „necessities.txt“ und fügen Sie drei Python-Bibliotheken hinzu, wie im folgenden Screenshot gezeigt (transformers, torch, gradio).

Transformatoren Hier lädt das Modell und kümmert sich um die Tokenisierung. Fackel führt das Modell aus, da es die neuronale Netzwerk-Engine bereitstellt. Gradio erstellt eine einfache Weboberfläche, damit Benutzer mit dem Modell chatten können.

// Schritt 4: Führen Sie Ihr bereitgestelltes Modell aus und testen Sie es

Wenn Sie das grüne Licht „Läuft“ sehen, bedeutet das, dass Sie fertig sind.

Jetzt testen wir es.

Sie können es testen, indem Sie zunächst hier auf die App klicken.

Lassen Sie uns damit ein Python-Skript schreiben, das Ausreißer in a erkennt durch Kommas getrennte Werte (CSV)-Datei mit Z-Rating und Interquartilbereich (IQR).

Hier sind die Testergebnisse;

// Verstehen der Bereitstellung, die Sie gerade erstellt haben

Das Ergebnis ist, dass Sie jetzt in der Lage sind, ein Sprachmodell mit mehr als 1 Milliarde Parametern zu erstellen, ohne jemals ein Terminal anfassen, einen Server einrichten oder einen Greenback ausgeben zu müssen. Hugging Face kümmert sich um das Internet hosting, die Rechenleistung und die Skalierung (bis zu einem gewissen Grad). Für mehr Visitors ist eine kostenpflichtige Stufe verfügbar. Für Experimentierzwecke ist dies jedoch superb.

Der beste Weg zu lernen? Zuerst bereitstellen, später optimieren.

# Wohin als nächstes: Verbessern und Erweitern Ihres Modells

Jetzt haben Sie einen funktionierenden Chatbot. Aber TinyLlama ist nur der Anfang. Wenn Sie bessere Antworten benötigen, versuchen Sie, mit demselben Verfahren ein Improve auf Phi-2 oder Mistral 7B durchzuführen. Ändern Sie einfach den Modellnamen in app.py und etwas mehr Rechenleistung hinzufügen.

Für schnellere Reaktionen schauen Sie sich die Quantisierung an. Sie können Ihr Modell auch mit einer Datenbank verbinden, Speicher zu Konversationen hinzufügen oder es anhand Ihrer eigenen Daten verfeinern, sodass die einzige Grenze Ihre Vorstellungskraft ist.

Nate Rosidi ist Datenwissenschaftler und in der Produktstrategie tätig. Er ist außerdem außerordentlicher Professor für Analytik und Gründer von StrataScratch, einer Plattform, die Datenwissenschaftlern hilft, sich mit echten Interviewfragen von Prime-Unternehmen auf ihre Interviews vorzubereiten. Nate schreibt über die neuesten Developments auf dem Karrieremarkt, gibt Ratschläge zu Vorstellungsgesprächen, stellt Information-Science-Projekte vor und behandelt alles rund um SQL.

Bild vom Autor

# Einführung

Vibe Coding macht Spaß…

Vibe Coding ist leistungsstark…

Vibe Coding ist NICHT billig.

Claude Code Max-Plan? $100/Monat.

Cursor? $20/Monat + API-Nutzung.

ChatGPT? $20/Monat.

MCP-Instruments? Viele beginnen bei $20–$30/Monat.

Und wenn Sie vollständige Arbeitsabläufe erstellen, benötigen Sie häufig mehr als eins davon.

Aber was wäre, wenn ich Ihnen sagen würde, dass Sie Vibe-Code erstellen, Agenten erstellen, Full-Stack-Apps bereitstellen, MCP-Server ausführen und Codierungs-CLIs verwenden können? Und leistungsstarke KI-Modelle integrieren, für weniger als 10 $/Monateinschließlich Codierungspläne + API-Nutzung + MCP-Server?

Ja.

Ich habe genau das getan.

In diesem Artikel werde ich meine teilen Vollständiger Arbeitsablaufwie ich spare Hunderte von Greenback jeden Monat, und der genaue Stack, den ich zum Vibe-Code verwende, ist intelligenter und nicht teurer.

Sie werden entdecken:

• Günstige Programmierpläne so intestine wie Sonnet 4.5
• Kostenlose Codierung von CLIs und MCP-Integrationen
• Open-Supply-Codierungsmodelle, die Sie lokal ausführen können
• Kostenlose API-Anbieter für Entwicklungsarbeit

Lasst uns darauf eingehen.

# Günstige, aber leistungsstarke Codierungspläne

Bild von GLM-Codierungsplan basierend auf GLM-4.6

Ich habe derzeit die abonniert MiniMax-Codierungsplan Und GLM-4.6-Codierungsplandie mir zu einem Bruchteil der Kosten Zugang zu den besten Open-Supply-Modellen verschaffen und außerdem die Freiheit haben, mein gesamtes Projekt in einem Rutsch zu erstellen.

• MiniMax: Dank ihres Black Friday-Angebots ist es einfach $2/Monat
• GLM-Codierungsplan: Normalerweise $3/Monatsupergünstig

Man denkt vielleicht, dass ihr Service unterdurchschnittlich ist oder dass die Modelle nicht mit denen von Anthropic mithalten können. Das wärst du so falsch. Ich habe sie zwei Monate lang verwendet, um mehrere Internet- und maschinelle Lernprojekte zu erstellen. Sie sind schnell, genau und Codebasen wirklich verstehen. Ich liebe sie.

Ich aircraft sogar eine Jahresabonnement für noch größere Rabatte (insbesondere mit den Black Friday-Angeboten von GLM). Ich kann es nur wärmstens empfehlen.

# Kostenlose Codierungstools

Bild von Google Antigravity-Preise

Hier sind einige völlig kostenlose (oder Freemium-)Codierungstools, die es in sich haben und kein Abonnement erfordern.

• Kilo-Code (Beste Agentic VS Code-Erweiterung): Melden Sie sich an für kostenlose Credit sofort und fügen Sie Ihre Kreditkarte hinzu noch mehr kostenlose Credit. Benutze sie weiter jedes Open-Supply- oder proprietäre Modell. Perfekt zum Lösen von Problemen in Ihrer Codebasis.
• Google Antigravity: Momentan frei mit Nutzungsbeschränkungen. Es ähnelt dem kostenpflichtigen Plan von Cursor, sticht aber dadurch hervor integrierte Browserfunktionen und mehr.
• Gemini-CLI: Völlig kostenlos Codierungs-CLI-Software. Erreichen Sie die Grenzen des kostenlosen Kontingents? Warte einfach einen Tag, Limits verlängern sich automatisch.
• OpenCode: Der leistungsstärkstes Open-Supply-CLI-Software für die Codierung. Das Beste daran: Kostenloser Zugang zu Topmodels von führenden Unternehmen (sie bieten es an, um Suggestions für Verbesserungen zu sammeln).
• Droide von Manufacturing facility: Exzellent Codierung der CLI-App zum Aufrufen von Terminal-Instruments und zum Verstehen Ihrer Codebasis. Kommt mit 1 Monat kostenloser Professional-Planerstellen und bereitstellen, ohne an Grenzen zu stoßen.

Diese Instruments haben mir jede Menge Zeit und Geld gespart. Probieren Sie es aus.

# Kostenlose MCP-Server

Bild von Brightdata/Brightdata-mcp

MCP-Server sind unerlässlich, um die neueste Dokumentation abzurufen, nach neuen Instruments zu suchen, Probleme zu lösen, Speicherebenen hinzuzufügen, auf Open-Supply-Instruments/-Projekte zuzugreifen (über GitHub und Hugging Face) und sequentielles Denken zu ermöglichen. Das Beste daran? Alle davon sind kostenlos.

Hier ist eine kuratierte Liste von Die besten kostenlosen MCP-Server zur Integration in Ihren Workflow:

Ich habe diese integriert Claude Code, OpenCode, Droid, Kilo Code und sogar VS Codebahnbrechend für die Produktivität.

# OpenSource-Modelle

Bild von gpt-oss

Wenn Sie Wert auf Datenschutz legen und Ihre Ausgaben begrenzen möchten, probieren Sie diese Open-Supply-Codierungsmodelle aus und führen Sie sie lokal aus Ollama oder LM Studio. Sie liegen auf Augenhöhe mit proprietären Modellen, benötigen aber viel RAM oder eine GPU mit reichlich VRAM.

Hier ist meine High-Liste für Codierungs-, Terminal- und Agenten-Workflows:

• GPT-OSS: Vielseitiges Kraftpaket für Codegenerierung und Debugging.
• Minimax-M2: Blitzschnell für komplexe Aufgaben und Terminaloperationen.
• Qwen3-Coder: Hervorragend in Agentenabläufen und mehrstufigem Denken.

Laden Sie es von Hugging Face herunter, starten Sie es lokal und programmieren Sie ohne Einschränkungen.

# Kostenlose API-Anbieter

Bild von Modelle | OpenRouter

Gehen billig? Warum nicht frei? Diese Anbieter geben Ihnen mit großzügigen kostenlosen Kontingenten einen schnellen Überblick über Topmodels, ohne dass Sie dafür Ihr Price range sprengen müssen!

• OpenRouter: Das ganze Jahr über freier Zugang zu Fashions. Schnappen Sie sich Ihren API-Schlüssel und integrieren Sie ihn mit Kilo Code, OpenCode oder einem anderen Software.
• Groq Cloud: Für immer kostenlose Stufe mit rasender Geschwindigkeit.
• Baseten: Kostenlose Credit für produktionsbereite Bereitstellungen, schneller als bei Standardanbietern.

Profi-Tipp: Nehmen Sie an Wettbewerben teil (insbesondere Hugging Face) und erhalten Sie kostenlose Credit von verschiedenen KI-Modellen. Ich habe auf diese Weise mehr als 300 $ Boosts erzielt. Stapeln Sie sie und programmieren Sie sie kostenlos

# Letzter Gedanke

Um das Beste aus einem KI-Modell herauszuholen, sollte es niemals allein auf den Preis ankommen. Einige Anbieter wie Anthropic machen das Experimentieren schmerzhaft teuer. Ich habe einmal verbrannt 40 $ bei nur drei Eingabeaufforderungen in einer Stunde, und da wusste ich, dass ich bessere Optionen brauchte.

Additionally begann ich, nach Alternativen zu suchen ausgewogen. Werkzeuge zu angemessenen Preisen, die Ihnen dennoch solide Leistung und echten Mehrwert bieten.

In diesem Artikel habe ich meine wichtigsten Verknüpfungen und geheimen Instruments für geteilt Vibe-Codierung, ohne die Financial institution zu sprengeneinschließlich günstiger und völlig kostenloser Setups, die Sie noch heute nutzen können.

Abid Ali Awan (@1abidaliawan) ist ein zertifizierter Datenwissenschaftler, der gerne Modelle für maschinelles Lernen erstellt. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben technischer Blogs zu maschinellem Lernen und Datenwissenschaftstechnologien. Abid verfügt über einen Grasp-Abschluss in Technologiemanagement und einen Bachelor-Abschluss in Telekommunikationstechnik. Seine Imaginative and prescient ist es, ein KI-Produkt mithilfe eines graphischen neuronalen Netzwerks für Schüler mit psychischen Erkrankungen zu entwickeln.

Einführung

Bei der Entwicklung von Sprachmodellen (LLMs) sind wir ständig durch Budgets eingeschränkt. Eine solche Einschränkung führt zu einem grundlegenden Kompromiss: Stellen Sie sich vor, wenn Sie ein Rechenbudget festlegen, bedeutet eine Erhöhung der Modellgröße, dass Sie die Modellgröße reduzieren müssen, auf der Sie trainieren können, und umgekehrt. Sie stellen additionally die Frage:

Sollten wir einem Modell mit mehr Parametern mehr zuweisen oder sollten wir es auf mehr Daten trainieren?

Insbesondere die Leistung und Effizienz von LLMs werden stark von diesem Kompromiss beeinflusst. Daher ist es entscheidend, ein optimales Gleichgewicht zwischen der Anzahl der Parameter eines Modells und der Anzahl der verwendeten Token zu finden.

Die gesamte Trainingsberechnung eines Transformators skaliert ungefähr wie folgt: C∝N×D, wobei

• N ist die Anzahl der Modellparameter.
• D ist die Anzahl der Token.
• C ist das feste Rechenbudget.

Es ist leicht zu erkennen, dass für ein festes C N und D umgekehrt proportional zueinander sind.

Frühere Studien (Kaplan et al., 2020; Hoffmann et al., 2022) haben herausgefunden, dass der Trainingsverlust von Modellen für maschinelles Lernen einem Potenzgesetz mit Berechnung folgt: L(C)∝C^{−α} und die optimum Modellgröße und Datensatzgrößenskala mit Berechnung als: N_opt∝C^a, D_opt∝C^b für einige constructive Werte a und b.

In diesem Artikel werden wir winzige Transformer verwenden, um zu untersuchen, wie man N und D unter einem festen Rechenwert C ausgleicht.

Versuchsaufbau

Wir entwerfen ein minimales Transformatormodell und nennen es „winziger Transformator“ mit den folgenden konfigurierbaren Eigenschaften, die die Parametergröße des Modells beeinflussen:

• Modelldimension (d_model)
• MLP-Dimension (d_mlp)
• Anzahl der Schichten (n_layers​)

Wir möchten den Transformator verschiedener Konfigurationen auf tokenisierten Sequenzen der Länge 64 des WikiText-2-Datensatzes trainieren.

Um den Effekt der Skalierung zu untersuchen, haben wir ein Raster von Modellen von sehr klein (16 versteckte Einheiten, 1 Ebene) bis relativ groß (128 versteckte Einheiten, 4 Ebenen) definiert und sie mit einer Reihe von Token von 5.000 bis 1 Mio. kombiniert. Siehe den folgenden Code:

model_configs = (
    {"d_model": 16,  "d_mlp": 64,   "n_layers": 1},  
    {"d_model": 24,  "d_mlp": 96,   "n_layers": 1},   
    {"d_model": 32,  "d_mlp": 128,  "n_layers": 2},
    {"d_model": 48,  "d_mlp": 192,  "n_layers": 2},
    {"d_model": 64,  "d_mlp": 256,  "n_layers": 3},
    {"d_model": 96,  "d_mlp": 384,  "n_layers": 3},
    {"d_model": 128, "d_mlp": 512,  "n_layers": 4},   
)
# variety of tokens (D) we prepare on — simulated by way of few steps × batch × seq_len
token_budgets = (5e3, 1e4, 3e4, 5e4, 1e5, 3e5, 5e5, 1e6)  # small for demo

Indem wir den Rechenaufwand als C≈N×D annähern, besteht unsere Idee darin, die Verlustfunktion für jedes (N,D)-Paar zu berechnen und das Paar (N,D) zu finden, mit dem das Modell die minimale Verlustfunktion für ein gegebenes C erreicht: Dies ist das Gleichgewicht, nach dem wir suchen.

Umsetzung und Beobachtungen

Wir verwenden den folgenden Code, um das Modell bis zu einer festen Anzahl von Schritten mit unterschiedlichen (N,D)-Paaren zu trainieren und das Ergebnis aufzuzeichnen.

outcomes = ()
gadget = "cuda" if torch.cuda.is_available() else "cpu"

for cfg in model_configs:
    mannequin = TinyTransformer(vocab_size=len(tokenizer), **cfg)
    N_params = count_params(mannequin)
    for D in token_budgets:
        steps = int(D // (SEQ_LEN * 16))  # assuming batch_size=16
        dataloader = DataLoader(
            tokenized_dataset("prepare").shuffle(seed=0),
            batch_size=16,
            collate_fn=collate_fn
        )
        avg_loss = train_one(mannequin, dataloader, steps=steps, gadget=gadget)
        compute = N_params * D
        outcomes.append({
            "N": N_params,
            "D": D,
            "C": compute,
            "loss": avg_loss
        })

Dann tragen wir den endgültigen Verlust gegen die Berechnung (N×D) auf:

Wir haben folgende wichtige Beobachtungen:

1. Für kleine Rechenbudgetsschneiden kleine Modelle, die mit den meisten verfügbaren Daten trainiert wurden, besser ab als größere Modelle, die mit sehr wenigen Daten trainiert wurden.
2. Für große RechenbudgetsGrößere Modelle werden besser, wenn genügend Daten verfügbar sind.
3. Die optimale Modellgröße wächst nicht linear mit dem Rechenbudget. Beispielsweise führt eine Verdoppelung der Rechenleistung nicht wirklich zu einer doppelt so optimalen Parameteranzahl wie zuvor.

Das folgende Diagramm zeigt die Effizienzgrenze über die Modellgröße hinweg, d. h. die Menge der Modellgrößen, die für eine bestimmte Berechnung den geringsten Verlust aufweisen.

„Bestes“ Modell

Um das „beste“ Modell zu ermitteln, würden wir das Paar aus Modellgröße und Anzahl der Token auswählen, das den Verlust bei einem festen Funds minimiert.

Wir gehen davon aus, dass beide einer Potenzgesetzbeziehung folgen: N_opt∝C^α, D_opt∝C^β, und wir möchten die unbekannten Exponenten α und β durch die folgenden Schritte schätzen:

1. Nehmen Sie den Logarithmus der Größen: log?(N_opt)=αlog?(C)+const, log?(D_opt)=βlog?(C)+const.
2. Passen Sie eine lineare Regression an. Die Steigung der Regression ist nichts anderes als der Exponent des Potenzgesetzes.

Der folgende Code gibt eine solche Regression:

# Match log-log linear regression
a_slope, a_intercept, *_ = st.linregress(np.log(frontier.C), np.log(frontier.N))
b_slope, b_intercept, *_ = st.linregress(np.log(frontier.C), np.log(frontier.D))

In unserem Spielzeugexperiment haben wir herausgefunden, dass N_opt ~C^0,14 und D_opt~ C^0,86. Dieses Ergebnis zeigt möglicherweise nicht das gesamte Bild, da wir das Experiment mit vereinfachten Modellen und Konfigurationen durchgeführt haben. Wir können jedoch immer noch erkennen, dass das Wachstum der Datenverarbeitung zu einer Zunahme der optimalen Modellgröße führt, allerdings mit abnehmender Geschwindigkeit. Natürlich sollte das verbleibende Funds für mehr Schulungsgutscheine verwendet werden.

Darüber hinaus ergibt die obige Berechnung, dass das beste Verhältnis N_opt/D_opt=C^-0,72 ist. Dies bedeutet, dass Sie bei einer Erhöhung der Rechenleistung mehr Trainingstoken hinzufügen sollten, anstatt die Modellgröße zu erhöhen.

Praktische Erkenntnisse

Aus diesem Experiment, obwohl es sich um einen Spielzeugkoffer handelt, können wir mehrere Erkenntnisse gewinnen:

1. Bei einem festen Funds kann die Verwendung eines mittleren Modells mit mehr Daten die Leistung eines sehr großen Modells mit begrenzten Daten übertreffen.
2. Die optimale Modellgröße und Datengröße wachsen mit der Rechenleistung. Trainieren Sie kein Modell mit vielen Parametern, wenn Sie über ein kleines Funds verfügen.
3. Wenn das Funds steigt, berücksichtigen Sie zunächst das optimale Verhältnis N_opt/D_opt, um zu bestimmen, ob Sie die Modellgröße erhöhen oder mehr Trainingsdaten hinzufügen sollten.

Abschluss

In diesem Blogbeitrag stellen wir eine Studie zum Kompromiss zwischen Modellgröße und Daten bei einem festen Rechenbudget für LLMs mit einem Spielzeugkoffer bereit. Das Experiment zeigt, dass wir das optimale Paar aus Modellgröße und Token-Anzahl finden können, um mit einem gegebenen Funds die beste Modellleistung zu erzielen, was es Forschern und Praktikern ermöglicht, LLMs sinnvoll zu entwerfen und die besten Ergebnisse zu erzielen.

Referenz

(1) Kaplan, J., McCandlish, S., Henighan, T., Brown, TB, Chess, B., Baby, R., Grey, S., Radford, A., Wu, J. und Amodei, D. (2020). Skalierungsgesetze für neuronale Sprachmodelle.

(2) Hoffmann, J., Borgeaud, S., Mensch, A., Buchatskaya, E., Cai, T., Rutherford, E., de Las Casas, D., Hendricks, LA, Welbl, J., Clark, A., Hennigan, T., Noland, E., Millican, Okay., van den Driessche, G., Damoc, B., Man, A., Osindero, S., Simonyan, Okay., Elsen, E., … Sifre, L. (2022). Coaching rechenoptimaler großer Sprachmodelle.

In den letzten Jahren habe ich hauptsächlich mit großen Sprachmodellen, Coaching, Feinabstimmung, Aufforderung usw. gearbeitet, da dies auf dem Markt und von Benutzern hoch angefordert wurde. Aber ich glaube, dass LLMs, die hauptsächlich auf Textual content funktionieren, nur der Beginn von Genai sind. An einem bestimmten Punkt wird jeder wollen Physische AIwo Modelle auf fundiertere, menschlichere Weise sehen, hören, fühlen und begründen können.

Beginnen wir additionally mit Multimodalität. In diesem Pocket book stelle ich Llava vor, eine Architektur, die sowohl Bilder als auch Textual content interpretieren kann, um multimodale Antworten zu generieren.

In diesem Tutorial werden wir eine leichtere Komponente verwenden, die geeignet ist, das Notizbuch in einer freien Stufe wie Google Colab auszuführen.

Die Komponenten, die wir verwenden werden, sind:

1⃣ Clip-vit B/32 als Bildcodierer

2⃣ Tinyllama-1.1b Als Sprachmodell

3⃣ a 2-layerer MLP-Adapter die beiden zu überbrücken

Aufstellen

Bevor wir in den Code eintauchen können, lassen Sie uns unsere Umgebung einrichten.

Lassen Sie uns zunächst die Datensätzebibliothek installieren.

!pip set up -U datasets

Wir müssen jetzt die erforderlichen Pakete aus dem Umarmen und Pytorch importieren. Diese Importe liefern vorgebrachte Modelle und Dienstprogramme für die multimodale Verarbeitung.

import json
from pathlib import Path

import requests
import safetensors
import torch
from datasets import load_dataset
from huggingface_hub import hf_hub_download
from PIL import Picture
from transformers import (
    AutoConfig,
    AutoTokenizer,
    LlamaTokenizer,
    LlavaConfig,
    LlavaForConditionalGeneration,
    LlavaProcessor,
    Seq2SeqTrainer,
    Seq2SeqTrainingArguments,
)
from transformers.fashions.clip.modeling_clip import CLIPVisionModel
from transformers.fashions.clip.image_processing_clip import CLIPImageProcessor

Laden Sie vorgebildete Modellkomponenten herunter

Unser LLAVA -Modell besteht aus:

Der hf_hub_download ist ein Hub, den wir erforschen, um vorgebrägliche Gewichte abzurufen:

vision_backbone_name = "openai/clip-vit-base-patch32"
text_backbone_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"

_ = hf_hub_download(
    vision_backbone_name, filename="pytorch_model.bin", local_dir="/content material"
)
_ = hf_hub_download(
    text_backbone_name, filename="mannequin.safetensors", local_dir="/content material"
)

Modell

Sofort ein neues LLAVA -Modell

Lassen Sie uns jetzt ein neues LLAVA -Modell instanziieren. Wie oben erläutert, besteht ein LLAVA -Modell aus zwei Teilen, einem visuellen Encoder und einem Textdecoder, den wir gerade heruntergeladen haben.

vision_config = AutoConfig.from_pretrained(vision_backbone_name).vision_config
text_config = AutoConfig.from_pretrained(text_backbone_name)

Wir geben die Spine -Modelle in der LLAVA -Konfiguration an. Wir instanziieren dann das tatsächliche Modell mit LlavaForConditionalGeneration(llava_config).

llava_config = LlavaConfig(vision_config=vision_config, text_config=text_config)

mannequin = LlavaForConditionalGeneration(llava_config).cuda()
mannequin

Einige chirurgische Operationen durchführen

Zuvor sagten wir, wir könnten ein LLAVA-Modell konstruieren, indem wir von einem vorgebildeten Bildcodierer und einem vorgebliebenen LLM ausgestattet sind. Lass uns genau das tun!

Das ursprüngliche LLAVA -Modell wird aus a initialisiert Clip-vit l/14 und a Vicuna v1.5 7b. Um die Dinge mit den Ressourcen, die im freien Plan von Google Colab bereitgestellt werden Clip-vit b/16 und a Tinyllama 1.1b.

Die einzige Komponente, die wir trainieren, ist ein 2-Schicht-MLP-Adapter dazwischen.

Um die Clip- und Tinyllama-Modelle zu verwenden, müssen wir ihre vorgebrachten Gewichte laden. Diese Gewichte können jedoch in verschiedenen Formaten wie Safetensoren oder .bin vorhanden sein. Die Funktion load_Weights übernimmt dies für uns. Es überprüft den Dateityp und ruft die richtige Ladefunktion auf.

def load_weights(path_to_weights: str):
    if path_to_weights.endswith(".safetensors"):
        return load_safetensors_weights(path_to_weights)
    elif path_to_weights.endswith(".bin"):
        return load_bin_weights(path_to_weights)
    else:
        elevate ValueError(f"Unsupported weights file: {path_to_weights}")

def load_bin_weights(path_to_weights: str):
    return torch.load(path_to_weights, weights_only=True)

def load_safetensors_weights(path_to_weights: str):
    return safetensors.torch.load_file(path_to_weights)

vision_backbone_state_dict = load_weights("/content material/pytorch_model.bin")
text_backbone_state_dict = load_weights("/content material/mannequin.safetensors")

Injizieren Sie das Gewicht des Imaginative and prescient Spine in das Modell

Die nächsten Linien lädt die Gewichte in den Sichtteil des Modells. Wir setzen strikt = falsch flexibel zu sein, da wir es ermöglicht, alle Gewichte zu überspringen, die nicht perfekt der erwarteten Struktur des Modells entsprechen.

incompatible_keys = mannequin.vision_tower.load_state_dict(
    vision_backbone_state_dict, strict=False
)

assert len(incompatible_keys.missing_keys) == 0, (
    f"Lacking keys in state dict: {incompatible_keys.missing_keys}"
)

incompatible_keys.unexpected_keys

In die Gewichte des Textes Rückgrat in das Modell einfügen

Gleiche Logik wie zuvor, aber auch für das Textmodell.

incompatible_keys = mannequin.language_model.load_state_dict(
    text_backbone_state_dict, strict=True
)

Die vorgeborenen Komponenten einfrieren

Wir möchten jetzt die Spine -Visible- und Textmodelle einfrieren, da wir ihre Gewichte während des Trainings nicht aktualisieren möchten.

Wir trainieren nur den kleinen Adapter (den MLP, der Sehvermögen und Sprache verbindet), das viel leichter und schneller zu trainieren ist.

_ = mannequin.vision_tower.requires_grad_(False)
_ = mannequin.language_model.requires_grad_(False)

# Then we outline a helper operate to rely mannequin parameters

def count_parameters(mannequin, trainable_only=False):
    return sum(
        p.numel()
        for p in mannequin.parameters()
        if not trainable_only or p.requires_grad
    )

print(f"Whole parameters: {count_parameters(mannequin)}")
print(f"Trainable parameters: {count_parameters(mannequin, trainable_only=True)}")

Prozessor

Bevor wir einen Textual content in unser Modell einfügen, müssen wir Wörter in Zahlen umwandeln. Dafür wird der Tokenizer benötigt.

tokenizer = LlamaTokenizer.from_pretrained(
    text_backbone_name, additional_special_tokens=("<picture>", "<pad>")
)
tokenizer.pad_token_id = 32001

Im Folgenden finden Sie das Format, mit dem wir mit unserem LLAVA -Modell chatten werden.

Der erste Teil ist der sogenannte Teil Systemaufforderungdie allgemeine Richtlinien für die Reaktion des Modells auf den Benutzer enthält.

Der zweite Teil ist eine Jinja -Vorlage (im Grunde genommen Code), die feststellt, wie die Konversation auf der Grundlage einer strukturierten Eingabe (siehe Beispiel unten) erstellt wird.

LLAVA_CHAT_TEMPLATE = (
    "A chat between a curious person and a man-made intelligence assistant. The assistant provides useful, detailed, and well mannered solutions to the person's questions. "
    "{% for message in messages %}{% if message('function') == 'person' %}USER: {% else %}ASSISTANT: {% endif %}{% for merchandise in message('content material') %}{% if merchandise('sort') == 'textual content' %}{{ merchandise('textual content') }}{% elif merchandise('sort') == 'picture' %}<picture>{% endif %}{% endfor %}{% if message('function') == 'person' %} {% else %}{{eos_token}}{% endif %}{% endfor %}"
)
tokenizer.chat_template = LLAVA_CHAT_TEMPLATE

sample_messages = (
    {
        "content material": (
            {
                "index": 0,
                "textual content": None,
                "sort": "picture"
            },
            {
                "index": None,
                "textual content": "nWhat potential actions is likely to be fashionable at this location?",
                "sort": "textual content"
            }
        ),
        "function": "person"
    },
    {
        "content material": (
            {
                "index": None,
                "textual content": (
                    "At this location, with a sandy path resulting in the ocean the place a number of boats, together with "
                    "sailboats, are moored, fashionable actions would possibly embody boating, crusing, swimming, and "
                    "beachcombing. Moreover, the sandy path and shoreline present an excellent setting for leisurely "
                    "strolls and picnics, whereas the ocean view affords a serene atmosphere for leisure and "
                    "pictures. Relying on the particular space and accessible amenities, different water sports activities akin to "
                    "kayaking, paddleboarding, and snorkeling may be prevalent."
                ),
                "sort": "textual content"
            }
        ),
        "function": "assistant"
    }
)

Wenden wir die Chat -Vorlage auf unsere Samples an.

tokenizer.apply_chat_template(
    sample_messages, tokenize=False, add_generation_prompt=False
)

Zu diesem Zeitpunkt haben wir unseren Tokenizer eingerichtet und das Imaginative and prescient -Modell heruntergeladen. Wir bringen sie in einen einheitlichen Einheit zusammen Prozessor.

processor = LlavaProcessor(
    image_processor=CLIPImageProcessor.from_pretrained(vision_backbone_name),
    tokenizer=tokenizer,
    patch_size=mannequin.config.vision_config.patch_size,
)
processor.chat_template = LLAVA_CHAT_TEMPLATE

Seit wir spezielle Token wie hinzugefügt haben <picture> Und <pad> Zu unserem Tokenizer früher muss das Modell vorhanden Passen Sie seinen Wortschatz an sie auch zu verstehen

mannequin.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8)

Datensatz

Lassen Sie uns den Datensatz herunterladen, den wir vom Umarmungsgesicht verwenden werden.

Der Datensatz, der Muster von Bild-Textual content-Paaren enthält, ist öffentlich verfügbar und kann gefunden werden Hier.

train_dataset = load_dataset(
    "HuggingFaceH4/llava-instruct-mix-vsft", break up="prepare", streaming=True
)

Wie sehen unsere Trainingsbeispiele aus?

subsequent(iter(train_dataset))

Wie bauen wir eine Reihe von Beispielen auf?

Die folgende Funktion nimmt RAW-Bild-Textual content-Beispiele auf und verwandelt sie in modellbereite Eingänge. Es formatiert die Nachrichten mithilfe der Chat -Vorlage, verarbeitet sowohl den Textual content als auch das Bild mit dem LlavaProcessor Wir haben zuvor definiert und erstellen ordnungsgemäße Trainingsetiketten, während wir die Polsterung ignoriert haben.

def get_data_collator(processor, ignore_index):
    def collate_examples(examples):
        # Extract texts and pictures from the uncooked examples
        texts = ()
        photographs = ()
        for instance in examples:
            messages = instance("messages")
            textual content = processor.tokenizer.apply_chat_template(
                messages, tokenize=False, add_generation_prompt=False
            )
            texts.append(textual content)
            photographs.append(instance("photographs")(0))

        # Course of the inputs (tokenize textual content and remodel photographs)
        batch = processor(texts, photographs, return_tensors="pt", padding=True)

        # Create labels
        labels = batch("input_ids").clone()
        if processor.tokenizer.pad_token_id just isn't None:
            labels(labels == processor.tokenizer.pad_token_id) = ignore_index
        batch("labels") = labels

        return batch

    return collate_examples

# NOTE: this does a bit greater than a collate operate ought to...

Ausbildung

Definieren wir schließlich die Trainingsargumente, einschließlich Chargengröße, Lernrate, Gesamtschritte und verwenden Sie gemischte Präzision (FP16) für die Geschwindigkeit. Wir vermeiden auch das Speichern von Kontrollpunkten, um die Dinge Licht zu halten. Dann wickeln wir alles in a ein Seq2SeqTrainerÜbergeben des Modells, des Datensatzes und unserem benutzerdefinierten Collator für Picture-Textual content-Eingaben.

args = Seq2SeqTrainingArguments(
    output_dir="/content material/training_output",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    max_steps=350,
    lr_scheduler_type="cosine_with_min_lr",
    lr_scheduler_kwargs={"min_lr": 2e-5},
    warmup_ratio=0.05,
    logging_strategy="steps",
    logging_steps=5,
    fp16=True,
    remove_unused_columns=False,  # Necessary!
    optim="adamw_torch",
    report_to="none",
    save_strategy="no",  # let's not save the checkpoint to disk, in any other case it will take 5 minutes
)

coach = Seq2SeqTrainer(
    mannequin=mannequin,
    args=args,
    data_collator=get_data_collator(
        processor, ignore_index=mannequin.config.ignore_index,
    ),
    train_dataset=train_dataset,
)

coach.prepare()

Schlussfolgerung

Um zu beachten, dass Inferenz wie erwartet funktioniert, sollten Sie schwerere Modelle verwenden und länger trainieren.

Wir werden dieses Bild für Inferenz verwenden:

dialog = (
    {
        "content material": (
            {
                "sort": "picture"
            },
            {
                "textual content": "nWhat is represented within the picture?",
                "sort": "textual content"
            }
        ),
        "function": "person"
    }
)

In diesem Zellblock laden wir als Beispiel ein Bild aus einer URL und formatieren eine Konversation mit der Chat -Vorlage. Der Prozessor verwandelt sich beide in Tensoren. Anschließend verschieben wir die Eingabe in das Gerät des Modells und generieren eine Antwort, sodass das Modell das Bild basierend auf der Eingabeaufforderung des Benutzers beschreiben lassen.

image_url = "https://llava-vl.github.io/static/photographs/monalisa.jpg"

inputs_for_generation = processor(
    photographs=Picture.open(requests.get(image_url, stream=True).uncooked),
    textual content=processor.apply_chat_template(dialog, add_generation_prompt=True),
    return_tensors="pt",
)

inputs_for_generation = inputs_for_generation.to(machine=mannequin.machine)
output = coach.mannequin.generate(
    **inputs_for_generation, max_new_tokens=200, do_sample=False
)

print(processor.decode(output(0), skip_special_tokens=True))

Erweiterungen und Verbesserungen

• Verwenden Sie einen größeren Bildcodierer (z. B. Clip-vit groß) und LLM (z. B. Lama 3.1 8b)
• Länger trainieren. Das Modell dauert einige Zeit, um herauszufinden, wie man Anweisungen in Gegenwart von Bildfunktionen befolgt
• Folgen Sie dem von der ursprünglichen LLAVA angenommenen mehrstufigen Schulungsverfahren
  • Stufe 1: Vorausbildung zur Function-Ausrichtung -> Trainieren Sie das Modell unter Anweisungsdaten mit Einzelverkehrsanweisungen, wo es aufgefordert wird, das Bild kurz zu beschreiben. Bildcodierer und LLM sind eingefroren
  • Stufe 2: Feinabstimmung Finish-to-Finish -> Trainieren Sie das Modell auf Multi-Flip-Befehlsdaten. Nur der Bildcodierer ist eingefroren

Arbeitsdemo: huggingface.co/areas/badayvedat/llava

Abschluss

Ich denke, dieses kleine Projekt ist interessant, um besser zu verstehen, wie multimodale Modelle wie Llava funktionieren. Selbst wenn wir kleinere Modelle verwendet haben, ist die Hauptidee dieselbe: Kombinieren Sie Imaginative and prescient und Sprache zu einem System, das Bilder verstehen und darüber sprechen kann.

Natürlich sind die in diesem Spielzeugbeispiel erzielten Ergebnisse nicht wirklich intestine; Es gibt viel Raum für Verbesserungen. Es ist jedoch eine große Herausforderung, Llava in einer Umgebung mit begrenzten Ressourcen zu machen

Folgen Sie mir weiter Tds Wenn Sie diesen Artikel mögen!

LinkedIn | x (Twitter) | Web site