Step 1 — Define the Problem

Before touching any data or code, clearly define what you are trying to predict. Answer these three questions:

1. What is the target variable? What exactly are you predicting? (e.g., “Will this passenger survive?” → binary classification)
2. What type of ML problem is it? Classification (predicting a category) or Regression (predicting a number)?
3. How will you measure success? What metric matters? (Accuracy for balanced classification, F1 for imbalanced, RMSE for regression)

For your first project: Choose a well-understood problem with a clear target variable and publicly available data. Avoid ambiguous problems where the target is not clearly defined.

Good first problems: Predicting whether a bank customer will churn (binary classification). Predicting house sale prices (regression). Classifying flowers by species (multi-class classification).

Step 2 — Collect Data

For your first project, use a public dataset — do not spend weeks scraping or collecting data. The goal is to learn the ML workflow, not data collection.

Best Sources for Public Datasets:

Step 3 — Exploratory Data Analysis (EDA)

Before any modelling, understand your data deeply. Surprises discovered in EDA are cheaper to handle now than after building a model.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Load data
df = pd.read_csv('your_dataset.csv')

# --- Basic overview ---
print("Shape:", df.shape)
print("\nData types:\n", df.dtypes)
print("\nFirst 5 rows:\n", df.head())
print("\nStatistical summary:\n", df.describe())
print("\nMissing values:\n", df.isnull().sum())

# --- Target variable distribution ---
print("\nTarget distribution:\n", df['target'].value_counts())
sns.countplot(x='target', data=df)
plt.title('Class Distribution')
plt.show()

# --- Numerical feature distributions ---
df.hist(figsize=(15, 10), bins=30)
plt.tight_layout()
plt.show()

# --- Correlation heatmap ---
plt.figure(figsize=(10, 8))
sns.heatmap(df.select_dtypes(include='number').corr(),
            annot=True, cmap='coolwarm', fmt='.2f')
plt.title('Feature Correlation Matrix')
plt.show()

# --- Check for class imbalance ---
class_counts = df['target'].value_counts()
imbalance_ratio = class_counts.max() / class_counts.min()
print(f"\nImbalance ratio: {imbalance_ratio:.1f}x")
if imbalance_ratio > 3:
    print("WARNING: Significant class imbalance detected!")
    print("Consider: class_weight='balanced', oversampling (SMOTE), or F1 metric")
    

Key EDA Questions to Answer:

• How many samples? How many features? Any missing data?
• Are classes balanced or imbalanced?
• What is the distribution of each feature? Any outliers?
• Which features correlate most with the target?
• Are any features highly correlated with each other (multicollinearity)?
• Are there any obvious data quality issues (negative ages, impossible values)?

Step 4 — Preprocess the Data

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

# --- Split FIRST (before any preprocessing) ---
X = df.drop('target', axis=1)
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y  # stratify for classification
)

# --- Identify feature types ---
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns.tolist()
categorical_cols = X.select_dtypes(include=['object', 'category']).columns.tolist()
print(f"Numerical features: {numerical_cols}")
print(f"Categorical features: {categorical_cols}")

# --- Build preprocessing pipeline ---
num_pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])
cat_pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])
preprocessor = ColumnTransformer([
    ('num', num_pipeline, numerical_cols),
    ('cat', cat_pipeline, categorical_cols)
])

# The preprocessor fits on train, transforms both train and test
X_train_processed = preprocessor.fit_transform(X_train)
X_test_processed  = preprocessor.transform(X_test)
print(f"\nProcessed shape: {X_train_processed.shape}")
    

Step 5 — Build a Baseline Model

Always start with the simplest possible model. A baseline tells you the minimum performance level — if a complex model cannot beat a simple baseline, something is wrong.

from sklearn.linear_model import LogisticRegression
from sklearn.dummy import DummyClassifier
from sklearn.metrics import accuracy_score, f1_score, classification_report

# Dumb baseline: always predict the most common class
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train_processed, y_train)
dummy_pred = dummy.predict(X_test_processed)
print(f"Dummy Baseline Accuracy: {accuracy_score(y_test, dummy_pred):.3f}")

# Simple ML baseline: Logistic Regression
baseline = LogisticRegression(random_state=42, max_iter=1000)
baseline.fit(X_train_processed, y_train)
baseline_pred = baseline.predict(X_test_processed)
print(f"Logistic Regression Accuracy: {accuracy_score(y_test, baseline_pred):.3f}")
print(f"Logistic Regression F1: {f1_score(y_test, baseline_pred, average='weighted'):.3f}")
print("\nClassification Report:")
print(classification_report(y_test, baseline_pred))
    

