PageRank:
mô hình và tính toán

Mỗi vòng PageRank là một phép nhân ma trận thưa với véc tơ; bước nhảy và bù nút cụt bảo đảm phép lặp hội tụ.

Bài 03 · Giải thuật nền tảng của Khoa học dữ liệu

Học kỳ 1 · Năm học 2026–2027

Trường Đại học Công nghệ · Đại học Quốc gia Hà Nội

Tiên quyết và quy ước

Nhắc lại: \(y=Av\), \(y_i=\sum_j a_{ij}v_j\); Map phát \((i,a_{ij}v_j)\), Reduce cộng theo khóa \(i\) (Bài 02).

Nhắc lại: Combine cộng cục bộ theo khóa; chi phí \(C=I+H\) (Bài 02).

Nhắc lại: phân phối trên \(n\) phần tử là véc tơ \(r\ge0\), \(\sum_i r_i=1\).

Ký hiệu: đồ thị có hướng \(G=(V,E)\), \(n=|V|\) trang, \(m=|E|\) liên kết; cạnh \(j\to i\) từ nguồn \(j\) tới đích \(i\).

Quy ước: véc tơ cột; \(t\) đếm vòng; dấu phẩy thập phân; dung lượng tính bằng byte.

Mục tiêu học tập

  1. Lập ma trận liên kết và tính một vòng chia điểm trên đồ thị bốn trang.
  2. Tính một vòng có bước nhảy và bù nút cụt; kiểm tổng điểm bằng 1.
  3. Đặc tả Map, Combine, Reduce theo khối; lập luận kết quả bằng phép tính một máy.
  4. Tính dung lượng, bộ nhớ một tác vụ, byte đầu vào và thời gian pha Map.
  5. Chạy pagerank.py và đối chiếu kết quả với bảng tính tay.

Nội dung

  1. Bài toán xếp hạng trang web
  2. Mô hình và thuật toán PageRank
  3. Tính PageRank trên đồ thị lớn
  4. Chi phí và lợi ích của cách tính
  1. Thực hành tính PageRank
  2. Tổng kết và tự kiểm tra
  3. Bài tập vận dụng

Đọc trước: Leskovec, Rajaraman, Ullman, Mining of Massive Datasets (MMDS), ấn bản 3, Chương 5, §§5.1–5.2, tr.175–195.

Vấn đề trung tâm

Nhu cầu: xếp hạng \(10^9\) trang; ma trận đặc quá lớn.

  • Chia theo bậc ra: liên kết của nguồn ít đích mang nhiều điểm hơn.
  • Bước nhảy, bù nút cụt: lặp hội tụ về nghiệm duy nhất.
  • Lưu thưa, chia khối: như tính một máy.
  • Thêm máy: Map nhanh hơn, không tỷ lệ số máy.
  • Chương trình khớp bảng tính tay.

Xếp hạng các trang kết quả

Sơ đồ: truy vấn dẫn tới các trang liên quan, các trang được sắp thứ tự để hiển thị, trong đó liên kết giữa các trang là một tín hiệu góp phần xác định độ quan trọng

PageRank cho điểm quan trọng theo liên kết, một tín hiệu bên cạnh mức khớp truy vấn.

Ví dụ: ma trận đặc của một tỷ trang

Giả định \(n=10^9\) trang; mỗi ô 8 byte.

Tính dung lượng ma trận liên kết đặc.

\(n^2=10^{18}\) ô.

\(10^{18}\times8=8\times10^{18}\) byte \(=8\) EB (1 EB là \(10^{18}\) byte).

Lưới ô ma trận thưa: phần lớn ô trống, chỉ một ít ô có liên kết thực cần lưu

Kết luận: chỉ lưu các liên kết tồn tại khi số liên kết nhỏ hơn nhiều số cặp trang.

Bài toán xếp hạng trang web

Đầu vào: đồ thị có hướng

\(G=(V,E)\), \(n\) trang, \(m\) liên kết.

Cạnh \(j\to i\): nguồn \(j\) trỏ tới đích \(i\).

Đầu ra: điểm và thứ tự

\(r_i\ge0\) với mọi \(i\), \(\sum_i r_i=1\).

Xếp giảm dần theo điểm; cho phép đồng hạng.

Giả thiết: \(G\) hữu hạn, \(n\ge1\); liên kết trùng gộp thành một cạnh.

Chuẩn hóa tổng bằng 1 chưa xác định cách chấm điểm.

Ví dụ: bốn trang web

Đồ thị bốn trang: A tới B, C, D; B tới A, D; C tới A; D tới B, C

\(n=4\) trang, \(m=8\) liên kết; xác định bậc ra.

TrangLiên kết ra tớiBậc ra
AB, C, D3
BA, D2
CA1
DB, C2

Diễn giải: bậc ra là số liên kết đi khỏi trang; tổng bậc ra bằng \(m=8\).

Đếm liên kết vào

Nhu cầu: thử quy tắc đơn giản nhất là đếm liên kết vào.

Đồ thị bốn trang với hai cạnh vào A là B tới A và C tới A được vẽ đậm, các cạnh còn lại nhạt
TrangLiên kết vào từSố liên kết vào
AB, C2
BA, D2
CA, D2
DA, B2

Chuẩn hóa: \(2/8=1/4\) mỗi trang; bốn trang đồng hạng.

Kết luận: cách đếm coi liên kết từ C (một đích) ngang liên kết từ A (ba đích).

Chia điểm theo liên kết ra

Đếm liên kết vào cho bốn trang cùng điểm \(1/4\).

Mỗi trang chia đều điểm hiện có cho các trang đích của nó.

