Hai điểm khác nhau vẫn có thể nhận khoảng cách Poincaré bằng 0 khi tính bằng float32. Với công thức arccosh(1 + 2*s), phép cộng có thể làm tròn đối số thành đúng 1. Dạng tương đương 2*arcsinh(sqrt(s)) tránh bước cộng ấy và giữ được khoảng cách nhỏ trong các trường hợp thí nghiệm dưới đây.
Độ chính xác còn phụ thuộc vào cách lưu tọa độ và cách tính s. Nếu hai tọa độ đã bị làm tròn thành cùng một điểm, thay công thức hoặc chuyển mảng đó sang float64 sau cùng đều không lấy lại được phần thông tin đã mất. Bài này đối chiếu tám cặp điểm trên float32 và float64, với hai tham chiếu mpmath riêng để phân biệt những nguồn sai số đó.
Công thức trên đĩa Poincaré
Trong mô hình có độ cong $-1$, hai điểm $u,v$ thuộc quả cầu đơn vị mở, tức $\lVert u\rVert<1$ và $\lVert v\rVert<1$. Đặt:
$$ s = \frac{\lVert u-v\rVert^2}{(1-\lVert u\rVert^2)(1-\lVert v\rVert^2)}. $$Khoảng cách là:
$$ d(u,v)=\operatorname{arcosh}(1+2s). $$Đây là công thức (1) trong bài Poincaré Embeddings for Learning Hierarchical Representations của Nickel và Kiela. Thí nghiệm ở đây dùng hai chiều, nên mỗi điểm có shape (2,). Bài báo Poincaré Embeddings, NeurIPS 2017
Bài nền tảng về hình học hyperbolic và khoảng cách trong Poincaré ball giải thích vì sao khoảng cách tăng nhanh khi tiến sát biên. Ở đây, ta kiểm tra cách các phép toán số học thực hiện công thức đó.
Vì $s\ge0$, đặt $a=\operatorname{asinh}(\sqrt{s})$. Từ $\cosh(2a)=1+2\sinh^2(a)$ suy ra $\cosh(2a)=1+2s$. Lấy nghịch đảo trên nhánh không âm, ta có:
$$ \operatorname{arcosh}(1+2s)=2\operatorname{asinh}(\sqrt{s}). $$NumPy cung cấp hai hàm np.arccosh và np.arcsinh. Đẳng thức trên đúng trong số học thực, còn hai chuỗi phép tính có thể cho kết quả dấu phẩy động khác nhau. Tài liệu arccosh, tài liệu arcsinh
Bước cộng với 1 làm mất khoảng cách nhỏ
np.finfo(dtype).eps cho khoảng cách từ 1 tới số biểu diễn được tiếp theo lớn hơn 1 trong kiểu số đó. Lần chạy dùng NumPy 2.2.5 cho các giá trị sau. Tài liệu finfo
| Kiểu số | eps |
|---|---|
| float32 | $1.1920928955\times10^{-7}$ |
| float64 | $2.2204460493\times10^{-16}$ |
Với $u=(0,0)$ và $v=(10^{-6},0)$, ta có $s$ xấp xỉ $10^{-12}$. Trong float32, 1 + 2*s được làm tròn thành đúng 1, nên arccosh trả 0. Dạng asinh bỏ qua bước cộng này và trả khoảng $2\times10^{-6}$.
Đổi sang float64 làm ngưỡng mất thông tin nhỏ hơn. Tuy vậy, với $v=(10^{-10},0)$, phép cộng ở dạng arccosh vẫn làm tròn về 1 ngay cả trong float64. Mã ghi lại cả đối số arccosh_argument để kiểm tra trực tiếp điều này.
Hai tham chiếu để xác định sai số đến từ đâu
Mã lưu tọa độ ban đầu dưới dạng chuỗi thập phân, như "0.250001", rồi tạo hai tham chiếu với mpmath ở độ chính xác làm việc 80 chữ số.
Tham chiếu đầu vào thập phân tính khoảng cách của các tọa độ mong muốn được đọc trực tiếp từ chuỗi. Tham chiếu đầu vào nhị phân đã làm tròn tính khoảng cách của đúng những giá trị đang nằm trong mảng float32 hoặc float64. Khi chuyển phần tử float32 thành Python float để đưa vào mpmath, giá trị float32 đó được giữ nguyên. Hướng dẫn độ chính xác và tạo số trong mpmath
Từ đó, mã báo riêng sai số do làm tròn đầu vào, sai số của từng công thức so với tham chiếu nhị phân, và sai số tổng so với tham chiếu thập phân. Các trường này được tính trước khi định dạng kết quả. JSON hiển thị tham chiếu và sai số với 14 chữ số có nghĩa.
Kết quả trên các cặp điểm cố định
Bảng trích sáu kết quả từ tám cặp điểm và hai kiểu số. Cột tham chiếu dùng đầu vào nhị phân đã làm tròn, để đối chiếu việc đánh giá công thức trên cùng tọa độ. Các số được rút gọn để dễ đọc.
| Cặp điểm | Kiểu số | Tham chiếu | Dạng arccosh | Dạng asinh |
|---|---|---|---|---|
| Gốc tới $(10^{-6},0)$ | float32 | $1.999999995\times10^{-6}$ | 0 | $1.999999995\times10^{-6}$ |
| Gốc tới $(10^{-6},0)$ | float64 | $2.000000000\times10^{-6}$ | $1.999977878\times10^{-6}$ | $2.000000000\times10^{-6}$ |
| Gốc tới $(10^{-10},0)$ | float64 | $2.000000000\times10^{-10}$ | 0 | $2.000000000\times10^{-10}$ |
| Cặp gần tâm | float32 | $2.198300723\times10^{-6}$ | 0 | $2.198300763\times10^{-6}$ |
| Cặp thông thường | float32 | 1,540340653 | 1,540340662 | 1,540340781 |
| Cặp sát biên theo bán kính | float32 | 0,692899145 | 0,692898870 | 0,692898810 |
“Cặp gần tâm” là $(0.25,0.125)$ và $(0.250001,0.125)$. “Cặp thông thường” là $(0.2,-0.3)$ và $(-0.4,0.1)$. Cặp sát biên theo bán kính là $(0.9999,0)$ và $(0.9998,0)$.
Ở cặp thông thường, sai số tuyệt đối so với tham chiếu nhị phân của arccosh khoảng $9.33\times10^{-9}$, còn asinh khoảng $1.29\times10^{-7}$. Với cặp sát biên theo bán kính, các sai số lần lượt khoảng $2.75\times10^{-7}$ và $3.35\times10^{-7}$. Dạng asinh có lợi rõ ở những hàng bị mất thông tin trong bước cộng với 1, nhưng không cho sai số nhỏ hơn trên mọi hàng.
Công thức tốt hơn vẫn chịu sai số tọa độ
Với cặp gần tâm, khoảng cách của tọa độ thập phân mong muốn là khoảng $2.169492114\times10^{-6}$. Sau khi lưu thành float32, khoảng cách tham chiếu của chính các tọa độ đã lưu tăng thành $2.198300723\times10^{-6}$.
Sai số do làm tròn đầu vào khoảng $2.88\times10^{-8}$. Trong khi đó, sai số tính dạng asinh trên đầu vào đã làm tròn chỉ khoảng $3.95\times10^{-14}$. So với tọa độ mong muốn, phần sai số lớn hơn đã xuất hiện trước khi gọi hàm khoảng cách.
Trường hợp $(0.9,0)$ và $(0.900000001,0)$ rõ hơn nữa. Cả hai tọa độ $x$ trở thành cùng giá trị float32 là 0.8999999761581421. Tham chiếu nhị phân bằng 0 và cả hai công thức đều trả 0, trong khi khoảng cách thập phân mong muốn khoảng $1.05263\times10^{-8}$. Muốn giữ khác biệt ban đầu, cần chọn cách biểu diễn đủ chính xác từ lúc đọc hoặc tạo tọa độ.
Kiểm tra miền mở khi sát biên
Cặp $(0.99999999,0)$ và $(0.99999998,0)$ nằm trong đĩa theo các giá trị thập phân ban đầu. Khi chuyển sang float32, cả hai tọa độ $x$ thành 1. Chúng chạm biên, và mã trả ValueError cho cả hai cách tính.
Hàm kiểm tra chuẩn bình phương được tính trong chính dtype đang thử và yêu cầu nó nhỏ hơn 1. Đây là kiểm tra miền trong số học hữu hạn. Khi rất sát biên, phép tính chuẩn cũng chịu sai số làm tròn, nên điều kiện này chưa phải chứng nhận chính xác bằng số học khoảng về chuẩn thực của điểm.
Mã giữ nguyên tọa độ khi tính, không cắt chúng vào trong bằng clip. Nếu một ứng dụng chủ động chiếu tọa độ về miền hợp lệ, bước đó thay đổi điểm mà ta đang đo và cần được ghi nhận riêng. Độ ổn định của s vẫn phụ thuộc vào phép trừ tọa độ, bình phương khoảng cách và hai thừa số mẫu số sát biên.
Mã tái lập và các phép kiểm tra
Mã dùng Python 3.10.11, NumPy 2.2.5 và mpmath 1.3.0. Lưu thành experiment.py rồi chạy python3 experiment.py. Chương trình in JSON cho đủ tám cặp điểm trên cả hai dtype.
Các kiểm tra xác nhận tính đối xứng và khoảng cách tự thân bằng 0 trên mọi trường hợp được chấp nhận. Một kiểm tra hình học độc lập đối chiếu $d((0,0),(0.5,0))$ với $\ln3$. Mã còn kiểm tra các trường hợp arccosh trả 0, hai đầu vào float32 trùng nhau và điểm làm tròn tới biên. Các phép thử này khảo sát tính đúng đắn số học trên các đầu vào đã chọn.
1import json
2import platform
3
4import mpmath as mp
5import numpy as np
6
7mp.mp.dps = 80
8
9CASES = [
10 ("origin_1e-6", ("0", "0"), ("0.000001", "0")),
11 ("origin_1e-10", ("0", "0"), ("0.0000000001", "0")),
12 ("center_pair_1e-6", ("0.25", "0.125"), ("0.250001", "0.125")),
13 ("same_float32_point", ("0.9", "0"), ("0.900000001", "0")),
14 ("ordinary_pair", ("0.2", "-0.3"), ("-0.4", "0.1")),
15 ("near_boundary_radial", ("0.9999", "0"), ("0.9998", "0")),
16 ("near_boundary_directions", ("0.9999", "0"), ("0", "0.9999")),
17 ("rounded_to_boundary", ("0.99999999", "0"), ("0.99999998", "0")),
18]
19
20
21def reference_distance(u, v):
22 norm_u = sum(x * x for x in u)
23 norm_v = sum(x * x for x in v)
24 if norm_u >= 1 or norm_v >= 1:
25 raise ValueError("reference point is outside the open unit ball")
26 squared_distance = sum((x - y) ** 2 for x, y in zip(u, v))
27 return 2 * mp.asinh(mp.sqrt(squared_distance / ((1 - norm_u) * (1 - norm_v))))
28
29
30def binary_reference(point):
31 # Converting float32 to Python float preserves its value exactly.
32 return tuple(mp.mpf(float(value)) for value in point)
33
34
35def short(value):
36 return mp.nstr(value, 14)
37
38
39def numpy_distances(u, v, dtype):
40 u = np.asarray(u, dtype=dtype)
41 v = np.asarray(v, dtype=dtype)
42 if u.shape != (2,) or v.shape != (2,):
43 raise ValueError("each point must have shape (2,)")
44 if not np.isfinite(u).all() or not np.isfinite(v).all():
45 raise ValueError("coordinates must be finite")
46 one, two = dtype(1), dtype(2)
47 norm_u = np.sum(u * u, dtype=dtype)
48 norm_v = np.sum(v * v, dtype=dtype)
49 if norm_u >= one or norm_v >= one:
50 raise ValueError("computed squared norm must be strictly below 1")
51 squared_distance = np.sum((u - v) ** 2, dtype=dtype)
52 with np.errstate(over="raise", invalid="raise", divide="raise"):
53 s = squared_distance / ((one - norm_u) * (one - norm_v))
54 argument = one + two * s
55 naive = np.arccosh(argument)
56 asinh = two * np.arcsinh(np.sqrt(s))
57 return {"naive": float(naive), "asinh": float(asinh),
58 "arccosh_argument": float(argument)}
59
60
61def run_case(name, raw_u, raw_v, dtype):
62 target = reference_distance(tuple(map(mp.mpf, raw_u)), tuple(map(mp.mpf, raw_v)))
63 u, v = np.array(raw_u, dtype=dtype), np.array(raw_v, dtype=dtype)
64 row = {"case": name, "dtype": np.dtype(dtype).name,
65 "target_u": raw_u, "target_v": raw_v,
66 "rounded_u": u.tolist(), "rounded_v": v.tolist(),
67 "reference_exact_decimal_input": short(target)}
68 try:
69 rounded = reference_distance(binary_reference(u), binary_reference(v))
70 except ValueError as error:
71 row["rounded_reference_error"] = str(error)
72 else:
73 row["reference_rounded_binary_input"] = short(rounded)
74 row["input_rounding_abs_error"] = short(abs(rounded - target))
75 try:
76 values = numpy_distances(u, v, dtype)
77 except ValueError as error:
78 row["numpy_error"] = "ValueError: " + str(error)
79 return row
80 row.update(values)
81 row["function_abs_error_vs_rounded"] = {
82 method: short(abs(mp.mpf(values[method]) - rounded))
83 for method in ("naive", "asinh")
84 }
85 row["total_abs_error_vs_target"] = {
86 method: short(abs(mp.mpf(values[method]) - target))
87 for method in ("naive", "asinh")
88 }
89 reverse = numpy_distances(v, u, dtype)
90 self_distance = numpy_distances(u, u, dtype)
91 for method in ("naive", "asinh"):
92 assert values[method] == reverse[method]
93 assert self_distance[method] == 0.0
94 assert values[method] >= 0.0
95 return row
96
97
98def main():
99 rows = [run_case(name, u, v, dtype)
100 for name, u, v in CASES for dtype in (np.float32, np.float64)]
101 by_case = {(row["case"], row["dtype"]): row for row in rows}
102 for name, dtype in (("origin_1e-6", "float32"), ("origin_1e-10", "float64")):
103 assert by_case[name, dtype]["naive"] == 0.0
104 assert by_case[name, dtype]["asinh"] > 0.0
105 collapsed = by_case["same_float32_point", "float32"]
106 assert collapsed["rounded_u"] == collapsed["rounded_v"]
107 assert collapsed["asinh"] == 0.0
108 assert "numpy_error" in by_case["rounded_to_boundary", "float32"]
109 origin_check = numpy_distances(("0", "0"), ("0.5", "0"), np.float64)
110 assert abs(origin_check["asinh"] - float(mp.log(3))) < 1e-14
111 report = {
112 "python": platform.python_version(), "numpy": np.__version__,
113 "mpmath": mp.__version__, "reference_decimal_digits": mp.mp.dps,
114 "curvature": -1, "coordinate_shape": [2],
115 "epsilon": {np.dtype(dtype).name: float(np.finfo(dtype).eps)
116 for dtype in (np.float32, np.float64)},
117 "geometry_checks": "symmetry and self-distance for all accepted cases; d(0,0.5)=log(3)",
118 "cases": rows,
119 }
120 print(json.dumps(report, indent=2, allow_nan=False))
121
122
123if __name__ == "__main__":
124 main()
Đọc thêm trên blog
Bài hình học phi Euclid qua hình học cầu và hyperbolic đặt mô hình Poincaré vào bức tranh hình học rộng hơn.
Bình luận