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 Autor

Früher habe ich Vibe-Coding gehasst. Ich glaubte, ich könnte besseren Code schreiben, sauberere Systeme entwerfen und selbst durchdachtere Architekturentscheidungen treffen. Das dürfte lange Zeit so gewesen sein. Im Laufe der Zeit änderten sich die Dinge. KI-Agenten haben sich deutlich verbessert. MCP-Server, Claude-Fähigkeiten, Agenten-Workflows, Planungs-First-Execution und Codierungstools mit langem Horizont machten die Vibe-Codierung von einer Spielerei zu einer praktischen Möglichkeit, echte Systeme aufzubauen.

Irgendwann habe ich nachgegeben. Seitdem verwende ich Claude Code und OpenCode, um Systeme zu erstellen, die ich normalerweise für zu komplex für eine schnelle Iteration halten würde. Dazu gehören Zahlungsplattformen, Stablecoin-Wallets, Buchleseanwendungen und produktionsbereite Full-Stack-Websysteme. Was mich überraschte, struggle nicht nur die Geschwindigkeit, sondern auch die Konsistenz der Ergebnisse, sobald die richtige Struktur und die richtigen Instruments vorhanden waren.

Das eigentliche Drawback, mit dem die meisten Menschen bei der Vibe-Codierung konfrontiert sind, besteht nicht darin, Code zu schreiben.

Es kommt auf die Wahl des richtigen Tech-Stacks an.

Frontend, Backend, Authentifizierung, Datenbanken, Speicher, E-Mail, Zahlungen und Bereitstellung bieten unzählige Optionen. Ohne einen klaren Stack fällt es selbst starken KI-Programmierern schwer, gute Entscheidungen zu treffen. Wenn einem Agenten ein klar definierter und fundierter Technologie-Stack zur Verfügung gestellt wird, kann er zuverlässig und mit weitaus weniger Reibungsverlusten eine Finish-to-Finish-Anwendung erstellen.

Darauf konzentriert sich dieser Artikel.

Ich werde meinen bevorzugten Tech-Stack für die Vibe-Codierung moderner Anwendungen durchgehen. Das ist der Stack, den ich wiederverwende, weil er funktioniert. Wir besprechen, wie die Teile zusammenpassen, wofür jedes Werkzeug verantwortlich ist und wie man von Null zu einem produktionsbereiten System gelangt. Außerdem werde ich eine Claude-Code-Beispielaufforderung und optionale Instruments vorstellen, die dabei helfen, einen funktionierenden Prototyp in ein produktionsreifes System umzuwandeln.

# Mein Tech-Stack und warum dieser Stack funktioniert

In diesem Abschnitt werde ich den genauen Tech-Stack, den ich für die Vibe-Codierung verwende, aufschlüsseln und erklären, warum diese Instruments beim Erstellen realer Anwendungen so intestine zusammenarbeiten.

Der Stapel

• Subsequent.js (App-Router) -> Frontend und Layouts
• shadcn/ui -> UI-Komponenten
• Serveraktionen + Routen -> Backend-Logik und Webhooks
• Supabase -> Datenbank, Authentifizierung, Speicher
• Erneut senden -> Transaktions-E-Mails
• Streifen -> Zahlungen und Abonnements
• Vercel -> Bereitstellung und Vorschau

Dieser Stapel ist bewusst einfach gehalten. Sie können das kostenlose Kontingent jeder hier aufgeführten Plattform nutzen, was es splendid für Einsteiger macht. Sie können eine vollständige Anwendung kostenlos auf Vercel bereitstellen und verwaltete Dienste ohne Vorabkosten verbinden.

Warum dieser Stapel skaliert werden kann, ohne dass es zu Unordnung kommt

Zwei Subsequent.js-Grundelemente übernehmen die meiste Arbeit, wenn die App wächst:

1. Serveraktionen Behandeln Sie Formularübermittlungen und serverseitige Mutationen. Sie sorgen dafür, dass Datenschreibvorgänge nahe an der Benutzeroberfläche erfolgen und viele Textbausteine ​​entfernt werden, die normalerweise früh auftauchen.
2. Routenhandler Behandeln Sie Webhooks, Gesundheitsprüfungen und benutzerdefinierte Endpunkte. Dies gibt Ihnen einen sauberen Ort, an dem externe Systeme mit Ihrer App kommunizieren können, ohne Ihre UI-Logik zu verschmutzen.

Supabase bietet Ihnen Datenbank, Authentifizierung und Speicherung mit einem Sicherheitsmodell, das nah an den Daten ist. Wenn Sie die Sicherheit auf Zeilenebene frühzeitig aktivieren, bleibt die Autorisierung konsistent, wenn das System wächst, und Sie vermeiden spätere mühsame Migrationen.

Erneut senden sorgt dafür, dass Transaktions-E-Mails einfach und umgebungsorientiert sind.

