Photo by writer | Chatgt
Mechanical reading There are powerful applications for all domains domain, but effectively and efficient use of the machine models in real world conditions requires the use of web structure.
DpangoThe Python high-quality web draft, is very famous for creating formal and protected web programs. When a couple and libraries like Scikit-learnDjango enables enhancements to use API testing machine readiness and allows you to create a user's website communication facilities for these types.
In this lesson, you will learn how to create a simple djangle app that works from predicting the machine for the machine. This step step by step will travel throughout the process, from training first model to verification and testing of API.
Obvious 1. Project Setup
We will start by creating the formation of the Base project and the installation required.
Create a new project directory and move to:
mkdir django-ml-app && cd django-ml-appEnter Python Packages Required:
pip install Django scikit-learn joblibStart a new django project called mlapp and create a new app whose name predictor:
django-admin startproject mlapp .
python manage.py startapp predictorSet up the template of our app's HTML file files:
mkdir -p templates/predictorAfter running the above instructions, your project folder should look like this:
django-ml-app/
├─ .venv/
├─ mlapp/
│ ├─ __init__.py
│ ├─ asgi.py
│ ├─ settings.py
│ ├─ urls.py
│ └─ wsgi.py
├─ predictor/
│ ├─ migrations/
│ ├─ __init__.py
│ ├─ apps.py
│ ├─ forms.py <-- we'll add this later
│ ├─ services.py <-- we'll add this later (model load/predict)
│ ├─ views.py <-- we'll update
│ ├─ urls.py <-- we'll add this later
│ └─ tests.py <-- we'll add this later
├─ templates/
│ └─ predictor/
│ └─ predict_form.html
├─ manage.py
├─ requirements.txt
└─ train.py <-- Machine learning training scriptObvious 2. Train the machine for the study machine
Next, we will build a model for the django app that will use to predict. In this lesson, we will work with Classic Iris dataset, installed in Skikit-Read.
In the root tracks of the project, create a text named train.py. This text is uploading the iris dataset and is broken into training sets with test sets. Next, trains Random Forest Classifer in Training Details. After training is completed, saves a trained model and its Metadata – which includes features of the feature and target labels – in the predictor/model/ The directory uses 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") / "model"
MODEL_DIR.mkdir(parents=True, exist_ok=True)
MODEL_PATH = MODEL_DIR / "iris_rf.joblib"
def main():
data = load_iris()
X, y = data.data, data.target
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.fit(X_train, y_train)
joblib.dump(
{
"estimator": clf,
"target_names": data.target_names,
"feature_names": data.feature_names,
},
MODEL_PATH,
)
print(f"Saved model to {MODEL_PATH.resolve()}")
if __name__ == "__main__":
main()Run the training text:
If everything runs successfully, you should see the message that guarantees that the model is saved.
Obvious 3. Prepare Dhango settings
Now that we have our App app and Crip Training program ready, we need to prepare for the django so you know about our new system and where to find templates.
Open mlapp/settings.py and make the following updates:
- Enroll
predictorApp inINSTALLED_APPS. This tells the django to enter our customary app on Project LifeCycle (models, views, forms, etc.). - Add
templates/Direction toTEMPLATESthe suspension. This ensures that the django can upload the HTML templates that are not directly disabled in a specific application, such as the form to construct later. - Setting
ALLOWED_HOSTSTo accept all hosstes during improvements. This makes it easier to conduct project in your area without mistakes related to management.
from pathlib import Path
BASE_DIR = Path(__file__).resolve().parent.parent
INSTALLED_APPS = [
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"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 = ["*"]Obvious 4. Add URLs
For our registered app, the next step is to enter a call URL lane So users can access our pages and API ENDPoints. Dudges of Dogango in urls.py files.
We will prepare two sets of routes:
- The provincial URLs of the project (
mlapp/urls.pySelected – Includes international means as a panel of the director and routes from thepredictorThe app. - The URLs in the middle (
predictor/urls.pySelected – Describe some lines of our web form and API.
Open Mlapp / URLS.py And update like this:
# mlapp/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path("admin/", admin.site.urls),
path("", include("predictor.urls")), # web & API routes
]Now create a new file Forecast / amurls.py And explain the relevant application methods:
# predictor/urls.py
from django.urls import path
from .views import home, predict_view, predict_api
urlpatterns = [
path("", home, name="home"),
path("predict/", predict_view, name="predict"),
path("api/predict/", predict_api, name="predict_api"),
]
Obvious 5. Create Form
Allowing users to meet our model by using a web interface, requires the installation form where they may include flowers. The django makes this easier for their built-in formulations.
We will create a simple class of the four digits of the IRIS CLASSFIER.
It forecast / The app, create a new file called Honors.Spy Then enter the following code:
# predictor/forms.py
from django import forms
class IrisForm(forms.Form):
sepal_length = forms.FloatField(min_value=0, label="Sepal length (cm)")
sepal_width = forms.FloatField(min_value=0, label="Sepal width (cm)")
petal_length = forms.FloatField(min_value=0, label="Petal length (cm)")
petal_width = forms.FloatField(min_value=0, label="Petal width (cm)")Obvious 6. Load model and predict
Now that we are trained and we saved our iris classifer, we need a method of django app for Upload the model and use it to predict. In order to keep things organized, we will set all the concepts related to predictable within the provision Resources.PO File in predictor The app.
This ensures that our ideas are clean and focused on the use / responding, while predicting is found in the repetitive service module.
In Forecast / resources.pyAdd the following code:
# predictor/services.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():
"""
Loads and caches the trained model bundle:
{
"estimator": RandomForestClassifier,
"target_names": ndarray[str],
"feature_names": list[str],
}
"""
global _MODEL_CACHE
if "bundle" not in _MODEL_CACHE:
model_path = Path(__file__).resolve().parent / "model"
_MODEL_CACHE["bundle"] = joblib.load(model_path)
return _MODEL_CACHE["bundle"]
def predict_iris(features):
"""
features: list[float] of length 4 (sepal_length, sepal_width, petal_length, petal_width)
Returns dict with class_name and probabilities.
"""
bundle = get_model_bundle()
clf = bundle["estimator"]
target_names = bundle["target_names"]
X = np.array([features], dtype=float)
proba = clf.predict_proba(X)[0]
idx = int(np.argmax(proba))
return {
"class_index": idx,
"class_name": str(target_names[idx]),
"probabilities": {str(name): float(p) for name, p in zip(target_names, proba)},
}Obvious 7. Views
This page overview Do like a glue between user input, model, and last reply (HTML or JSON). In this step, we will create three views:
- home – Enables a prediction form.
- predictor_view – Dogs to create a form from the web interface.
- prediction_api – Provides the end of Jonson API in disaster response.
In Forecast / views.py.pyAdd the following code:
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 .forms import IrisForm
from .services import predict_iris
import json
def home(request):
return render(request, "predictor/predict_form.html", {"form": IrisForm()})
@require_http_methods(["POST"])
def predict_view(request):
form = IrisForm(request.POST)
if not form.is_valid():
return render(request, "predictor/predict_form.html", {"form": form})
data = form.cleaned_data
features = [
data["sepal_length"],
data["sepal_width"],
data["petal_length"],
data["petal_width"],
]
result = predict_iris(features)
return render(
request,
"predictor/predict_form.html",
{"form": IrisForm(), "result": result, "submitted": True},
)
@csrf_exempt # <-- add this line
@require_http_methods(["POST"])
def predict_api(request):
# Accept JSON only (optional but recommended)
if request.META.get("CONTENT_TYPE", "").startswith("application/json"):
try:
payload = json.loads(request.body or "{}")
except json.JSONDecodeError:
return JsonResponse({"error": "Invalid JSON."}, status=400)
else:
# fall back to form-encoded if you want to keep supporting it:
payload = request.POST.dict()
required = ["sepal_length", "sepal_width", "petal_length", "petal_width"]
missing = [k for k in required if k not in payload]
if missing:
return JsonResponse({"error": f"Missing: {', '.join(missing)}"}, status=400)
try:
features = [float(payload[k]) for k in required]
except ValueError:
return JsonResponse({"error": "All features must be numeric."}, status=400)
return JsonResponse(predict_iris(features))Obvious 8. Template
Finally, we will create a HTML template that works as an interface of our IRIS stolen user.
This images help:
- Provide fields in the django form that we specified before.
- Provide a clean, set form with the installation of the answer form.
- To display the effects of predicting when available.
- Say the end of API to the developers they like to have formal.
Iris Predictor
Enter Iris flower measurements to get a prediction.
{% if submitted and result %}
Predicted class: {{ result.class_name }}
Probabilities:
{% for name, p in result.probabilities.items %}
- {{ name }}: {{ p|floatformat:3 }}
{% endfor %}
{% endif %}
API available at POST /api/predict/
Obvious 9. Run application
With everything in place, it is time to use our DJango project and test both web form and API ENDPONT.
Run the following command to set automatic dgango (administrative, sessions, etc.):
Launch the Dhango Development server:
python manage.py runserverIf all is well cut, you will see the outgoing such as:
Watching for file changes with StatReloader
Performing system checks...
System check identified no issues (0 silenced).
September 09, 2025 - 02:01:27
Django version 5.2.6, using settings 'mlapp.settings'
Starting development server at
Quit the server with CTRL-BREAK.Open your browser and visit: To use the web form identifier.
You can also send post request to API using curl:
curl -X POST api/predict/
-H "Content-Type: application/json"
-d '{"sepal_length":5.1,"sepal_width":3.5,"petal_length":1.4,"petal_width":0.2}'Expected Reply:
{
"class_index": 0,
"class_name": "setosa",
"probabilities": {
"setosa": 1.0,
"versicolor": 0.0,
"virginica": 0.0
}
}
Obvious 10. To explore
Before folding, it is a good practice to ensure that our app works as expected. The django supplies The checkpoint framework that includes Python unittest Module.
We will create a few simple tests to make sure:
- This page Home Page Translates well and input.
- This page API ENDPOINT Returns a valid forecast response.
In predictor/tests.pyAdd the following code:
from django.test import TestCase
from django.urls import reverse
class PredictorTests(TestCase):
def test_home_renders(self):
resp = self.client.get(reverse("home"))
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.client.post(url, payload)
self.assertEqual(resp.status_code, 200)
data = resp.json()
self.assertIn("class_name", data)
self.assertIn("probabilities", data)Run the following command in your furnace:
You should see the outgoing such as:
Found 2 test(s).
Creating test database for alias 'default'...
System check identified no issues (0 silenced).
..
----------------------------------------------------------------------
Ran 2 tests in 0.758s
OK
Destroying test database for alias 'default'...Through these trials pass, you can be sure that your DFATA machine program works well.
Obvious Summary
You have successfully created a comprehensive machine learning program using django Framework, bringing all parts together in the operating system.
Starting with training and maintenance model, including django services to make predictions. He has developed a pure user's web application and reflects a formal access. Additionally, you have worked out automatic tests to ensure that the app is reliable.
While the project is focused on the IRIS data, the same structure can be expanded to obtain severe models, large datasets, or even API ready for the production, which makes it a solid basis for international learning applications.
Abid Awa (@ 1abidaswan) is a certified scientist for a scientist who likes the machine reading models. Currently, focus on the creation of the content and writing technical blogs in a machine learning and data scientific technology. Avid holds a Master degree in technical management and Bachelor degree in Telecommunication Engineering. His viewpoint builds AI product uses a Graph Neural network for students who strive to be ill.
