Deep Learning Data Science Projects

Complete Implementation Guide — From Setup to Deployment

Prepared for: Harini S. | [Link] IT, MSEC Chennai Covers: FNN · CNN · RNN · LSTM · GRU · Autoencoder · GAN · Transformer

How to Use This Guide

Each project section below follows the same structure so you can execute it end-to-end:

1. Problem overview
2. Dataset (with real download link)
3. Environment setup commands
4. Project folder structure
5. Full code — preprocessing → model → training → evaluation
6. Explainability / visualization
7. Deployment (Streamlit dashboard)
8. Exact terminal commands to run everything

All code uses Python 3.10+, TensorFlow/Keras, scikit-learn, pandas, and Streamlit. Every project can be built and demoed in Cursor /
VS Code the same way, so once you do Project 1 carefully, the rest go much faster.

One-time global setup (do this once)

# Create a project workspace

mkdir dl-portfolio && cd dl-portfolio

# Create a virtual environment

python -m venv venv

# Activate it
# Windows:
venv\Scripts\activate
# Mac/Linux:
source venv/bin/activate

# Upgrade pip
pip install --upgrade pip

# Core libraries used across ALL 8 projects

pip install tensorflow keras scikit-learn pandas numpy matplotlib seaborn shap streamlit plotly jupyter kagg
lehub

To download Kaggle datasets via command line, set up the Kaggle API once:

pip install kaggle

# Go to [Link] -> Account -> Create New API Token, this downloads [Link]
mkdir -p ~/.kaggle
mv ~/Downloads/[Link] ~/.kaggle/
chmod 600 ~/.kaggle/[Link]

1
1. Feedforward Neural Network (FNN)

Project: Employee Attrition Risk Prediction System

1.1 Overview

Predict whether an employee is likely to leave the company using structured/tabular HR data (age, salary, satisfaction scores, overtime,
promotion history, etc.), then explain why using SHAP and surface results on a dashboard.

1.2 Dataset

IBM HR Analytics Employee Attrition & Performance Dataset (Kaggle, ~1,470 rows, 35 columns) Link: [Link]
datasets/pavansubhasht/ibm-hr-analytics-attrition-dataset

kaggle datasets download -d pavansubhasht/ibm-hr-analytics-attrition-dataset

unzip [Link] -d data/

1.3 Project Structure

attrition-fnn/
├── data/[Link]
├── [Link]
├── [Link]
├── [Link]
├── [Link]
└── model/attrition_model.h5

2
1.4 Preprocessing ( [Link] )

import pandas as pd
from sklearn.model_selection import train_test_split
from [Link] import StandardScaler, LabelEncoder
import joblib

df = pd.read_csv("data/[Link]")

# Drop non-informative constant columns

[Link](columns=["EmployeeCount", "EmployeeNumber", "Over18", "StandardHours"], inplace=True)

# Encode target
df["Attrition"] = df["Attrition"].map({"Yes": 1, "No": 0})

# Encode categorical columns

cat_cols = df.select_dtypes(include="object").columns
encoders = {}
for col in cat_cols:
le = LabelEncoder()
df[col] = le.fit_transform(df[col])
encoders[col] = le

X = [Link](columns=["Attrition"])
y = df["Attrition"]

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, stratify=y, random_state=42
)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = [Link](X_test)

[Link](scaler, "model/[Link]")
[Link](encoders, "model/[Link]")
[Link]((X_train_scaled, X_test_scaled, y_train, y_test, [Link]()), "model/[Link]")
print("Preprocessing complete:", X_train_scaled.shape, X_test_scaled.shape)

3
1.5 Model + Training ( [Link] )

import joblib
import tensorflow as tf
from [Link] import layers, models, callbacks
from [Link] import classification_report, roc_auc_score

X_train, X_test, y_train, y_test, feature_names = [Link]("model/[Link]")

model = [Link]([
[Link](shape=(X_train.shape[1],)),
[Link](64, activation="relu"),
[Link](0.3),
[Link](32, activation="relu"),
[Link](0.2),
[Link](16, activation="relu"),
[Link](1, activation="sigmoid")
])

