In diesem Tutorial stellen wir die bereit 1-Bit Bonsai-27B Sprachmodell mithilfe des PrismML-Zweigs von llama.cpp, der die speziellen CUDA-Kernel bereitstellt, die zum Dekodieren des Q1_0_g128 GGUF-Quantisierungsformats des Modells erforderlich sind. Wir beginnen mit der Validierung der GPU-Laufzeit, der Set up der erforderlichen Python-Abhängigkeiten, dem Kompilieren der CUDA-fähigen Inferenz-Binärdateien und dem Herunterladen der komprimierten Modellgewichte von Hugging Face. Anschließend testen wir das Modell über llama-cli, starten einen OpenAI-kompatiblen lokalen Inferenzserver und interagieren mit ihm über einen wiederverwendbaren Python-Shopper, der Standardvervollständigungen, gestreamte Antworten, Konversationen mit mehreren Runden und Codegenerierung unterstützt. Wir untersuchen auch optionale Konfigurationen für Durchsatz-Benchmarking, quantisiertes Schlüsselwert-Caching, Lengthy-Context-Inferenz, spekulative Dekodierung und multimodale Erweiterungen.

import os
import sys
import time
import json
import shutil
import subprocess
import multiprocessing
WORK_DIR      = "/content material"
REPO_URL      = "https://github.com/PrismML-Eng/llama.cpp"
REPO_DIR      = os.path.be a part of(WORK_DIR, "llama.cpp")
BUILD_DIR     = os.path.be a part of(REPO_DIR, "construct")
BIN_DIR       = os.path.be a part of(BUILD_DIR, "bin")
HF_REPO       = "prism-ml/Bonsai-27B-gguf"
MODEL_FILE    = "Bonsai-27B-Q1_0.gguf"
MODEL_PATH    = os.path.be a part of(WORK_DIR, MODEL_FILE)
SERVER_HOST   = "127.0.0.1"
SERVER_PORT   = 8080
SERVER_URL    = f"http://{SERVER_HOST}:{SERVER_PORT}"
GEN_PARAMS    = {"temperature": 0.7, "top_p": 0.95, "top_k": 20}
CTX_SIZE      = 8192
N_GPU_LAYERS  = 99
USE_KV_Q4     = False
def sh(cmd, examine=True, **kw):
   """Run a shell command, streaming output to the pocket book."""
   print(f"n$ {cmd}")
   return subprocess.run(cmd, shell=True, examine=examine, **kw)
print("=" * 70)
print("(1/7) Checking surroundings")
print("=" * 70)
gpu = subprocess.run("nvidia-smi --query-gpu=identify,reminiscence.whole --format=csv,noheader",
                    shell=True, capture_output=True, textual content=True)
if gpu.returncode != 0:
   sys.exit("No GPU detected. In Colab: Runtime -> Change runtime sort -> GPU (T4).")
print(f"GPU detected: {gpu.stdout.strip()}")
print("Bonsai-27B wants solely ~5.2 GB peak at 4K context — any Colab GPU works.")
sh("pip -q set up huggingface_hub requests")

Wir konfigurieren den Colab-Arbeitsbereich, das Modell-Repository, den Server-Endpunkt, die Inferenzparameter, die Kontextgröße und die GPU-Offloading-Einstellungen, die im gesamten Tutorial erforderlich sind. Wir definieren eine wiederverwendbare Shell-Befehlsfunktion und überprüfen, ob die Laufzeit eine kompatible NVIDIA-GPU bereitstellt, bevor wir fortfahren. Anschließend installieren wir den Hugging Face Hub und die HTTP-Shopper-Abhängigkeiten, die für den Modellabruf und die API-Kommunikation erforderlich sind.

print("=" * 70)
print("(2/7) Constructing PrismML llama.cpp fork with CUDA (cached after 1st run)")
print("=" * 70)
if not os.path.isdir(REPO_DIR):
   sh(f"git clone --depth 1 {REPO_URL} {REPO_DIR}")
