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.

Anthropic hat in einer Woche zwei Updates veröffentlicht, und keine der beiden Geschichten hört beim Modell selbst auf. In einer Geschichte geht es darum, wie weit eine Regierung gehen wird, um Grenz-KI zu kontrollieren, bevor sie die Benutzer erreicht. Beim anderen geht es darum, wie günstig Agenten-KI werden muss, bevor sie zur routinemäßigen Geschäftsinfrastruktur wird. Ein dritter Thread verläuft unter den ersten beiden: Wo ein Unternehmen auf der Landkarte steht, bestimmt nun, welche Anthropic-Modelle es überhaupt in Produktion bringen kann.

Fable 5 kehrt nach einem Regierungsverbot zurück

Anthropic brachte Claude Fable 5 und Claude Mythos 5 am 9. Juni 2026 auf den Markt. Fable 5 und Mythos 5 liegen in der Leistungsfähigkeit über der Opus-Stufe, eine Kategorie, die Anthropic als „Mythos-Klasse“ bezeichnet. Fable 5 ist die Model für den allgemeinen Gebrauch, die mit umfassenden Sicherheitsvorkehrungen ausgestattet ist. Mythos 5 ist das gleiche zugrunde liegende Modell mit weniger Leitplanken und auf geprüfte Cyber-Verteidigungspartner im Rahmen von Venture Glasswing, dem Regierungskooperationsprogramm von Anthropic, beschränkt. Anthropic hat den Preis für die beiden Modelle auf 10 US-Greenback professional Million Enter-Tokens und 50 US-Greenback professional Million Output-Tokens festgelegt.

Am 12. Juni führte das US-Handelsministerium Exportkontrollen für Fable 5 und Mythos 5 ein und wies Anthropic an, den Zugang für Ausländer zu sperren. Anthropic sagte, es verfüge über keine zuverlässige Möglichkeit, die Nationalität in Echtzeit zu überprüfen, und habe daher den Zugriff auf Fable 5 und Mythos 5 für jeden Benutzer weltweit gesperrt, anstatt das Risiko einzugehen, gegen die Anordnung zu verstoßen.

Was hat das Verbot ausgelöst?

Auslöser struggle ein Bericht von Amazon-Forschern, die eine Eingabeaufforderungsmethode gefunden hatten, die Fable 5 dazu brachte, Software program-Schwachstellen zu identifizieren. In einem Fall erzeugte das Modell Code, der demonstrierte, wie man eine davon ausnutzt. Anthropic testete später andere Modelle anhand desselben Berichts und stellte etwas Bemerkenswertes fest: Schwächere, bereits öffentliche Systeme, darunter Opus 4.8, GPT-5.5 und Kimi K2.7, konnten dieselben Schwachstellen identifizieren. Jedes von Anthropic getestete Modell, einschließlich Sonnet 4.6 und sogar Haiku 4.5, konnte die Exploit-Demonstration ebenfalls reproduzieren. Das Argument von Anthropic: Das gemeldete Verhalten befand sich in einer vorsichtigen Grauzone, die die Sicherheitsmaßnahmen abfangen sollten, und nicht in einer Fähigkeit, die nur dem leistungsstärksten Modell vorbehalten ist.

Was sich vor der Aufhebung des Verbots änderte

Anthropic hat einen neuen Sicherheitsklassifikator entwickelt, der die spezifische Bypass-Technik in mehr als 99 % der Fälle blockiert. Gutachter des Middle for AI Requirements and Innovation des Handelsministeriums testeten das Replace und bezeichneten die daraus resultierenden Sicherheitsmaßnahmen laut Anthropic als außerordentlich stark. Am 26. Juni wurde der Zugang zu Mythos 5 für eine Reihe von US-Organisationen wiederhergestellt. Am 30. Juni hob Commerce die Exportkontrollen vollständig auf, und Anthropic erklärte, dass es keine Exportlizenz mehr benötige, als Gegenleistung für die Verpflichtung, Sicherheitsrisiken proaktiv zu kennzeichnen und Bedrohungsinformationen mit Regierungspartnern zu teilen.

Fable 5 ist seit dem 1. Juli wieder für globale Benutzer verfügbar. In den Professional-, Max-, Crew- und ausgewählten Enterprise-Plänen ist es bis zur Hälfte der wöchentlichen Nutzungslimits bis zum 7. Juli enthalten. Danach läuft der Zugriff auf Nutzungsguthaben.

Ein gemeinsames Branchen-Framework

