chore: import upstream snapshot with attribution

2026-07-13 13:30:25 +08:00
commit f19b2512d7
562 changed files with 38082 additions and 0 deletions
@@ -0,0 +1,24 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestAbs(unittest.TestCase):
+
+    def test_abs(self):
+        np.random.seed(1234)
+        x = nn.Parameter(np.random.randn(5, 7))
+        sign = np.sign(x.value)
+        y = nn.abs(x)
+        self.assertTrue((y.value == np.abs(x.value)).all())
+
+        for _ in range(10000):
+            x.cleargrad()
+            y = nn.abs(x)
+            nn.square(y - 0.01).sum().backward()
+            x.value -= x.grad * 0.001
+        self.assertTrue(np.allclose(x.value, 0.01 * sign))
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,25 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestAdd(unittest.TestCase):
+
+    def test_add(self):
+        x = nn.Parameter(2)
+        z = x + 5
+        self.assertEqual(z.value, 7)
+        z.backward()
+        self.assertEqual(x.grad, 1)
+
+        x = np.random.rand(5, 4)
+        y = np.random.rand(4)
+        p = nn.Parameter(y)
+        z = x + p
+        self.assertTrue((z.value == x + y).all())
+        z.backward(np.ones((5, 4)))
+        self.assertTrue((p.grad == np.ones(4) * 5).all())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,26 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestDivide(unittest.TestCase):
+
+    def test_divide(self):
+        x = nn.Parameter(10.)
+        z = x / 2
+        self.assertEqual(z.value, 5)
+        z.backward()
+        self.assertEqual(x.grad, 0.5)
+
+        x = np.random.rand(5, 10, 3)
+        y = np.random.rand(10, 1)
+        p = nn.Parameter(y)
+        z = x / p
+        self.assertTrue((z.value == x / y).all())
+        z.backward(np.ones((5, 10, 3)))
+        d = np.sum(-x / y ** 2, axis=0).sum(axis=1, keepdims=True)
+        self.assertTrue((p.grad == d).all())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,24 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestExp(unittest.TestCase):
+
+    def test_exp(self):
+        x = nn.Parameter(2.)
+        y = nn.exp(x)
+        self.assertEqual(y.value, np.exp(2))
+        y.backward()
+        self.assertEqual(x.grad, np.exp(2))
+
+        x = np.random.rand(5, 3)
+        p = nn.Parameter(x)
+        y = nn.exp(p)
+        self.assertTrue((y.value == np.exp(x)).all())
+        y.backward(np.ones((5, 3)))
+        self.assertTrue((p.grad == np.exp(x)).all())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,18 @@
+import unittest
+from prml import nn
+
+
+class TestGamma(unittest.TestCase):
+
+    def test_gamma(self):
+        self.assertEqual(24, nn.gamma(5).value)
+        a = nn.Parameter(2.5)
+        eps = 1e-5
+        b = nn.gamma(a)
+        b.backward()
+        num_grad = ((nn.gamma(a + eps) - nn.gamma(a - eps)) / (2 * eps)).value
+        self.assertAlmostEqual(a.grad, num_grad)
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,24 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestLog(unittest.TestCase):
+
+    def test_log(self):
+        x = nn.Parameter(2.)
+        y = nn.log(x)
+        self.assertEqual(y.value, np.log(2))
+        y.backward()
+        self.assertEqual(x.grad, 0.5)
+
+        x = np.random.rand(4, 6)
+        p = nn.Parameter(x)
+        y = nn.log(p)
+        self.assertTrue((y.value == np.log(x)).all())
+        y.backward(np.ones((4, 6)))
+        self.assertTrue((p.grad == 1 / x).all())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,26 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestMatMul(unittest.TestCase):
+
+    def test_matmul(self):
+        x = np.random.rand(10, 3)
+        y = np.random.rand(3, 5)
+        g = np.random.rand(10, 5)
+        xp = nn.Parameter(x)
+        z = xp @ y
+        self.assertTrue((z.value == x @ y).all())
+        z.backward(g)
+        self.assertTrue((xp.grad == g @ y.T).all())
+
+        yp = nn.Parameter(y)
+        z = x @ yp
+        self.assertTrue((z.value == x @ y).all())
+        z.backward(g)
+        self.assertTrue((yp.grad == x.T @ g).all())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,25 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestMean(unittest.TestCase):
+
+    def test_mean(self):
+        x = np.random.rand(5, 1, 2)
+        xp = nn.Parameter(x)
+        z = xp.mean()
+        self.assertEqual(z.value, x.mean())
+        z.backward()
+        self.assertTrue((xp.grad == np.ones((5, 1, 2)) / 10).all())
+        xp.cleargrad()
+
+        z = xp.mean(axis=0, keepdims=True)
+        self.assertEqual(z.shape, (1, 1, 2))
+        self.assertTrue((z.value == x.mean(axis=0, keepdims=True)).all())
+        z.backward(np.ones((1, 1, 2)))
+        self.assertTrue((xp.grad == np.ones((5, 1, 2)) / 5).all())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,25 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestMultiply(unittest.TestCase):
+
+    def test_multiply(self):
+        x = nn.Parameter(2)
+        y = x * 5
+        self.assertEqual(y.value, 10)
+        y.backward()
+        self.assertEqual(x.grad, 5)
+
+        x = np.random.rand(5, 4)
+        y = np.random.rand(4)
+        yp = nn.Parameter(y)
+        z = x * yp
+        self.assertTrue((z.value == x * y).all())
+        z.backward(np.ones((5, 4)))
+        self.assertTrue((yp.grad == x.sum(axis=0)).all())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,24 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestNegative(unittest.TestCase):
+
+    def test_negative(self):
+        x = nn.Parameter(2.)
+        y = -x
+        self.assertEqual(y.value, -2)
+        y.backward()
+        self.assertEqual(x.grad, -1)
+
+        x = np.random.rand(2, 3)
+        xp = nn.Parameter(x)
+        y = -xp
+        self.assertTrue((y.value == -x).all())
+        y.backward(np.ones((2, 3)))
+        self.assertTrue((xp.grad == -np.ones((2, 3))).all())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,24 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestPower(unittest.TestCase):
+
+    def test_power(self):
+        x = nn.Parameter(2.)
+        y = 2 ** x
+        self.assertEqual(y.value, 4)
+        y.backward()
+        self.assertEqual(x.grad, 4 * np.log(2))
+
+        x = np.random.rand(10, 2)
+        xp = nn.Parameter(x)
+        y = xp ** 3
+        self.assertTrue((y.value == x ** 3).all())
+        y.backward(np.ones((10, 2)))
+        self.assertTrue(np.allclose(xp.grad, 3 * x ** 2))
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,17 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestSqrt(unittest.TestCase):
+
+    def test_sqrt(self):
+        x = nn.Parameter(2.)
+        y = nn.sqrt(x)
+        self.assertEqual(y.value, np.sqrt(2))
+        y.backward()
+        self.assertEqual(x.grad, 0.5 / np.sqrt(2))
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,17 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestSqrt(unittest.TestCase):
+
+    def test_sqrt(self):
+        x = nn.Parameter(2.)
+        y = nn.square(x)
+        self.assertEqual(y.value, 4)
+        y.backward()
+        self.assertEqual(x.grad, 4)
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,25 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestSubtract(unittest.TestCase):
+
+    def test_forward_backward(self):
+        x = nn.Parameter(2)
+        z = x - 5
+        self.assertEqual(z.value, -3)
+        z.backward()
+        self.assertEqual(x.grad, 1)
+
+        x = np.random.rand(5, 4)
+        y = np.random.rand(4)
+        p = nn.Parameter(y)
+        z = x - p
+        self.assertTrue((z.value == x - y).all())
+        z.backward(np.ones((5, 4)))
+        self.assertTrue((p.grad == -np.ones(4) * 5).all())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,25 @@
+import unittest
+import numpy as np
+from prml import nn
+
+
+class TestSum(unittest.TestCase):
+
+    def test_sum(self):
+        x = np.random.rand(5, 1, 2)
+        xp = nn.Parameter(x)
+        z = xp.sum()
+        self.assertEqual(z.value, x.sum())
+        z.backward()
+        self.assertTrue((xp.grad == np.ones((5, 1, 2))).all())
+        xp.cleargrad()
+
+        z = xp.sum(axis=0, keepdims=True)
+        self.assertEqual(z.shape, (1, 1, 2))
+        self.assertTrue((z.value == x.sum(axis=0, keepdims=True)).all())
+        z.backward(np.ones((1, 1, 2)))
+        self.assertTrue((xp.grad == np.ones((5, 1, 2))).all())
+
+
+if __name__ == '__main__':
+    unittest.main()