Nút A có điểm 1/4, ba mũi tên tới B, C, D, mỗi mũi tên mang nhãn 1/12

Với \(r_A=1/4\) và ba đích, mỗi đích nhận \((1/4)/3=1/12\).

Ví dụ: bốn trang web, cộng điểm tại A

Hai mũi tên từ B và C vào A; B đóng góp 1/8, C đóng góp 1/4; điểm mới của A là 3/8

A nhận \(1/8\) từ B (hai đích) và \(1/4\) từ C (một đích): \(1/8+1/4=3/8\).

Ví dụ: bốn trang web, kết quả sau một vòng

Điểm cũ \(1/4\) mỗi trang; mọi trang tính đồng thời từ điểm cũ.

TrangCác đóng góp nhận đượcĐiểm mới
A\(1/8+1/4\)\(9/24=3/8\)
B\(1/12+1/8\)\(5/24\)
C\(1/12+1/8\)\(5/24\)
D\(1/12+1/8\)\(5/24\)

Kết luận: tổng \(9/24+3\cdot5/24=1\); A đứng trước, B, C, D đồng hạng.

Câu hỏi về bài toán xếp hạng

Câu hỏi: trên đồ thị bốn trang vừa xét.

  1. Nêu đầu vào, đầu ra của bài toán xếp hạng trang web.
  2. Từ \(r^0=(1/2,1/6,1/6,1/6)\) theo thứ tự A–D, tính điểm mới của D.
  3. A và B cùng có hai liên kết vào; giải thích vì sao A được điểm cao hơn.

2.Mô hình và thuật toán PageRank

Muốn lặp phép chia điểm trên đồ thị bất kỳ, phải xử lý nút cụt, bẫy liên kết và nêu điều kiện dừng.

Ma trận liên kết · Nút cụt · Bẫy liên kết · Bước nhảy ngẫu nhiên · Hội tụ

Chia điểm và bước đi ngẫu nhiên

Nhu cầu: lặp phép chia điểm trên đồ thị bất kỳ.

Nút j mang điểm cũ rⱼ chia đều cho ba trang đích, mỗi mũi tên mang nhãn rⱼ/dⱼ

Nhắc lại: một vòng trên bốn trang cho A \(3/8\), mỗi trang B, C, D \(5/24\).

Người đọc ở \(j\) chọn đều một trong \(d_j\) liên kết ra (bậc ra); mỗi đích nhận xác suất \(r_j/d_j\).

Bước đi ngẫu nhiên (random walk): \(r_i\) là xác suất người đọc đang ở trang \(i\).

Ma trận liên kết

A trỏ tới B, C, D. Mỗi cạnh nối đúng hàng B, C, D trong cột A, với giá trị một phần ba; hàng A bằng không.

\(d_j\) là số liên kết ra của trang \(j\).

Định nghĩa. Ma trận liên kết \(M_0\) cỡ \(n\times n\) có \((M_0)_{ij}=1/d_j\) khi \(j\to i\); mọi ô khác bằng 0.

Cột là nguồn; hàng là đích.

A có ba liên kết ra: mỗi hàng B, C, D trong cột A nhận giá trị \(1/3\).

Lặp phép truyền điểm

Giả thiết: mọi trang có liên kết ra.

\[r^{t+1}=M_0r^t\]

TrangĐiểm cũ \(r^0\)Điểm mới \(r^1\)
A\(1/4\)\(9/24\)
B, C, D (mỗi trang)\(1/4\)\(5/24\)

Khởi tạo đều \(r_i^0=1/n\); mọi điểm mới trong một vòng tính từ cùng \(r^t\).

\(r^1\) khớp bảng tính tay; phép lặp tìm \(r^*=M_0r^*\), chưa bảo đảm hội tụ.

Nút cụt

Định nghĩa. Trang không có liên kết ra gọi là nút cụt (dead end).

Bỏ cạnh C tới A; C vẫn nhận từ A và D nhưng không có cạnh ra.

Bỏ C→A: C là nút cụt; \(r^0\) đều \(1/4\).

\[M_0r^0=(3/24,5/24,5/24,5/24)^T\]

Truyền được: \(3/4\)Thiếu \(1/4\)

Tổng sau một vòng chỉ còn \(18/24=3/4\); phần thiếu là điểm cũ của C.

Bẫy liên kết

Định nghĩa. Bẫy liên kết (spider trap) là nhóm trang có liên kết ra nhưng không trỏ ra ngoài nhóm.

Đồ thị bốn trang với cạnh C tới A thay bằng vòng lặp C tới chính C; nút C tô cam nhạt

Thay C→A bằng C→C: C là bẫy một nút.

Người đã đến C không rời C khi chỉ theo liên kết.

Trên ví dụ này, lặp thô dồn toàn bộ điểm về C.

Bước nhảy ngẫu nhiên

Nhu cầu: người đọc phải có cách rời bẫy C.

Hai nhánh từ trang hiện tại: nhánh xác suất beta tới một đích liên kết; nhánh xác suất một trừ beta tới một trang bất kỳ

Với xác suất \(\beta\): đi theo một liên kết ra, chọn đều.

Bước nhảy ngẫu nhiên (teleport) là nhảy đều tới một trang bất kỳ với xác suất \(1-\beta\).

\(0<\beta<1\); ví dụ dùng \(\beta=4/5\).

Bước nhảy cho người đọc cơ hội rời bẫy liên kết và tới bất kỳ trang nào.

Phân phối lại điểm ở nút cụt

Tổng điểm nút cụt được phân phối đều tới cả bốn trang A, B, C, D; mũi tên nét đứt chỉ phép bù của mô hình