Der größere Schritt liegt dem Relaunch zugrunde. Anthropic, Amazon, Microsoft, Google und andere Glasswing-Companion entwerfen ein gemeinsames Framework, um den Schweregrad von KI-Jailbreaks anhand von vier Kriterien zu bewerten: wie viel Leistungsfähigkeit ein Bypass gewährt, wie viele Angriffstypen er abdeckt, wie einfach er als Waffe eingesetzt werden kann und wie leicht er zu entdecken ist. Das Modell lehnt sich direkt an das Widespread Vulnerability Scoring System der Softwareindustrie an. Anthropic verpflichtete sich außerdem, der Regierung vor der Veröffentlichung Zugang zu zukünftigen Grenzmodellen und dedizierter Rechenleistung für unabhängige Exams zu gewähren, als Teil einer umfassenderen Reaktion auf eine Durchführungsverordnung vom 2. Juni zur KI-Sicherheit.

Meine Meinung: Die Decision stellt das erste Mal dar, dass das Exportkontrollgesetz auf das Verhalten eines bestimmten KI-Modells und nicht auf die ihm zugrunde liegenden Chips einwirkt, und sie weist Washington eine formelle Rolle bei der künftigen Auslieferung seiner leistungsfähigsten Systeme durch Anthropic zu. Unternehmen, die auf der Frontier-Ebene von Anthropic aufbauen, sollten die staatliche Überprüfung jetzt als festen Bestandteil des Veröffentlichungszyklus und nicht als einmalige Unterbrechung betrachten.

Sonnet 5 Preise Agenten wie eine Ware

Die zweite Markteinführung läuft in die entgegengesetzte Richtung: Preis sinkt, Beschränkungen steigen nicht. Claude Sonnet 5 wurde am 30. Juni als Standardmodell für Free- und Professional-Benutzer ausgeliefert und für Max, Crew, Enterprise, Claude Code und die API eingeführt. Anthropic hat den Preis bis zum 31. August 2026 auf 2 US-Greenback professional Million Enter-Tokens und 10 US-Greenback professional Million Output-Tokens festgesetzt und steigt auf 3 US-Greenback bzw. 15 US-Greenback, sobald das Einführungsfenster geschlossen wird. Der Preis übertrifft den Preis von 5 $/25 $ für Opus 4.8 und übertrifft auch OpenAIs GPT-5.5 und Googles Gemini 3.1 Professional, obwohl Googles Gemini 3.5 Flash immer noch weniger kostet.

Die Zahlen

Bei einem von TechCrunch zitierten Agenten-Codierungs-Benchmark erreichte Sonnet 5 63,2 Prozent gegenüber 58,1 Prozent bei Sonnet 4.6 und 69,2 Prozent bei Opus 4.8. Laut Anthropic übertrifft Sonnet 5 Opus 4.8 bei einem separaten Wissensarbeits-Benchmark leicht und schließt in den vier Monaten seit der Auslieferung von Sonnet 4.6 im Februar den größten Teil der Lücke zu seinem Flaggschiffmodell. Die technische Dokumentation von Anthropic bestätigt, dass Sonnet 5 standardmäßig mit einem 1-Millionen-Token-Kontextfenster, einer echten Kapazitätssteigerung gegenüber Sonnet 4.6 und adaptivem Denken ausgeliefert wird, das die Argumentationstiefe automatisch anpasst, es sei denn, ein Entwickler legt einen festen Aufwand fest.

Die Preisgestaltung bringt einen Haken mit sich, den es wert ist, überprüft zu werden, bevor irgendjemand darüber nachdenkt. Sonnet 5 läuft auf einem aktualisierten Tokenizer, der gleichen Änderung, die Anthropic mit Opus 4.7 eingeführt hat, und die gleiche Eingabe kann jetzt je nach Inhaltstyp 1,0- bis 1,35-mal mehr Token zugeordnet werden. Anthropic gibt an, den Einführungspreis so festgelegt zu haben, dass der Übergang annähernd kostenneutral ist. Der tatsächliche Rabatt hängt additionally von der Arbeitsbelastung jedes Käufers ab und nicht nur vom Aufkleberpreis.

Das Wettbewerbsfeld

