Ab Version 0.35 unterst\u00fctzt Ollama Entscheidungsmodelle, die auf der Jev-API von TypeSafe basieren. Hierbei handelt es sich nicht um Chat-Modelle im \u00fcblichen Sinne: Sie schreiben keinen Text, sondern beantworten eine Reihe getippter Fragen zum \u00fcbertragenen Zustand. F\u00fcr die Klassifizierung, Weiterleitung, Moderation und Triage erweist sich dies als schneller und zuverl\u00e4ssiger, als einen regul\u00e4ren LLM zu bitten, JSON zur\u00fcckzugeben und dann seine Antwort zu analysieren.<\/p>\n
In diesem Beitrag schaue ich mir an, was Entscheidungsmodelle sind, wie sie auf HTTP-Ebene funktionieren, welche Modelle bereits verf\u00fcgbar sind und wie man sie in vorhandenen Code einbaut, damit regul\u00e4re generative Modelle weiterhin funktionieren.<\/p>\n
?<\/h2>\n
Ein regul\u00e4rer LLM empf\u00e4ngt eine Eingabeaufforderung und generiert Token f\u00fcr Token Text. Selbst wenn Sie sie bitten, mit einem Wort zu antworten, findet die Generierung immer noch im Inneren statt, und das Format der Antwort muss durch ein Diagramm, Anweisungen und anschlie\u00dfende \u00dcberpr\u00fcfung kontrolliert werden. Das Entscheidungsmodell funktioniert anders: Sie \u00fcbergeben Status und Fragen mit Typen und das Modell gibt Wahrscheinlichkeiten und ausgew\u00e4hlte Optionen zur\u00fcck. Kein Freitext, kein JSON-Parsing aus der Antwort.<\/p>\n
Der neue Endpunkt hei\u00dft \/v1\/systemone. In einer Anfrage k\u00f6nnen Sie mehrere Fragen gleichzeitig stellen und das Model wird alle beantworten. Dies ist praktisch f\u00fcr Aufgaben, bei denen Sie mehrere zusammenh\u00e4ngende Entscheidungen treffen m\u00fcssen: zum Beispiel die Bestimmung des Teams, die Notwendigkeit einer R\u00fcckgabe und die Dringlichkeit des Tickets.<\/p>\n
Jetzt k\u00f6nnen Sie drei Entscheidungsmodelle \u00fcber Ollama ausf\u00fchren:<\/p>\n
Sie arbeiten alle lokal, erfordern keine Bezahlung und senden keine Daten an einen externen Dienst. Ollama 0.35 und h\u00f6her werden unterst\u00fctzt.<\/p>\n
\u00dcberpr\u00fcfen Sie zun\u00e4chst die Ollama-Version:<\/p>\n
ollama --version\n<\/code><\/pre>\n<\/div>\nLaden Sie dann das gew\u00fcnschte Modell herunter. F\u00fcr die einfachste:<\/p>\n
\nollama pull tev1:0.8b\n<\/code><\/pre>\n<\/div>\nF\u00fcr die Vollversion von tev1:<\/p>\n
\nollama pull tev1\n<\/code><\/pre>\n<\/div>\nF\u00fcr flink:<\/p>\n
\nollama pull nimble\n<\/code><\/pre>\n<\/div>\nDas flinke Modell ben\u00f6tigt etwa 9,5 GB Speicherplatz, daher empfiehlt es sich, vor dem Herunterladen etwas Speicherplatz freizugeben. tev1:0.8b ben\u00f6tigt weniger als ein Gigabyte.<\/p>\n
Erste Anfrage per Curl<\/h2>\n
Das einfachste Beispiel ist die Feststellung, ob es sich bei einem Text um eine Stellenanzeige handelt:<\/p>\n
\ncurl http:\/\/localhost:11434\/v1\/systemone -d '{\n \"model\": \"tev1:0.8b\",\n \"state\": {\n \"message\": \"Senior Swift developer, Berlin, remote friendly\"\n },\n \"questions\": {\n \"isJob\": {\n \"type\": \"noul\",\n \"instructions\": \"Does the message advertise a job posting that someone can apply to?\"\n }\n }\n}'\n<\/code><\/pre>\n<\/div>\nDie Antwort sieht so aus:<\/p>\n
\n{\n \"model\": \"tev1:0.8b\",\n \"answers\": {\n \"isJob\": {\n \"type\": \"noul\",\n \"noul\": 0.921\n }\n },\n \"usage\": {\n \"input_tokens\": 42,\n \"output_tokens\": 0\n }\n}\n<\/code><\/pre>\n<\/div>\nDas Noul-Feld ist eine Wahrscheinlichkeit von 0 bis 1. Die Entscheidung wird durch Vergleich mit einem Schwellenwert getroffen, normalerweise 0,5. Im Gegensatz zum generativen Modell ist es nicht erforderlich, eine Antwort im JSON-Format anzufordern und dann zu \u00fcberpr\u00fcfen, ob das Modell sie nicht besch\u00e4digt hat.<\/p>\n
Arten von Fragen<\/h2>\n
Entscheidungsmodelle unterst\u00fctzen drei Arten von Fragen.<\/p>\n
noul<\/b> ist eine bin\u00e4re Frage. Gibt die Wahrscheinlichkeit zur\u00fcck, dass eine Aussage wahr ist:<\/p>\n\n{\n \"questions\": {\n \"refund\": {\n \"type\": \"noul\",\n \"instructions\": \"Does the customer explicitly ask for a refund?\"\n }\n }\n}\n<\/code><\/pre>\n<\/div>\nAuswahl<\/b> \u2013 Auswahl einer Option aus einem bestimmten Satz. Gibt die ausgew\u00e4hlte Option, die Wahrscheinlichkeiten aller Optionen und die Konfidenz zur\u00fcck:<\/p>\n\n{\n \"questions\": {\n \"team\": {\n \"type\": \"choice\",\n \"instructions\": \"Which team should handle this ticket?\",\n \"criteria\": {\n \"billing\": \"Payments and refunds\",\n \"technical\": \"Bugs and integrations\",\n \"other\": \"None of the above\"\n }\n }\n }\n}\n<\/code><\/pre>\n<\/div>\nScore<\/b> \u2013 Bewertung auf einer Skala. Gibt die Zahl, Legende und Wahrscheinlichkeiten f\u00fcr jeden Skalenpunkt zur\u00fcck:<\/p>\n\n{\n \"questions\": {\n \"urgency\": {\n \"type\": \"score\",\n \"instructions\": \"How urgent is this ticket?\",\n \"criteria\": [\"Routine\", \"Soon\", \"Urgent\"]\n }\n }\n}\n<\/code><\/pre>\n<\/div>\nEine Anfrage kann mehrere Fragen unterschiedlichen Typs gleichzeitig enthalten. Dies macht Entscheidungsmodelle f\u00fcr die Triage geeignet: eine Operation, ein Zustand, mehrere unabh\u00e4ngige Entscheidungen.<\/p>\n
Python ohne zus\u00e4tzliche Bibliotheken<\/h2>\n
F\u00fcr Anfragen reicht die Standard-URLib aus; Ein separates SDK ist nicht erforderlich:<\/p>\n
\nimport json\nfrom urllib.request import Request, urlopen\n\nOLLAMA_DECISION_URL = \"http:\/\/localhost:11434\/v1\/systemone\"\n\ndef ask_decision(state, questions, model=\"tev1:0.8b\"):\n payload = {\n \"model\": model,\n \"state\": state,\n \"questions\": questions,\n }\n request = Request(\n OLLAMA_DECISION_URL,\n data=json.dumps(payload).encode(),\n headers={\"Content-Type\": \"application\/json\"},\n method=\"POST\",\n )\n with urlopen(request, timeout=3600) as response:\n return json.loads(response.read().decode())[\"answers\"]\n<\/code><\/pre>\n<\/div>\nVerwendung:<\/p>\n
\nanswers = ask_decision(\n {\"message\": \"Senior Swift developer, Berlin, remote friendly\"},\n {\n \"isJob\": {\n \"type\": \"noul\",\n \"instructions\": \"Does the message advertise a job posting that someone can apply to?\"\n }\n },\n)\n\nprobability = answers[\"isJob\"][\"noul\"]\nis_job = probability >= 0.5\n<\/code><\/pre>\n<\/div>\nWenn Sie ein offizielles Python-SDK ben\u00f6tigen, hei\u00dft es typesafe-sdk. F\u00fcr localhost kann es mit den Umgebungsvariablen TYPESAFE_BASE_URL, TYPESAFE_API_KEY und TYPESAFE_DEFAULT_MODEL an Ollama weitergeleitet werden. F\u00fcr einfache Aufgaben reicht jedoch eine direkte HTTP-Anfrage.<\/p>\n
Wie man versteht, dass ein Modell eine Entscheidung unterst\u00fctzt<\/h2>\n
Entscheidungsmodelle k\u00f6nnen nicht \u00fcber \/api\/generate oder \/api\/chat antworten. Wenn Sie eine solche Anfrage senden, gibt Ollama einen 400-Fehler mit einem Text wie dem folgenden zur\u00fcck:<\/p>\n
\n\"tev1:0.8b\" does not support generate\n<\/code><\/pre>\n<\/div>\nDies ist wichtig, wenn Sie bereits Code haben, der \u00fcber \/api\/generate mit regul\u00e4ren Modellen funktioniert: Wenn Sie das Modell in ein Entscheidungsmodell \u00e4ndern, funktioniert es nicht mehr. Besser ist es, sich vorab \u00fcber \/api\/show \u00fcber die F\u00e4higkeiten des Modells zu informieren und die entsprechende Aufrufmethode auszuw\u00e4hlen:<\/p>\n
\nimport json\nfrom urllib.request import Request, urlopen\n\nOLLAMA_SHOW_URL = \"http:\/\/localhost:11434\/api\/show\"\n\ndef supports_decision(model):\n request = Request(\n OLLAMA_SHOW_URL,\n data=json.dumps({\"model\": model}).encode(),\n headers={\"Content-Type\": \"application\/json\"},\n method=\"POST\",\n )\n try:\n with urlopen(request, timeout=30) as response:\n capabilities = json.loads(response.read().decode()).get(\"capabilities\", [])\n except (OSError, TypeError, ValueError):\n return False\n return \"decision\" in capabilities\n<\/code><\/pre>\n<\/div>\nEntscheidungsmodelle werden nur Entscheidungen in ihren F\u00e4higkeiten haben. Normale Modelle verf\u00fcgen dort \u00fcber Vervollst\u00e4ndigungen, Werkzeuge oder andere Funktionen. Wenn Ollama nicht verf\u00fcgbar ist, ist es sinnvoll, das Modell als normal zu betrachten und den generativen Pfad zu verwenden.<\/p>\n
So integrieren Sie es in vorhandenen Code<\/h2>\n
Der einfachste Weg besteht darin, den Klassifikator nicht neu zu schreiben, sondern ihn in zwei Strategien zu unterteilen. Die generative Strategie funktioniert wie zuvor: Sie sammelt die Eingabeaufforderung, sendet sie an \/api\/generate und analysiert den JSON. Die Entscheidungsstrategie sendet den Status und die eingegebene Frage an \/v1\/systemone und vergleicht die Wahrscheinlichkeit mit einem Schwellenwert.<\/p>\n
Die Wahl der Strategie erfolgt an einer Stelle beim Erstellen eines Klassifikators:<\/p>\n
\ndef create_classifier(model):\n if supports_decision(model):\n return DecisionClassifier(model)\n return GenerativeClassifier(model)\n<\/code><\/pre>\n<\/div>\nDieser Ansatz hat mehrere Vorteile. Generative Modelle laufen unver\u00e4ndert weiter. Das Entscheidungsmodell kann durch \u00c4ndern einer Umgebungsvariablen aktiviert werden. Und der gesamte Unterschied zwischen den beiden Methoden konzentriert sich auf zwei kleine Klassen und ist nicht \u00fcber die gesamte Anwendung verteilt.<\/p>\n
F\u00fcr eine bin\u00e4re Klassifizierung sieht die Entscheidungsstrategie etwa so aus:<\/p>\n
\nasync def classify(text):\n answers = await ask_decision(\n {\"message\": text},\n {\n \"isJob\": {\n \"type\": \"noul\",\n \"instructions\": instructions,\n }\n },\n model,\n )\n probability = answers[\"isJob\"][\"noul\"]\n return probability >= 0.5, probability\n<\/code><\/pre>\n<\/div>\nBitte beachten Sie, dass das Entscheidungsmodell keine Erkl\u00e4rung zur\u00fcckgibt. Wenn Ihr Ergebnisformat ein Grundfeld enth\u00e4lt, k\u00f6nnen Sie es aus der Wahrscheinlichkeit konstruieren: Speichern Sie beispielsweise die Wahrscheinlichkeit selbst oder eine Zeichenfolge wie \u201eDas Modell hat die Nachricht mit 0,935 als freie Stelle bewertet.\u201c Das ist ehrlicher, als einen Grund zu erfinden, den das Modell nicht angegeben hat.<\/p>\n
Anweisungen sollten eine Frage sein<\/h2>\n
Dies ist die wichtigste praktische Schlussfolgerung. Entscheidungsmodelle verstehen keine langen Eingabeaufforderungen im Stil von \u201eSie klassifizieren Nachrichten, antworten mit wahr, wenn…, andernfalls mit falsch.\u201c Sie wollen eine kurze, direkte Frage.<\/p>\n
Auf die gleiche Nachricht zu einer offenen Stelle habe ich folgende Wahrscheinlichkeiten erhalten:<\/p>\n
\n- Direkte Frage \u201eIst diese Nachricht eine Stellenausschreibung?\u201c \u2013 0,921.<\/li>\n
- Lange Anweisungen, die erkl\u00e4ren, was als freie Stelle gilt \u2013 0,026.<\/li>\n
- Lange Anweisungen mit einer Frage am Ende \u2013 0,391.<\/li>\n<\/ul>\n
Der Unterschied betr\u00e4gt fast das Drei\u00dfigfache. Das Modell macht keinen Fehler bei der Klassifizierung, es versteht einfach nicht, was es von ihm will, wenn die Frage in einem Absatz versteckt ist. Daher lohnt es sich, f\u00fcr Entscheidungsmodelle separate kurze Anweisungen zu behalten und f\u00fcr generative Modelle lange Eingabeaufforderungen zu belassen.<\/p>\n
Es ist praktisch, eine separate Umgebungsvariable zu erstellen:<\/p>\n
\nOLLAMA_JOB_CLASSIFIER_DECISION_INSTRUCTIONS=Does the message advertise a job posting that someone can apply to?\n<\/code><\/pre>\n<\/div>\nUnd verwenden Sie eine regul\u00e4re Eingabeaufforderung nur f\u00fcr den generativen Pfad.<\/p>\n
Schwellenwert und Wahrscheinlichkeiten<\/h2>\n
Der Schwellenwert von 0,5 eignet sich als Standardwert, es ist jedoch sinnvoll, ihn in die Konfiguration einzubeziehen. Bei verschiedenen Aufgaben sind die Kosten einer falsch positiven und einer falsch negativen Antwort unterschiedlich. Zur Moderation ist es sicherer, die Schwelle anzuheben; Bei der Suche nach offenen Stellen ist es sicherer, den Wert zu senken, um keine n\u00fctzlichen Nachrichten zu verpassen.<\/p>\n
Es ist auch n\u00fctzlich, die Wahrscheinlichkeit selbst zu protokollieren und nicht nur den resultierenden booleschen Wert. Wenn der Klassifikator einen Fehler macht, zeigt das Protokoll, ob es sich um eine sichere Antwort oder eine Entscheidung an der Grenze handelte. Bei Auswahlfragen lohnt es sich, Wahrscheinlichkeiten und Vertrauen zu speichern: Sie zeigen, wie stark das Modell zwischen den Optionen schwankt.<\/p>\n
Leistung und Speicher<\/h2>\n
Die Geschwindigkeit h\u00e4ngt stark von der Gr\u00f6\u00dfe des Modells und der Hardware ab. Auf der CPU habe ich in meinen Tests folgende Zahlen erhalten:<\/p>\n
\n- tev1:0.8b<\/b> \u2013 Sekundenbruchteile zum L\u00f6sen, passt problemlos in den Speicher.<\/li>\n
- tev1<\/b> \u2013 4B, deutlich langsamer, aber immer noch f\u00fcr interaktive Aufgaben geeignet.<\/li>\n
- flink<\/b> \u2013 9\u00a0B in Q8_0, etwa 10\u00a0GB im Speicher. Die erste Anfrage inklusive Laden des Modells dauerte etwa 137 Sekunden, nachfolgende L\u00f6sungen ben\u00f6tigten zwischen 12 und 32 Sekunden auf der CPU.<\/li>\n<\/ul>\n
Nimble ben\u00f6tigt viel RAM. Auf einer Maschine mit 16 GB und Docker\/WSL mit einem Limit von etwa 8 GB passt das Modell nicht: Das System beginnt zu tauschen und die Container reagieren nicht mehr. Das Erh\u00f6hen des WSL-Limits auf 12 GB \u00fcber die .wslconfig-Datei hat geholfen:<\/p>\n
\n[wsl2]\nmemory=12GB\nswap=8GB\n<\/code><\/pre>\n<\/div>\nNach der \u00c4nderung m\u00fcssen Sie \u201ewsl –shutdown\u201c und Docker Desktop neu starten. Aber selbst mit 12 GB bleibt die Reserve gering: Das Modell nimmt etwa 10 GB auf, und f\u00fcr das System bleibt nicht mehr viel \u00fcbrig.<\/p>\n
Standardm\u00e4\u00dfig entl\u00e4dt Ollama das Modell nach f\u00fcnf Minuten Inaktivit\u00e4t und gibt so Speicher frei. Das ist praktisch: Nimble besch\u00e4ftigt nicht st\u00e4ndig 10 GB, sondern l\u00e4dt das Modell bei jedem neuen Start nach einer Pause erneut.<\/p>\n
Wann sollten Entscheidungsmodelle verwendet werden?<\/h2>\n
Entscheidungsmodelle eignen sich gut f\u00fcr Aufgaben, bei denen Sie eine schnelle und kosteng\u00fcnstige Antwort auf eine klar formulierte Frage ben\u00f6tigen:<\/p>\n
\n- Klassifizierung von Nachrichten, Tickets und Anfragen.<\/li>\n
- Routing nach Befehlen oder Ausf\u00fchrern.<\/li>\n
- Inhaltsmoderation und Sicherheits\u00fcberpr\u00fcfungen.<\/li>\n
- Schnelle bin\u00e4re und multivariate L\u00f6sungen f\u00fcr Spiele oder interaktive Anwendungen.<\/li>\n<\/ul>\n
Sie eignen sich schlecht f\u00fcr Aufgaben, bei denen detaillierter Text ben\u00f6tigt wird: Erkl\u00e4rung, Feldextraktion, Zusammenfassung, Antwortgenerierung. Zu diesem Zweck bleiben die \u00fcblichen generativen Modelle bestehen. Das beste Ergebnis wird durch die Kombination erzielt: Ein Entscheidungsmodell trifft eine Entscheidung, und ein generatives Modell erkl\u00e4rt sie oder extrahiert Daten.<\/p>\n
Gesamt<\/h2>\n
Entscheidungsmodelle in Ollama sind ein separates, engeres Werkzeug als regul\u00e4re LLMs. Sie ersetzen keine generativen Modelle, aber sie nehmen den Routineteil der Arbeit weg: getippte Antworten, Wahrscheinlichkeiten statt Textanalyse und ein vorhersehbares Format. Wenn Sie bereits \u00fcber eine Klassifizierungspipeline verf\u00fcgen, besteht der \u00dcbergang darin, die F\u00e4higkeiten des Modells zu \u00fcberpr\u00fcfen, eine separate Aufrufstrategie festzulegen und kurze Anleitungsfragen zu stellen.<\/p>\n
Quellen
\nhttps:\/\/ollama.com\/blog\/ollama-now-supports-jev-style-decision-models<\/a>
\nhttps:\/\/ollama.com\/library\/nimble<\/a>
\nhttps:\/\/ollama.com\/library\/tev1<\/a>
\nhttps:\/\/typesafe.ai<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"Ab Version 0.35 unterst\u00fctzt Ollama Entscheidungsmodelle, die auf der Jev-API von TypeSafe basieren. Hierbei handelt es sich nicht um Chat-Modelle im \u00fcblichen Sinne: Sie schreiben keinen Text, sondern beantworten eine Reihe getippter Fragen zum \u00fcbertragenen Zustand. F\u00fcr die Klassifizierung, Weiterleitung, Moderation und Triage erweist sich dies als schneller und zuverl\u00e4ssiger, als einen regul\u00e4ren LLM zu […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[],"class_list":["post-200","post","type-post","status-publish","format-standard","hentry","category-notes"],"translation":{"provider":"WPGlobus","version":"3.0.6","language":"de","enabled_languages":["en","ru","zh","de","ja","fr","es","pt","hi"],"languages":{"en":{"title":true,"content":true,"excerpt":false},"ru":{"title":true,"content":true,"excerpt":false},"zh":{"title":true,"content":true,"excerpt":false},"de":{"title":true,"content":true,"excerpt":false},"ja":{"title":true,"content":true,"excerpt":false},"fr":{"title":true,"content":true,"excerpt":false},"es":{"title":true,"content":true,"excerpt":false},"pt":{"title":true,"content":true,"excerpt":false},"hi":{"title":true,"content":true,"excerpt":false}}},"_links":{"self":[{"href":"https:\/\/demensdeum.com\/blog\/de\/wp-json\/wp\/v2\/posts\/200","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/demensdeum.com\/blog\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/demensdeum.com\/blog\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/demensdeum.com\/blog\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/demensdeum.com\/blog\/de\/wp-json\/wp\/v2\/comments?post=200"}],"version-history":[{"count":0,"href":"https:\/\/demensdeum.com\/blog\/de\/wp-json\/wp\/v2\/posts\/200\/revisions"}],"wp:attachment":[{"href":"https:\/\/demensdeum.com\/blog\/de\/wp-json\/wp\/v2\/media?parent=200"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/demensdeum.com\/blog\/de\/wp-json\/wp\/v2\/categories?post=200"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/demensdeum.com\/blog\/de\/wp-json\/wp\/v2\/tags?post=200"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}