else:
   print("Repo already cloned — skipping.")
cli_bin    = os.path.be a part of(BIN_DIR, "llama-cli")
server_bin = os.path.be a part of(BIN_DIR, "llama-server")
bench_bin  = os.path.be a part of(BIN_DIR, "llama-bench")
if not (os.path.exists(cli_bin) and os.path.exists(server_bin)):
   jobs = multiprocessing.cpu_count()
   sh(f"cmake -S {REPO_DIR} -B {BUILD_DIR} -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Launch")
   sh(f"cmake --build {BUILD_DIR} -j{jobs} --target llama-cli llama-server llama-bench")
else:
   print("Binaries already constructed — skipping.")

Wir klonen den PrismML-Zweig von llama.cpp, der die speziellen Kernel bereitstellt, die für das Quantisierungsformat Q1_0_g128 des Modells erforderlich sind. Wir konfigurieren einen CUDA-fähigen Launch-Construct mit CMake und kompilieren die ausführbaren Befehlszeilen-, Server- und Benchmarking-Dateien. Wir verwenden auch zuvor generierte Binärdateien wieder, wenn sie bereits vorhanden sind, wodurch die wiederholte Einrichtungszeit in derselben Colab-Sitzung reduziert wird.

print("=" * 70)
print("(3/7) Downloading weights from Hugging Face")
print("=" * 70)
from huggingface_hub import hf_hub_download
if not os.path.exists(MODEL_PATH):
   downloaded = hf_hub_download(repo_id=HF_REPO, filename=MODEL_FILE,
                                local_dir=WORK_DIR)
   print(f"Downloaded to: {downloaded}")
else:
   print("Mannequin already on disk — skipping.")
print(f"Mannequin dimension on disk: {os.path.getsize(MODEL_PATH) / 1e9:.2f} GB")

Wir stellen eine Verbindung zum Hugging Face Hub her und laden das Bonsai-27B GGUF-Modell in den Colab-Arbeitsbereich herunter. Wir überspringen die Übertragung, wenn die Modelldatei bereits lokal verfügbar ist, sodass nachfolgende Läufe effizienter ablaufen können. Anschließend berechnen und zeigen wir die Größe des bereitgestellten Modells an, um zu bestätigen, dass die komprimierten Gewichte korrekt gespeichert werden.

print("=" * 70)
print("(4/7) Smoke check with llama-cli")
print("=" * 70)
sh(
   f'{cli_bin} -m {MODEL_PATH} '
   f'-p "Clarify in two sentences why 1-bit quantization saves reminiscence." '
   f'-n 128 -ngl {N_GPU_LAYERS} '
   f'--temp {GEN_PARAMS("temperature")} '
   f'--top-p {GEN_PARAMS("top_p")} --top-k {GEN_PARAMS("top_k")} '
   f'-no-cnv 2>/dev/null',
   examine=False,
)
print("=" * 70)
print("(5/7) Beginning llama-server (OpenAI-compatible API)")
print("=" * 70)
import requests
kv_flags = "-ctk q4_0 -ctv q4_0" if USE_KV_Q4 else ""
server_cmd = (
   f"{server_bin} -m {MODEL_PATH} "
   f"--host {SERVER_HOST} --port {SERVER_PORT} "
   f"-ngl {N_GPU_LAYERS} -c {CTX_SIZE} {kv_flags}"
)
print(f"$ {server_cmd}  (background)")
server_log = open(os.path.be a part of(WORK_DIR, "server.log"), "w")
server_proc = subprocess.Popen(server_cmd, shell=True,
                              stdout=server_log, stderr=server_log)
for _ in vary(120):
   attempt:
       if requests.get(f"{SERVER_URL}/well being", timeout=2).status_code == 200:
           print("Server is up.")
           break
   besides requests.exceptions.RequestException:
       move
   time.sleep(2)