Streifenkasse In Kombination mit Webhooks erhalten Sie eine zuverlässige Möglichkeit, Zahlungen in echte Ansprüche umzuwandeln, statt in verstreute Function-Flags.

Vercel sorgt dafür, dass Vorschau- und Produktionsbereitstellungen aufeinander abgestimmt sind, sodass Sie vom ersten Tag an in realen Umgebungen testen können.

Dieser Stack eignet sich intestine für die Vibe-Codierung, da er eigensinnig und vorhersehbar ist und für einen KI-Coding-Agenten leicht nachvollziehbar ist. Sobald die Grenzen klar sind, baut sich das System quick von selbst auf.

# Bauen Sie einen Plan von Null auf einen bezahlten MVP auf

Dieser Construct-Plan ist für die Vibe-Codierung mit echten Instruments konzipiert. Das Ziel ist es, eine zu bekommen zunächst ein serienreifes Grundgerüstund fügen Sie dann in kleinen Phasen Funktionen hinzu, ohne frühere Entscheidungen zu zerstören. Jede Section ist direkt dem von Ihnen verwendeten Stack zugeordnet, sodass ein KI-Coding-Agent sie von Anfang bis Ende verfolgen kann.

Section 1: MVP-Gründung

Bauen Sie den vollständigen Produktkreislauf mit minimalem Umfang auf.

• Aufstellen Subsequent.js (App-Router) Projekt mit Vercel Einsatz
• Dashboard-Shell und Navigation mit shadcn/ui
• Authentifizierungsflüsse mit Supabase-Auth (Anmelden, Anmelden, Zurücksetzen)
• Eine zentrale benutzereigene Tabelle in Supabase Postgres
• CRUD-Bildschirme powered by Subsequent.js-Serveraktionen
• Vorschau der Bereitstellungen bei jeder Änderung über Vercel

Am Ende dieser Section verfügen Sie bereits über eine nutzbare App, die in der Produktion läuft, auch wenn der Funktionsumfang gering ist.

Section 2: Datensicherheit und Zugriffskontrolle

Sperren Sie Benutzerdaten, bevor Sie weitere Funktionen hinzufügen.

• Aktivieren Sicherheit auf Zeilenebene auf benutzereigenen Tabellen in Supabase
• Definieren Sie Lese- und Schreibrichtlinien basierend auf dem Eigentum
• Verwenden Sie konsistente Muster wie „owner_id“, „created_at“, „update_at“.
• Validieren Sie Zugriffsregeln durch echte UI-Abläufe, nicht nur durch SQL

Diese Section verhindert zukünftige Umschreibungen und sorgt dafür, dass die Sicherheit an der tatsächlichen Funktionsweise der App ausgerichtet ist.

Section 3: E-Mail und Speicherung

Fügen Sie Vertrauen und Dateiverwaltung hinzu.

• Transaktions-E-Mails über Erneut senden (Willkommen, Verifizierung, Zurücksetzen)
• Verwendung privater Speichereimer Supabase-Speicher
• Laden Sie Flows hoch, die dieselben Eigentumsregeln wie Ihre Datenbank berücksichtigen
• Signierte URLs oder kontrollierter Zugriff basierend auf der Benutzeridentität

Ab diesem Zeitpunkt fühlt sich das Produkt vollständig statt experimentell an.

Section 4: Abrechnung und Ansprüche

Verwandeln Sie Nutzung in Umsatz.

• Erstellen Streifenkasse Sitzungen und Umleitung von Benutzern
• Handhaben Stripe-Webhooks mit Subsequent.js-Routenhandlern
• Speichern Sie den Abonnement- oder Kaufstatus in Supabase
• Erhalten Sie Premium-Funktionen basierend auf gespeicherten Berechtigungen
• Machen Sie die Webhook-Verarbeitung mithilfe verarbeiteter Ereignis-IDs idempotent

Am Ende dieser Section verfügen Sie über einen kostenpflichtigen MVP, der skaliert werden kann, ohne die Kernarchitektur zu ändern.

# Claude Code Starter-Eingabeaufforderung

Sie können ersetzen „Buchladen + Reader MVP“ mit Ihrer eigenen Idee über die gleiche Claude-Code-Eingabeaufforderung.

Construct a **E-book Store + Reader MVP** utilizing this stack:
- Subsequent.js App Router  
- shadcn/ui  
- Supabase (Postgres, Auth, Storage)  
- Resend  
- Stripe (Checkout + webhooks)  
- Vercel  

## Aim
Ship a production-ready E-book Store and Reader with paid entry.

## Construct
- Public pages: touchdown, pricing, ebook checklist  
- Auth: enroll, register, reset password  
- Protected app: reader dashboard  

## Information
- `books`, `chapters`
- Row Degree Safety so customers entry solely their very own information