Der Begin landet auch innerhalb eines breiteren Musters, obwohl die Kind des Musters einer Korrektur bedarf. OpenAI gab in der Woche zuvor eine Vorschau auf GPT-5.6, aufgeteilt in drei Preisstufen: Sol, ein Flaggschiffmodell mit 5/30 US-Greenback professional Million Token; Terra, eine Choice mit mittleren Kosten, die mit 2,50 $/15 $ als praktischer Customary angeboten wird; und Luna, eine schnelle, günstige Stufe für 1 $/6 $. Keiner der drei erreichte ChatGPT. OpenAI hat die Vorschau nur über die API und den Codex an vertrauenswürdige Companion weitergegeben, eine engere Einführung als die Erstveröffentlichung von Sonnet 5 für alle kostenpflichtigen und kostenlosen Claude-Benutzer. Googles Gemini 3.5 Flash, das im Mai auf den Markt kam, hat sich von einer Gesprächspräsentation zu einer Agentenpräsentation entwickelt. Drei Labore verwenden derzeit das gleiche Spielbuch: Teilen Sie die Funktionalität in Preisstufen auf und lassen Sie Agentic Reasoning zur Basisfunktion und nicht zur Premiumfunktion werden. Daniel Shepard, ein leitender Ingenieur bei Zapier, beschrieb, wie man Sonnet 5 eine zweiteilige Aufgabe übergab: die Aktualisierung der Salesforce-Kontostufen und das Versenden einer Startankündigung an Unternehmenskontakte. Die Arbeit wurde von Ende zu Ende abgeschlossen, während frühere Modelle auf halbem Weg ins Stocken gerieten.

Was die Sicherheit anbelangt, halluziniert Sonnet 5 weniger als Sonnet 4.6 und widersteht den Entführungen durch sofortige Injektion besser, so die Bewertungen von Anthropic. Es zeigt auch eine weitaus schwächere Cybersicherheitsfähigkeit als die Modelle der Opus- und Mythos-Klasse von Anthropic und erzeugte während des Exams nie einen funktionierenden Exploit für eine gepatchte Firefox-Schwachstelle. Anthropic liefert es mit den gleichen Cyber-Schutzmaßnahmen wie Opus 4.7 und 4.8, die jedoch weniger streng festgelegt sind als die Leitplanken zum Schutz von Fable 5.

Wo sich die Zugriffsfrage wiederholt

Bringen Sie die beiden Begins in eine Reihe und die Strategie von Anthropic wird klarer. Einerseits treibt Sonnet 5 den Preis für Agentenarbeit für alltägliche Geschäftsaufgaben gegen Null. Auf der anderen Seite stehen Fable 5 und Mythos 5 hoch im Kurs, da sie in ausreichend staatlich überprüfte Schutzmaßnahmen eingebunden sind, und ein Exportkontrollstreit wurde durch eine Klassifizierungsaktualisierung und nicht durch eine dauerhafte Abschaltung beigelegt.

Die Gießereilücke in Europa

Die Zugangsfrage endete nicht bei Washington. Claude-Modelle, darunter Sonnet 5, wurden am 1. Juli auf Microsoft Foundry allgemein verfügbar und bieten Azure-Kunden native Abrechnung, Entra-ID-Authentifizierung und Governance innerhalb einer bestehenden Azure-Umgebung. Für Unternehmen, die bereits durch Beschaffungsregeln blockiert sind, ist die Entsperrung actual: Das bereits durch Azure-Verbrauchsvereinbarungen gebundene Finances deckt jetzt die Claude-Nutzung ab, ohne dass eine neue Lieferantenbeziehung eröffnet werden muss.

Laut Berichten von InfoQ beschreiben europäische Praktiker eine andere Erfahrung. Anthropic bleibt der Datenverarbeiter für von Foundry gehostete Claude-Modelle, unabhängig von der Internet hosting-Choice, gemäß der Dokumentation von Microsoft, und für Claude gibt es derzeit keine europäische Datenzone auf Foundry. Ein Praktiker, der mit einer niederländischen Financial institution zusammenarbeitet, sagte, der Kunde werde Anthropic-Modelle nicht über Foundry genehmigen, und verwies auf die gleiche Datenresidenzlücke. Auf der regionalen Compliance-Seite von Anthropic wird die europäische Verfügbarkeit von Foundry für später im Jahr 2026 angegeben, ohne dass ein festes Datum angegeben wird.

Wenn man die Geschichte der Exportkontrolle und die Foundry-Lücke nebeneinander betrachtet, zeigt sich das gleiche Muster in zwei unterschiedlichen Maßstäben. Achtzehn Tage lang entschied Washington, welche Nutzer weltweit Fable 5 überhaupt erreichen konnten. Die fehlende europäische Datenzone entscheidet nun darüber, welche europäischen Unternehmen Sonnet 5 unabhängig vom Finances in ihrer bevorzugten Cloud in Produktion bringen können. Keine der beiden Einschränkungen hat viel mit dem Preis oder den Benchmark-Ergebnissen zu tun, dennoch steht jede einzelne jetzt direkt auf der Checkliste für die Sorgfaltspflicht eines Käufers.