[Link](optimizer="adam", loss="binary_crossentropy", metrics=["accuracy", [Link](name="

auc")])

early_stop = [Link](patience=8, restore_best_weights=True)

history = [Link](
X_train, y_train,
validation_split=0.2,
epochs=100,
batch_size=32,
callbacks=[early_stop],
verbose=1
)

y_pred = ([Link](X_test) > 0.5).astype(int)

print(classification_report(y_test, y_pred))
print("ROC-AUC:", roc_auc_score(y_test, [Link](X_test)))

[Link]("model/attrition_model.h5")

1.6 Explainability ( [Link] )

import shap
import joblib
import tensorflow as tf

model = [Link].load_model("model/attrition_model.h5")
X_train, X_test, y_train, y_test, feature_names = [Link]("model/[Link]")

explainer = [Link]([Link], X_train[:100])

shap_values = explainer.shap_values(X_test[:50])

shap.summary_plot(shap_values[0], X_test[:50], feature_names=feature_names, show=False)

import [Link] as plt
[Link]("model/shap_summary.png", bbox_inches="tight")
print("SHAP summary saved.")

4
1.7 Dashboard ( [Link] )

import streamlit as st
import joblib
import tensorflow as tf
import numpy as np
import pandas as pd

st.set_page_config(page_title="Employee Attrition Risk", layout="wide")

model = [Link].load_model("model/attrition_model.h5")
scaler = [Link]("model/[Link]")
_, _, _, _, feature_names = [Link]("model/[Link]")

[Link]("Employee Attrition Risk Dashboard")

uploaded = st.file_uploader("Upload employee CSV", type="csv")

if uploaded:
df = pd.read_csv(uploaded)
df_scaled = [Link](df[feature_names])
risk_scores = [Link](df_scaled).flatten()
df["Attrition_Risk_%"] = (risk_scores * 100).round(2)
[Link](df.sort_values("Attrition_Risk_%", ascending=False))
st.bar_chart(df.set_index([Link][0])["Attrition_Risk_%"])

1.8 Run Everything

python [Link]
python [Link]
python [Link]
streamlit run [Link]

5
2. Convolutional Neural Network (CNN)

Project: Satellite Land Cover Classification

2.1 Overview

Classify satellite image patches into land-cover categories (urban, agricultural, forest, water, barren, wetland) using CNN + transfer
learning, then visualize environmental trends.

2.2 Dataset

EuroSAT — Sentinel-2 satellite images, 27,000 labeled 64x64 patches, 10 classes. Link: [Link]
apollo2506/eurosat-dataset (Also available via TensorFlow Datasets: [Link]('eurosat') )

kaggle datasets download -d apollo2506/eurosat-dataset

unzip [Link] -d data/

2.3 Project Structure

landcover-cnn/
├── data/EuroSAT/<class_folders>/
├── [Link]
├── [Link]
├── [Link]
└── model/landcover_cnn.h5

6
2.4 Data Pipeline + Model ( [Link] )

import tensorflow as tf
from [Link] import layers, models
from [Link] import MobileNetV2

IMG_SIZE = (64, 64)

BATCH = 32

train_ds = [Link].image_dataset_from_directory(
"data/EuroSAT", validation_split=0.2, subset="training",
seed=42, image_size=IMG_SIZE, batch_size=BATCH
)
val_ds = [Link].image_dataset_from_directory(
"data/EuroSAT", validation_split=0.2, subset="validation",
seed=42, image_size=IMG_SIZE, batch_size=BATCH
)
class_names = train_ds.class_names
print("Classes:", class_names)

# Augmentation
augment = [Link]([
[Link]("horizontal_and_vertical"),
[Link](0.2),
[Link](0.1),
])

AUTOTUNE = [Link]
train_ds = train_ds.map(lambda x, y: (augment(x, training=True), y)).prefetch(AUTOTUNE)
val_ds = val_ds.prefetch(AUTOTUNE)

# Transfer learning backbone

base_model = MobileNetV2(input_shape=(64, 64, 3), include_top=False, weights="imagenet")
base_model.trainable = False

model = [Link]([
[Link](1./255),
base_model,
layers.GlobalAveragePooling2D(),
[Link](128, activation="relu"),
[Link](0.3),
[Link](len(class_names), activation="softmax")
])

[Link](optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])

history = [Link](train_ds, validation_data=val_ds, epochs=15)

[Link]("model/landcover_cnn.h5")
import json
[Link](class_names, open("model/class_names.json", "w"))

7
2.5 Evaluation ( [Link] )

import tensorflow as tf
import numpy as np
import json
from [Link] import confusion_matrix, classification_report
import seaborn as sns
import [Link] as plt

model = [Link].load_model("model/landcover_cnn.h5")
class_names = [Link](open("model/class_names.json"))

val_ds = [Link].image_dataset_from_directory(
"data/EuroSAT", validation_split=0.2, subset="validation",
seed=42, image_size=(64, 64), batch_size=32
)

y_true, y_pred = [], []

for images, labels in val_ds:
preds = [Link]([Link](images), axis=1)
y_true.extend([Link]())
y_pred.extend(preds)

print(classification_report(y_true, y_pred, target_names=class_names))

cm = confusion_matrix(y_true, y_pred)
[Link](cm, annot=True, fmt="d", xticklabels=class_names, yticklabels=class_names)
[Link]("model/confusion_matrix.png", bbox_inches="tight")

2.6 Web App ( [Link] )

import streamlit as st
import tensorflow as tf
import numpy as np
import json
from PIL import Image

[Link]("Satellite Land Cover Classifier")

model = [Link].load_model("model/landcover_cnn.h5")
class_names = [Link](open("model/class_names.json"))

uploaded = st.file_uploader("Upload a satellite image patch", type=["jpg", "png", "jpeg"])

if uploaded:
img = [Link](uploaded).resize((64, 64))
[Link](img, caption="Input image")
arr = np.expand_dims([Link](img), axis=0)
preds = [Link](arr)[0]
top = [Link](preds)[::-1][:3]
for i in top:
[Link](f"**{class_names[i]}**: {preds[i]*100:.2f}%")

2.7 Run Everything

python [Link]
python [Link]
streamlit run [Link]

8
3. Recurrent Neural Network (RNN)

Project: Customer Purchase Behavior Prediction

3.1 Overview

Learn sequential purchasing patterns from transaction history and predict the next product category a customer is likely to buy.

3.2 Dataset

Online Retail II Dataset (UCI / Kaggle) — ~1M transaction rows, UK-based online retailer. Link: [Link]
mashlyn/online-retail-ii-uci

kaggle datasets download -d mashlyn/online-retail-ii-uci

unzip [Link] -d data/

3.3 Project Structure

purchase-rnn/
├── data/online_retail_II.csv
├── build_sequences.py
├── [Link]
├── [Link]
└── model/purchase_rnn.h5

3.4 Sequence Building ( build_sequences.py )

import pandas as pd
import numpy as np
from [Link] import pad_sequences
from [Link] import LabelEncoder
import joblib

df = pd.read_csv("data/online_retail_II.csv", encoding="ISO-8859-1")
df = [Link](subset=["Customer ID", "Description"])
df = df.sort_values(["Customer ID", "InvoiceDate"])

le = LabelEncoder()
df["ItemCode"] = le.fit_transform(df["Description"])

sequences = [Link]("Customer ID")["ItemCode"].apply(list)

sequences = sequences[[Link](len) >= 5] # keep customers with enough history

X, y = [], []
SEQ_LEN = 5
for seq in sequences:
for i in range(len(seq) - SEQ_LEN):
[Link](seq[i:i+SEQ_LEN])
[Link](seq[i+SEQ_LEN])

X = pad_sequences(X, maxlen=SEQ_LEN)
y = [Link](y)

[Link]((X, y, le), "model/[Link]")

print("Sequences built:", [Link], [Link], "Vocab size:", len(le.classes_))

9
3.5 Model + Training ( [Link] )

import joblib
import tensorflow as tf
from [Link] import layers, models
from sklearn.model_selection import train_test_split

X, y, le = [Link]("model/[Link]")
vocab_size = len(le.classes_)

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

model = [Link]([
[Link](input_dim=vocab_size, output_dim=64, input_length=[Link][1]),
[Link](128, return_sequences=False),
[Link](0.3),
[Link](128, activation="relu"),
[Link](vocab_size, activation="softmax")
])

[Link](optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])

[Link](X_train, y_train, validation_data=(X_test, y_test), epochs=20, batch_size=256)

[Link]("model/purchase_rnn.h5")

3.6 Recommendation Generation ( [Link] )

import joblib
import tensorflow as tf
import numpy as np
from [Link] import pad_sequences

model = [Link].load_model("model/purchase_rnn.h5")
X, y, le = [Link]("model/[Link]")

def recommend_next(item_sequence, top_k=5):

codes = [Link](item_sequence)
padded = pad_sequences([codes], maxlen=[Link][1])
preds = [Link](padded)[0]
top_idx = [Link](preds)[::-1][:top_k]
return le.inverse_transform(top_idx)

# Example
sample_seq = list(le.inverse_transform(X[0]))
print("History:", sample_seq)
print("Recommended next items:", recommend_next(sample_seq))

3.7 Run Everything

python build_sequences.py
python [Link]
python [Link]

10
4. Long Short-Term Memory (LSTM)

Project: Air Quality Forecasting System

4.1 Overview

Forecast future Air Quality Index (AQI) values using historical pollution, weather, and atmospheric readings, with anomaly detection for
unusual spikes.

4.2 Dataset

Air Quality Data in India (2015–2020) — station-wise hourly/daily pollutant readings. Link: [Link]
rohanrao/air-quality-data-in-india

kaggle datasets download -d rohanrao/air-quality-data-in-india

unzip [Link] -d data/

4.3 Project Structure

aqi-lstm/
├── data/city_day.csv
├── [Link]
├── [Link]
├── [Link]
├── [Link]
└── model/aqi_lstm.h5

4.4 Preprocessing ( [Link] )

import pandas as pd
import numpy as np
from [Link] import MinMaxScaler
import joblib

df = pd.read_csv("data/city_day.csv", parse_dates=["Date"])
city_df = df[df["City"] == "Delhi"].sort_values("Date")
city_df = city_df[["Date", "PM2.5", "PM10", "NO2", "CO", "SO2", "O3", "AQI"]].dropna()

scaler = MinMaxScaler()
scaled = scaler.fit_transform(city_df.drop(columns=["Date"]))

SEQ_LEN = 14 # use 14 days to predict next day's AQI

X, y = [], []
for i in range(len(scaled) - SEQ_LEN):
[Link](scaled[i:i+SEQ_LEN])
[Link](scaled[i+SEQ_LEN][-1]) # AQI column

X, y = [Link](X), [Link](y)
split = int(len(X) * 0.85)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

[Link]((X_train, X_test, y_train, y_test, scaler, city_df), "model/[Link]")

print("Shapes:", X_train.shape, X_test.shape)

11
4.5 Model + Training ( [Link] )

import joblib
from [Link] import layers, models, callbacks

X_train, X_test, y_train, y_test, scaler, city_df = [Link]("model/[Link]")

model = [Link]([
[Link](shape=(X_train.shape[1], X_train.shape[2])),
[Link](64, return_sequences=True),
[Link](0.2),
[Link](32),
[Link](16, activation="relu"),
[Link](1)
])

[Link](optimizer="adam", loss="mse", metrics=["mae"])

es = [Link](patience=10, restore_best_weights=True)
[Link](X_train, y_train, validation_data=(X_test, y_test), epochs=100, batch_size=32, callbacks=[es])

[Link]("model/aqi_lstm.h5")

4.6 Forecasting + Anomaly Detection ( [Link] )

import joblib
import tensorflow as tf
import numpy as np

model = [Link].load_model("model/aqi_lstm.h5")
X_train, X_test, y_train, y_test, scaler, city_df = [Link]("model/[Link]")

preds = [Link](X_test).flatten()
residuals = [Link](preds - y_test)
threshold = [Link]() + 2 * [Link]()
anomalies = [Link](residuals > threshold)[0]

print(f"Detected {len(anomalies)} anomalous AQI days out of {len(y_test)}")

print("Anomaly indices:", anomalies)

4.7 Dashboard ( [Link] )

import streamlit as st
import joblib
import tensorflow as tf
import plotly.graph_objects as go

[Link]("Air Quality Forecasting Dashboard — Delhi")

model = [Link].load_model("model/aqi_lstm.h5")
X_train, X_test, y_train, y_test, scaler, city_df = [Link]("model/[Link]")

preds = [Link](X_test).flatten()

fig = [Link]()
fig.add_trace([Link](y=y_test, name="Actual AQI (scaled)"))
fig.add_trace([Link](y=preds, name="Predicted AQI (scaled)"))
st.plotly_chart(fig, use_container_width=True)

4.8 Run Everything

python [Link]
python [Link]
python [Link]
streamlit run [Link]

12
5. Gated Recurrent Unit (GRU)

Project: Smart Energy Consumption Forecasting

5.1 Overview

Forecast future electricity demand using historical hourly energy usage, enabling smart-grid load balancing.

5.2 Dataset

Hourly Energy Consumption (PJM Interconnection) — multi-year hourly MW readings. Link: [Link]
robikscube/hourly-energy-consumption

kaggle datasets download -d robikscube/hourly-energy-consumption

unzip [Link] -d data/

5.3 Project Structure

energy-gru/
├── data/PJME_hourly.csv
├── [Link]
├── [Link]
├── [Link]
└── model/energy_gru.h5

5.4 Preprocessing ( [Link] )

import pandas as pd
import numpy as np
from [Link] import MinMaxScaler
import joblib

df = pd.read_csv("data/PJME_hourly.csv", parse_dates=["Datetime"])
df = df.sort_values("Datetime")
df["hour"] = df["Datetime"].[Link]
df["dayofweek"] = df["Datetime"].[Link]
df["month"] = df["Datetime"].[Link]

features = df[["PJME_MW", "hour", "dayofweek", "month"]].values

scaler = MinMaxScaler()
scaled = scaler.fit_transform(features)

SEQ_LEN = 24 # past 24 hours -> next hour

X, y = [], []
for i in range(len(scaled) - SEQ_LEN):
[Link](scaled[i:i+SEQ_LEN])
[Link](scaled[i+SEQ_LEN][0])

X, y = [Link](X), [Link](y)
split = int(len(X) * 0.9)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

[Link]((X_train, X_test, y_train, y_test, scaler), "model/[Link]")

print("Shapes:", X_train.shape, X_test.shape)

13
5.5 Model + Training ( [Link] )

import joblib
from [Link] import layers, models, callbacks

X_train, X_test, y_train, y_test, scaler = [Link]("model/[Link]")

model = [Link]([
[Link](shape=(X_train.shape[1], X_train.shape[2])),
[Link](64, return_sequences=True),
[Link](0.2),
[Link](32),
[Link](16, activation="relu"),
[Link](1)
])

[Link](optimizer="adam", loss="mse", metrics=["mae"])

es = [Link](patience=8, restore_best_weights=True)
[Link](X_train, y_train, validation_data=(X_test, y_test), epochs=50, batch_size=64, callbacks=[es])

[Link]("model/energy_gru.h5")

5.6 Evaluation + Visualization ( [Link] )

import joblib
import tensorflow as tf
import [Link] as plt
from [Link] import mean_absolute_error, mean_squared_error

model = [Link].load_model("model/energy_gru.h5")
X_train, X_test, y_train, y_test, scaler = [Link]("model/[Link]")

preds = [Link](X_test).flatten()
print("MAE:", mean_absolute_error(y_test, preds))
print("RMSE:", mean_squared_error(y_test, preds, squared=False))

[Link](figsize=(12, 4))
[Link](y_test[:200], label="Actual")
[Link](preds[:200], label="Predicted")
[Link]()
[Link]("Energy Demand Forecast (sample window)")
[Link]("model/forecast_plot.png")

5.7 Run Everything

python [Link]
python [Link]
python [Link]

14
6. Autoencoder

Project: Credit Card Fraud Anomaly Detection

6.1 Overview

Train an autoencoder only on normal (non-fraud) transactions so it learns to reconstruct them well. Fraudulent transactions produce high
reconstruction error, flagging them as anomalies — with a real-time monitoring dashboard.

6.2 Dataset

Credit Card Fraud Detection Dataset (Kaggle / ULB) — 284,807 transactions, 492 frauds, PCA-anonymized features. Link: https://
[Link]/datasets/mlg-ulb/creditcardfraud

kaggle datasets download -d mlg-ulb/creditcardfraud

unzip [Link] -d data/

6.3 Project Structure

fraud-autoencoder/
├── data/[Link]
├── [Link]
├── [Link]
├── [Link]
└── model/fraud_autoencoder.h5

15
6.4 Model + Training ( [Link] )

import pandas as pd
import numpy as np
from [Link] import StandardScaler
from sklearn.model_selection import train_test_split
from [Link] import layers, models, callbacks
import joblib

df = pd.read_csv("data/[Link]")
X = [Link](columns=["Class"])
y = df["Class"]

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Train ONLY on normal transactions

X_train_full, X_test, y_train_full, y_test = train_test_split(
X_scaled, y, test_size=0.2, stratify=y, random_state=42
)
X_train_normal = X_train_full[y_train_full == 0]

input_dim = X_train_normal.shape[1]
model = [Link]([
[Link](shape=(input_dim,)),
[Link](20, activation="relu"),
[Link](10, activation="relu"),
[Link](20, activation="relu"),
[Link](input_dim, activation="linear")
])

[Link](optimizer="adam", loss="mse")
es = [Link](patience=5, restore_best_weights=True)
[Link](X_train_normal, X_train_normal, epochs=50, batch_size=256,
validation_split=0.1, callbacks=[es])

[Link]("model/fraud_autoencoder.h5")
[Link]((X_test, y_test, scaler), "model/test_data.pkl")

6.5 Threshold Selection + Evaluation ( [Link] )

import joblib
import tensorflow as tf
import numpy as np
from [Link] import classification_report, precision_recall_curve

model = [Link].load_model("model/fraud_autoencoder.h5")
X_test, y_test, scaler = [Link]("model/test_data.pkl")

reconstructions = [Link](X_test)
mse = [Link]([Link](X_test - reconstructions), axis=1)

precisions, recalls, thresholds = precision_recall_curve(y_test, mse)

f1_scores = 2 * (precisions * recalls) / (precisions + recalls + 1e-9)
best_threshold = thresholds[[Link](f1_scores)]
print("Best threshold:", best_threshold)

y_pred = (mse > best_threshold).astype(int)

print(classification_report(y_test, y_pred))

[Link](best_threshold, "model/[Link]")

16
6.6 Real-Time Monitoring Dashboard ( [Link] )

import streamlit as st
import joblib
import tensorflow as tf
import numpy as np
import pandas as pd

[Link]("Credit Card Fraud — Real-Time Anomaly Monitor")

model = [Link].load_model("model/fraud_autoencoder.h5")
_, _, scaler = [Link]("model/test_data.pkl")
threshold = [Link]("model/[Link]")

uploaded = st.file_uploader("Upload transaction batch (CSV)", type="csv")

if uploaded:
df = pd.read_csv(uploaded)
X = [Link]([Link](columns=["Class"], errors="ignore"))
recon = [Link](X)
mse = [Link]([Link](X - recon), axis=1)
df["Reconstruction_Error"] = mse
df["Fraud_Alert"] = mse > threshold
[Link]("Flagged Transactions", int(df["Fraud_Alert"].sum()))
[Link](df[df["Fraud_Alert"]].sort_values("Reconstruction_Error", ascending=False))
st.line_chart(df["Reconstruction_Error"])

6.7 Run Everything

python [Link]
python [Link]
streamlit run [Link]

17
7. Generative Adversarial Network (GAN)

Project: Synthetic Healthcare Data Generator

7.1 Overview

Train a GAN to generate realistic but fully synthetic patient records (demographic + clinical features), enabling privacy-safe research data
sharing.

7.2 Dataset

Diabetes Health Indicators Dataset (Kaggle, CDC BRFSS-derived, ~250K records, demographic + clinical fields) — used as the real-
data source the GAN learns from. Link: [Link]

kaggle datasets download -d alexteboul/diabetes-health-indicators-dataset

unzip [Link] -d data/

7.3 Project Structure

synthetic-health-gan/
├── data/diabetes_binary_health_indicators_BRFSS2015.csv
├── train_gan.py
├── [Link]
└── model/generator.h5

18
7.4 GAN Model + Training ( train_gan.py )

import pandas as pd
import numpy as np
from [Link] import MinMaxScaler
import tensorflow as tf
from [Link] import layers, models
import joblib

df = pd.read_csv("data/diabetes_binary_health_indicators_BRFSS2015.csv")
scaler = MinMaxScaler()
data = scaler.fit_transform([Link])
n_features = [Link][1]
LATENT_DIM = 32

def build_generator():
return [Link]([
[Link](shape=(LATENT_DIM,)),
[Link](64, activation="relu"),
[Link](128, activation="relu"),
[Link](n_features, activation="sigmoid")
])

def build_discriminator():
return [Link]([
[Link](shape=(n_features,)),
[Link](128, activation="relu"),
[Link](0.3),
[Link](64, activation="relu"),
[Link](1, activation="sigmoid")
])

generator = build_generator()
discriminator = build_discriminator()
[Link](optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])
[Link] = False

