Bài 4: Notebook (.ipynb) Là Gì Và Quy Trình Làm Việc Theo Cell

Sau bài này, bạn sẽ:

• Hiểu file .ipynb là gì và chứa gì bên trong.
• Phân biệt được code cell và markdown cell.
• Biết khái niệm kernel và state chia sẻ giữa các cell.
• Nắm quy trình cell-by-cell: viết → chạy → quan sát → sửa → chạy lại.
• Biết khi nào nên rời notebook để viết file .py.

Bài 3 đã đề cập Google Colab — một platform để chạy notebook. Bài này tập trung vào bản thân file notebook, không phụ thuộc Colab, Jupyter Lab hay VS Code. Cùng một file .ipynb mở được trên cả ba.

Notebook là một định dạng tài liệu cho phép xen kẽ code, văn bản và kết quả chạy code (text output, bảng, biểu đồ, ảnh) trong cùng một file. Phần mở rộng chuẩn là .ipynb — viết tắt của "IPython Notebook" (tên cũ trước khi project được tách ra thành Jupyter).

Về bản chất, một file .ipynb là một file JSON. Bạn có thể mở bằng bất kỳ text editor nào để nhìn cấu trúc thô:

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": ["# Phân tích dữ liệu bán hàng\n"]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": ["Hello, notebook!\n"]
        }
      ],
      "source": ["print(\"Hello, notebook!\")"]
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}

Các trường chính:

• cells: mảng các cell, mỗi cell có cell_type (code hoặc markdown), source (nội dung), và với code cell còn có outputs (kết quả chạy lần gần nhất) và execution_count (số thứ tự lần chạy).
• metadata.kernelspec: kernel nào được dùng (Python 3 trong ví dụ trên).
• nbformat: phiên bản format của notebook.

Khi mở trên Jupyter, Colab hay VS Code, các tool này đọc JSON này và render thành giao diện cell. Output đã được lưu cùng file, nên người khác mở notebook có thể thấy kết quả mà không cần chạy lại.

Để hiểu notebook, so sánh trực tiếp với file .py:

Notebook không thay thế .py. Hai định dạng phục vụ hai mục đích khác nhau và thường dùng song song trong cùng một dự án AI.

Code Cell

Chứa code Python (hoặc ngôn ngữ khác tuỳ kernel). Khi chạy:

• Code được gửi đến kernel để execute.
• Output (stdout, giá trị trả về của expression cuối, biểu đồ) hiển thị ngay dưới cell.
• Một số thứ tự thực thi (execution_count) tăng lên: [1], [2], [3]...

Ví dụ một code cell ngắn:

# Cell 1: import thư viện
import math

x = 16
print(math.sqrt(x))

Output hiển thị ngay dưới cell:

4.0

Markdown Cell

Chứa văn bản viết bằng cú pháp Markdown. Khi chạy (Shift+Enter), cell được render thành văn bản đã format: heading, list, bold, italic, link, công thức toán LaTeX, ảnh. Markdown cell không gửi code đến kernel — chỉ render hiển thị.

Dùng markdown cell để:

• Chia bố cục notebook thành các phần (heading).
• Giải thích từng bước phân tích cho người đọc (và cho chính mình sau này).
• Ghi công thức toán: $E = mc^2$.
• Note giả định, kết luận, câu hỏi cần trả lời.

Hầu hết tool cũng hỗ trợ raw cell (giữ nguyên text không render) nhưng rất ít dùng — bỏ qua được trong giai đoạn đầu.

Công việc của một AI / Data Engineer phần lớn là khám phá: đọc dữ liệu, vẽ biểu đồ, thử một model, đánh giá kết quả, sửa giả thiết. Workflow này có ba đặc điểm khớp với thiết kế của notebook:

• Iterative (lặp ngắn). Mỗi bước thử là một cell nhỏ. Không cần chạy lại toàn bộ file mỗi lần sửa.
• Visual (cần thấy dữ liệu). Biểu đồ Matplotlib / Seaborn / Plotly và bảng Pandas hiển thị inline ngay dưới cell — không phải mở cửa sổ riêng.
• Sharable (chia sẻ kèm kết quả). Output được lưu trong file. Mở notebook trên GitHub, Colab hay nbviewer đều thấy đầy đủ code + biểu đồ + kết luận mà không cần chạy lại.

Đây là lý do gần như mọi tutorial về Pandas, NumPy, scikit-learn, PyTorch, TensorFlow đều phát hành dưới dạng notebook, và các nền tảng như Kaggle, Colab, Hugging Face đều dùng notebook làm môi trường mặc định.