Was das für Käufer bedeutet

Für einen Geschäftskäufer struggle die Modellwahl keine reine Kosten- und Leistungsentscheidung mehr, als Regierungen und Cloud-Gerichtsbarkeiten begannen, den Zugang so zu gestalten, wie es einst Chip-Exportlizenzen taten. Bei einer Anbieterbewertung muss nun gefragt werden, welche Regierungsbeziehung hinter dem Grenzprodukt steht und welche Regionen der Anbieter tatsächlich bedienen kann, und nicht, welche auf einer Preisseite erscheinen. Anthropic beantwortete die erste Frage schnell: Achtzehn Tage von der Suspendierung bis zum vollständigen Relaunch. Die zweite Frage wurde noch nicht beantwortet: Es gibt kein festes Datum für eine europäische Datenzone für Foundry.

Erwarten Sie, dass sich das Muster wiederholt und dass es sich eher ausdehnt als schließt. Da Grenzmodelle immer tiefer in die Cybersicherheit und Biologie vordringen, werden Regierungen wahrscheinlich weiterhin einzelne Freisetzungen als Sicherheitsentscheidungen von Fall zu Fall und nicht als feste Regulierungskategorie behandeln und die Möglichkeit haben, den Zugriff über Nacht zu unterbrechen. Da Cloud-Plattformen weiterhin KI-Anbieter zu Marktbedingungen statt zur nativen Integration hinzufügen, werden Käufer in regulierten Branchen weiterhin auf die gleiche Hürde stoßen, auf die niederländische Financial institution- und Unternehmenspraktiker in diesem Monat stoßen. Anthropic hat die US-Runde schnell gemeistert. Der europäische ist noch offen.

Wenn es um KI-Computing geht, sind die großen Cloud-Plattform-Anbieter Chip-agnostisch und übernehmen Prozessoren der großen Chip-Unternehmen (hauptsächlich NVIDIA) zusammen mit ihren eigenen maßgeschneiderten GPUs, die als ASICS bezeichnet werden. OpenAI übernimmt diese Strategie nun mit aller Macht.

OpenAI hat nicht nur riesige GPU-Offers abgeschlossen mit NVIDIA und AMD In den letzten Wochen arbeitet das Unternehmen nun mit Broadcom an der Entwicklung eigener KI-Rechnerprozessoren. Die beiden Unternehmen kündigten eine Zusammenarbeit für 10 Gigawatt kundenspezifischer KI-Beschleuniger an.

OpenAI wird die Beschleuniger und Systeme entwerfen, die in Zusammenarbeit mit Broadcom entwickelt und eingesetzt werden. OpenAI sagte, dass OpenAI durch die Entwicklung seiner eigenen Chips und Systeme das, was es aus der Entwicklung von Grenzmodellen und -produkten gelernt hat, direkt in die {Hardware} einbetten kann, um „neue Ebenen an Leistungsfähigkeit und Intelligenz freizusetzen“.

Die mit Ethernet und anderen Konnektivitätslösungen von Broadcom skalierten Racks sollen der steigenden Nachfrage nach KI gerecht werden und werden in den Einrichtungen und Partnerrechenzentren von OpenAI eingesetzt.

AWS ist ein beliebter Cloud -Anbieter, der die Bereitstellung und Skalierung großer Anwendungen ermöglicht. Das Mastering mindestens eine Cloud -Plattform ist eine wesentliche Fähigkeit für Software program -Ingenieure und Datenwissenschaftler. Das lokale Ausführen einer Anwendung reicht nicht aus, um sie in der Produktion verwendbar zu machen. Sie muss auf einem Server bereitgestellt werden, um den Endbenutzern zugänglich zu machen.

In diesem Tutorial werden wir ein Beispiel für die Bereitstellung einer Fastapi -Anwendung durchlaufen. Während sich das Beispiel auf die Kern -EC2 -Netzwerkkonzepte konzentriert, sind die Prinzipien im Großen und Ganzen auch für andere Arten von Anwendungen anwendbar.

Bitte beachten Sie, dass dieses Tutorial keine Finest Practices für die Verwendung von AWS abdeckt. Stattdessen ist es das Ziel, den Lesern eine praktische Einführung in die Anwendungsbereitstellung mithilfe von EC2-Instanzen zu geben.

# 01. Instanzkreation

Navigieren zum EC2 Dashboard im AWS -Dienstmenü und wählen Sie eine neue Instanz. Dadurch wird eine Seite geöffnet, auf der wir Instanzparameter definieren können.