gan_input = [Link](shape=(LATENT_DIM,))
gan_output = discriminator(generator(gan_input))
gan = [Link](gan_input, gan_output)
[Link](optimizer="adam", loss="binary_crossentropy")

BATCH = 128
EPOCHS = 3000
for epoch in range(EPOCHS):
idx = [Link](0, [Link][0], BATCH)
real = data[idx]
noise = [Link](0, 1, (BATCH, LATENT_DIM))
fake = [Link](noise, verbose=0)

[Link] = True
d_loss_real = discriminator.train_on_batch(real, [Link]((BATCH, 1)))
d_loss_fake = discriminator.train_on_batch(fake, [Link]((BATCH, 1)))
[Link] = False

noise = [Link](0, 1, (BATCH, LATENT_DIM))

g_loss = gan.train_on_batch(noise, [Link]((BATCH, 1)))

if epoch % 200 == 0:
print(f"Epoch {epoch} | D_real: {d_loss_real[0]:.4f} D_fake: {d_loss_fake[0]:.4f} G_loss: {g_loss:.
4f}")

[Link]("model/generator.h5")
[Link](scaler, "model/[Link]")

19
7.5 Quality + Privacy Evaluation ( [Link] )

import numpy as np
import pandas as pd
import tensorflow as tf
import joblib
from [Link] import ks_2samp

