Deploying machine learning models turns complex data science work into useful real-world applications. And guess what? You don’t need to be a tech wizard to make it happen. With Flask, a lightweight and flexible Python web framework, you can get your model up and running online. Let’s walk through this—step-by-step—in a way that won’t make your head spin.
First things first, it’s about setting up the environment. You’ll need to gather your tools, kinda like laying out all your ingredients before you start cooking. Here, we’re talking about installing libraries and creating a virtual space for your project. This keeps things tidy and avoids the dreaded version conflicts.
# Create a new directory for your project
mkdir ml-deployment
cd ml-deployment
# Create a virtual environment
python3 -m venv venv
source venv/bin/activate
# Install Flask and other required libraries
pip install flask pandas numpy scikit-learn
Once you’ve got your environment set up, the next step is to create a basic Flask application. Think of this as your canvas.
from flask import Flask, render_template, request, jsonify
app = Flask(__name__)
@app.route('/')
def home():
return "Hello, World!"
if __name__ == '__main__':
app.run(debug=True)
Running this script, you should see “Hello, World!” in your browser when you navigate to http://localhost:5000/. It’s a good sign—your basic Flask app is alive.
Next, let’s make the app prettier and more interactive with some HTML. You’ll put this in a directory called templates.
<!-- templates/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>ML Model Deployment</title>
</head>
<body>
<h1>Machine Learning Model Deployment</h1>
<form action="/predict" method="post">
<label for="input">Enter your data:</label>
<input type="text" id="input" name="input">
<input type="submit" value="Predict">
</form>
</body>
</html>
Now, update your Flask app to render this template:
from flask import Flask, render_template, request, jsonify
app = Flask(__name__)
@app.route('/')
def home():
return render_template('index.html')
if __name__ == '__main__':
app.run(debug=True)
Great! We’ve got the looks. Now let’s talk brains—your machine learning model. Using a decision tree classifier trained on the Adult dataset, you’ll weave this into your Flask app. First, train and save your model using scikit-learn and pickle.
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
import pickle
# Load the dataset
df = pd.read_csv('adult.csv')
# Preprocess the data
X = df.drop('target', axis=1)
y = df['target']
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=100)
# Train the model
dt_clf = DecisionTreeClassifier(criterion="gini", random_state=100, max_depth=5, min_samples_leaf=5)
dt_clf.fit(X_train, y_train)
# Save the model
with open('model.pkl', 'wb') as f:
pickle.dump(dt_clf, f)
Once you’ve saved your model, load it into your Flask application and start making predictions.
from flask import Flask, render_template, request, jsonify
import pickle
import pandas as pd
app = Flask(__name__)
# Load the saved model
with open('model.pkl', 'rb') as f:
model = pickle.load(f)
@app.route('/')
def home():
return render_template('index.html')
@app.route('/predict', methods=['POST'])
def predict():
input_data = request.form['input']
# Preprocess the input data
input_df = pd.DataFrame([input_data], columns=['feature'])
prediction = model.predict(input_df)
return jsonify({'prediction': prediction})
if __name__ == '__main__':
app.run(debug=True)
Ready for the big leagues? Let’s deploy this bad boy. One of the popular platforms is Render. First, push your code to GitHub. Then head over to Render, create a new web service, link your GitHub repo, and get your app hosted.
Your render.yaml might look something like this:
services:
- type: web
name: ml-deployment
env: python
build:
command: "pip install -r requirements.txt"
run:
command: "python app.py"
healthCheck:
path: "/"
To ensure the app looks snazzy, you can add some CSS. Create a static directory and drop in a styles.css.
/* static/styles.css */
body {
font-family: Arial, sans-serif;
background-color: #f4f4f4;
}
h1 {
color: #333;
}
form {
margin-top: 20px;
}
input[type="text"] {
width: 50%;
height: 30px;
font-size: 16px;
padding: 10px;
margin-bottom: 20px;
}
input[type="submit"] {
width: 100px;
height: 30px;
font-size: 16px;
background-color: #4CAF50;
color: white;
padding: 10px;
border: none;
border-radius: 5px;
cursor: pointer;
}
input[type="submit"]:hover {
background-color: #3e8e41;
}
Update your index.html to include this CSS file:
<!-- templates/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>ML Model Deployment</title>
<link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }}">
</head>
<body>
<h1>Machine Learning Model Deployment</h1>
<form action="/predict" method="post">
<label for="input">Enter your data:</label>
<input type="text" id="input" name="input">
<input type="submit" value="Predict">
</form>
</body>
</html>
What if you need to make your model available through an API? No problem. You can add more routes to your Flask app like this:
from flask import Flask, render_template, request, jsonify
import pickle
import pandas as pd
app = Flask(__name__)
# Load the saved model
with open('model.pkl', 'rb') as f:
model = pickle.load(f)
@app.route('/')
def home():
return render_template('index.html')
@app.route('/predict', methods=['POST'])
def predict():
input_data = request.form['input']
# Preprocess the input data
input_df = pd.DataFrame([input_data], columns=['feature'])
prediction = model.predict(input_df)
return jsonify({'prediction': prediction})
@app.route('/api/predict', methods=['POST'])
def api_predict():
data = request.get_json()
input_df = pd.DataFrame([data['input']], columns=['feature'])
prediction = model.predict(input_df)
return jsonify({'prediction': prediction})
if __name__ == '__main__':
app.run(debug=True)
Now, you can interact with your model via HTTP requests. Handy for other applications to use your model.
Deploying machine learning models using Flask might seem like a complicated beast, but it doesn’t have to be. With a bit of setup, some HTML, CSS, and a pinch of Python, you’ve got this! Follow these steps to make your machine learning models accessible and interactive, ready to churn out real-world predictions. Your tidy, well-prepped code environment, combined with a sleek user interface, will ensure a delightful user experience. Happy coding!