\(\delta=\sum_{j:\,d_j=0}r_j\) là tổng điểm đang ở các nút cụt.

Ở nhánh theo liên kết, nút cụt chọn đều một trang bất kỳ.

Mỗi trang nhận thêm \(\beta\delta/n\).

Biến thể nút cụt C: \(\delta=1/4\), mỗi trang nhận thêm \(\beta\delta/n=1/20\).

Quy tắc cập nhật đầy đủ

Theo liên kết

\[\beta\sum_{j:\,j\to i}\frac{r_j^t}{d_j}\]

Bước nhảy

\[\frac{1-\beta}{n}\]

Bù nút cụt

\[\frac{\beta\delta^t}{n}\]

↓ Cộng ba phần: điểm mới \(r_i^{t+1}\)

\(\delta^t=\sum_{j:\,d_j=0}r_j^t\) là tổng điểm cũ ở các nút cụt.

Dạng khác: \(r^{t+1}=\beta M_0r^t+\big((1-\beta)+\beta\delta^t\big)u\), với \(u_i=1/n\).

Ba phần cùng dùng \(r^t\); khởi tạo \(r^0=u\).

Ví dụ: bốn trang web, một vòng có bước nhảy

Đồ thị gốc, không nút cụt nên \(\delta=0\); \(\beta=4/5\); \(r^0\) đều \(1/4\).

Trang\(\beta\,M_0r^0\)\((1-\beta)/n\)\(r^1\)
A\(\dfrac{4}{5}\cdot\dfrac{3}{8}=\dfrac{3}{10}\)\(\dfrac{1}{20}\)\(\dfrac{7}{20}\)
B\(\dfrac{4}{5}\cdot\dfrac{5}{24}=\dfrac{1}{6}\)\(\dfrac{1}{20}\)\(\dfrac{13}{60}\)
C\(\dfrac{4}{5}\cdot\dfrac{5}{24}=\dfrac{1}{6}\)\(\dfrac{1}{20}\)\(\dfrac{13}{60}\)
D\(\dfrac{4}{5}\cdot\dfrac{5}{24}=\dfrac{1}{6}\)\(\dfrac{1}{20}\)\(\dfrac{13}{60}\)

Kết luận: tổng \(7/20+3\cdot13/60=1\); A giảm từ \(3/8\) xuống \(7/20\) vì một phần điểm chia đều.

Ví dụ: nút cụt C, một vòng

Xóa C→A: C là nút cụt, \(\delta^0=1/4\); \(\beta=4/5\); \(r^0\) đều \(1/4\).

Thành phần chung: \(\dfrac{(1-\beta)+\beta\delta^0}{n}=\dfrac{1/5+1/5}{4}=\dfrac{1}{10}\).

Trang\(\beta\,M_0r^0\)Chung\(r^1\)
A\(\dfrac{4}{5}\cdot\dfrac{1}{8}=\dfrac{1}{10}\)\(\dfrac{1}{10}\)\(\dfrac{1}{5}\)
B, C, D (mỗi trang)\(\dfrac{4}{5}\cdot\dfrac{5}{24}=\dfrac{1}{6}\)\(\dfrac{1}{10}\)\(\dfrac{4}{15}\)

Tổng \(1/5+3\cdot4/15=1\): điểm của C được hoàn lại đầy đủ qua phần bù.

Thuật toán: PageRank lặp

Đầu vào: danh sách kề của \(G\), \(n\ge1\), \(0<\beta<1\), ngưỡng \(\tau>0\), giới hạn vòng \(T_{\max}\) nguyên dương.

Đầu ra: véc tơ điểm xấp xỉ và trạng thái đạt hoặc chưa đạt ngưỡng.


r = (1/n, ..., 1/n)
lặp t = 1, ..., Tmax:
  delta = tổng r[j] của các nút cụt
  với mỗi i: new[i] = (1 - beta + beta * delta) / n
  với mỗi j có d[j] > 0:
    với mỗi i thuộc out[j]: new[i] += beta * r[j] / d[j]
  Delta = tổng |new[i] - r[i]|
  r = new
  nếu Delta <= tau: trả về (r, đạt ngưỡng)
trả về (r, chưa đạt)

Trường hợp biên: mọi trang là nút cụt (kể cả \(n=1\)) cho \(r^1=u\) ngay vòng đầu.

Độ thay đổi và điều kiện dừng

Đo tổng mức thay đổi của các trang giữa hai vòng liên tiếp.

\[\Delta_t=\sum_i|r_i^{t+1}-r_i^t|\]

Trang\(r^1\)\(r^2\)Chênh lệch tuyệt đối
A\(7/20\)\(31/100\)\(1/25\)
B, C, D (mỗi trang)\(13/60\)\(23/100\)\(1/75\)

Đồ thị gốc, \(\beta=4/5\): \(\Delta_1=1/25+3\cdot1/75=2/25=0{,}08\).

Điều kiện dừng: \(\Delta_t\le\tau\), hoặc hết \(T_{\max}\) vòng (báo chưa đạt).

Tính đúng: bảo toàn tổng điểm

Mệnh đề. Nếu \(r^t\ge0\) và \(\sum_ir_i^t=1\) thì \(r^{t+1}\ge0\) và \(\sum_ir_i^{t+1}=1\).

Chứng minh. Ba phần không âm: (1) theo liên kết, (2) bù nút cụt, (3) bước nhảy.

\[\underbrace{\beta(1-\delta)}_{(1)}+\underbrace{\beta\delta}_{(2)}+\underbrace{(1-\beta)}_{(3)}=1\]

Ví dụ nút cụt C: \(\beta=4/5,\ \delta=1/4\).