else:
   server_proc.kill()
   sys.exit("Server failed to start out — examine /content material/server.log")

Wir führen einen Rauchtest über die Befehlszeile durch, um zu überprüfen, ob die kompilierte Laufzeit das quantisierte Modell laden und eine gültige Antwort generieren kann. Anschließend starten wir den Lama-Server mit vollständigem GPU-Layer-Offloading, dem ausgewählten Kontextfenster und optionalen quantisierten KV-Cache-Einstellungen. Wir fragen den Gesundheitsendpunkt wiederholt ab, bis der OpenAI-kompatible Inferenzdienst für Clientanfragen bereit ist.

print("=" * 70)
print("(6/7) Speaking to Bonsai-27B through the OpenAI-compatible API")
print("=" * 70)
def chat(messages, stream=False, max_tokens=512, **overrides):
   """Minimal OpenAI-compatible chat consumer for the native llama-server."""
   payload = {
       "mannequin": "bonsai-27b",
       "messages": messages,
       "max_tokens": max_tokens,
       "stream": stream,
       **GEN_PARAMS,
       **overrides,
   }
   if not stream:
       r = requests.submit(f"{SERVER_URL}/v1/chat/completions", json=payload)
       r.raise_for_status()
       return r.json()("selections")(0)("message")("content material")
   r = requests.submit(f"{SERVER_URL}/v1/chat/completions", json=payload, stream=True)
   r.raise_for_status()
   full = ()
   for line in r.iter_lines():
       if not line or not line.startswith(b"information: "):
           proceed
       chunk = line(len(b"information: "):)
       if chunk == b"(DONE)":
           break
       delta = json.hundreds(chunk)("selections")(0)("delta").get("content material", "")
       full.append(delta)
       print(delta, finish="", flush=True)
   print()
   return "".be a part of(full)
SYSTEM = {"function": "system", "content material": "You're a useful assistant"}
print("n--- 6a: fundamental completion ---")
reply = chat((SYSTEM, {"function": "consumer",
                       "content material": "What's the capital of France? One sentence."}))
print(reply)
print("n--- 6b: math reasoning, streamed token-by-token ---")
chat((SYSTEM, {"function": "consumer",
              "content material": "A prepare travels 120 km at 80 km/h, then 90 km at "
                         "60 km/h. What's its common velocity for the entire "
                         "journey? Present your reasoning briefly."}),
    stream=True, max_tokens=700)
print("n--- 6c: multi-turn chat ---")
historical past = (SYSTEM)
for user_msg in ("My identify is Priya and I like graph algorithms.",
                "Counsel one mission thought that mixes my curiosity with LLMs.",
                "What was my identify once more?"):
   historical past.append({"function": "consumer", "content material": user_msg})
   reply = chat(historical past, max_tokens=300)
   historical past.append({"function": "assistant", "content material": reply})
   print(f"nUSER: {user_msg}nBONSAI: {reply}")
print("n--- 6d: code era ---")
print(chat((SYSTEM, {"function": "consumer",
                    "content material": "Write a Python operate that returns the n-th "
                               "Fibonacci quantity utilizing memoization. Code solely."}),
          max_tokens=400))

Wir definieren einen wiederverwendbaren Python-Chat-Shopper, der OpenAI-kompatible Anfragen an den lokal gehosteten Bonsai-27B-Server sendet. Wir unterstützen sowohl Normal- als auch vom Server gesendete Ereignis-Streaming-Antworten unter Anwendung der konfigurierten Temperatur-, High-P- und High-Okay-Abtastparameter. Anschließend bewerten wir grundlegende sachliche Antworten, mathematisches Denken, mehrstufiges Konversationsgedächtnis und Python-Codegenerierung.

print("=" * 70)
print("(7/7) Non-compulsory extras")
print("=" * 70)
RUN_BENCHMARK = False
if RUN_BENCHMARK:
   sh(f"{bench_bin} -m {MODEL_PATH} -ngl {N_GPU_LAYERS}", examine=False)