Wählen Sie den entsprechenden Instanztyp aus. In diesem Tutorial starten wir einen sehr einfachen Server mit minimalen technischen Anforderungen so. t3.nano sollte für unsere Bedürfnisse ausreichen.

Für seine Container verwendet AWS die SSH -Authentifizierung. Beim Erstellen einer neuen Instanz ist es erforderlich, ein neues Schlüsselpaar zu erstellen, mit dem wir uns mit dem SSH -Protokoll von der lokalen Maschine anmelden können. Klicken Sie auf Erstellen Sie neues Schlüsselpaar.

Weisen Sie dem neuen Schlüssel einen Namen zu. Wir werden hier nicht in die möglichen Optionen eintauchen, daher wählen wir RSA als Schlüsselpaartyp und .pem als personal Schlüsseldateiformat.

Um Zeit zu sparen, werden wir uns in unserer Demonstrationsanwendung nicht um Sicherheit sorgen. Für die Netzwerkeinstellungen ticken Sie alle Kontrollkästchen, die SSH-, HTTP- und HTTPS -Datenverkehr entsprechen.

Großartig! Durch Klicken StartinstanzAWS wird eine neue Instanz erstellen.

Nachdem die Instanz erstellt wurde, a .Pem Die Datei wird in Ihren lokalen Pc heruntergeladen. Diese Datei enthält den privaten Schlüssel, der die SSH -Authentifizierung ermöglicht. Speichern Sie diese Datei als gute Praxis an einem sicheren Ort, da AWS keine Möglichkeit bietet, sie wiederherzustellen, wenn sie verloren geht.

Durch das Öffnen des EC2 -Dashboards werden Sie feststellen, dass die erstellte Instanz über eine zugehörige IP -Adresse verfügt. Diese IP wird unter dem Etikett angezeigt „Öffentliche IPv4 -Adresse“. Zum Beispiel ist es im Bild unten, es ist es „16.16.202.153“. Sobald wir unsere Anwendung bereitstellen, ist sie mit dieser IP -Adresse aus einem Browser zugegriffen.

# 02. SSH -Verbindung

AWS bietet verschiedene Möglichkeiten zur Authentifizierung. In unserem Fall werden wir den SSH -Mechanismus verwenden.

Klicken Sie im Instanzmenü, klicken Sie auf Verbinden und auswählen SSH -Kunde von der oberen Bar.

Öffnen Sie das lokale Terminal und kopieren und führen Sie den Befehl 3 kopieren und ausführen.chmod 400 "<key_name>.pem") zusammen mit dem unter dem angezeigten Befehl „Beispiel“ Etikett. Stellen Sie sicher, dass Ihr aktuelles Terminalverzeichnis dem Ort entspricht, an dem die .Pem Der Schlüssel wurde im vorherigen Schritt heruntergeladen.

Während der SSH -Verbindung kann das Terminal dazu auffordern, weiterzumachen. Wenn dies der Fall ist, geben Sie ein „Ja“.

Zu diesem Zeitpunkt sind wir erfolgreich vom lokalen Terminal mit der EC2 -Instanz verbunden. Alle in das Terminal eingegebenen Befehle werden nun direkt im EC2 -Container ausgeführt.

# 03. Umgebungskonfiguration

Nach der Verbindung zur Instanz vom lokalen Terminal besteht der nächste Schritt darin, den Paketmanager zu aktualisieren und Python zusammen mit Nginx zu installieren.

sudo apt-get replace
sudo apt set up -y python3-pip nginx

Um den Verkehr zu unserer Anwendung umzuleiten, müssen wir eine Nginx -Konfigurationsdatei erstellen. Diese Datei sollte im Verzeichnis platziert werden /and so forth/nginx/sites-enabled/ und kann einen benutzerdefinierten Namen haben. Wir werden die folgende Konfiguration hinzufügen:

server {
  hear 80;
  server_name <Public_IP_Address>;
  location / {
    proxy_pass http://127.0.0.1:8000;
  }
}

Grundsätzlich geben wir an, dass eine externe Anfrage, die an die IP -Adresse der EC2 -Instanz an der Standardport 80 gesendet wurde http://127.0.0.1:8000. Zur Erinnerung ist dies die Commonplace -HTTP -Adresse und die von Fastapi zugewiesene Port.

Um diese Änderungen anzuwenden, müssen wir Nginx neu starten:

sudo service nginx restart

Wenn wir einen Fastapi -Server haben, den wir starten möchten, wäre es am einfachsten, ihn auf Github zu veröffentlichen und das Repository in die EC2 -Instanz zu klonen.

git clone <GitHub_URL> <listing>
cd <listing>