Theo liên kết: \(3/5\)Bù: \(1/5\)Nhảy: \(1/5\)

Bất biến: tổng điểm bằng 1 ở mọi vòng; dùng để kiểm chương trình.

Hội tụ của mô hình đầy đủ

Định lý. Với \(0<\beta<1\), bước nhảy đều và bù nút cụt, phép cập nhật đầy đủ \(F\) thỏa

\[\|F(x)-F(y)\|_1\le\beta\|x-y\|_1,\qquad \|x\|_1=\sum_i|x_i|.\]

Hai phân phối x và y đi qua cùng phép cập nhật F, cho F(x) và F(y). So sánh khoảng cách trước và sau, không so sánh riêng từng điểm.

Chứng minh. \(F(x)=\beta\bar Mx+(1-\beta)u\), với \(\bar M\) là \(M_0\) có cột nút cụt thay bằng \(u\).

Phần nhảy triệt tiêu trong hiệu; \(\bar M\) không âm, mỗi cột có tổng 1, nên khoảng cách co theo hệ số \(\beta\).

Do đó dãy lặp hội tụ tới phân phối duy nhất \(r^*=F(r^*)\).

Câu hỏi về mô hình và thuật toán

Câu hỏi: trên mô hình vừa xây dựng.

  1. Trên đồ thị gốc A–D, viết cột D của \(M_0\).
  2. Phân biệt nút cụt với bẫy liên kết; nêu cách xử lý mỗi trường hợp.
  3. Lần kiểm tra có \(\Delta=0{,}08\), \(\tau=0{,}1\): xác định trạng thái trả về.

3.Tính PageRank trên đồ thị lớn

Muốn tính một vòng khi đồ thị không vừa bộ nhớ, phải lưu thưa và chia ma trận, véc tơ thành khối.

Danh sách liên kết ra · Chia khối · Map và Combine · Reduce · Tính đúng

Ma trận đặc và danh sách liên kết

Nhu cầu: tính một vòng khi đồ thị và véc tơ không vừa bộ nhớ chính (RAM).

Nhắc lại: với \(n=10^9\), ma trận đặc cần \(8\cdot10^{18}\) byte.

Dữ liệu cần xử lý

\(n\) trang, \(m\) liên kết.

Ma trận đặc lưu \(n^2\) ô; danh sách liên kết chỉ ghi \(m\) cạnh có thật.

Khi \(m\ll n^2\), phần lớn ô bằng 0; quy tắc cập nhật giữ nguyên.

Ví dụ: danh sách liên kết ra của bốn trang

NguồnBậc \(d_j\)Đích
A3B, C, D
B2A, D
C1A
D2B, C

Mỗi bản ghi: (nguồn, \(d_j\), danh sách đích).

Nút cụt giữ bản ghi với \(d_j=0\), danh sách rỗng.

Giá trị \(1/d_j\) suy từ bậc ra nên không lưu từng phần tử.

Ví dụ: cộng đóng góp theo trang đích

Đồ thị gốc, điểm cũ mỗi trang \(1/4\). Theo dõi các đóng góp có đích A.

Map: tạo bản ghi

B→A: \((A,1/8)\)

C→A: \((A,1/4)\)

Nhóm theo đích

Khóa A

\([1/8,1/4]\)

Reduce: cộng

\(1/8+1/4\)

\(=3/8\)

Một vòng là phép nhân ma trận–véc tơ của Bài 02: Map phát (đích, đóng góp), Reduce cộng theo đích.

Chia ma trận và véc tơ thành khối

Đặt \(z=M_0r\); \(k=2\): cắt sau B ở cả hàng và cột, tạo bốn khối \(2\times2\).

Hàng là đích ↓ · Cột là nguồn →

\(M_0\)ABCD
A0\(1/2\)10
B\(1/3\)00\(1/2\)
C\(1/3\)00\(1/2\)
D\(1/3\)\(1/2\)00

Khối \(M_{ab}\) gồm hàng đích \(a\), cột nguồn \(b\); \(k\) dải mỗi chiều cho \(k^2\) khối.

Ví dụ: dải điểm cấp cho từng khối

Đồ thị gốc, \(k=2\), \(r^0\) đều \(1/4\).

Dải nguồn A, B: \(r_1=(1/4,1/4)^T\) cấp cho \(M_{11}\), \(M_{21}\).

Dải nguồn C, D: \(r_2=(1/4,1/4)^T\) cấp cho \(M_{12}\), \(M_{22}\).

Mỗi tác vụ giữ \(r_b\), tích lũy \(z_a\) và đọc khối tuần tự.

Ký hiệu: \(r_b\), \(z_a\) là dải theo khối; \(r_j\), \(z_A\) là giá trị của một trang.

Mỗi dải điểm được đọc \(k\) lần, mỗi lần bởi một tác vụ cùng cột.

Dữ liệu trong một khối

Bản ghi của A: \((A,3,[B,C,D])\) → chia danh sách đích theo hàng khối.
KhốiNguồn\(d_j\)Đích trong khối
\(M_{11}\): đích A, BA3B
\(M_{11}\): đích A, BB2A
\(M_{21}\): đích C, DA3C, D
\(M_{21}\): đích C, DB2D

\(M_{12}\): (C, 1, [A]), (D, 2, [B]); \(M_{22}\): (D, 2, [C]).

Mỗi cạnh thuộc một khối; \(d_A=3\) là bậc toàn cục ở cả hai khối.

Thuật toán: Map và Combine trên một khối

Đầu vào: bản ghi của khối \(M_{ab}\) và dải điểm cũ \(r_b\).