print("""
NOTES & NEXT STEPS
------------------
* Lengthy context: the mannequin helps as much as 262K tokens. On Colab, increase
 CTX_SIZE and set USE_KV_Q4 = True (4-bit KV cache) — with it, 100K-token
 contexts slot in roughly 6.8 GB peak, properly inside a T4's 16 GB.
* Speculative decoding: the repo ships a DSpark drafter (Q4_1, ~1.79 GB)
 that provides a lossless ~1.37x decode speedup on CUDA. See the PrismML
 llama.cpp fork's README for the serving flags, and obtain the drafter
 pack from the identical HF repo if you wish to attempt it.
* Imaginative and prescient: an non-obligatory ~0.63 GB mmproj pack provides picture enter; it's only
 loaded when a picture arrives, so text-only serving by no means pays for it.
* High quality vs dimension: if you'd like extra headroom, the ternary sibling
 (prism-ml/Ternary-Bonsai-27B-gguf, ~5.9 GB, ~95% of FP16) is a drop-in
 swap — simply change HF_REPO / MODEL_FILE above.
* Shutting down: run  server_proc.kill()  in a later cell to free the GPU.
""")
print("Finished. The server remains to be operating — name chat((...)) from new cells!")

Wir stellen einen optionalen Benchmarking-Schalter zur Verfügung, der die Leistung der Eingabeaufforderungsverarbeitung und der Token-Generierung mit der kompilierten ausführbaren Datei „llama-bench“ misst. Wir prüfen erweiterte Bereitstellungsoptionen, einschließlich Lengthy-Context-Inferenz, 4-Bit-KV-Caching, spekulative Dekodierung, Imaginative and prescient-Unterstützung und eine ternäre Modellvariante mit höherer Kapazität. Wir beenden den Vorgang, während der Serverprozess aktiv bleibt, damit wir die Chat-Funktion weiterhin aus weiteren Colab-Zellen aufrufen können.

Zusammenfassend haben wir einen vollständigen lokalen Inferenz-Workflow für die Ausführung von Bonsai-27B eingerichtet. Wir haben die PrismML-Implementierung verwendet, um die Kompatibilität mit der hochkomprimierten 1,125-Bit-Gewichtungsdarstellung des Modells zu wahren und gleichzeitig den Zugriff auf die vollständige Inferenzpipeline sowohl über die Befehlszeile als auch über OpenAI-kompatible Schnittstellen sicherzustellen. Wir validierten Argumentation, Konversationsgedächtnis, Streaming-Generierung und Programmierfähigkeiten und behielten gleichzeitig die Kontrolle über Sampling-Parameter, Kontextlänge, GPU-Offloading und KV-Cache-Präzision. Dieses Setup bietet uns eine Plattform zum Experimentieren mit großen Low-Bit-Sprachmodellen, zum Bewerten ihrer Effizienz und Ausgabequalität und zum Integrieren dieser Modelle in Python-Anwendungen, ohne auf einen externen gehosteten Inferenzdienst angewiesen zu sein.

Schauen Sie sich das an Vollständiger Code hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 150k+ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Möchten Sie mit uns zusammenarbeiten, um Ihr GitHub-Repo ODER Ihre Hugging Face Web page ODER Produktveröffentlichung ODER Ihr Webinar usw. zu bewerben? Vernetzen Sie sich mit uns

Sana Hassan, Beratungspraktikantin bei Marktechpost und Twin-Diploma-Studentin am IIT Madras, ist leidenschaftlich daran interessiert, Technologie und KI zur Bewältigung realer Herausforderungen einzusetzen. Mit großem Interesse an der Lösung praktischer Probleme bringt er eine neue Perspektive in die Schnittstelle zwischen KI und realen Lösungen ein.

# Einführung

