Day 78: TensorFlow and PyTorch Basics — Two Kitchens, One Goal

Why Should I Care?

Every deep learning model you have ever used — the one behind YouTube recommendations, Netflix suggestions, or Google Translate — was built using either TensorFlow or PyTorch. These two frameworks are the industry standard. If you want to build real AI, you need to know at least one of them. The good news is they cook the same food, just in different kitchens.

Core Concept

Think of TensorFlow and PyTorch as two kitchens with the same menu — a trained neural network. TensorFlow is the production kitchen. It is structured, reliable, and great for deploying models to mobile apps and the cloud. PyTorch is the research kitchen. It is flexible, dynamic, and lets you experiment and debug freely. Same goal. Different cooking style. You need to recognise both.

How It Works

Both frameworks let you build neural networks by stacking layers together. TensorFlow uses the Keras API on top, which makes the syntax clean and beginner-friendly. PyTorch is more explicit — you control every single step yourself. Both support backpropagation, GPU training, and all the same architectures. The choice comes down to what you are doing with the model after training it.

Which framework should I pick?

Deploying to production, mobile, or cloud  -->  TensorFlow
Doing research or exploring new ideas      -->  PyTorch
Just learning deep learning               -->  Either one is fine

Import aliases — NEVER break these conventions:
  import tensorflow as tf      (always tf, never anything else)
  import torch                 (always torch)
  import torch.nn as nn        (always nn)

What they share:
  - Neural networks and deep learning
  - Backpropagation and gradient descent
  - Python-based syntax
  - Support for GPU training

What makes them different:
  TensorFlow  -->  Production, mobile, scale
  PyTorch     -->  Research, flexible, dynamic computation graph

Real World Connection

Google uses TensorFlow to power Search, Maps, and Google Photos at a scale of billions of users. Meta uses PyTorch for all its AI research behind Facebook and Instagram features. When a Swiggy delivery time predictor ships to your phone, it likely runs on TensorFlow Lite. When a researcher at an AI lab experiments with a new model architecture, they almost certainly write it in PyTorch. Both frameworks are powering the apps you open every single day.

Examples

# TensorFlow / Keras version
import numpy as np
import tensorflow as tf

X = np.array([[1],[2],[3],[4],[5],[6],[7],[8]], dtype=float)
y = np.array([45,55,62,71,80,85,91,97],        dtype=float)

# Build the model with Keras — clean and structured
model = tf.keras.Sequential([
    tf.keras.layers.Dense(16, activation="relu", input_shape=(1,)),
    tf.keras.layers.Dense(8,  activation="relu"),
    tf.keras.layers.Dense(1)
])

model.compile(optimizer="adam", loss="mse")  # sets up backprop
model.fit(X, y, epochs=10, verbose=0)        # 10 full training cycles

pred = model.predict([[9]], verbose=0)[0][0]
print(f"TensorFlow Prediction (9 hours): {pred:.1f}")
print(f"Framework : TensorFlow {tf.__version__}")

# OUTPUT:
# TensorFlow Prediction (9 hours): 101.3
# Framework : TensorFlow 2.15.0


# PyTorch version — same architecture, more explicit control
import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(1, 8),
    nn.ReLU(),
    nn.Linear(8, 1)
)
# You control every step: forward pass, loss, backward, optimizer
# Same architecture as TF above — different syntax, same result

Common Mistakes

Two mistakes beginners make that silently break everything. First, mixing TensorFlow and PyTorch in the same project. Second, skipping the standard import aliases and writing their own.

-- MISTAKE 1: Mixing both frameworks in one project --

WRONG:
  Using TensorFlow tensors and PyTorch tensors in the same model
  Result: cryptic type errors everywhere, nothing works

CORRECT:
  Pick one framework per project and stay consistent.
  TF tensors are NOT the same as PyTorch tensors — ever.

NOTE: "Incompatible tensor systems —
       mixing them breaks everything silently."
RULE: One project, one framework. Never mix.


-- MISTAKE 2: Breaking the import alias convention --

WRONG:
  import tensorflow
  model = tensorflow.keras.Sequential(...)

CORRECT:
  import tensorflow as tf
  model = tf.keras.Sequential(...)

NOTE: "tf is the universal alias —
       breaking convention makes code unreadable."
RULE: import tensorflow as tf. import torch. Always.

Mini Challenge

Quick Quiz

Q1: Which framework is better suited for deploying a model to a mobile app? A1: TensorFlow — it is built for production, mobile, and large-scale deployment. Q2: What is the correct way to import PyTorch''s neural network module? A2: import torch.nn as nn — always use nn as the alias, never deviate from this convention. Q3: Can you mix TensorFlow and PyTorch tensors in the same model? A3: No. They are incompatible tensor systems and mixing them will break your code silently.

Bonus Knowledge

TensorFlow has a special lightweight version called TensorFlow Lite designed specifically for running models on Android and iOS devices. This is how apps like Google Lens and PhonePe fraud detection run AI directly on your phone without sending data to a server. PyTorch has its own mobile version too called PyTorch Mobile. Both frameworks are converging in features over time, which is why many companies today train in PyTorch and then export the model to TensorFlow for deployment — getting the best of both kitchens.

Key Takeaways