generator = [Link].load_model("model/generator.h5")
scaler = [Link]("model/[Link]")
df = pd.read_csv("data/diabetes_binary_health_indicators_BRFSS2015.csv")
real = [Link]([Link])

noise = [Link](0, 1, (len(real), 32))

synthetic = [Link](noise)
synthetic_df = [Link](scaler.inverse_transform(synthetic), columns=[Link])

# Statistical similarity: Kolmogorov-Smirnov test per column

print("Column-wise KS statistic (lower = more similar):")
for col in [Link]:
stat, p = ks_2samp(df[col], synthetic_df[col])
print(f"{col}: KS={stat:.4f}, p={p:.4f}")

synthetic_df.to_csv("model/synthetic_patients.csv", index=False)
print("Synthetic dataset saved.")

7.6 Run Everything

python train_gan.py
python [Link]

20
8. Transformer

Project: Research Paper Recommendation and Summarization System

8.1 Overview

Use transformer sentence embeddings on paper abstracts to power semantic search, recommendations, topic clustering, and extractive/
abstractive summaries — wrapped in a web app for researchers.

8.2 Dataset

arXiv Dataset (Kaggle, Cornell University) — 1.7M+ paper metadata records (title, abstract, categories, authors). Link: https://
[Link]/datasets/Cornell-University/arxiv