Vòng lặp cơ bản khi làm việc trong notebook:

1. Viết một đoạn code nhỏ vào cell (1–10 dòng là đủ).
2. Chạy cell bằng Shift+Enter (chạy cell hiện tại và nhảy sang cell tiếp theo) hoặc Ctrl+Enter (chạy và ở lại).
3. Quan sát output: đúng kỳ vọng chưa? Có warning / error không?
4. Sửa code trong chính cell đó nếu cần.
5. Chạy lại cell. Output cũ được thay bằng output mới.

Ví dụ chuỗi 3 cell tiêu biểu khi bắt đầu một phân tích dữ liệu:

# Cell 1: import thư viện
import pandas as pd
import numpy as np

# Cell 2: load dữ liệu và xem 5 dòng đầu
df = pd.read_csv("sales.csv")
df.head()

# Cell 3: thống kê cơ bản
df.describe()

Khi expression cuối cùng của một code cell không có print(), notebook tự hiển thị giá trị của nó (Pandas DataFrame được render thành bảng đẹp). Đây là khác biệt với file .py — ở .py phải print(df.head()) mới thấy output.

Phím tắt nên thuộc (giống nhau giữa Jupyter, Colab, VS Code với khác biệt nhỏ):

• Shift+Enter — chạy cell, sang cell kế.
• Ctrl+Enter — chạy cell, ở lại.
• Esc — thoát chế độ edit, vào chế độ command.
• Ở chế độ command: A insert cell phía trên, B insert cell phía dưới, D D xoá cell, M chuyển sang markdown, Y chuyển sang code.

Kernel là một process Python chạy nền, do tool (Jupyter, Colab, VS Code) khởi động khi bạn mở notebook. Mỗi cell code được gửi sang kernel để execute, kết quả gửi ngược lại tool để hiển thị.

Đặc điểm quan trọng nhất: tất cả cell trong cùng một notebook dùng chung một kernel, tức là chung một bộ nhớ Python. Biến định nghĩa ở cell trước vẫn còn ở cell sau.

# Cell 1
x = 10

# Cell 2 — vẫn dùng được x từ Cell 1
print(x * 2)
# Output: 20

# Cell 3 — gán lại x, các cell sau sẽ thấy giá trị mới
x = 100

Điều này tiện lợi (không phải load lại dữ liệu mỗi lần) nhưng cũng là nguồn gốc của vấn đề ở mục tiếp theo.

Khi bạn đóng notebook hoặc tool tắt kernel, toàn bộ state (biến, dữ liệu đã load, model đã train) biến mất. Lần mở sau bạn phải chạy lại các cell load dữ liệu. File .ipynb chỉ lưu source code và output đã render, không lưu state của kernel.

Notebook cho phép chạy cell theo bất kỳ thứ tự nào. Đây vừa là điểm mạnh (thử nghiệm linh hoạt) vừa là cái bẫy lớn nhất với người mới.

Ví dụ:

# Cell 1
x = 10

# Cell 2
x = x + 5
print(x)

Nếu chạy Cell 1 rồi Cell 2 lần đầu: x = 15. Nếu chạy Cell 2 thêm một lần nữa mà không chạy lại Cell 1: x = 20. Chạy thêm lần nữa: x = 25. Số [N] bên trái mỗi cell cho biết lần thực thi gần nhất; nếu thứ tự [N] không tăng dần từ trên xuống dưới, notebook đang ở trạng thái không reproducible.

Hệ quả: khi đưa notebook cho người khác (hoặc cho chính mình một tháng sau) chạy lại từ đầu, kết quả có thể khác với output đang hiển thị trong file.

Cách xử lý:

• Restart kernel + Run all (menu Kernel → Restart & Run All hoặc tương đương trên Colab / VS Code). Hành động này clear toàn bộ state và chạy lại tất cả cell từ trên xuống. Nếu notebook chạy được sạch sẽ, nó đáng tin cậy.
• Thực hiện việc này trước khi commit lên Git và trước khi share notebook cho người khác.
• Khi gặp lỗi khó hiểu kiểu "biến này đáng lẽ phải bằng X", restart kernel trước khi debug — rất nhiều "bug" thực ra chỉ là state cũ.

Bạn không cần học hết Markdown — vài cú pháp dưới đây đủ dùng trong 95% trường hợp.

# Heading lớn (h1) — dùng cho tiêu đề notebook
## Heading vừa (h2) — dùng cho từng phần
### Heading nhỏ (h3) — dùng cho mục con