## Options
- CRUD by way of Server Actions  
- Reader view with progress monitoring  
- Non-public storage for ebook property  
- Welcome e-mail  
- Stripe Checkout + webhook-based entitlements  

## Output
- Clear app construction
- Minimal dependencies
- README with setup, env vars, migrations, Stripe, and Vercel steps
- Handbook verification guidelines per characteristic

Sie müssen lediglich auf Claude Code umsteigen Planmodusfügen Sie die Eingabeaufforderung ein und ändern Sie die Idee oder passen Sie den Umfang entsprechend Ihren Anforderungen an.

Sobald Sie beginnen, plant Claude zunächst das System und beginnt dann Schritt für Schritt ohne Reibungsverluste mit dem Aufbau. Außerdem werden Sie durch die Einrichtung erforderlicher Dienste, die Erstellung von Konten auf Plattformen von Drittanbietern und die Generierung von API-Schlüsseln bei Bedarf geführt.

Dies macht es einfach, von einer Idee zu einer funktionierenden Anwendung zu gelangen, ohne bei der Einrichtung oder den Entscheidungen hängenzubleiben.

# Optionale Instruments

Diese Instruments sind für die Auslieferung der ersten Model nicht erforderlich, helfen Ihnen jedoch beim Testen, Überwachen und Härten der Anwendung, während sie im realen Einsatz wächst.

# Letzte Gedanken

Moderne Entwicklungs- und Engineering-Instruments entwickeln sich schnell weiter. Die meisten von ihnen sind mittlerweile auf die KI-Integration ausgelegt und bieten eine gute Dokumentation, APIs und Zugriff im MCP-Stil, sodass KI-Agenten direkt mit ihnen zusammenarbeiten und Software program schneller als je zuvor erstellen können.

Wenn Sie ein Datenwissenschaftler sind, der sich noch nie mit Webentwicklung beschäftigt hat, oder ein absoluter Anfänger, der etwas Reales aufbauen oder ein Startup gründen möchte, empfehle ich dringend, mit diesem Tech-Stack zu beginnen. Es erfordert nur minimale Einrichtung und ermöglicht die nahezu sofortige Bereitstellung einer funktionierenden Anwendung.

Ich habe quick drei Monate gebraucht, um Instruments zu testen und zu vergleichen, bevor ich mich für diesen Stack entschieden habe. Wenn Sie hier beginnen, sparen Sie diese Zeit.

Wenn Sie später mehr Flexibilität wünschen, können Sie die Dinge aufteilen. Verwenden Sie zum Beispiel Neon für die Datenbank, Sachbearbeiter zur Authentifizierung und lassen Sie alles andere gleich. Wenn Ihr System wächst, können Sie durch die Aufteilung der Verantwortlichkeiten auf mehrere Instruments einfacher ein Teil ersetzen, ohne den Relaxation zu beschädigen.

Beginnen Sie einfach, liefern Sie früh aus und entwickeln Sie sich nur dann weiter, wenn Sie es brauchen.

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.

Google DeepMind-Forscher stellen Gemma Scope 2 vor, eine offene Suite von Interpretierbarkeitstools, die offenlegt, wie Gemma 3-Sprachmodelle Informationen über alle Ebenen hinweg verarbeiten und darstellen, von 270M bis 27B Parametern.

Das Hauptziel ist einfach: KI-Sicherheits- und Ausrichtungsteams eine praktische Möglichkeit zu geben, das Modellverhalten auf interne Merkmale zurückzuführen, anstatt sich nur auf die Eingabe-Ausgabe-Analyse zu verlassen. Wenn ein Gemma-3-Modell einen Jailbreak ausführt, halluziniert oder kriecherisches Verhalten zeigt, können Forscher mit Gemma Scope 2 untersuchen, welche internen Funktionen ausgelöst wurden und wie diese Aktivierungen durch das Netzwerk flossen.

Was ist Gemma Scope 2?

Gemma Scope 2 ist eine umfassende, offene Suite von Sparse-Autoencodern und zugehörigen Instruments, die auf interne Aktivierungen der Gemma 3-Modellfamilie trainiert sind. Sparse Autoencoder (SAEs) fungieren als Mikroskop für das Modell. Sie zerlegen hochdimensionale Aktivierungen in einen spärlichen Satz menschlicher inspizierbarer Merkmale, die Konzepten oder Verhaltensweisen entsprechen.

Für das Coaching von Gemma Scope 2 waren die Speicherung von etwa 110 Petabyte an Aktivierungsdaten und die Anpassung von über 1 Billion Gesamtparametern an alle Interpretierbarkeitsmodelle erforderlich.

Die Suite zielt auf alle Gemma-3-Varianten ab, einschließlich der Parametermodelle 270M, 1B, 4B, 12B und 27B, und deckt die gesamte Tiefe des Netzwerks ab. Dies ist wichtig, da viele sicherheitsrelevante Verhaltensweisen erst in größeren Maßstäben auftreten.