kaggle datasets download -d Cornell-University/arxiv

unzip [Link] -d data/

8.3 Project Structure

paper-recommender-transformer/
├── data/[Link]
├── build_index.py
├── [Link]
├── [Link]
└── model/[Link]

8.4 Setup (additional libraries)

pip install sentence-transformers transformers torch scikit-learn

8.5 Build Embedding Index ( build_index.py )

import json
import pandas as pd
import numpy as np
from sentence_transformers import SentenceTransformer
from [Link] import KMeans

records = []
with open("data/[Link]") as f:
for i, line in enumerate(f):
if i >= 20000: # sample for a manageable local index
break
[Link]([Link](line))

df = [Link](records)[["id", "title", "abstract", "categories"]].dropna()

df["text"] = df["title"] + ". " + df["abstract"]

model = SentenceTransformer("all-MiniLM-L6-v2")
embeddings = [Link](df["text"].tolist(), show_progress_bar=True, batch_size=64)

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

df["topic_cluster"] = kmeans.fit_predict(embeddings)

[Link]("model/[Link]", embeddings)
df.to_pickle("model/[Link]")
print("Index built:", [Link])

21
8.6 Summarization ( [Link] )

from transformers import pipeline

summarizer = pipeline("summarization", model="facebook/bart-large-cnn")