Đoạn văn bình thường. Có thể **bôi đậm**, *in nghiêng*,
hoặc dùng `inline code` cho tên biến / hàm.

- Bullet list item 1
- Bullet list item 2
  - Sub item
- Bullet list item 3

1. Numbered list
2. Item thứ hai

Code block nhiều dòng:

```python
def square(x):
    return x * x
```

Link: [Jupyter Documentation](https://docs.jupyter.org/)

Công thức toán inline: $y = wx + b$

Công thức toán block:

$$
L = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2
$$

Khi nhấn Shift+Enter trên markdown cell, nội dung trên được render thành văn bản đã format. Click đúp (hoặc Enter ở chế độ command) để quay về chế độ chỉnh sửa.

Quy ước thực dụng: mỗi markdown cell nên ngắn (1–5 dòng), đặt ngay trước nhóm code cell mà nó giải thích. Tránh viết một markdown cell dài 50 dòng — chia thành nhiều cell nhỏ dễ đọc hơn.

Notebook tốt cho khám phá, nhưng không phải mọi loại code đều thuộc về notebook. Các trường hợp nên chuyển sang file .py:

• Production code. API server, batch job, model serving, pipeline ETL — chạy tự động trên server, không có ai bấm Shift+Enter. Đây là môi trường của file .py + framework (FastAPI, Airflow, Prefect, ...).
• Module được import từ nhiều nơi. Code tiện ích, hàm helper, class dùng lại nhiều chỗ nên để trong .py và import vào notebook khi cần. Notebook không phải nơi định nghĩa thư viện.
• Test tự động. Pytest / unittest đọc file .py. Hệ thống CI / CD chạy test theo .py. Có công cụ chạy test trong notebook nhưng đó là exception, không phải mặc định.
• File quá dài (vượt ~30–40 cell). Notebook dài khó scroll, khó review, khó merge khi nhiều người sửa. Tách thành nhiều notebook nhỏ theo chủ đề, hoặc trích logic ra .py rồi import.
• Code cần version control nghiêm túc. Diff của .ipynb là JSON với output binary lẫn trong — đọc rất khó trên GitHub. Có giải pháp như nbdime, jupytext, hoặc xoá output trước khi commit, nhưng vẫn không bằng diff trên .py.

Pattern phổ biến trong dự án AI thực tế: notebook để khám phá và báo cáo, file .py để chứa logic ổn định. Hai loại file sống chung trong cùng một repo.

Không có chuẩn duy nhất, nhưng một convention được nhiều team data dùng là tiền tố số + slug ngắn:

notebooks/
├── 01-eda-customers.ipynb           # Exploratory Data Analysis
├── 02-feature-engineering.ipynb
├── 03-baseline-model.ipynb
├── 04-hyperparameter-tuning.ipynb
└── 05-error-analysis.ipynb

Lợi ích:

• Sort theo tên file là theo đúng thứ tự thực hiện.
• Tên ngắn, mô tả mục đích notebook (không phải mô tả nội dung từng cell).
• Dễ tìm khi repo có 20+ notebook.

Trong dự án AI thường có thêm các folder tách bạch:

project/
├── data/             # dữ liệu raw / đã xử lý
├── notebooks/        # các .ipynb khám phá
├── src/              # các module .py tái sử dụng
├── models/           # model đã train (file .pkl, .pt, ...)
└── requirements.txt

Quy ước này chỉ là gợi ý — mỗi team có thể điều chỉnh. Điểm quan trọng: tách notebook và .py ra hai folder khác nhau để rõ ràng đâu là code khám phá, đâu là code dùng lại.

• File .ipynb là JSON chứa các cell xen kẽ code và markdown, kèm output đã render.
• Hai loại cell chính: code (gửi đến kernel để chạy) và markdown (text giải thích).
• Tất cả cell dùng chung một kernel → state (biến) được chia sẻ.
• Quy trình điển hình: viết cell nhỏ → Shift+Enter → xem output → sửa → chạy lại.
• Chạy cell không theo thứ tự là cái bẫy lớn nhất. Xử lý bằng Restart kernel + Run all trước khi commit / share.
• Notebook không thay thế .py cho production code, module dùng lại, hoặc test tự động.

Bài 4 kết thúc nhóm Định hướng & Môi trường. Từ bài 5 trở đi sang nhóm Python Cơ bản cho AI, bắt đầu với biến và 4 kiểu dữ liệu nguyên thủy int, float, str, bool — viên gạch đầu tiên để đọc được code AI.