Was ist neu im Vergleich zum ursprünglichen Gemma Scope??

Die erste Gemma Scope-Veröffentlichung konzentrierte sich auf Gemma 2 und ermöglichte bereits die Erforschung von Modellhalluzinationen, die Identifizierung von Geheimnissen, die einem Modell bekannt sind, und das Coaching sichererer Modelle.

Gemma Scope 2 erweitert diese Arbeit im Wesentlichen auf vier Arten:

1. Die Instruments decken nun die gesamte Gemma-3-Familie mit bis zu 27B Parametern ab, was zur Untersuchung neu auftretender Verhaltensweisen erforderlich ist, die nur in größeren Modellen beobachtet werden, wie beispielsweise das Verhalten, das zuvor im C2S-Scale-Modell der Größe 27B für wissenschaftliche Entdeckungsaufgaben analysiert wurde.
2. Gemma Scope 2 umfasst SAEs und Transcoder, die auf jeder Ebene von Gemma 3 geschult sind. Skip-Transcoder und Cross-Layer-Transcoder helfen dabei, mehrstufige Berechnungen zu verfolgen, die über Ebenen verteilt sind.
3. Die Suite wendet die Matryoshka-Trainingstechnik an, sodass SAEs nützlichere und stabilere Funktionen erlernen und einige in der früheren Gemma Scope-Model identifizierte Mängel beheben können.
4. Es gibt spezielle Interpretierbarkeitstools für Gemma 3-Modelle, die für den Chat optimiert sind und es ermöglichen, mehrstufiges Verhalten wie Jailbreaks, Ablehnungsmechanismen und die Treue der Gedankenkette zu analysieren.

Wichtige Erkenntnisse

1. Gemma Scope 2 ist eine offene Interpretierbarkeitssuite für alle Gemma 3-Modelle, von 270M bis 27B Parametern, mit SAEs und Transcodern auf jeder Ebene sowohl vorab trainierter als auch auf Anweisungen abgestimmter Varianten.
2. Die Suite verwendet Sparse-Autoencoder als Mikroskop, das interne Aktivierungen in spärliche, konzeptähnliche Options zerlegt, sowie Transcoder, die verfolgen, wie sich diese Options über Schichten hinweg ausbreiten.
3. Gemma Scope 2 ist explizit für die KI-Sicherheitsarbeit positioniert, um Jailbreaks, Halluzinationen, Speichelleckerei, Ablehnungsmechanismen und Diskrepanzen zwischen internem Zustand und kommunizierter Argumentation in Gemma 3 zu untersuchen.

Schauen Sie sich das an Papier, Technische Particulars Und Modellgewichte. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Michal Sutter ist ein Information-Science-Experte mit einem Grasp of Science in Information Science von der Universität Padua. Mit einer soliden Grundlage in statistischer Analyse, maschinellem Lernen und Datentechnik ist Michal hervorragend darin, komplexe Datensätze in umsetzbare Erkenntnisse umzuwandeln.

RENO, Nevada, 6. November 2025 – CIQ kündigte heute erweiterte Funktionen an und fügte Rocky Linux von CIQ (RLC) neben der zuvor angekündigten NVIDIA CUDA Toolkit-Integration auch NVIDIA DOCA OFED-Unterstützung hinzu.

Laut CIQ ist RLC damit die erste Linux-Distribution, die für die Bereitstellung des NVIDIA KI- und Netzwerksoftware-Stacks, einschließlich CUDA Toolkit und DOCA OFED, lizenziert ist und sofort einsatzbereit ist.

CIQ ist der Gründungs-Assist- und Servicepartner von Rocky Linux, der für leistungsstarke Software program-Infrastrukturen entwickelt wurde. Mit diesen neuen Funktionen ist RLC sowohl für die GPU-beschleunigte Entwicklung als auch für Cluster-Bereitstellungen im Unternehmensmaßstab geeignet. Während Entwickler von einem Equipment-ähnlichen Erlebnis für GPU-Computing profitieren, erhalten Unternehmen die entscheidenden Netzwerk- und Verbindungsfunktionen, die sie für die Bereitstellung und Optimierung großer Cluster mit Tausenden von Knoten benötigen, die auf Premium-{Hardware} von DELL, HPE und anderen erstklassigen Serverherstellern laufen.

Beschleunigtes Rechnen hat sich von spezialisierter {Hardware} zu einer wesentlichen Infrastruktur für KI, maschinelles Lernen und wissenschaftliches Rechnen entwickelt. Dennoch stehen Unternehmen vor einer doppelten Herausforderung: Sie müssen KI-Software program-Stacks mit ihren Treiberkonflikten und Konfigurationskomplexitäten bereitstellen und dann von Entwicklungsknoten zu Produktionsclustern mit Tausenden von Knoten skalieren.