Step 6 — Improve the Model

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.svm import SVC

# --- Compare multiple models with cross-validation ---
models = {
    'Logistic Regression': LogisticRegression(max_iter=1000),
    'Random Forest':       RandomForestClassifier(n_estimators=100, random_state=42),
    'Gradient Boosting':   GradientBoostingClassifier(n_estimators=100, random_state=42),
    'SVM':                 SVC(kernel='rbf', probability=True)
}

print("Model Comparison (10-Fold Cross-Validation F1):")
best_model_name = None
best_score = 0
for name, model in models.items():
    scores = cross_val_score(model, X_train_processed, y_train,
                             cv=10, scoring='f1_weighted')
    mean_score = scores.mean()
    print(f"  {name:<25}: {mean_score:.3f} +/- {scores.std():.3f}")
    if mean_score > best_score:
        best_score = mean_score
        best_model_name = name

print(f"\nBest model: {best_model_name} (F1: {best_score:.3f})")

# --- Hyperparameter tuning for best model ---
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [None, 10, 20],
    'min_samples_leaf': [1, 5, 10]
}
grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid, cv=5, scoring='f1_weighted', n_jobs=-1
)
grid_search.fit(X_train_processed, y_train)
print(f"\nBest hyperparameters: {grid_search.best_params_}")
print(f"Best CV F1: {grid_search.best_score_:.3f}")
    

Step 7 — Evaluate and Interpret Results

from sklearn.metrics import (confusion_matrix, classification_report,
                              roc_auc_score, RocCurveDisplay)
import matplotlib.pyplot as plt
import numpy as np

# Final evaluation on held-out test set
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test_processed)
y_prob = best_model.predict_proba(X_test_processed)[:, 1]

print("=== FINAL TEST SET RESULTS ===")
print(f"Accuracy:  {accuracy_score(y_test, y_pred):.3f}")
print(f"F1 Score:  {f1_score(y_test, y_pred, average='weighted'):.3f}")
print(f"AUC-ROC:   {roc_auc_score(y_test, y_prob):.3f}")
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

# Confusion matrix
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.show()

# Feature importance
if hasattr(best_model, 'feature_importances_'):
    # Get feature names after one-hot encoding
    feature_names = (numerical_cols +
                     list(preprocessor.named_transformers_['cat']
                          .named_steps['encoder'].get_feature_names_out(categorical_cols)))
    importances = best_model.feature_importances_
    top_idx = np.argsort(importances)[-10:]  # Top 10 features
    plt.barh(range(10), importances[top_idx])
    plt.yticks(range(10), [feature_names[i] for i in top_idx])
    plt.title('Top 10 Feature Importances')
    plt.show()
    

Step 8 — Document and Share

A well-documented project on GitHub is your most valuable ML portfolio asset. Here is what to include:

README.md Structure:

• Project Title & Description: What problem does this solve? Why is it interesting?
• Dataset: Source, size, features, target variable.
• Approach: Which algorithms did you try? What was your evaluation strategy?
• Results: Final metrics on the test set. Comparison table of all models tried.
• Key Findings: What did you learn? What surprised you? What would you do differently?
• How to Run: Installation instructions, how to reproduce results.

Where to Share:

• GitHub: Upload your Jupyter notebook and README. Make it public.
• Kaggle: Submit your notebook to the relevant competition or publish as a public notebook.
• LinkedIn: Post about your project — what you learned, your results, a visualisation from your EDA.

Recommended First Project Ideas

Common Mistakes in First ML Projects

• Starting with a complex problem: Object detection, speech recognition, or NLP before mastering tabular data ML. Start with simple classification on structured data.
• Skipping EDA: Jumping straight to model building without understanding the data. Data surprises found after modelling cost 10x more time to fix.
• Not splitting data before preprocessing: Fitting scalers and imputers on the full dataset causes data leakage. Always split first, then preprocess.
• Evaluating only on training data: 100% training accuracy almost certainly means overfitting. Always evaluate on a held-out test set.
• Not sharing your work: A private project on your laptop contributes nothing to your portfolio. Share on GitHub, even if imperfect. Done is better than perfect.