Qwythos-9B-Claude-Mythos-5-1M ist ein 9B-Argumentations- und Codierungsmodell, das auf Qwen3.5 basiert und für lokale Codierungsworkflows, Agentenentwicklung und Aufgaben mit langem Kontext entwickelt wurde. Das Interessante daran ist, dass es klein genug ist, um auf Client-{Hardware} ausgeführt zu werden, und dennoch leistungsfähig genug ist, um bei praktischen Codierungsaufgaben zu helfen.

In dieser Anleitung zeige ich Ihnen, wie Sie das Mythos-erweiterte Qwythos-Modell lokal ausführen können lama.cppdann verbinden Sie es mit Pi Sie können es additionally als lokalen Codierungsagenten verwenden. Ich verwende eine RTX 4070 Ti Tremendous mit 16 GB VRAM, wodurch ich die Q6_K MTP-Quantisierung bequem ausführen kann. Wenn Sie über eine 8-GB-GPU verfügen, empfehle ich, mit der Q4_K_M-Variante zu beginnen, da diese ein besseres Gleichgewicht zwischen Qualität, Geschwindigkeit und Speichernutzung bietet.

# llama.cpp installieren

Installieren Sie zunächst die offizielle Befehlszeilenschnittstelle (CLI) llama.cpp. Dadurch erhalten Sie Zugriff auf die llama Befehl, einschließlich llama servedie wir verwenden werden, um das Modell lokal auszuführen.

curl -LsSf https://llama.app/set up.sh | sh

Fügen Sie als Nächstes das Installationsverzeichnis zu Ihrem Shell-Pfad hinzu, damit Ihr Terminal es finden kann llama Befehl:

echo 'export PATH="$HOME/.native/bin:$PATH"' >> ~/.bashrc
supply ~/.bashrc

Um zu bestätigen, dass die Set up funktioniert hat, führen Sie Folgendes aus:

Wenn alles korrekt installiert ist, sollten Sie die verfügbaren Befehle und Optionen von llama.cpp sehen.

# Einrichten eines Hugging Face Cache-Verzeichnisses

Stellen Sie die ein Umarmendes Gesicht Speichern Sie den Cache an einem Ort mit ausreichend freiem Speicherplatz. Dies ist besonders nützlich auf Cloud-Maschinen, bei denen das Customary-Dwelling-Verzeichnis über begrenzten Speicherplatz verfügt.

export HF_HOME="/workspace/huggingface"
mkdir -p "$HF_HOME"

Um es über neue Terminalsitzungen hinweg beizubehalten, fügen Sie es Ihrer Shell-Konfiguration hinzu:

echo 'export HF_HOME="/workspace/huggingface"' >> ~/.bashrc
supply ~/.bashrc

# Starten des Qwythos MTP-Modells

Führen Sie das Q6_K MTP GGUF-Modell mit allen verfügbaren GPU-Schichten aus:

llama serve 
  -hf "empero-ai/Qwythos-9B-Claude-Mythos-5-1M-GGUF:MTP-Q6_K" 
  --alias "qwythos-9b-mtp" 
  --host 0.0.0.0 
  --port 8910 
  --n-gpu-layers all 
  --ctx-size 100000 
  --parallel 1 
  --batch-size 1024 
  --ubatch-size 512 
  --flash-attn on 
  --cache-type-k q8_0 
  --cache-type-v q8_0 
  --spec-type draft-mtp 
  --spec-draft-n-max 6 
  --threads 12 
  --threads-batch 24 
  --temp 0.6 
  --top-p 0.95 
  --top-k 20 
  --repeat-penalty 1.05 
  --jinja 
  --perf

Wenn Sie diesen Befehl zum ersten Mal ausführen, lädt llama.cpp die Modelldateien von Hugging Face herunter.

Danach wird das Modell in den GPU-Speicher geladen und ein lokaler Server gestartet.

Sobald das Modell ausgeführt wird, öffnen Sie die lokale Schnittstelle in Ihrem Browser:

