Bild von Autor | Chatgpt
Maschinelles Lernen verfügt über leistungsstarke Anwendungen in verschiedenen Domänen, aber die effektive Bereitstellung maschineller Lernmodelle in realen Szenarien erfordert häufig die Verwendung eines Internet-Frameworks.
DjangoEin hochrangiges Internet-Framework für Python ist besonders beliebt, um skalierbare und sichere Webanwendungen zu erstellen. In Kombination mit Bibliotheken wie Scikit-StudyMit Django können Entwickler über APIs maschinelles Modellinferenz servieren und intuitive Weboberflächen für die Benutzerinteraktion mit diesen Modellen erstellen.
In diesem Tutorial lernen Sie, wie Sie eine einfache Django -Anwendung erstellen, die Vorhersagen aus einem maschinellen Lernmodell dient. Diese Schritt-für-Schritt-Anleitung führt Sie durch den gesamten Prozess, beginnend vom ersten Modelltraining bis hin zu Inferenz- und Check-APIs.
# 1. Projekt -Setup
Wir werden zunächst die Basisstruktur erstellen und die erforderlichen Abhängigkeiten installieren.
Erstellen Sie ein neues Projektverzeichnis und gehen Sie hinein:
mkdir django-ml-app && cd django-ml-appInstallieren Sie die erforderlichen Python -Pakete:
pip set up Django scikit-learn joblibInitialisieren Sie ein neues Django -Projekt namens namens mlapp und erstellen Sie eine neue App mit dem Namen predictor:
django-admin startproject mlapp .
python handle.py startapp predictorRichten Sie Vorlagenverzeichnisse für die HTML -Dateien unserer App ein:
mkdir -p templates/predictorNach dem Ausführen der obigen Befehle sollte Ihr Projektordner so aussehen:
django-ml-app/
├─ .venv/
├─ mlapp/
│ ├─ __init__.py
│ ├─ asgi.py
│ ├─ settings.py
│ ├─ urls.py
│ └─ wsgi.py
├─ predictor/
│ ├─ migrations/
│ ├─ __init__.py
│ ├─ apps.py
│ ├─ types.py <-- we'll add this later
│ ├─ providers.py <-- we'll add this later (mannequin load/predict)
│ ├─ views.py <-- we'll replace
│ ├─ urls.py <-- we'll add this later
│ └─ checks.py <-- we'll add this later
├─ templates/
│ └─ predictor/
│ └─ predict_form.html
├─ handle.py
├─ necessities.txt
└─ prepare.py <-- Machine studying coaching script# 2. Trainieren Sie das Modell des maschinellen Lernens
Als nächstes werden wir ein Modell erstellen, das unsere Django -App für Vorhersagen verwenden wird. Für dieses Tutorial arbeiten wir mit dem klassischen Iris-Datensatz zusammen, der in Scikit-Study enthalten ist.
Erstellen Sie im Stammverzeichnis des Projekts ein Skript mit dem Namen prepare.py. Dieses Skript lädt den IRIS -Datensatz und spaltet ihn in Trainings- und Testsätze auf. Als nächstes schult es einen zufälligen Waldklassifizierer für die Trainingsdaten. Nach Abschluss des Trainings speichert es das geschulte Modell zusammen mit seinen Metadaten, die Characteristic -Namen und Zieletiketten enthalten – into die predictor/mannequin/ Verzeichnis verwendet Joblib.
from pathlib import Path
import joblib
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
MODEL_DIR = Path("predictor") / "mannequin"
MODEL_DIR.mkdir(mother and father=True, exist_ok=True)
MODEL_PATH = MODEL_DIR / "iris_rf.joblib"
def essential():
information = load_iris()
X, y = information.information, information.goal
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
clf = RandomForestClassifier(n_estimators=200, random_state=42)
clf.match(X_train, y_train)
joblib.dump(
{
"estimator": clf,
"target_names": information.target_names,
"feature_names": information.feature_names,
},
MODEL_PATH,
)
print(f"Saved mannequin to {MODEL_PATH.resolve()}")
if __name__ == "__main__":
essential()Führen Sie das Trainingsskript aus:
Wenn alles erfolgreich ausgeführt wird, sollten Sie eine Nachricht sehen, die bestätigt, dass das Modell gespeichert wurde.
# 3. Konfigurieren Sie die Django -Einstellungen
Nachdem wir unser App- und Schulungsskript bereit haben, müssen wir Django konfigurieren, damit es über unsere neue Anwendung und die Suche nach Vorlagen kann.
Offen mlapp/settings.py und machen Sie die folgenden Updates:
- Registrieren Sie die
predictorApp inINSTALLED_APPS. Dies fordert Django an, unsere benutzerdefinierte App in den Projektlebenszyklus (Modelle, Ansichten, Formulare usw.) aufzunehmen. - Fügen Sie die hinzu
templates/Verzeichnis in derTEMPLATESKonfiguration. Dies stellt sicher, dass Django HTML -Vorlagen laden kann, die nicht direkt an eine bestimmte App gebunden sind, wie das Formular, das wir später erstellen werden. - Satz
ALLOWED_HOSTSalle Gastgeber während der Entwicklung zu akzeptieren. Dies erleichtert es, das Projekt ohne Host-bezogene Fehler lokal auszuführen.
from pathlib import Path
BASE_DIR = Path(__file__).resolve().dad or mum.dad or mum
INSTALLED_APPS = (
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.classes",
"django.contrib.messages",
"django.contrib.staticfiles",
"predictor", # <-- add
)
TEMPLATES = (
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": (BASE_DIR / "templates"), # <-- add
"APP_DIRS": True,
"OPTIONS": {
"context_processors": (
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
),
},
},
)
# For dev
ALLOWED_HOSTS = ("*")# 4. URLs hinzufügen
Mit unserer registrierten App besteht der nächste Schritt darin, die zu verkabeln URL -Routing So können Benutzer auf unsere Seiten und API -Endpunkte zugreifen. Django Routes eingehende HTTP -Anfragen durch urls.py Dateien.
Wir konfigurieren zwei Sätze von Routen:
- URLs auf Projektebene (
mlapp/urls.py) – Beinhaltet globale Routen wie das Administratorfeld und Routen aus dempredictorApp. - URLs auf App-Ebene (
predictor/urls.py) – Definiert die spezifischen Routen für unser Webform und unsere API.
Offen mlapp/urls.py und aktualisieren Sie es wie folgt:
# mlapp/urls.py
from django.contrib import admin
from django.urls import path, embody
urlpatterns = (
path("admin/", admin.web site.urls),
path("", embody("predictor.urls")), # internet & API routes
)Erstellen Sie nun eine neue Datei Prädiktor/urls.py und definieren Sie die App-spezifischen Routen:
# predictor/urls.py
from django.urls import path
from .views import house, predict_view, predict_api
urlpatterns = (
path("", house, title="house"),
path("predict/", predict_view, title="predict"),
path("api/predict/", predict_api, title="predict_api"),
)
# 5. Bauen Sie die Type auf
Damit Benutzer über eine Webschnittstelle mit unserem Modell interagieren können, benötigen wir ein Eingabebuch, in dem sie Blumenmessungen (Sepal- und Blütenblattabmessungen) eingeben können. Django erleichtert dies mit seinem integrierten Formulierungsmodul.
Wir erstellen eine einfache Formklasse, um die vier vom IRIS -Klassifikator erforderlichen numerischen Eingaben zu erfassen.
In deinem Prädiktor/ App, erstellen Sie eine neue Datei mit dem Namen types.py und fügen Sie den folgenden Code hinzu:
# predictor/types.py
from django import types
class IrisForm(types.Type):
sepal_length = types.FloatField(min_value=0, label="Sepal size (cm)")
sepal_width = types.FloatField(min_value=0, label="Sepal width (cm)")
petal_length = types.FloatField(min_value=0, label="Petal size (cm)")
petal_width = types.FloatField(min_value=0, label="Petal width (cm)")# 6. Lastmodell und Vorhersage
Nachdem wir unseren Iris -Klassifizierer trainiert und gerettet haben, brauchen wir eine Möglichkeit für die Django -App Laden Sie das Modell und verwenden Sie es für Vorhersagen. Um die Dinge organisiert zu halten, werden wir alle prognostizierenden Logik in eine engagierte Logik platzieren providers.py Datei in der predictor App.
Dies stellt sicher, dass unsere Ansichten sauber bleiben und auf Anfrage-/Antwortbehandlungen konzentriert werden, während die Vorhersagelogik in einem wiederverwendbaren Service -Modul lebt.
In Predictor/Providers.pyFügen Sie den folgenden Code hinzu:
# predictor/providers.py
from __future__ import annotations
from pathlib import Path
from typing import Dict, Any
import joblib
import numpy as np
_MODEL_CACHE: Dict(str, Any) = {}
def get_model_bundle():
"""
Hundreds and caches the educated mannequin bundle:
{
"estimator": RandomForestClassifier,
"target_names": ndarray(str),
"feature_names": listing(str),
}
"""
world _MODEL_CACHE
if "bundle" not in _MODEL_CACHE:
model_path = Path(__file__).resolve().dad or mum / "mannequin"https://www.kdnuggets.com/"iris_rf.joblib"
_MODEL_CACHE("bundle") = joblib.load(model_path)
return _MODEL_CACHE("bundle")
def predict_iris(options):
"""
options: listing(float) of size 4 (sepal_length, sepal_width, petal_length, petal_width)
Returns dict with class_name and possibilities.
"""
bundle = get_model_bundle()
clf = bundle("estimator")
target_names = bundle("target_names")
X = np.array((options), dtype=float)
proba = clf.predict_proba(X)(0)
idx = int(np.argmax(proba))
return {
"class_index": idx,
"class_name": str(target_names(idx)),
"possibilities": {str(title): float(p) for title, p in zip(target_names, proba)},
}# 7. Ansichten
Der Ansichten Fungieren Sie als Klebstoff zwischen Benutzereingaben, dem Modell und der endgültigen Antwort (HTML oder JSON). In diesem Schritt werden wir drei Ansichten erstellen:
- heim – Rendert die Vorhersageform.
- Predict_view – Griff Formulareinführungen von der Webschnittstelle.
- Predict_api – Bietet einen JSON -API -Endpunkt für programmatische Vorhersagen.
In Prädiktor/Ansichten.PyFügen Sie den folgenden Code hinzu:
from django.http import JsonResponse
from django.shortcuts import render
from django.views.decorators.http import require_http_methods
from django.views.decorators.csrf import csrf_exempt # <-- add
from .types import IrisForm
from .providers import predict_iris
import json
def house(request):
return render(request, "predictor/predict_form.html", {"kind": IrisForm()})
@require_http_methods(("POST"))
def predict_view(request):
kind = IrisForm(request.POST)
if not kind.is_valid():
return render(request, "predictor/predict_form.html", {"kind": kind})
information = kind.cleaned_data
options = (
information("sepal_length"),
information("sepal_width"),
information("petal_length"),
information("petal_width"),
)
consequence = predict_iris(options)
return render(
request,
"predictor/predict_form.html",
{"kind": IrisForm(), "consequence": consequence, "submitted": True},
)
@csrf_exempt # <-- add this line
@require_http_methods(("POST"))
def predict_api(request):
# Settle for JSON solely (elective however really helpful)
if request.META.get("CONTENT_TYPE", "").startswith("utility/json"):
attempt:
payload = json.masses(request.physique or "{}")
besides json.JSONDecodeError:
return JsonResponse({"error": "Invalid JSON."}, standing=400)
else:
# fall again to form-encoded if you wish to maintain supporting it:
payload = request.POST.dict()
required = ("sepal_length", "sepal_width", "petal_length", "petal_width")
lacking = (okay for okay in required if okay not in payload)
if lacking:
return JsonResponse({"error": f"Lacking: {', '.be part of(lacking)}"}, standing=400)
attempt:
options = (float(payload(okay)) for okay in required)
besides ValueError:
return JsonResponse({"error": "All options have to be numeric."}, standing=400)
return JsonResponse(predict_iris(options))# 8. Vorlage
Schließlich erstellen wir die HTML -Vorlage, die als Benutzeroberfläche für unseren IRIS -Prädiktor dient.
Diese Vorlage wird:
- Rendern Sie die Django -Formfelder, die wir zuvor definiert haben.
- Geben Sie ein sauberes, gestaltetes Format mit reaktionsschnellen Formulareingängen an.
- Anzeigen Sie die Vorhersageergebnisse, sofern verfügbar.
- Erwähnen Sie den API -Endpunkt für Entwickler, die den programmatischen Zugriff bevorzugen.
<!doctype html>
<html>
<head>
<meta charset="utf-8" />
<title>Iris Predictor</title>
<meta title="viewport" content material="width=device-width, initial-scale=1" />
<fashion>
physique { font-family: Inter, system-ui, -apple-system, Segoe UI, Roboto, Arial, sans-serif; margin: 2rem; }
.card { max-width: 540px; padding: 1.25rem; border: 1px stable #e5e7eb; border-radius: 12px; }
.row { show: grid; hole: 0.75rem; grid-template-columns: 1fr 1fr; }
label { font-size: 0.9rem; coloration: #111827; }
enter { width: 100%; padding: 0.5rem; border: 1px stable #d1d5db; border-radius: 8px; }
button { margin-top: 1rem; padding: 0.6rem 0.9rem; border: 0; border-radius: 8px; background: #111827; coloration: white; cursor: pointer; }
.consequence { margin-top: 1rem; background: #f9fafb; border: 1px stable #e5e7eb; border-radius: 8px; padding: 0.75rem; }
.muted { coloration: #6b7280; }
</fashion>
</head>
<physique>
<h1>Iris Predictor</h1>
<p class="muted">Enter Iris flower measurements to get a prediction.</p>
<div class="card">
<kind motion="/predict/" technique="put up">
{% csrf_token %}
<div class="row">
<div>
<label for="id_sepal_length">Sepal size (cm)</label>
{{ kind.sepal_length }}
</div>
<div>
<label for="id_sepal_width">Sepal width (cm)</label>
{{ kind.sepal_width }}
</div>
<div>
<label for="id_petal_length">Petal size (cm)</label>
{{ kind.petal_length }}
</div>
<div>
<label for="id_petal_width">Petal width (cm)</label>
{{ kind.petal_width }}
</div>
</div>
<button sort="submit">Predict</button>
</kind>
{% if submitted and consequence %}
<div class="consequence">
Predicted class: {{ consequence.class_name }}<br />
<div class="muted">
Chances:
<ul>
{% for title, p in consequence.possibilities.objects %}
<li>{{ title }}: {floatformat:3 }</li>
{% endfor %}
</ul>
</div>
</div>
{% endif %}
</div>
<p class="muted" fashion="margin-top:1rem;">
API out there at <code>POST /api/predict/</code>
</p>
</physique>
</html># 9. Führen Sie die Anwendung aus
Bei allem ist es Zeit, unser Django -Projekt durchzuführen und sowohl das Webform als auch den API -Endpunkt zu testen.
Führen Sie den folgenden Befehl aus, um die Normal -Django -Datenbank (für Administrator, Sitzungen usw.) einzurichten:
Starten Sie den Django Improvement Server:
python handle.py runserverWenn alles korrekt eingerichtet ist, sehen Sie eine ähnliche Ausgabe wie folgt:
Waiting for file adjustments with StatReloader
Performing system checks...
System examine recognized no points (0 silenced).
September 09, 2025 - 02:01:27
Django model 5.2.6, utilizing settings 'mlapp.settings'
Beginning growth server at http://127.0.0.1:8000/
Stop the server with CTRL-BREAK.Öffnen Sie Ihren Browser und besuchen Sie: http://127.0.0.1:8000/, um die Webformoberfläche zu verwenden.
Sie können auch eine Postanforderung mit Curl an die API senden:
curl -X POST http://127.0.0.1:8000/api/predict/
-H "Content material-Kind: utility/json"
-d '{"sepal_length":5.1,"sepal_width":3.5,"petal_length":1.4,"petal_width":0.2}'Erwartete Antwort:
{
"class_index": 0,
"class_name": "setosa",
"possibilities": {
"setosa": 1.0,
"versicolor": 0.0,
"virginica": 0.0
}
}
# 10. Exams
Vor dem Abschluss ist eine gute Praxis zu überprüfen, ob unsere Anwendung wie erwartet funktioniert. Django bietet ein integriert Testframework Das integriert sich in Python’s unittest Modul.
Wir werden ein paar einfache Exams erstellen, um sicherzustellen:
- Der Homepage Renders richtig und enthält den Titel.
- Der API -Endpunkt Gibt eine gültige Vorhersageantwort zurück.
In predictor/checks.pyFügen Sie den folgenden Code hinzu:
from django.take a look at import TestCase
from django.urls import reverse
class PredictorTests(TestCase):
def test_home_renders(self):
resp = self.consumer.get(reverse("house"))
self.assertEqual(resp.status_code, 200)
self.assertContains(resp, "Iris Predictor")
def test_api_predict(self):
url = reverse("predict_api")
payload = {
"sepal_length": 5.0,
"sepal_width": 3.6,
"petal_length": 1.4,
"petal_width": 0.2,
}
resp = self.consumer.put up(url, payload)
self.assertEqual(resp.status_code, 200)
information = resp.json()
self.assertIn("class_name", information)
self.assertIn("possibilities", information)Führen Sie den folgenden Befehl in Ihrem Terminal aus:
Sie sollten eine ähnliche Ausgabe sehen:
Discovered 2 take a look at(s).
Creating take a look at database for alias 'default'...
System examine recognized no points (0 silenced).
..
----------------------------------------------------------------------
Ran 2 checks in 0.758s
OK
Destroying take a look at database for alias 'default'...Wenn diese Exams bestehen, können Sie sicher sein, dass Ihre Django + maschinelles Lernen-App von Finish-to-Finish korrekt funktioniert.
# Zusammenfassung
Sie haben erfolgreich eine vollständige Anwendung für maschinelles Lernen über das Django -Framework erstellt, um alle Komponenten in ein funktionales System zusammenzubringen.
Beginnend mit dem Coaching und Speichern eines Modells haben Sie es in Django -Dienste integriert, um Vorhersagen zu machen. Sie haben außerdem ein sauberes Webformular für die Benutzereingabe erstellt und eine JSON -API für den programmatischen Zugriff enthüllt. Darüber hinaus haben Sie automatisierte Exams implementiert, um sicherzustellen, dass die Anwendung zuverlässig ausgeführt wird.
Während sich dieses Projekt auf den IRIS-Datensatz konzentrierte, kann dieselbe Struktur erweitert werden, um komplexere Modelle, größere Datensätze oder sogar produktionsbereite APIs aufzunehmen, wodurch es zu einer soliden Grundlage für Anwendungen für maschinelle Lernen in realer Welt ist.
Abid Ali Awan (@1abidaliawan) ist ein zertifizierter Datenwissenschaftler, der es liebt, maschinelles Lernenmodelle zu bauen. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben von technischen Blogs über maschinelles Lernen und Datenwissenschaftstechnologien. Abid hat einen Grasp -Abschluss in Technologiemanagement und einen Bachelor -Abschluss in Telekommunikationstechnik. Seine Imaginative and prescient ist es, ein KI -Produkt zu bauen, das ein Diagramm neuronales Netzwerk für Schüler mit psychische Erkrankungen mit kämpfender Krankheiten unterhält.