Đầu ra: cặp (trang đích, đóng góp hoặc tổng từng phần).


Map(M_ab, r_b):
  với mỗi (j, dj, dests) trong M_ab:
    với mỗi i trong dests:
      yield(i, r_b[j] / dj)
Combine(i, values):
  yield(i, sum(values))
Ví dụ \(M_{21}\), \(r_A=r_B=1/4\)Map phátCombine phát
\((A,3,[C,D])\)
\((B,2,[D])\)		\((C,1/12)\)
\((D,1/12),(D,1/8)\)		\((C,1/12)\)
\((D,5/24)\)

Khóa là trang đích: hai đóng góp cho D được cộng tại chỗ trước khi chuyển dữ liệu.

Thuật toán: Reduce và điểm ở nút cụt

Tính theo trang nguồn

\(\delta=\sum_{j:d_j=0}r_j\), tính một lần; gửi \(\delta\) tới các Reduce.

Giữ đủ trang đích

Thêm bản ghi \((i,0)\) cho mỗi trang \(i\).

Đầu vào: \(L_i\) là các đóng góp hoặc tổng từng phần mang khóa \(i\).


Reduce(i, L_i):
  z_i = sum(L_i)
  return(i, beta * z_i + (1 - beta + beta * delta) / n)

Phần chung được cộng đúng một lần cho mỗi đích, sau khi đã gộp các đóng góp.

Ví dụ: bốn trang web, gộp hai khối tại A

Đồ thị gốc, \(r^0\) đều \(1/4\), \(\beta=4/5\), \(k=2\); không có nút cụt.

Khối M11 tạo (A,1/8), khối M12 tạo (A,1/4); tổng đóng góp tại A bằng 3/8

\(z_A=1/8+1/4=3/8\).

\[r_A^1=\frac45\cdot\frac38+\frac1{20}=\frac7{20}\]

Hai tác vụ cùng tạo khóa A; \(r_A^1=7/20\) khớp phép tính một máy.

Tính đúng: chia khối

Mệnh đề. Nếu mọi tác vụ dùng cùng \(r\) và các tập nguồn \(V_1,\ldots,V_k\) không chồng nhau thì

\[\sum_{b=1}^{k}\sum_{j\in V_b:\,j\to i}\frac{r_j}{d_j}=\sum_{j:\,j\to i}\frac{r_j}{d_j}.\]

  1. Mỗi cạnh \(j\to i\) thuộc đúng một khối, nên \(r_j/d_j\) được tạo đúng một lần.
  2. \(\delta\) tính một lần theo nguồn; phần chung cộng một lần theo đích.
  3. Combine và Reduce chỉ nhóm lại các tổng.

Do đó kết quả bằng phép tính một máy trên số thực.

Tổ chức một vòng tính

Điểm cũ cố định; tính Map và tổng điểm nút cụt; Combine tại chỗ; chuyển và nhóm theo khóa; Reduce; tính độ thay đổi và chuyển sang vòng sau nếu cần

\(k^2\) là số tác vụ khối, không phải số máy; với \(k=2\), bốn tác vụ có thể chạy trên hai máy.

Câu hỏi về cách chia khối

Câu hỏi: vận dụng cách chia khối.

  1. Trong \(M_{21}\), nguồn A phải ghi bậc 3 hay bậc 2 (số đích trong khối)?
  2. Một đích không có liên kết nào đi vào: nó nhận điểm từ đâu?
  3. Với \(k=2\) trên hai máy: có bao nhiêu tác vụ khối? Nêu một cách phân bổ.

4.Chi phí và lợi ích của cách tính

Muốn biết cách chia khối tiết kiệm được gì, phải đo dung lượng, bộ nhớ một tác vụ, tổng việc và thời gian.

Dung lượng đồ thị · Bộ nhớ một tác vụ · Combine · Băng thông · Thời gian một vòng

Bốn đại lượng chi phí

\(S\): dung lượng lưu

byte biểu diễn đồ thị

\(B\): bộ nhớ một tác vụ

byte RAM một tác vụ giữ

\(W\): tổng việc

thời gian nếu chạy tuần tự

\(T\): thời gian hoàn thành

từ lúc bắt đầu tới lúc xong

Ký hiệu: \(n\) trang, \(m\) liên kết, \(k\) dải mỗi chiều, \(p\) máy; \(B\) là bộ nhớ, khác trang B.

Chi phí: dung lượng biểu diễn đồ thị

Mô hình: điểm là số thực 8 byte; mã trang và bậc ra là số nguyên 4 byte.

Cách biểu diễnCông thứcVí dụ \(n=4,\ m=8\)
Ma trận đặc\(S_{\text{dense}}=8n^2\)128 byte
Danh sách liên kết, mã nguồn ngầm\(S_{\text{adj}}\approx 4(n+m)\)48 byte

\(S_{\text{adj}}\) gồm \(n\) bậc ra và \(m\) mã đích, không tính siêu dữ liệu.

Tỷ số \(S_{\text{dense}}/S_{\text{adj}}\approx2n^2/(n+m)\) lớn khi \(m\ll n^2\).

Chi phí: bộ nhớ một tác vụ

Tác vụ đọc khối qua bộ đệm, dùng dải điểm vào và dải tích lũy, mỗi dải n/k giá trị.

Mô hình: \(k\) chia hết \(n\); mỗi dải \(n/k\) giá trị 8 byte.

\[B_{\text{task}}\approx \frac{16n}{k}+B_{\text{buf}}\]

Ví dụ \(n=4,\ k=2\): \(2\cdot 2\cdot 8=32\) byte cộng \(B_{\text{buf}}\).