Dadurch erhalten Sie auch einen OpenAI-kompatiblen lokalen API-Endpunkt unter:

Die Q6_K-Variante bietet eine bessere Ausgabequalität, verbraucht aber auch mehr Speicher. Wenn Sie auf VRAM- oder RAM-Probleme stoßen, reduzieren Sie diese --ctx-size Erste. Wenn das immer noch nicht reicht, probieren Sie stattdessen die Variante Q4_K_M.

Hier sind die wichtigsten Flags im Befehl:

Auf meiner RTX 4070 Ti Tremendous erreichte ich etwa 81,74 Token professional Sekunde. In meinem Take a look at warfare das Modell auch in der Lage, die Aufgabe zu durchdenken, die erforderlichen Instruments aufzurufen und den aktuellen Goldpreis zurückzugeben, wenn es im lokalen Agenten-Workflow verwendet wurde.

# Set up von Pi und der llama.cpp-Integration

Pi kann eine Verbindung zum lokalen llama.cpp-Server herstellen und das Modell als Codierungsagent verwenden. Der pi-llama Das Plugin wurde entwickelt, um Pi mit einem laufenden lokalen llama.cpp-Server zu verbinden, ohne dass ein externer API-Schlüssel erforderlich ist.

Pi installieren:

curl -fsSL https://pi.dev/set up.sh | sh

Installieren Sie das Plugin llama.cpp für Pi:

pi set up git:github.com/huggingface/pi-llama

Erstellen Sie ein kleines Testprojekt:

mkdir new-project
cd new-project

Standardmäßig sucht das Plugin nach llama.cpp auf Port 8080. In dieser Anleitung läuft unser lokaler Server auf Port 8910, daher müssen wir die richtige lokale API-Adresse festlegen, bevor wir Pi starten:

export LLAMA_BASE_URL="http://127.0.0.1:8910/v1"

Starten Sie nun Pi:

Geben Sie in Pi Folgendes ein:

Wählen Sie den lokalen Modellalias aus:

Das Modell sollte in Pi aufgelistet sein. Sobald Sie es ausgewählt haben, können Sie es als lokalen Codierungsagenten verwenden.

# Testen des Mythos-Enhanced Coding Mannequin mit Pi

Jetzt ist es an der Zeit, das lokale Modell an realen Codierungsaufgaben in Pi zu testen. Ich habe zwei einfache, aber praktische Aufgaben verwendet: ein Browserspiel und ein kleines Python-CLI-Software.

// Erstellen eines einfachen Browsergames

Beginnen Sie mit einer Eingabeaufforderung, die Pi auffordert, ein kleines Browserspiel namens „Beat the AI“ zu erstellen.

Erstellen Sie ein einfaches Browserspiel namens „Beat the AI“.

Der Spieler hat 30 Sekunden Zeit, um kurze Fragen zur Mustererkennung zu beantworten. Jede richtige Antwort erhöht die Punktzahl um eins. Zeigen Sie einen Countdown-Timer, eine Punkteanzeige, einen Fortschrittsbalken und einen Bildschirm mit den Endergebnissen an.

Anforderungen:
– Verwenden Sie nur HTML, CSS und Vanilla-JavaScript.
– Generieren Sie mindestens drei Arten von Fragen, z. B. Zahlenmuster, schnelle Mathematik und Wortlogik.
– Fügen Sie nach Spielende eine Neustart-Schaltfläche hinzu.
– Sorgen Sie dafür, dass sich die Benutzeroberfläche verspielt und elegant anfühlt.
– Halten Sie den gesamten Code leicht verständlich und vermeiden Sie unnötige Dateien.

Testen Sie das Spiel im Browser, bevor Sie es beenden.

In meinem Take a look at hat Pi das vollständige Spiel in einer einzigen HTML-Datei mit eingebettetem CSS und JavaScript erstellt, wodurch das Projekt einfach und leicht zu überprüfen bleibt.