Erstellen und aktivieren Sie eine virtuelle Umgebung:

python3 -m venv venv
supply venv/bin/activate

Installieren Sie die erforderlichen Python -Anforderungen (vorausgesetzt, das geklonte Repository enthält a Anforderungen.txt Datei):

pip3 set up -r necessities.txt

Führen Sie den Server aus:

python3 -m uvicorn <server_filename>:app

Öffnen Sie den Browser und geben Sie die IP -Adresse der Instanz ein.

Stellen Sie sicher, dass Sie das HTTP -Protokoll (nicht HTTPS) verwenden. Zum Beispiel: <a href="http://16.16.202.153/" rel="noreferrer noopener" goal="_blank">http://16.16.202.153</a>. Die Firewall kann Ihre Verbindung blockieren, aber Sie sollten die Webseite öffnen. Hinzufügen /docs Nach der URL, um eine schnelle API zu öffnen, Prahlerei.

Übung

Wenn Sie ein Fastapi -Beispiel ausführen möchten, können Sie ein einfaches Repository erstellen, das aus nur einem besteht primary.py Datei und a Anforderungen.txt.

primary.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hi there, World!"}

Anforderungen.txt

fastapi
uvicorn

Dateien hochladen

Wenn Sie versuchen, eine Datei auf einen Server hochzuladen und einen 413 -Standing mit der Fehlermeldung zu erhalten „Fehler: Anfrage Entität zu groß“Dies ist wahrscheinlich, weil Nginx eine Grenze für die maximale Dateigröße hat, die hochgeladen werden kann. Um dieses Downside zu beheben, gehen Sie zur Nginx -Konfigurationsdatei und geben Sie die maximal zulässige Dateigröße an, indem Sie die verwenden client_max_body_size Richtlinie (das Einstellen auf 0 gibt keine Grenzen für Eingabedateigrößen an):

server {
  hear 80;
  server_name <PUBLIC_IP_ADDRESS>;
  location / {
    proxy_pass http://127.0.0.1:8000;
    client_max_body_size 0;
  }
}

Vergessen Sie nach dem Ändern der Konfigurationsdatei nicht, Nginx neu zu starten.

Abschluss

In diesem Artikel haben wir gelernt, wie man schnell eine laufende EC2 -Instanz mit einem Fastapi -Server erstellt. Obwohl wir nicht den besten Bereitstellungs- und Sicherheitspraktiken befolgt haben, warfare das Hauptziel des Artikels, Anfängern nur minimale Informationen bereitzustellen, um ihren ersten Server auf AWS zu starten.

Der nächste logische Schritt in der AWS -Studien -Roadmap besteht darin, mehrere EC2 -Instanzen zu erstellen und sie miteinander zu verbinden.

Alle Bilder, sofern nicht anders angegeben, werden vom Autor angegeben.

Verbinde mich mit mir

Bild vom Autor

Unter Modellbereitstellung versteht man den Prozess, bei dem trainierte Modelle in praktische Anwendungen integriert werden. Dazu gehört die Definition der erforderlichen Umgebung, die Festlegung, wie Eingabedaten in das Modell eingeführt werden und welche Ausgabe erzeugt wird, sowie die Fähigkeit, neue Daten zu analysieren und relevante Vorhersagen oder Kategorisierungen bereitzustellen. Lassen Sie uns den Prozess der Bereitstellung von Modellen in der Produktion untersuchen.

Schritt 1: Datenvorverarbeitung

Behandeln Sie fehlende Werte, indem Sie sie mit Mittelwerten ersetzen oder die Zeilen/Spalten löschen. Stellen Sie sicher, dass kategoriale Variablen ebenfalls durch One-Scorching-Encoding oder Label-Encoding von qualitativen in quantitative Daten umgewandelt werden. Normalisieren und standardisieren Sie numerische Merkmale, um sie auf eine gemeinsame Skala zu bringen.

import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, StandardScaler, MinMaxScaler

# Load your information
df = pd.read_csv('your_data.csv')

# Deal with lacking values
imputer_mean = SimpleImputer(technique='imply')
df('numeric_column') = imputer_mean.fit_transform(df(('numeric_column')))

# Encode categorical variables
one_hot_encoder = OneHotEncoder()
encoded_features = one_hot_encoder.fit_transform(df(('categorical_column'))).toarray()
encoded_df = pd.DataFrame(encoded_features, columns=one_hot_encoder.get_feature_names_out(('categorical_column')))

# Normalize and standardize numerical options
# Standardization (zero imply, unit variance)
scaler = StandardScaler()
df('standardized_column') = scaler.fit_transform(df(('numeric_column')))