Diese Skalierungsherausforderung tritt auf, wenn Proof-of-Idea-Bereitstellungen in die Produktion übergehen. Im großen Maßstab werden Netzwerkoptimierung und GPU-zu-GPU-Kommunikation zu kritischen Engpässen. Server der Enterprise-Klasse wie der Dell PowerEdge

Rocky Linux von CIQ löst beide Herausforderungen mit vorgefertigten, validierten Photographs, die den kompletten NVIDIA-Stack enthalten: CUDA Toolkit, DOCA OFED-Netzwerktreiber und unterstützende Komponenten. Unternehmen stellen innerhalb von Minuten produktionsbereite Umgebungen bereit und skalieren ohne Rätselraten auf Cluster mit tausend Knoten. CIQ eliminiert die Komplexität in jeder Part, beschleunigt Innovationen und senkt gleichzeitig die Gesamtbetriebskosten mit NVIDIA drastisch.

„Wenn Sie Anwendungen erstellen, die beschleunigtes Computing nutzen, ist Rocky Linux von CIQ jetzt die offensichtliche Wahl“, sagte Gregory Kurtzer, Gründer und CEO von CIQ. „Wir haben alle Barrieren zwischen Entwicklern und GPU-Leistung beseitigt. Mit dem vollständigen, validierten NVIDIA-Stack, der von CIQ direkt in Rocky Linux integriert ist, können sich Groups ganz auf Innovation statt auf die Infrastruktur konzentrieren. Das ist das Equipment-Erlebnis, das die Entwickler-Group benötigt hat: herunterladen, bereitstellen und sofort mit dem Aufbau beginnen.“

Die Plattform bietet:

• Sofortige Produktivität: Mit vorkonfigurierten, validierten Umgebungen gelangen Sie in wenigen Minuten von der Set up zum ersten Token

• Einsatzbereitschaft im Unternehmensmaßstab: Die vollständige DOCA OFED-Integration ermöglicht eine nahtlose Skalierung von Entwicklungsknoten auf Tausende von Produktionsknoten mit optimierter GPU-zu-GPU-Kommunikation

• Niedrigere Gesamtbetriebskosten: Reduzierte Einrichtungszeit, minimierte Fehlerbehebung und optimierte Effizienz führen zu erheblichen Kosteneinsparungen im gesamten Entwicklungs- und Bereitstellungslebenszyklus

• Kein Rätselraten: Jede Komponente, vom GPU-Treiber bis zum Netzwerk-Stack, wird getestet und zertifiziert, wodurch Konfigurationsunsicherheiten in der gesamten Infrastruktur beseitigt werden

• Erweiterte Netzwerkfunktionen: Die integrierte Unterstützung für RDMA, IDPF und Hochleistungsverbindungen optimiert die Clusterkommunikation für anspruchsvolle Arbeitslasten

• Sicherheit auf Unternehmensniveau: Vollständig signierte Treiber und integrierte sichere Boot-Unterstützung lösen die komplexe Herausforderung der GPU-Treiberbereitstellung in modernen sicherheitsbewussten Umgebungen

• Deterministische Leistung: Die durch {Hardware} erzwungene Ressourcenisolierung ermöglicht eine vorhersehbare, jitterfreie Ausführung geschäftskritischer Arbeitslasten

CIQ wird dieses neue Full-Stack-Erlebnis auf kommenden Entwicklerveranstaltungen vorstellen, darunter KubeCon + CloudNativeCon North America (10.–13. November 2025, Atlanta) und SC25 (16.–21. November 2025, St. Louis), wo Accomplice validierte Referenzkits und reale Anwendungsfälle mit Rocky Linux von CIQ mit NVIDIA AI-Infrastruktur, NVIDIA ConnectX SuperNICs und NVIDIA BlueField DPUs vorführen.

Weitere Informationen zu Rocky Linux von CIQ mit integrierter NVIDIA-Unterstützung finden Sie unter https://ciq.com/companions/nvidia/.

Die Datensatzvorbereitung für einen Workflow für Objekterkennungstrainings kann lange dauern und oft frustrierend sein. Label StudioEin Open-Supply-Datenannotation-Instrument kann durch eine einfache Möglichkeit für die Annotierung von Datensätzen mitwirken. Es unterstützt eine Vielzahl von Annotationsvorlagen, einschließlich Laptop Imaginative and prescient, natürlicher Sprachverarbeitung und Audio- oder Sprachverarbeitung. Wir werden uns jedoch speziell auf den Workflow der Objekterkennung konzentrieren.

Aber was ist, wenn Sie vorankundigierte Open-Supply-Datensätze wie den Pascal VOC-Datensatz nutzen möchten? In diesem Artikel zeige ich Ihnen, wie Sie diese Aufgaben problemlos in das Format von Label Studio importieren können, während Sie den gesamten Stapel einrichten – einschließlich einer PostgreSQL -Datenbank. Minio Objektspeicher, ein Nginx Reverse Proxy und das Label Studio Backend. Minio ist ein S3-kompatibler Objektspeicherdienst: Sie können Cloud-nativen Speicher in der Produktion verwenden, können ihn jedoch auch lokal für die Entwicklung und Prüfung ausführen.