Pi fasste dann zusammen, was es erstellt hat, einschließlich des 30-Sekunden-Countdowns, der Punkteverfolgung, des Fortschrittsbalkens, der Fragetypen und der Neustart-Schaltfläche.

Danach habe ich das Spiel im Browser geöffnet, um zu überprüfen, ob es richtig funktioniert.

Das Ergebnis warfare ein ausgefeiltes kleines Spiel mit:

• Ein Countdown-Timer
• Eine Punkteanzeige
• Ein Fortschrittsbalken
• Mehrere Fragetypen
• Ein Neustartablauf nach Spielende

Dies ist ein gutes Beispiel dafür, wie das Modell eine komplette Entrance-Finish-Aufgabe lokal bewältigen kann, ohne dass eine externe API erforderlich ist.

// Erstellen einer CSV-zu-Excel-Python-CLI

Bitten Sie Pi für den zweiten Take a look at, eine kleine Python-CLI zu erstellen, die eine CSV-Datei in eine Excel-Datei konvertiert .xlsx Datei.

Erstellen Sie eine einfache Python-CLI, die eine CSV-Datei in eine Excel-XLSX-Datei konvertiert, Eingabe- und Ausgabedateipfade als Argumente akzeptiert, Spaltenüberschriften beibehält, fehlende Dateien validiert und klare Erfolgs- oder Fehlermeldungen ausgibt. Bevor Sie fertig sind, erstellen Sie eine kleine Dummy-CSV-Datei mit Beispieldaten, testen Sie damit die CLI, überprüfen Sie, ob die Excel-Datei korrekt erstellt wurde, und fassen Sie dann das Testergebnis zusammen.

Pi hat ein Python-Skript mit dem Namen erstellt csv2excel.pygenerierte eine Beispiel-CSV-Datei, führte den Testbefehl aus und fasste dann die Ergebnisse zusammen.

python csv2excel.py sample_data.csv output.xlsx

In meinem Durchlauf zeigte die Zusammenfassung, dass das Skript:

• Akzeptierte Eingabe- und Ausgabedateipfade.
• Die Spaltenüberschriften wurden beibehalten.
• Die Beispieldaten wurden korrekt konvertiert.
• Fehlende Dateien wurden mit eindeutigen Fehlermeldungen behandelt.
• Fehlende Ausgabepfade wurden ordnungsgemäß behandelt.

Ich habe auch die generierte Excel-Datei geöffnet, um zu bestätigen, dass die Ausgabe korrekt warfare.

In der Beispielausgabe wurden die Zeilen und Header korrekt beibehalten, was bestätigte, dass die CLI wie erwartet funktionierte.

# Letzte Gedanken

Ich magazine dieses kleine lokale Codierungsmodell wirklich. Es ist schnell, genau genug für alltägliche Codierungsaufgaben und benötigt nicht viel VRAM, um nützlich zu sein. Sie können es mit Pi verwenden, Claude Code, OpenCodeoder ein beliebiges Codierungssetup, das lokale OpenAI-kompatible oder Anthropic-kompatible Endpunkte unterstützt.

Für einfache Entrance-Finish-Apps, Python-Skripte, CLI-Instruments und schnelle Prototypen funktioniert es überraschend intestine. Sie können nützliche Projekte lokal erstellen, ohne auf externe APIs angewiesen zu sein oder für jede Anfrage zu bezahlen.

Um noch bessere Ergebnisse zu erzielen, empfehle ich dringend, Fähigkeiten zur Websuche hinzuzufügen. Kontext7und andere nützliche Pi-Integrationen. Sie können sich hier auch meinen vollständigen Leitfaden zur Optimierung Ihres Pi-Coding-Agent-Setups ansehen: So richten Sie Kimi K2.7-Code mit Pi ein: Die ultimative KI-Codierungsumgebung.

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.