# Normalization (scaling to a spread of (0, 1))
normalizer = MinMaxScaler()
df('normalized_column') = normalizer.fit_transform(df(('numeric_column')))

Schritt 2: Modelltraining und -bewertung

Teilen Sie die Daten in zwei Gruppen auf: Trainingsdatensatz und Testdatensatz, um das Modell zu trainieren. Wählen Sie ein Modell aus und trainieren Sie es mit den verwendeten Daten. Durch die Feinabstimmung der Hyperparameter werden die leistungsstärksten Modelle für maschinelles Lernen ausgewählt. Das Modell wird mit verschiedenen Untergruppen der Daten auf seine Stabilität geprüft, um eine Kreuzvalidierung durchzuführen.

import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, StandardScaler, MinMaxScaler

# Load your information
df = pd.read_csv('information.csv')

# Cut up information into coaching and testing units
X = df.drop(columns=('target_column'))
y = df('target_column')

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Hyperparameter tuning
param_grid = {
    'n_estimators': (50, 100, 200),
    'max_depth': (None, 10, 20, 30),
    'min_samples_split': (2, 5, 10)
}

grid_search = GridSearchCV(estimator=RandomForestClassifier(random_state=42),
                           param_grid=param_grid,
                           cv=5,
                           scoring='accuracy',
                           n_jobs=-1)

# Match the grid search to the info
grid_search.match(X_train, y_train)

# Get the perfect mannequin from the grid search
best_model = grid_search.best_estimator_

# Cross-validation to evaluate mannequin generalization and robustness
cv_scores = cross_val_score(best_model, X_train, y_train, cv=5, scoring='accuracy')

print(f"Cross-validation scores: {cv_scores}")
print(f"Imply cross-validation rating: {cv_scores.imply()}")

Schritt 3: Modellverpackung

Quelle: https://data.dataiku.com/newest/mlops-o16n/structure/concept-model-packaging.html

Serialisieren Sie den Code in ein geeigneteres Format, das gespeichert oder an das andere System verteilt werden kann. Pickle ist eines der herkömmlichen Formate, gefolgt von den Formaten Joblib und ONNX, je nach den Anforderungen des Benutzers. Nachdem Sie Ihr Modell definiert und optimiert haben, speichern Sie es in einer Datei oder Datenbank. Plattformen wie Git sind auch praktisch, um die vorzunehmenden Änderungen und Modifikationen zu handhaben. Wenden Sie spezielle Maßnahmen wie die Verschlüsselung von Daten sowohl während der Speicherung als auch während der Übertragung an, damit die Daten für niemanden leicht zugänglich sind.

import joblib

joblib.dump(mannequin, 'mannequin.pkl')

Legen Sie Ihr serialisiertes Modell in einen Container wie Docker. Dadurch wird es portierbar und der Transport von Machine-Studying-Modellen in verschiedene Umgebungen wird einfacher.

# Docker code
FROM python:3.8-slim
COPY mannequin.pkl /app/mannequin.pkl
COPY app.py /app/app.py
WORKDIR /app
RUN pip set up -r necessities.txt
CMD ("python", "app.py")

Schritt 4: Einrichten der Umgebung für die Bereitstellung

Um Infrastruktur und Ressourcen für die Modellbereitstellung einzurichten, wird empfohlen, Cloud-Dienste wie AWS, Azure oder Google Cloud zu verwenden. Ändern Sie die erforderlichen Komponenten, die zum Hosten des Modells erforderlich sind, wie Server, Datenbanken und all das kann auf den richtigen Cloud-Infrastrukturdiensten der ausgewählten Cloud-Plattform erfolgen.

AWS: EC2-Instanz mit AWS CLI einrichten

aws ec2 run-instances 
    --image-id ami-0abcdef1234567890 
    --count 1 
    --instance-type t2.micro 
    --key-name MyKeyPair 
    --security-group-ids sg-0abcdef1234567890 
    --subnet-id subnet-0abcdef1234567890

Azurblau: Virtuelle Maschine mit Azure CLI einrichten

az vm create 
  --resource-group myResourceGroup 
  --name myVM 
  --image UbuntuLTS 
  --admin-username azureuser 
  --generate-ssh-keys

Google Cloud: Compute Engine-Instanz mit Google Cloud CLI einrichten

gcloud compute cases create my-instance 
  --zone=us-central1-a 
  --machine-type=e2-medium 
  --subnet=default 
  --network-tier=PREMIUM 
  --maintenance-policy=MIGRATE 
  --image=debian-9-stretch-v20200902 
  --image-project=debian-cloud 
  --boot-disk-size=10GB 
  --boot-disk-type=pd-standard 
  --boot-disk-device-name=my-instance