Bộ nhớ làm việc cho hai dải véc tơ, không phải toàn bộ RAM của hệ thống.

Chi phí: dữ liệu đầu vào các tác vụ

Mô hình: \(I=S_{\mathrm{blocks}}+8kn\); chi phí là kích thước đầu vào tác vụ (Bài 02).

BướcSố lầnChi phí mỗi lầnĐóng góp
Đọc bản ghi nguồn (mã nguồn, bậc ra)78 byte56 byte
Đọc mã đích\(m=8\)4 byte32 byte
Đọc dải điểm\(k^2=4\)\(8n/k=16\) byte64 byte
Tổng\(I=152\) byte

\(S_{\mathrm{blocks}}=56+32=88\) byte; \(I\) gồm cả đọc cục bộ, chưa tính \(\delta\), \(\Delta\) và điều phối.

Chi phí: Combine và đầu vào Reduce

Trong tác vụ M21, hai đóng góp A tới D một phần mười hai và B tới D một phần tám được gộp thành năm phần hai mươi tư.
Phương ánBản ghiByte
Không Combine\(m=8\) bản ghi cạnh, 12 byte/bản ghi96
Có Combine\(q=7\) bản ghi khóa, 12 byte/bản ghi84

Khóa 4 byte, giá trị 8 byte; \(H\) là tổng đầu vào Reduce sau gộp cục bộ.

\(C=I+H\) giảm từ \(248\) xuống \(236\) byte khi chỉ tính lõi phép nhân.

Chi phí: thời gian pha Map khi tăng số máy

Mô hình: mỗi cạnh tốn \(c_e\) giây, \(W=m\cdot c_e\); bỏ đọc, truyền và lập lịch.

Công việc bốn khối: \(2c_e,\ 2c_e,\ 3c_e,\ 1c_e\); \(W=8c_e\).

Một máy xử lý tuần tự 8 đơn vị thời gian; bốn máy chạy bốn khối cùng lúc và hoàn tất sau 3 đơn vị.

Bốn máy: \(T_{\mathrm{map}}=3c_e\), tăng tốc \(8/3\) thay vì 4; \(W\) không đổi.

Chi phí: dữ liệu qua mạng

Mô hình: \(Q\) là byte thực sự qua mạng; \(b_{\mathrm{eff}}\) là băng thông hiệu quả (byte/giây).

Bản ghi sau Combine có thể đi tới Reduce cùng máy qua đường cục bộ, hoặc qua mạng tới Reduce ở máy khác. Chỉ nhánh qua mạng góp vào Q.

\[T_{\mathrm{shuffle}}\ge Q/b_{\mathrm{eff}}\]

Nếu cả 7 bản ghi sau Combine qua mạng: \(Q=7\cdot12=84\) byte.

Bỏ nén, chạy lại và phần phụ trội; \(Q\) phụ thuộc nơi đặt tác vụ.

Chi phí: thời gian một vòng và cả công việc

Mô hình: các pha không chồng nhau; thời gian đo bằng giây.

\(T_\delta\)

Cộng điểm nút cụt

\(T_{\mathrm{map}}\)

Tính đóng góp

\(T_{\mathrm{shuffle}}\)

Chuyển, nhóm

\(T_{\mathrm{reduce}}\)

Gộp, cập nhật

\(T_{\mathrm{sync}}\)

Đồng bộ

\[T_{\mathrm{round}}\approx T_\delta+T_{\mathrm{map}}+T_{\mathrm{shuffle}}+T_{\mathrm{reduce}}+T_{\mathrm{sync}}\]

\(L\) vòng: \(T_{\mathrm{job}}=T_{\mathrm{setup}}+\sum_{t=1}^{L}T_{\mathrm{round},t}\).

Thêm máy giảm \(T_{\mathrm{map}}\); truyền, gộp và đồng bộ vẫn tốn thời gian.

Câu hỏi về chi phí

Câu hỏi: dùng các công thức chi phí.

  1. Với \(n=4\), \(k=2\), điểm 8 byte: tính bộ nhớ hai dải véc tơ của một tác vụ.
  2. \(p=4\), công việc khối \(2c_e,2c_e,3c_e,1c_e\): tính \(T_{\mathrm{map}}\) lý tưởng.
  3. Xác định có suy được \(I=Q\) từ dữ kiện đã có không.

5.Thực hành tính PageRank

Muốn kiểm công thức cập nhật bằng số, phải viết chương trình Python và đối chiếu với kết quả tính tay.

Giao diện hàm · Một vòng cập nhật · Điều kiện dừng · Kiểm chứng

Sản phẩm và môi trường thực hành

Thực hành

Kết quả chương trình

  • Véc tơ điểm \(r\) với tổng bằng 1.
  • Trạng thái dừng, số vòng và độ thay đổi \(\Delta\) cuối.

Môi trường

Python 3, chỉ thư viện chuẩn; chạy trên một máy để kiểm công thức, không đo tăng tốc.

Mã: Tải pagerank.py

Dữ liệu và giao diện hàm

Thực hành

Danh sách kề (nhãn chuỗi)

adj = {
    "A": ["B", "C", "D"],
    "B": ["A", "D"],
    "C": ["A"],
    "D": ["B", "C"],
}

pagerank(adj, beta=0.8, tol=1e-8, max_iter=100)

Trả về dict: rank, converged, iterations, delta.

Giữ mọi nút, kể cả nút không có liên kết vào hoặc không có liên kết ra.

adj + điểm cũ r + beta → step → điểm mới new

Giả thiết: \(n\ge1\); mọi đích là khóa của dict; \(0<\beta<1\), \(\tau\) (tol) \(>0\), \(T_{\max}\) (max_iter) nguyên dương.

