How TensorFlow Helps You Land a Data Scientist Job Faster

# Create an environment and install TensorFlow (CPU is fine for learning)
python -m venv .venv
source .venv/bin/activate
pip install tensorflow scikit-learn pandas

python -c "import tensorflow as tf; print(tf.__version__)"
python -c "import tensorflow as tf; print(tf.config.list_physical_devices())"

# Keras is included: tf.keras
python -c "from tensorflow import keras; print(keras.__version__)"

# Always build a simple baseline before a neural network
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)

scaler = StandardScaler().fit(X_train)
X_train_s, X_test_s = scaler.transform(X_train), scaler.transform(X_test)

base = LogisticRegression(max_iter=1000).fit(X_train_s, y_train)
print("Baseline ROC AUC:", roc_auc_score(y_test, base.predict_proba(X_test_s)[:, 1]))

# Continues from the baseline: same scaled split
import tensorflow as tf
from tensorflow import keras

tf.random.set_seed(42)

model = keras.Sequential([
    keras.Input(shape=(X_train_s.shape[1],)),
    keras.layers.Dense(32, activation="relu"),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(16, activation="relu"),
    keras.layers.Dense(1, activation="sigmoid"),
])

model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss="binary_crossentropy",
    metrics=[keras.metrics.AUC(name="auc")],
)

history = model.fit(
    X_train_s, y_train,
    validation_split=0.2,
    epochs=100, batch_size=32, verbose=0,
    callbacks=[keras.callbacks.EarlyStopping(
        monitor="val_loss", patience=10, restore_best_weights=True)],
)

from sklearn.metrics import roc_auc_score, classification_report

probs = model.predict(X_test_s, verbose=0).ravel()
print("Keras ROC AUC   :", roc_auc_score(y_test, probs))
print("Baseline ROC AUC:", roc_auc_score(y_test, base.predict_proba(X_test_s)[:, 1]))

print(classification_report(y_test, (probs >= 0.5).astype(int)))

# Report honestly: on small tabular data the baseline is often
# just as good. Say so, and explain when the neural net would win
# (more data, images, text, complex interactions).
print("Epochs trained:", len(history.history["loss"]))

import tensorflow as tf

AUTOTUNE = tf.data.AUTOTUNE

train_ds = (
    tf.data.Dataset.from_tensor_slices((X_train_s, y_train))
    .cache()
    .shuffle(buffer_size=len(X_train_s), seed=42)
    .batch(32)
    .prefetch(AUTOTUNE)
)

test_ds = (
    tf.data.Dataset.from_tensor_slices((X_test_s, y_test))
    .batch(64)
    .prefetch(AUTOTUNE)
)

# Same API for large image or text datasets, for example:
# tf.keras.utils.image_dataset_from_directory("data/train",
#     image_size=(224, 224), batch_size=32)

model.evaluate(test_ds, verbose=0)

import numpy as np
import joblib
from tensorflow import keras

# Save model and the preprocessing it depends on
model.save("cancer_model.keras")
joblib.dump(scaler, "scaler.joblib")

# Reload test: predictions must match
reloaded = keras.models.load_model("cancer_model.keras")
sc = joblib.load("scaler.joblib")
a = model.predict(X_test_s[:5], verbose=0)
b = reloaded.predict(sc.transform(X_test[:5]), verbose=0)
assert np.allclose(a, b, atol=1e-6)

# SavedModel directory for TensorFlow Serving (Keras 3)
model.export("export/cancer_model/1")

PROJECT BRIEF - fill in before writing any model code

Problem      : What decision will this model support?
Data         : Source, size, licence, label definition
Target metric: e.g. recall at fixed precision, MAE
Why it matters: cost of a false positive vs false negative
Baseline     : Simple model or rule to beat (must exist)
Split        : Train / validation / test, how and why
               (time-based split for time series)
Deep learning justification:
  [ ] Images / text / audio / sequences
  [ ] Large data with complex patterns
  [ ] Baseline clearly insufficient
Done when    : Metric target met on untouched test set

EXPERIMENT LOG - one line per run

Run | Model          | Key settings                  | Val metric | Notes
----|----------------|-------------------------------|------------|-----------------------
 01 | LogReg         | C=1.0, scaled                 |            | baseline
 02 | Dense 32-16    | dropout 0.2, lr 1e-3          |            | early stop epoch __
 03 | Dense 64-32    | dropout 0.3, L2 1e-4          |            |
 04 |                |                               |            |

Rules
- Change one thing per run
- Fix random seeds and note them
- Test set is used ONCE, for the final chosen model
- Keep failed runs in the log; they are interview material

MODEL CARD

Model name     : ______  Version: ______  Date: ______
Framework      : TensorFlow ____ / Keras ____
Task           : Binary classification (example)

Training data  : Source, rows, date range, known gaps
Preprocessing  : Scaler saved as scaler.joblib
Inputs         : Feature list with units
Output         : Probability 0-1; threshold used: ____

Performance (test set)
  Metric       : ______  Baseline: ______
  Weak spots   : Groups or cases where it performs worse

Limitations    : Where it should NOT be used
Files          : model.keras, scaler.joblib, export/1/
Reload check   : Passed on ____ (predictions match)