Schritt 5: Erstellen der Bereitstellungspipeline

Verwenden Sie beispielsweise Jenkins oder GitLab CI/CD, um den Schritt der Bereitstellung des Modells zu automatisieren. Entwerfen Sie eine Liste der auszuführenden Schritte, um den Bereitstellungsprozess effizienter zu gestalten, und verwenden Sie im Kontext von GitHub Actions eine Jenkinsfile- oder YAML-Konfiguration.

# Utilizing Jenkins for CI/CD pipeline
pipeline {
  agent any
  levels {
    stage('Construct') {
      steps {
        sh 'python setup.py construct'
      }
    }
    stage('Check') {
      steps {
        sh 'python -m unittest uncover'
      }
    }
    stage('Deploy') {
      steps {
        sh 'docker construct -t mymodel:newest .'
        sh 'docker run -d -p 5000:5000 mymodel:newest'
      }
    }
  }
}

Schritt 6: Modelltests

Führen Sie Exams durch, um sicherzustellen, dass alle Funktionen des Modells angemessen erfüllt werden. Anschließend werden die prognostizierten Beträge mit den Ergebnissen verglichen, die dieses Modell liefern soll. Überprüfen Sie die Generalisierungsfähigkeit des Modells, um festzustellen, ob es bei anderen neuen Daten intestine funktioniert. Wählen Sie zum Vergleich mit den Beispieldaten die richtigen Bewertungskriterien – Genauigkeit, Präzision, Rückruf.

# Import mandatory libraries
from sklearn.metrics import accuracy_score, precision_score, recall_score

# Load your take a look at information 
test_df = pd.read_csv('your_test_data.csv')  

X_test = test_df.drop(columns=('target_column'))
y_test = test_df('target_column')

# Predict outcomes on the take a look at set
y_pred_test = best_model.predict(X_test)

# Consider efficiency metrics
test_accuracy = accuracy_score(y_test, y_pred_test)
test_precision = precision_score(y_test, y_pred_test, common="weighted")
test_recall = recall_score(y_test, y_pred_test, common="weighted")

# Print efficiency metrics
print(f"Check Set Accuracy: {test_accuracy}")
print(f"Check Set Precision: {test_precision}")
print(f"Check Set Recall: {test_recall}")

Schritt 7: Überwachung und Wartung

Stellen Sie mithilfe von Instruments wie AWS CloudWatch, Azure Monitor oder Google Cloud Monitoring sicher, dass das Modell keine Fehler enthält. Dazu muss aufgezeigt werden, wie das in Zukunft bereitgestellte Modell geändert werden muss, um es noch besser zu machen.

AWS CloudWatch

aws cloudwatch put-metric-alarm --alarm-name CPUAlarm --metric-name CPUUtilization 
--namespace AWS/EC2 --statistic Common --period 300 --threshold 70 
--comparison-operator GreaterThanThreshold --dimensions "Identify=InstanceId,Worth=i-1234567890abcdef0" 
--evaluation-periods 2 --alarm-actions arn:aws:sns:us-east-1:123456789012:my-sns-topic

Quelle: https://blogs.vmware.com/administration/2021/03/cloud-services-aws-cloudwatch-azure-monitor.html

Azure Monitor

az monitor metrics alert create --name 'CPU Alert' --resource-group myResourceGroup 
--scopes /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/suppliers/Microsoft.Compute/virtualMachines/{vm-name} 
--condition "avg Share CPU > 80" --description 'Alert if CPU utilization exceeds 80%'

Quelle: https://blogs.vmware.com/administration/2021/03/cloud-services-aws-cloudwatch-azure-monitor.html

Einpacken

Die in diesem Tutorial beschriebenen Strategien stellen sicher, dass Sie über die wichtigsten Schritte verfügen, die zum Bereitstellen von Machine-Studying-Modellen erforderlich sind. Wenn Sie die oben genannten Schritte befolgen, können Sie die trainierten Modelle für den praxisbezogenen Einsatz nutzbar und einfach bereitstellen. Vom Erstellen des Modells bis zum Konfigurieren und Validieren der Struktur wissen Sie jetzt, wie Sie Ihre Machine-Studying-Bemühungen vom Hypothetischen in die Praxis umsetzen.

Jayita Gulati ist eine Enthusiastin für maschinelles Lernen und technische Autorin, die von ihrer Leidenschaft für die Erstellung von Modellen für maschinelles Lernen angetrieben wird. Sie hat einen Grasp-Abschluss in Informatik von der Universität Liverpool.