Mã cập nhật một vòng

Thực hành
def step(adj, r, beta):
    n = len(adj)
    delta = sum(r[j] for j in adj if not adj[j])
    common = (1.0 - beta + beta * delta) / n
    new = {i: common for i in adj}
    for j, targets in adj.items():
        if not targets:
            continue
        share = beta * r[j] / len(targets)
        for i in targets:
            new[i] += share
    return new

common cấp phần chung cho mọi trang; điểm cũ \(r\) chỉ được đọc.

Mã lặp và điều kiện dừng

Thực hành
n = len(adj)
r = {i: 1.0 / n for i in adj}
iterations, converged = 0, False
for _ in range(max_iter):
    new = step(adj, r, beta)
    delta = sum(abs(new[i] - r[i]) for i in adj)
    r = new
    iterations += 1
    if delta <= tol:
        converged = True
        break
# Trả r, converged, iterations, delta sau vòng lặp.

delta đo Δ

Đồ thị gốc, \(\beta=4/5\).

\(r^0\longrightarrow r^1\)
\(\Delta_0=0{,}2\)

\(r^1\longrightarrow r^2\)
\(\Delta_1=0{,}08\)

Với \(\tau=10^{-8}\): cả hai vòng chưa đạt.

Tính \(\Delta\) trước khi gán \(r=\mathrm{new}\); \(\tau\) đo độ thay đổi, không đo sai số nghiệm.

Chạy chương trình

Thực hành
python3 materials/lec-03/code/pagerank.py \
    --variant base --beta 0.8 --tol 1e-8 --max-iter 100

Chạy từ thư mục 2627-1. Đầu ra là JSON: rank, converged, iterations, delta, rank_sum.

Giá trị hội tụ của base:

\(r_A=9/28\approx0{,}321429\)

\(r_B=r_C=r_D=19/84\approx0{,}226190\)

Đạt ngưỡng sau 20 vòng; độ thay đổi cuối \(\Delta\approx5{,}50\times10^{-9}\).

Kiểm chứng kết quả

Thực hành
Phép kiểmGiá trị đúng
Tổng điểm, dấu\(\sum_i r_i\approx1\), mọi \(r_i\ge0\)
Một bước, base, \(r^0\) đều, \(\beta=0{,}8\)\(r_A=7/20\); \(r_B=r_C=r_D=13/60\)
Một bước, dead (bỏ C→A), cùng \(r^0\), \(\beta\)\(r_A=1/5\); \(r_B=r_C=r_D=4/15\)

So sánh bằng dung sai: abs(got - want) <= 1e-12, không dùng so sánh bằng của số thực.

Trường hợp biên: toàn nút cụt và một nút có khuyên, kiểm trong practice-README.md.

Câu hỏi về chương trình

Thực hành

Câu hỏi: tìm và sửa lỗi trong ba đoạn cập nhật sau.

  1. Trong vòng lặp, mã cập nhật trực tiếp r[i] += ... khi quét từng cạnh.
  2. Trước khi chạy, mã bỏ đi mọi nút không có liên kết nào đi vào.
  3. Khi đã chạy hết max_iter mà chưa đạt ngưỡng, mã vẫn gắn converged = True.

6.Tổng kết và tự kiểm tra

Muốn chọn cách tính PageRank cho một tỷ trang, phải nêu giả thiết, bảo đảm và chi phí của từng kết quả.

Giả thiết · Bảo đảm và chi phí · Một tỷ trang · Câu hỏi tự kiểm tra · Tài liệu đọc

Kết quả và giả thiết không được bỏ

Kết quảGiả thiết không được bỏCông thức hoặc thuật toán
Một vòng cập nhậtmọi trang dùng cùng \(r^t\); chia theo bậc ra toàn cục\({r^{t+1}=\beta M_0r^t+c^tu}\), \({c^t=(1-\beta)+\beta\delta^t}\)
Bảo toàn tổng\(r^t\ge0\), tổng 1; giữ phần bù nút cụt\(\beta(1-\delta)+\beta\delta+(1-\beta)=1\)
Hội tụ, nghiệm duy nhất\(0<\beta<1\); bước nhảy đều; bù nút cụt\(\|F(x)-F(y)\|_1\le\beta\|x-y\|_1\)
Điều kiện dừng\(\tau>0\); \(T_{\max}\) nguyên dương\(\Delta_t\le\tau\); \(\Delta_t\) không là sai số nghiệm
Chia khối đúngđiểm cũ cố định; tập nguồn không chồng nhau; \(\delta\) tính một lần\({\sum_b\sum_{j\in V_b,\,j\to i}r_j/d_j}={\sum_{j\to i}r_j/d_j}\)

Thuật toán, bảo đảm và chi phí

Mô hình: thời gian theo số trang và cạnh; bộ nhớ theo byte, điểm 8 byte, mã 4 byte.

Thuật toánĐầu vàoBảo đảmChi phí
PageRank lặp, một máydanh sách kề, \(\beta\), \(\tau\), \(T_{\max}\)tổng 1 mỗi vòng; trạng thái dừng đúng\(O(n+m)\) mỗi vòng; bộ nhớ \(16n\) byte
Một vòng theo khối\(k^2\) khối, dải \(r_b\), \(\delta\)như một máy trên số thực\({16n/k+B_{\text{buf}}}\) byte một tác vụ; \({I=S_{\mathrm{blocks}}+8kn}\)
Lưu liên kết ra\(n\) trang, \(m\) cạnhsuy được \(1/d_j\) từ bậc ra\(\approx4(n+m)\) byte so với \(8n^2\)