In diesem Tutorial werden wir die folgenden Schritte durchlaufen:

1. Pascal VOC -Anmerkungen konvertieren – Begrenzungsboxen von XML in Label Studio -Aufgaben im JSON -Format verwandeln.
2. Führen Sie den vollen Stapel aus – Starten Sie das Label Studio mit Postgresql, Minio, Nginx und dem Backend mit Docker Compose.
3. Richten Sie ein Label Studio -Projekt ein – Konfigurieren Sie ein neues Projekt in der Label Studio -Schnittstelle.
4. Laden Sie Bilder und Aufgaben in Minio hoch hoch -Speichern Sie Ihren Datensatz in einem S3-kompatiblen Eimer.
5. MINIO MINIO mit dem Label Studio anschließen – Fügen Sie den Cloud -Speicher -Bucket Ihrem Projekt hinzu, damit Label Studio Bilder und Annotationen direkt abrufen kann.

Voraussetzungen

Um diesem Tutorial zu folgen, stellen Sie sicher, dass Sie:

Vom VOC zu Label Studio: Vorbereitung von Anmerkungen

Der Pascal VOC -Datensatz verfügt über eine Ordnerstruktur, in der die Zug- und Testdatensätze bereits aufgeteilt sind. Der Anmerkungen Der Ordner enthält die Annotationsdateien für jedes Bild. Insgesamt enthält der Trainingssatz 17.125 Bilder mit jeweils eine entsprechende Annotationsdatei.

.
└── VOC2012
    ├── Annotations  # 17125 annotations
    ├── ImageSets 
    │   ├── Motion
    │   ├── Format
    │   ├── Primary
    │   └── Segmentation
    ├── JPEGImages  # 17125 pictures
    ├── SegmentationClass
    └── SegmentationObject

Das folgende XML -Snippet, das aus einer der Annotationen entnommen wurde, definiert einen Begrenzungsbox um ein Objekt mit dem Namen „Individual“. Die Field wird mit vier Pixelkoordinaten angegeben: xminAnwesend yminAnwesend xmaxUnd ymax.

Die folgende Abbildung zeigt das innere Rechteck als kommentierter Begrenzungsbox, definiert durch die obere linke Ecke (xminAnwesend ymin) und die untere rechte Ecke (xmaxAnwesend ymax) innerhalb des äußeren Rechtecks, das das Bild darstellt.

Label Studio erwartet, dass jede Begrenzungsbox durch seine Breite, Höhe und obere linke Ecke definiert wird, die als Prozentsätze der Bildgröße ausgedrückt wird. Nachfolgend finden Sie ein funktionierendes Beispiel für das konvertierte JSON -Format für die oben gezeigte Annotation.

{
  "knowledge": {
    "picture": "s3://<bucket_name>/<prefix>/2007_000027.jpg"
  },
  "annotations": (
    {
      "consequence": (
        {
          "from_name": "label",
          "to_name": "picture",
          "sort": "rectanglelabels",
          "worth": {
            "x": 35.802,
            "y": 20.20,
            "width": 36.01,
            "top": 50.0,
            "rectanglelabels": ("particular person")
          }
        }
      )
    }
  )
}

Wie Sie im JSON -Format sehen können, müssen Sie auch den Speicherort der Bilddatei angeben – beispielsweise einen Pfad in Minio oder einem S3 -Bucket, wenn Sie den Cloud -Speicher verwenden.

Während der Vorverarbeitung der Daten habe ich den gesamten Datensatz zusammengeführt, obwohl diese bereits in Coaching und Validierung unterteilt waren. Dies simuliert ein reales Szenario, in dem Sie normalerweise mit einem einzigen Datensatz beginnen und die Aufteilung in Trainings- und Validierungssätze vor dem Coaching selbst durchführen.

Ausführen des vollständigen Stacks mit Docker Compose

Ich habe das zusammengeführt docker-compose.yml Und docker-compose.minio.yml Dateien in eine vereinfachte Einzelkonfiguration, damit der gesamte Stack im selben Netzwerk ausgeführt wird. Beide Dateien wurden vom Beamten übernommen Label Studio Github Repository.

