PyTorch vs Old Tools: What Changed for Full Stack Developers

# Old tools — TensorFlow 1.x style
# Define a graph, then run it in a session
import tensorflow as tf

graph = tf.Graph()
with graph.as_default():
    x = tf.placeholder(tf.float32, [None, 784])
    W = tf.Variable(tf.zeros([784, 10]))
    b = tf.Variable(tf.zeros([10]))
    y = tf.nn.softmax(tf.matmul(x, W) + b)

with tf.Session(graph=graph) as sess:
    sess.run(tf.global_variables_initializer())
    result = sess.run(y, feed_dict={x: data})

# Hard to debug, abstract, and slow to iterate.

# PyTorch — eager execution, normal Python
import torch
import torch.nn as nn

model = nn.Linear(784, 10)

def predict(x):
    with torch.no_grad():
        return torch.softmax(model(x), dim=-1)

result = predict(torch.tensor(data))
print(result)

# Print statements work. Breakpoints work.
# Debugging feels like debugging normal code.

# Export a PyTorch model to ONNX
import torch
import torch.onnx

model = MyModel()
model.load_state_dict(torch.load("model.pt"))
model.eval()

dummy_input = torch.randn(1, 3, 224, 224)

torch.onnx.export(
    model,
    dummy_input,
    "model.onnx",
    input_names=["input"],
    output_names=["output"],
    dynamic_axes={
        "input": {0: "batch_size"},
        "output": {0: "batch_size"},
    },
)

# Now you can run model.onnx in:
# - Python (onnxruntime)
# - Node.js (onnxruntime-node)
# - Java, C++, Rust, Go
# - Browsers (onnxruntime-web)
# - Mobile (onnxruntime mobile)

# Serve the model with FastAPI
from fastapi import FastAPI, UploadFile
from PIL import Image
import io
import torch
import torchvision.transforms as T

app = FastAPI()
model = load_model()
preprocess = T.Compose([
    T.Resize(224),
    T.ToTensor(),
])

@app.post("/predict")
async def predict(file: UploadFile):
    img = Image.open(io.BytesIO(await file.read()))
    tensor = preprocess(img).unsqueeze(0)
    with torch.no_grad():
        logits = model(tensor)
    return {
        "class": logits.argmax().item(),
        "confidence": torch.softmax(logits, -1).max().item(),
    }

# Dockerfile — containerise the model API
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY model.pt app.py ./

EXPOSE 8000

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# Build and run
# docker build -t my-model-api .
# docker run -p 8000:8000 my-model-api

Weekly Plan for Full Stack Devs:

Mon — PyTorch concepts (1 hour)
Tue — Practice on a small dataset (1 hour)
Wed — Hugging Face or tutorials (1 hour)
Thu — Project code (1 hour)
Fri — Review + notes (30 min)
Sat — Deep project work (2–3 hours)
Sun — Rest or light reading

Before claiming "AI features" on your resume:

□ Can I load a pre-trained Hugging Face model?
□ Can I fine-tune a model on my own data?
□ Can I export to ONNX and load it in Python?
□ Have I deployed a model behind an API?
□ Does my project work end-to-end in the browser?
□ Do I have a GitHub repo with a clear README?

That is enough to start applying to full stack
roles that expect AI feature delivery.