Câu trả lời cho vấn đề trung tâm

  • Bốn trang, một vòng: A \(3/8\), B, C, D \(5/24\); đếm liên kết vào: mỗi trang \(1/4\).
  • \(0<\beta<1\), bước nhảy, bù nút cụt: nghiệm duy nhất; đồ thị bốn trang gốc, \(\beta=4/5\): \(r_A=9/28\), \({r_B=r_C=r_D=19/84}\).
  • \(n=10^9\), mã 4 byte: liên kết ra \(\approx4(10^9+m)\) byte so với \(8\cdot10^{18}\); \(k^2\) khối, cùng điểm cũ: như một máy.
  • Chỉ pha Map, ví dụ bốn khối \(2,2,3,1\,c_e\): bốn máy tăng tốc \(8/3\), dưới 4.
  • Chương trình: \(r^1\) khớp tính tay; đạt \(\tau=10^{-8}\) sau 20 vòng.

Kết luận: với \(0<\beta<1\) và \(m\ll n^2\), PageRank của \(10^9\) trang tính được bằng lặp theo khối.

Câu hỏi tự kiểm tra

Câu hỏi: vận dụng.

  1. Biến thể nút cụt C, \(r^0\) đều, \(\beta=4/5\): bỏ phần bù, tính tổng điểm sau vòng 1.
  2. \(\beta=1\), biến thể bẫy C: nêu giả thiết bị vi phạm, nơi điểm dồn về.
  3. Tác vụ đọc \(r\) khi tác vụ khác đã ghi điểm mới: nêu giả thiết bị vi phạm.
  4. Xếp bốn tác vụ khối \(2,2,3,1\,c_e\) trên hai máy để \(T_{\mathrm{map}}\) nhỏ nhất.

Nguồn và tài liệu đọc

Nguồn: Leskovec, Rajaraman, Ullman (2020), Mining of Massive Datasets, ấn bản 3, Chương 5, §§5.1–5.2, tr.175–195; §2.5.1, tr.53–54.

Sách và trang chiếu của các tác giả: http://www.mmds.org.

Nguồn: Stanford CS246 (2026), Leskovec và Kanatsoulis, bài “PageRank”, trang chiếu 45, 51 và 54.

Bài 04 giữ phép lặp, đổi nơi đến của bước nhảy theo chủ đề hoặc tập tin cậy.

Ghi chú bài giảng

7.Bài tập vận dụng

Muốn kiểm mô hình điểm và cách lưu liên kết ra, phải lập hệ cân bằng và bảng liên kết ra trên đồ thị nhỏ.

Không bước nhảy · Có bước nhảy · Ngưỡng ma trận thưa · Danh sách liên kết ra

Bài tập: điểm theo liên kết của ba trang

Đồ thị Hình 5.7: a trỏ tới a, b, c; b trỏ tới a, c; c trỏ tới b, c; bảy cạnh có hai vòng lặp trên a và c

Câu hỏi: tính PageRank của từng trang trên đồ thị Hình 5.7, không có bước nhảy.

Trình bày các phương trình, điểm từng trang và phép kiểm tổng bằng 1.

Hình 5.7: a→a, b, c; b→a, c; c→b, c; bảy cạnh, khuyên ở a và c.

Nguồn: MMDS, Bài 5.1.1, §5.1.7, tr.187–188, Hình 5.7.

Bài tập: ba trang có bước nhảy

Đồ thị Hình 5.7: a trỏ tới a, b, c; b trỏ tới a, c; c trỏ tới b, c; bảy cạnh có hai vòng lặp trên a và c

Câu hỏi: tính PageRank của từng trang trên cùng đồ thị với \(\beta=0{,}8\).

Trình bày các phương trình, điểm từng trang và phép kiểm tổng bằng 1.

Đồ thị không có nút cụt nên \(\delta=0\).

Nguồn: MMDS, Bài 5.1.2, §5.1.7, tr.188.

Bài tập: ngưỡng lưu ma trận thưa

Câu hỏi: ma trận Boolean \(n\times n\) (chỉ chứa 0 và 1) được lưu theo hai cách.

  • Đặc: lưu từng bit, \(n^2\) bit.
  • Thưa: mỗi ô 1 lưu hai tọa độ, mỗi tọa độ \(\lceil\log_2 n\rceil\) bit.

Gọi \(m\) là số ô 1, \(\rho=m/n^2\); xác định \(\rho\) để cách thưa tốn ít bit hơn.

Trình bày hai biểu thức dung lượng và điều kiện của \(\rho\).

Nguồn: MMDS, Bài 5.2.1, §5.2.6, tr.195.

Bài tập: biểu diễn hai đồ thị theo liên kết ra

Đồ thị Hình 5.4: A trỏ tới B, C, D; B trỏ tới A, D; C trỏ tới E; D trỏ tới B, C; E không có liên kết ra Đồ thị Hình 5.7: a trỏ tới a, b, c; b trỏ tới a, c; c trỏ tới b, c; bảy cạnh có hai vòng lặp trên a và c

Câu hỏi: với Hình 5.4 và Hình 5.7, lập bảng nguồn, bậc ra, danh sách đích theo §5.2.1.

Trái: Hình 5.4, nút E không có liên kết ra. Phải: Hình 5.7, bảy cạnh, khuyên ở a và c.

Nguồn: MMDS, Bài 5.2.2, §5.2.6, tr.195; Hình 5.4, tr.184; Hình 5.7, tr.188.

Giải thuật nền tảng của Khoa học dữ liệu · Học kỳ 1, 2026–2027 · Bài 03