def summarize_abstract(abstract, max_len=60):

result = summarizer(abstract, max_length=max_len, min_length=15, do_sample=False)
return result[0]["summary_text"]

if __name__ == "__main__":
import pandas as pd
df = pd.read_pickle("model/[Link]")
sample = [Link][0]["abstract"]
print("Original:", sample[:200], "...")
print("Summary:", summarize_abstract(sample))

8.7 Web App — Semantic Search + Recommendations ( [Link] )

import streamlit as st
import numpy as np
import pandas as pd
from sentence_transformers import SentenceTransformer
from [Link] import cosine_similarity

st.set_page_config(page_title="Research Paper Recommender", layout="wide")

[Link]("Research Paper Recommendation & Summarization")

@st.cache_resource
def load_resources():
model = SentenceTransformer("all-MiniLM-L6-v2")
embeddings = [Link]("model/[Link]")
df = pd.read_pickle("model/[Link]")
return model, embeddings, df

model, embeddings, df = load_resources()

query = st.text_input("Search papers by topic, keyword, or abstract snippet:")

if query:
query_vec = [Link]([query])
sims = cosine_similarity(query_vec, embeddings)[0]
top_idx = [Link](sims)[::-1][:10]
for idx in top_idx:
row = [Link][idx]
[Link](row["title"])
[Link](f"Category: {row['categories']} | Similarity: {sims[idx]:.3f}")
[Link](row["abstract"][:300] + "...")
[Link]()

