TensorFlow vs NumPy — Comparison for Beginners

# NumPy — arrays and math.
# The foundation every ML framework builds on.

import numpy as np

# Create arrays
a = np.array([1, 2, 3, 4])
b = np.zeros((2, 3))       # 2x3 zeros
c = np.random.randn(3, 3)  # 3x3 random normal
d = np.arange(10)          # [0..9]

# Vectorised math — no Python loops
print(a * 2)               # [2, 4, 6, 8]
print(a ** 2)              # [1, 4, 9, 16]
print(a + a)               # [2, 4, 6, 8]

# Broadcasting — shapes align automatically
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(matrix + 10)         # every element + 10
print(matrix + a[:3])      # each row + [1, 2, 3]

# Linear algebra
X = np.random.randn(100, 5)
W = np.random.randn(5, 3)
y = X @ W                  # 100x3 matrix product
print(y.shape)             # (100, 3)

# Statistics
print(a.mean())            # 2.5
print(a.std())             # 1.118...
print(np.corrcoef(a, a * 2)[0, 1])  # 1.0

# What this teaches:
# - Arrays are the core data structure
# - Vectorisation means "operate on the whole array"
# - Broadcasting aligns shapes without copies
# - Linear algebra is a one-line operation
#
# What this is used for in ML:
# - Preparing data (features, labels)
# - Computing metrics (accuracy, MAE)
# - Implementing algorithms from scratch
# - The foundation of every other library

# TensorFlow — a tiny model.
# Everything NumPy does, plus autograd and GPU.

import tensorflow as tf
import numpy as np

# Tensors look like NumPy arrays
x = tf.constant([1, 2, 3, 4], dtype=tf.float32)
print(x)
print(x * 2)  # tensors support the same vectorised math

# The big difference — gradients
w = tf.Variable(2.0)
with tf.GradientTape() as tape:
    y = w * w * w + 2 * w  # y = w^3 + 2w
    # take derivative: dy/dw = 3w^2 + 2
grad = tape.gradient(y, w)
print(grad)  # 14.0 (at w=2)

# Build a small neural network
model = tf.keras.Sequential([
    tf.keras.layers.Dense(16, activation="relu", input_shape=(4,)),
    tf.keras.layers.Dense(3, activation="softmax"),
])

model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

# Train on dummy data (replace with real data)
X = np.random.randn(1000, 4).astype("float32")
y = np.random.randint(0, 3, 1000)
model.fit(X, y, epochs=5, batch_size=32, verbose=0)

# What this teaches:
# - Tensors support NumPy-style operations
# - GradientTape computes derivatives automatically
# - Keras provides high-level layers, optimisers, metrics
# - Training is "fit the model to the data" — 3 lines

# What NumPy cannot do on its own:
# - Compute gradients automatically
# - Run on a GPU with a one-line change
# - Save the model in a deployable format

# That is what TensorFlow adds.

# The full pipeline — NumPy prepares, TensorFlow trains.
# This is the real pattern in almost every ML project.

import numpy as np
import tensorflow as tf

# ── STEP 1: NumPy loads and prepares the data ──
# (In real projects, pandas reads the CSV, then NumPy converts it.)

raw = np.random.randn(5000, 20).astype("float32")

# Normalise features — mean 0, std 1
mean = raw.mean(axis=0)
std = raw.std(axis=0)
X = (raw - mean) / std

# Create synthetic labels: 0 if sum > 0, else 1
y = (X.sum(axis=1) > 0).astype("int32")

print(f"Features: {X.shape}, Labels: {y.shape}")
print(f"Feature mean: {X.mean():.3f}, std: {X.std():.3f}")

# ── STEP 2: TensorFlow builds and trains the model ──

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation="relu", input_shape=(20,)),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(2, activation="softmax"),
])

model.compile(
    optimizer=tf.keras.optimizers.Adam(1e-3),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

history = model.fit(
    X, y,
    epochs=10,
    batch_size=32,
    validation_split=0.2,
    verbose=1,
)

# ── STEP 3: Evaluate and save ──
test_loss, test_acc = model.evaluate(X, y, verbose=0)
print(f"Test accuracy: {test_acc:.3f}")

model.save("model.keras")

# What this shows:
# - NumPy did the data work (loading, normalising, shaping)
# - TensorFlow did the model work (training, evaluation, saving)
# - Neither could do the whole thing alone

# This is what real ML looks like:
# NumPy is the data layer. TensorFlow is the training layer.
# They are complements, not competitors.

# The interview question: "How would you preprocess X?"
# The answer is a NumPy answer.
# "How would you train the model?"
# The answer is a TensorFlow answer.
# Both come up in every ML interview.