Pandas or PyTorch First: What Beginners Should Learn

# sales_analysis.py — a real Pandas analysis
# This is the kind of work that makes up the first 80% of any ML project.

import pandas as pd

# 1. Load the data
df = pd.read_csv("sales.csv", parse_dates=["order_date"])

# 2. Inspect before doing anything
print(df.shape)
print(df.dtypes)
print(df.isna().sum())

# 3. Clean
df = df.dropna(subset=["customer_id", "order_date", "amount"])
df = df[df["amount"] >= 0]

# 4. Feature engineering
df["month"] = df["order_date"].dt.to_period("M")
df["is_big_order"] = df["amount"] > 5000

# 5. Aggregate by region and month
monthly = (
    df.groupby(["month", "region"])
      .agg(
          orders=("order_id", "count"),
          revenue=("amount", "sum"),
          avg_order=("amount", "mean"),
      )
      .reset_index()
)

print(monthly.sort_values("revenue", ascending=False).head(10))

# 6. Understand the customer base
top_customers = (
    df.groupby("customer_id")
      .agg(orders=("order_id", "count"), revenue=("amount", "sum"))
      .sort_values("revenue", ascending=False)
      .head(20)
)

print(top_customers)


# What this file teaches:
# - How to load and inspect data
# - How to clean and filter safely
# - How to engineer features
# - How to group and aggregate
# - How to sort and inspect results
#
# Why this matters for ML:
# - Every PyTorch project starts with a DataFrame like this
# - Feature engineering here improves model quality later
# - Clean data prevents "garbage in, garbage out"

# pandas_to_torch.py — the bridge between Pandas and PyTorch
# This is the actual workflow every PyTorch beginner should see.

import pandas as pd
import torch
from torch.utils.data import Dataset, DataLoader
from sklearn.preprocessing import StandardScaler

# 1. Load data in Pandas — the natural starting point
df = pd.read_csv("customers.csv")
df = df.dropna()

# 2. Separate target and features
y = df["churned"].values
X = df.drop(columns=["churned", "customer_id"])

# 3. Identify column types
num_cols = X.select_dtypes(include="number").columns
cat_cols = X.select_dtypes(include="object").columns

# 4. Scale numeric features
scaler = StandardScaler()
X[num_cols] = scaler.fit_transform(X[num_cols])

# 5. Encode categorical features
X = pd.get_dummies(X, columns=cat_cols, drop_first=True)

# 6. Convert to numpy, then to tensors
X_tensor = torch.tensor(X.values, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.float32).unsqueeze(1)

# 7. Wrap in a Dataset and DataLoader
class ChurnDataset(Dataset):
    def __init__(self, X, y):
        self.X = X
        self.y = y

    def __len__(self):
        return len(self.X)

    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

dataset = ChurnDataset(X_tensor, y_tensor)
loader = DataLoader(dataset, batch_size=32, shuffle=True)


# What this file teaches:
# - The actual path from Pandas to PyTorch
# - Why scaling matters for neural networks
# - Why encoding matters for categorical data
# - How DataLoader wraps tensors for training
#
# Why interviewers expect this workflow:
# - Almost every real PyTorch project begins this way
# - Knowing this proves you can get from raw data to model

# train_churn.py — a clean PyTorch training loop on prepared data
# The model layer — what you learn AFTER Pandas.

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from pandas_to_torch import loader  # from the previous example

# 1. Define a simple model
class ChurnNet(nn.Module):
    def __init__(self, n_features):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n_features, 64),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1),
        )

    def forward(self, x):
        return self.net(x)

# 2. Instantiate
n_features = next(iter(loader))[0].shape[1]
model = ChurnNet(n_features)

# 3. Loss and optimiser
loss_fn = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

# 4. Training loop
for epoch in range(10):
    epoch_loss = 0.0
    for X_batch, y_batch in loader:
        optimizer.zero_grad()
        logits = model(X_batch)
        loss = loss_fn(logits, y_batch)
        loss.backward()
        optimizer.step()
        epoch_loss += loss.item()

    print(f"Epoch {epoch + 1}: loss={epoch_loss:.4f}")


# What this file teaches:
# - The standard PyTorch training loop
# - Why zero_grad, backward, and step happen in that order
# - Why BCEWithLogitsLoss is used for binary classification
# - Why dropout helps prevent overfitting
#
# Why this matters:
# - This is the entire "modelling" layer
# - Everything else is data — which is why Pandas first