Machine Learning Project for Professionals

Machine learning is a branch of artificial intelligence where algorithms learn patterns from data instead of relying entirely on manually written rules.

Common Professional Applications

• Customer churn prediction
• Fraud detection
• Sales forecasting
• Credit risk prediction
• Recommendation systems
• Demand forecasting
• Customer segmentation
• Predictive maintenance
• Spam detection
• Quality inspection

A professional ML project is more than training a model. It includes business understanding, data preparation, validation, deployment, and monitoring.

Install the common packages used in this project:

pip install pandas numpy scikit-learn matplotlib joblib fastapi uvicorn

For professional projects, use a virtual environment and pin dependencies for reproducibility.

Consider a subscription company with thousands of customers. The business wants to identify customers who may cancel their subscription so the retention team can intervene.

Business Objective

Predict whether a customer is likely to churn based on historical customer behavior.

A supervised learning dataset normally contains input features and a target variable.

import pandas as pd

data = {
    "tenure_months": [3, 24, 8, 36, 12, 48, 5, 30],
    "monthly_spend": [99, 79, 120, 65, 89, 55, 130, 72],
    "support_tickets": [7, 1, 5, 0, 3, 1, 8, 2],
    "usage_hours": [12, 42, 18, 55, 30, 62, 10, 45],
    "churn": [1, 0, 1, 0, 0, 0, 1, 0]
}

df = pd.DataFrame(data)

print(df)

Real-world data frequently contains missing values, duplicates, inconsistent formats, invalid values, and unexpected categories.

print(df.isnull().sum())

df = df.drop_duplicates()

df["monthly_spend"] = pd.to_numeric(
    df["monthly_spend"],
    errors="coerce"
)

df = df.dropna()

print(df.info())

Feature engineering converts raw business information into variables that can help a model learn useful patterns.

df["spend_per_usage_hour"] = (
    df["monthly_spend"] /
    df["usage_hours"].replace(0, 1)
)

df["support_rate"] = (
    df["support_tickets"] /
    df["tenure_months"].replace(0, 1)
)

print(df)

These derived features can capture business relationships that raw columns alone may not represent clearly.

The model should be evaluated on data it did not use during training.

from sklearn.model_selection import train_test_split

features = [
    "tenure_months",
    "monthly_spend",
    "support_tickets",
    "usage_hours"
]

X = df[features]
y = df["churn"]

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

Logistic regression is a useful baseline for binary classification problems.

from sklearn.linear_model import LogisticRegression

model = LogisticRegression(max_iter=1000)

model.fit(X_train, y_train)

predictions = model.predict(X_test)

print(predictions)

After training, a new customer record can be sent to the model for a prediction.

new_customer = pd.DataFrame([{
    "tenure_months": 4,
    "monthly_spend": 125,
    "support_tickets": 7,
    "usage_hours": 11
}])

prediction = model.predict(new_customer)[0]
probability = model.predict_proba(new_customer)[0][1]

print("Churn:", prediction)
print("Churn Probability:", round(probability, 3))

Accuracy alone is often insufficient for business classification problems.

from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score,
    confusion_matrix
)

print("Accuracy:", accuracy_score(y_test, predictions))
print("Precision:", precision_score(y_test, predictions))
print("Recall:", recall_score(y_test, predictions))
print("F1:", f1_score(y_test, predictions))
print(confusion_matrix(y_test, predictions))

A binary classifier produces four important outcomes:

In churn prediction, a false negative can mean missing a customer who is actually at risk. The business should decide which error matters most before selecting a model threshold.

Some algorithms work better when numerical features are placed on comparable scales.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model.fit(X_train_scaled, y_train)

Pipelines help keep preprocessing and model training together.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("model", LogisticRegression(max_iter=1000))
])

pipeline.fit(X_train, y_train)

predictions = pipeline.predict(X_test)

A pipeline makes the transformation sequence explicit and easier to reuse during deployment.

from sklearn.ensemble import RandomForestClassifier

rf_model = RandomForestClassifier(
    n_estimators=200,
    random_state=42
)

rf_model.fit(X_train, y_train)

rf_predictions = rf_model.predict(X_test)

print("Accuracy:",
      accuracy_score(y_test, rf_predictions))

Tree-based ensembles can capture nonlinear relationships between business variables.

Cross-validation evaluates a model across multiple training and validation splits.

from sklearn.model_selection import cross_val_score

scores = cross_val_score(
    rf_model,
    X,
    y,
    cv=5,
    scoring="f1"
)

print("Fold Scores:", scores)
print("Mean F1:", scores.mean())

Hyperparameters control how a machine learning algorithm behaves.

from sklearn.model_selection import GridSearchCV

params = {
    "n_estimators": [100, 200],
    "max_depth": [None, 5, 10]
}

search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    params,
    cv=5,
    scoring="f1"
)

search.fit(X_train, y_train)

print(search.best_params_)

importance = pd.Series(
    rf_model.feature_importances_,
    index=features
).sort_values(ascending=False)

print(importance)

Feature importance can help analysts understand which variables contribute to a tree-based model's predictions, but it should not automatically be interpreted as causality.

A sales organization can use machine learning to estimate which incoming leads have characteristics associated with historical conversions.

lead = pd.DataFrame([{
    "company_size": 250,
    "website_visits": 12,
    "demo_requested": 1,
    "email_engagement": 8
}])

probability = model.predict_proba(lead)[0][1]

if probability >= 0.70:
    action = "Priority Follow-Up"
else:
    action = "Standard Follow-Up"

print(probability)
print(action)

Classification predicts categories. Regression predicts continuous numeric values.

from sklearn.linear_model import LinearRegression

reg_model = LinearRegression()

reg_model.fit(X_train, y_train)

prediction = reg_model.predict(X_test)