providers:
  nginx:
    # Acts as a reverse proxy for Label Studio frontend/backend
    picture: heartexlabs/label-studio:newest
    restart: unless-stopped
    ports:
      - "8080:8085" 
      - "8081:8086"
    depends_on:
      - app
    setting:
      - LABEL_STUDIO_HOST=${LABEL_STUDIO_HOST:-}
    
    volumes:
      - ./mydata:/label-studio/knowledge:rw # Shops Label Studio tasks, configs, and uploaded recordsdata
    command: nginx

  app:
    stdin_open: true
    tty: true
    picture: heartexlabs/label-studio:newest
    restart: unless-stopped
    expose:
      - "8000"
    depends_on:
      - db
    setting:
      - DJANGO_DB=default
      - POSTGRE_NAME=postgres
      - POSTGRE_USER=postgres
      - POSTGRE_PASSWORD=
      - POSTGRE_PORT=5432
      - POSTGRE_HOST=db
      - LABEL_STUDIO_HOST=${LABEL_STUDIO_HOST:-}
      - JSON_LOG=1
    volumes:
      - ./mydata:/label-studio/knowledge:rw  # Shops Label Studio tasks, configs, and uploaded recordsdata
    command: label-studio-uwsgi

  db:
    picture: pgautoupgrade/pgautoupgrade:13-alpine
    hostname: db
    restart: unless-stopped
    setting:
      - POSTGRES_HOST_AUTH_METHOD=belief
      - POSTGRES_USER=postgres
    volumes:
      - ${POSTGRES_DATA_DIR:-./postgres-data}:/var/lib/postgresql/knowledge  # Persistent storage for PostgreSQL database
  minio:
    picture: "minio/minio:${MINIO_VERSION:-RELEASE.2025-04-22T22-12-26Z}"
    command: server /knowledge --console-address ":9009"
    restart: unless-stopped
    ports:
      - "9000:9000"
      - "9009:9009"
    volumes:
      - minio-data:/knowledge   # Shops uploaded dataset objects (like pictures or JSON duties)
    # configure env vars in .env file or your techniques setting
    setting:
      - MINIO_ROOT_USER=${MINIO_ROOT_USER:-minio_admin_do_not_use_in_production}
      - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD:-minio_admin_do_not_use_in_production}
      - MINIO_PROMETHEUS_URL=${MINIO_PROMETHEUS_URL:-http://prometheus:9090}
      - MINIO_PROMETHEUS_AUTH_TYPE=${MINIO_PROMETHEUS_AUTH_TYPE:-public}
 
volumes:
  minio-data: # Named quantity for MinIO object storage

Diese vereinfachte Docker Compose -Datei definiert vier Kerndienste mit ihren Volumenzuordnungen:

App – führt das Label Studio Backend selbst aus.

• Teilt die mydata Verzeichnis mit nginx, in dem Projekte, Konfigurationen und hochgeladene Dateien gespeichert werden.
• Verwendet a Binden Sie die Halterung: ./mydata:/label-studio/knowledge:rw → bildet einen Ordner von Ihrem Host in den Container.

Nginx – fungiert als Reverse Proxy für das Label Studio Frontend und Backend.

• Teilt die mydata Verzeichnis mit dem App -Dienst.

PostgreSQL (DB) – Verwaltet Metadaten und Projektinformationen.

• Speichert persistente Datenbankdateien.
• Verwendet a Binden Sie die Halterung: ${POSTGRES_DATA_DIR:-./postgres-data}:/var/lib/postgresql/knowledge.

Minio -Ein S3-kompatibler Objektspeicherdienst.

• Speichert Datensatzobjekte wie Bilder oder JSON -Annotationsaufgaben.
• Verwendet a Volumen genannt: minio-data:/knowledge.

Wenn Sie Hostordner wie montieren, z. ./mydata Und ./postgres-dataSie müssen dem Host demselben Benutzer, der im Container ausgeführt wird, Eigentümer zuweisen. Label Studio wird nicht als Root ausgeführt-es verwendet einen Nicht-Root-Benutzer mit UID 1001. Wenn die Hostverzeichnisse einem anderen Benutzer gehören, hat der Container keinen Schreibzugriff und Sie werden darauf eingehen Zugriff verweigert Fehler.

Nachdem Sie diese Ordner in Ihrem Projektverzeichnis erstellt haben, können Sie deren Besitz mit:

mkdir mydata 
mkdir postgres-data
sudo chown -R 1001:1001 ./mydata ./postgres-data

Nachdem die Verzeichnisse vorbereitet sind, können wir den Stapel mit Docker Compose ansprechen. Einfach rennen:

docker compose up -d

Es kann einige Minuten dauern, bis alle erforderlichen Bilder von Docker Hub und Label Studio eingerichtet wurden. Sobald das Setup abgeschlossen ist, öffnen Sie sich http: // localhost: 8080 In Ihrem Browser zugreifen Sie auf die Label Studio -Schnittstelle. Sie müssen ein neues Konto erstellen, und dann können Sie sich mit Ihren Anmeldeinformationen anmelden, um auf die Benutzeroberfläche zuzugreifen. Sie können ein Legacy -API -Token aktivieren, indem Sie zu gehen Organisation → API -Token -Einstellungen. Mit diesem Token können Sie mit der Label Studio API kommunizieren, die besonders für Automatisierungsaufgaben nützlich ist.

Richten Sie ein Label Studio -Projekt ein

Jetzt können wir unser erstes Datenannotationsprojekt auf Label Studio erstellen, insbesondere für einen Workflow für Objekterkennung. Bevor Sie jedoch anfangen, Ihre Bilder zu kommentieren, müssen Sie die Arten von Klassen definieren, aus denen Sie auswählen können. Im Pascal VOC-Datensatz gibt es 20 Arten vorankündigter Objekte.

Laden Sie Bilder und Aufgaben in Minio hoch hoch

Sie können die Minio -Benutzeroberfläche in Ihrem Browser unter öffnen LOCALHOST: 9000und melden Sie sich dann mit den Anmeldeinformationen an, die Sie unter dem entsprechenden Dienst in der angegeben haben docker-compose.yml Datei.

Ich habe einen Eimer mit Ordnern erstellt, von denen einer zum Speichern von Bildern und eine andere für JSON -Aufgaben verwendet wird, die gemäß den obigen Anweisungen formatiert sind.

Wir haben einen S3-ähnlichen Service lokal eingerichtet, mit dem wir S3 Cloud-Speicher simulieren können, ohne Gebühren zu erfüllen. Wenn Sie Dateien in einen S3 -Bucket auf AWS übertragen möchten, ist es besser, dies direkt über das Web zu tun, da die Datenübertragungskosten berücksichtigt werden. Die gute Nachricht ist, dass Sie mit dem AWS -CLI auch mit Ihrem Minio -Eimer interagieren können. Dazu müssen Sie ein Profil in hinzufügen ~/.aws/config und geben die entsprechenden Anmeldeinformationen in ~/.aws/credentials unter dem gleichen Profilnamen.

Und dann können Sie mit den folgenden Befehlen problemlos mit Ihrem lokalen Ordner synchronisieren:

#!/bin/bash
set -e

PROFILE=<your_profile_name>
MINIO_ENDPOINT=<your_minio_endpoint>   # e.g. http://localhost:9000
BUCKET_NAME=<your_bucket_name>
SOURCE_DIR=<your_local_source_dir>    
DEST_DIR=<your_bucket_destination_dir> 

aws s3 sync 
      --endpoint-url "$MINIO_ENDPOINT" 
      --no-verify-ssl 
      --profile "$PROFILE" 
      "$SOURCE_DIR" "s3://$BUCKET_NAME/$DEST_DIR"

 

MINIO MINIO mit dem Label Studio anschließen

Nachdem alle Daten, einschließlich der Bilder und Anmerkungen, hochgeladen wurden, können wir uns mit dem im vorherigen Schritt erstellten Projekt zum Hinzufügen von Cloud -Speicher überlegen.

Aus Ihren Projekteinstellungen gehen Sie zu Wolkenspeicher und fügen Sie die erforderlichen Parameter hinzu, wie z. B. den Endpunkt (der zusammen mit der Portnummer, z. minio:9000), der Bucket -Identify und das relevante Präfix, bei dem die Annotationsdateien gespeichert werden. Jeder Pfad in den JSON -Dateien verweist dann auf das entsprechende Bild.

Nach der Überprüfung, ob die Verbindung funktioniert, können Sie Ihr Projekt mit dem Cloud -Speicher synchronisieren. Möglicherweise müssen Sie den Befehl sync mehrmals ausführen, da der Datensatz 22.263 Bilder enthält. Es magazine zuerst scheitern, aber wenn Sie die Synchronisierung neu starten, macht es weiterhin Fortschritte. Schließlich werden alle Pascal VOC -Daten erfolgreich in das Label Studio importiert.

Sie können die importierten Aufgaben mit ihren Miniaturbildern in der Aufgabenliste sehen. Wenn Sie auf eine Aufgabe klicken, wird das Bild mit seinen Vorannotungen angezeigt.

Schlussfolgerungen

In diesem Tutorial haben wir gezeigt, wie der Pascal VOC-Datensatz in Label Studio importiert wird, indem Sie XML-Annotationen in das JSON-Format von Label Studio konvertieren, einen vollständigen Stack mit Docker Compose ausführen und Minio als S3-kompatibler Speicher anschließen. Mit diesem Setup können Sie auf Ihre lokale Maschine mit großflächigen, vorankundigten Datensätzen auf Ihre lokale Maschine arbeiten. Das Testen Ihrer Projekteinstellungen und Dateiformate lokal sorgt zuerst für einen reibungsloseren Übergang, wenn Sie in Cloud -Umgebungen wechseln.

Ich hoffe, dieses Tutorial hilft Ihnen dabei, Ihr Datenannotationsprojekt mit vorankündigten Daten zu starten, die Sie problemlos erweitern oder validieren können. Sobald Ihr Datensatz für das Coaching bereit ist, können Sie alle Aufgaben in beliebten Formaten wie Coco oder Yolo exportieren.