8.8 Run Everything

python build_index.py
python [Link]
streamlit run [Link]

22
Appendix A — Common Issues & Fixes

Issue Fix

ModuleNotFoundError Activate venv, re-run pip install -r [Link]

Kaggle API 403 error Regenerate [Link] , check chmod 600 permission

CUDA/GPU not detected pip install tensorflow[and-cuda] or run on CPU (all code above works CPU-only, just slower)

Out-of-memory during training Reduce batch_size , or sample fewer rows (as done in the transformer index step)

Streamlit port conflict streamlit run [Link] --[Link] 8502

23
Appendix B — Freeze Your Environment (for resume/GitHub)

pip freeze > [Link]

git init
git add .
git commit -m "Initial commit: DL project"
git remote add origin [Link]
git push -u origin main

24
Appendix C — Resume Bullet Templates
• Built an FNN-based employee attrition predictor (Keras, SHAP) with 85%+ ROC-AUC and an interactive Streamlit risk dashboard.
• Developed a CNN transfer-learning pipeline (MobileNetV2) achieving 90%+ accuracy on 10-class satellite land-cover
classification (EuroSAT).
• Designed an LSTM forecasting system for AQI prediction with anomaly detection, deployed via Plotly/Streamlit dashboard.
• Implemented a GAN for privacy-preserving synthetic healthcare data generation, validated with KS-statistic similarity testing.
• Built a Transformer-based semantic search and summarization app over 20K+ arXiv papers using Sentence-BERT and BART.

End of guide. Each project folder is self-contained — copy the relevant section's commands into Cursor/VS Code terminal and run top to
bottom.

25