print(prediction)

Professional regression use cases include revenue forecasting, delivery-time prediction, demand estimation and price estimation.

Unsupervised learning can identify groups without a predefined target label.

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

segment_features = df[
    ["monthly_spend", "usage_hours"]
]

scaled = StandardScaler().fit_transform(
    segment_features
)

kmeans = KMeans(
    n_clusters=3,
    random_state=42,
    n_init=10
)

df["segment"] = kmeans.fit_predict(scaled)

print(df[["monthly_spend", "usage_hours", "segment"]])

The resulting segments can support marketing analysis, customer research, or differentiated service strategies.

Some business problems contain far fewer positive cases than negative cases, such as fraud or rare equipment failures.

• Inspect the class distribution.
• Use appropriate evaluation metrics.
• Consider class weights.
• Use stratified validation when appropriate.
• Choose thresholds based on business costs.

model = LogisticRegression(
    class_weight="balanced",
    max_iter=1000
)

model.fit(X_train, y_train)

Data leakage occurs when information unavailable at prediction time accidentally enters model training.

Examples

• Using future revenue to predict a past decision.
• Scaling the complete dataset before splitting.
• Including a post-outcome field as an input feature.
• Creating features from future transactions.

Once a model is validated, it can be serialized so an application can load it later.

import joblib

joblib.dump(
    pipeline,
    "churn_model.joblib"
)

loaded_model = joblib.load(
    "churn_model.joblib"
)

prediction = loaded_model.predict(new_customer)

print(prediction)

A trained model can be exposed through an API so other applications can request predictions.

from fastapi import FastAPI
import joblib
import pandas as pd

app = FastAPI()

model = joblib.load("churn_model.joblib")

@app.post("/predict")
def predict(customer: dict):

    data = pd.DataFrame([customer])

    prediction = model.predict(data)[0]
    probability = model.predict_proba(data)[0][1]

    return {
        "prediction": int(prediction),
        "probability": float(probability)
    }

This pattern can support fraud screening, recommendation, churn detection, lead scoring, anomaly detection, and many other production use cases.

Deployment is not the end of a machine learning project. Production models need monitoring.

Monitor both technical health and business outcomes.

Data drift occurs when the distribution of production inputs changes relative to the data used during model development.

Example

A churn model trained when most customers used desktop applications may behave differently after the product shifts heavily toward mobile usage.

• Compare feature distributions.
• Monitor category frequencies.
• Track missing-value rates.
• Monitor prediction distributions.
• Measure business outcomes when labels become available.

Models may need retraining when new data changes the relationship between inputs and outcomes.

def retrain_model(new_training_data):

    X = new_training_data[features]
    y = new_training_data["churn"]

    pipeline.fit(X, y)

    joblib.dump(
        pipeline,
        "churn_model_new.joblib"
    )

    return "New model trained"

Retraining should be controlled by a documented process rather than blindly triggered every time new data arrives.

Machine learning systems should have automated tests around data preparation, feature creation, prediction interfaces, and business rules.

def test_prediction_output():

    customer = {
        "tenure_months": 6,
        "monthly_spend": 110,
        "support_tickets": 4,
        "usage_hours": 15
    }

    result = predict_customer(
        loaded_model,
        customer
    )

    assert "prediction" in result
    assert "probability" in result
    assert 0 <= result["probability"] <= 1

Professionals should understand not only whether a model predicts correctly, but also what information influenced predictions and where the model has limitations.

• Inspect important features.
• Compare predictions across meaningful groups.
• Document training data and assumptions.
• Record model versions.
• Explain uncertainty where appropriate.
• Provide human review for high-impact decisions.

A payment platform may evaluate a transaction immediately after it is initiated.

In this type of system, prediction latency, false positives, false negatives, security, and operational review workflows all matter alongside model accuracy.

Business Problem

Predict customer churn so a subscription company can identify accounts that may require retention attention.

Step 1 — Collect Data

Gather historical customer activity, support interactions, subscription details, and churn outcomes.

Step 2 — Prepare Data

Clean missing values, remove duplicates, validate ranges, encode categories, and create useful features.

Step 3 — Train Models

Establish a baseline and compare suitable algorithms using cross-validation.

Step 4 — Evaluate

Measure precision, recall, F1, calibration or other metrics relevant to the actual business objective.

Step 5 — Deploy

Package the preprocessing and model into a prediction service.

Step 6 — Business Action

Combine predictions with business rules and route selected accounts to the appropriate workflow.

Step 7 — Monitor

Track data drift, latency, prediction distributions, operational outcomes, and model quality.

• Starting with an algorithm instead of a business problem.
• Using an inappropriate target variable.
• Ignoring missing or invalid data.
• Allowing data leakage.
• Using accuracy as the only metric.
• Overfitting the training data.
• Repeatedly tuning against the test set.
• Ignoring class imbalance.
• Deploying without monitoring.
• Assuming correlation means causation.
• Ignoring changes in production data.
• Failing to document model assumptions.

• Define the business objective and success metric first.
• Build a simple baseline before complex models.
• Keep training, validation, and test data separated.
• Use reproducible preprocessing pipelines.
• Track experiments and model versions.
• Validate data quality continuously.
• Choose metrics based on business costs.
• Monitor production performance.
• Document features and model assumptions.
• Design rollback and retraining procedures.
• Protect sensitive data and model endpoints.
• Use human review where business impact warrants it.

Professional machine learning is not simply about choosing the most sophisticated algorithm. A successful project connects business objectives, reliable data, appropriate features, measurable model performance, production engineering, and continuous monitoring.

A useful machine learning professional should be able to move from a business question to a validated prediction system and then operate that system responsibly in production.

Machine Learning Project for Professionals

Build models that connect data science with real-world business decisions.