def test_mul(self):
print('test_mul')
np.testing.assert_almost_equal(
(kp.arr(2) * kp.arr(3)).numpy(),
[6]
)
def test_sub(self):
print('test_sub')
np.testing.assert_almost_equal(
(kp.arr(2) - kp.arr(3)).numpy(),
[-1]
)
def test_div(self):
print('test_div')
np.testing.assert_almost_equal(
(kp.arr(2) / kp.arr(3)).numpy(),
[0.6666666666666]
)
def test_inplace_mul(self):
print('test_inplace_mul')
a = kp.arr(2);
a *= kp.arr(1.5)
np.testing.assert_almost_equal(
a.numpy(),
[3]
)
def test_inplace_sub(self):
print('test_inplace_sub')
a = kp.arr(2);
a -= kp.arr(1)
np.testing.assert_almost_equal(
a.numpy(),
[1],
)
def test_inplace_div(self):
print('test_inplace_div')
a = kp.arr(2);
a /= kp.arr(1.5)
np.testing.assert_almost_equal(
a.numpy(),
[1.33333333]
)
def test_shape_attr(self):
print('test_shape_attr')
shape = [3, 4, 5]
with self.assertRaises(AttributeError):
kp.arr(1).shape = [1, 2]
self.assertEqual(
kp.arr(1, shape=shape).shape,
tuple(shape)
)
def test_subscript(self):
print('test_subscript')
a = kp.arr('range', shape=[5, 5, 5, 5, 5])
b = a.numpy()
with self.assertRaises(kp.KarrayError):
a[..., ...]
with self.assertRaises(ValueError):
a[5]
with self.assertRaises(TypeError):
a[1.3]
with self.assertRaises(ValueError):
print(a[-7])
with self.assertRaises(ValueError):
a[..., 5]
a[1:1]
c = kp.arr([1, 2])
c[[1, 0]]
subscripts = [(1),
(-1),
(-3),
(-3, -3, slice(-1, 0, -1)),
(0, ...),
(..., 0),
(..., 4),
(slice(None),slice(None)),
(..., slice(1, 2, 3)),
(..., (1, 2, 3)),
(1, 2, ..., slice(1, 2, 3)),
(slice(None), ..., slice(1, 2, 3)),
(..., slice(None), slice(1, 2, 3)),
(0, 1, 2, 3, 4)]
for subscript in subscripts:
np.testing.assert_almost_equal(
a[subscript].numpy(),
b[subscript],
err_msg=f"error occured with subscript {subscript}"
)
def test_matmul(self):
print('test_matmul')
a = kp.arr('range', shape=[3, 3]).reshape([1, 3, 3]).broadcast([2, 3, 3])
b = kp.arr('range', shape=[3, 2])
np.testing.assert_almost_equal(
(a @ b).numpy(),
np.array([[[10., 13.],
[28., 40.],
[46., 67.]],
[[10., 13.],
[28., 40.],
[46., 67.]]])
)
def step(self, x_batch, y_batch):
drelu = lambda x: kp.relu(x) / (kp.relu(x) + kp.arr(0.000000000001))
s1 = self.W1 @ x_batch
s2 = s1 + self.b
s3 = kp.relu(s2)
s4 = self.W2 @ s3
s5 = kp.softmax(s4.reshape([self.batch_size, self.o
])).reshape([self.batch_size, self.o, 1])
loss = (s5 - y_batch)
x_entropy = (-y_batch * kp.log(s5)).mean()
dW2 = loss @ s3.reshape([self.batch_size, 1, self.h])
r1 = loss.reshape([self.batch_size, 1, self.o]) @ self.W2
r2 = r1.reshape([self.batch_size, self.h, 1]) * drelu(s2)
db = r2
dW1 = r2 @ x_batch.reshape([self.batch_size, 1, 784])
self.W1 -= self.learning_rate * dW1.mean(0)
self.b -= self.learning_rate * db.mean(0)
self.W2 -= self.learning_rate * dW2.mean(0)
return x_entropy.mean()
def test_mean(self):
print('test_mean')
a = np.random.rand(2, 3, 4).astype(np.float32)
ka = kp.arr(a)
np.testing.assert_almost_equal(
ka.mean().numpy(),
a.mean()
)
np.testing.assert_almost_equal(
ka.mean(0).numpy(),
a.mean(0)
)
np.testing.assert_almost_equal(
ka.mean(1).numpy(),
a.mean(1)
)
np.testing.assert_almost_equal(
ka.mean(2).numpy(),
a.mean(2)
)
np.testing.assert_almost_equal(
ka.mean(-1).numpy(),
a.mean(-1)
)
class LinNN:
learning_rate = kp.arr(0.5)
def __init__(self, i, h, o):
self.i = i
self.h = h
self.o = o
self.W1 = kp.arr('rand', shape=[h, i]) - kp.arr(0.5)
self.b = kp.arr('rand', shape=[h, 1]) - kp.arr(0.5)
self.W2 = kp.arr('rand', shape=[o, h]) - kp.arr(0.5)
def step(self, x_batch, y_batch):
drelu = lambda x: kp.relu(x) / (kp.relu(x) + kp.arr(0.000000000001))
s1 = self.W1 @ x_batch
s2 = s1 + self.b
s3 = kp.relu(s2)
s4 = self.W2 @ s3
s5 = kp.softmax(s4.reshape([self.batch_size, self.o
])).reshape([self.batch_size, self.o, 1])
loss = (s5 - y_batch)
x_entropy = (-y_batch * kp.log(s5)).mean()
dW2 = loss @ s3.reshape([self.batch_size, 1, self.h])
r1 = loss.reshape([self.batch_size, 1, self.o]) @ self.W2
r2 = r1.reshape([self.batch_size, self.h, 1]) * drelu(s2)
db = r2
dW1 = r2 @ x_batch.reshape([self.batch_size, 1, 784])
self.W1 -= self.learning_rate * dW1.mean(0)
self.b -= self.learning_rate * db.mean(0)
self.W2 -= self.learning_rate * dW2.mean(0)
return x_entropy.mean()
def train(self, train, labels, epochs=1, batch_size=64, verbose=20):
self.batch_size = batch_size
for k in range(epochs):
for batch in range(train.shape[0] // batch_size):
x_batch = train[batch * batch_size:(batch + 1) * batch_size]
y_batch = labels[batch * batch_size:(batch + 1) * batch_size]
if batch % verbose == 0:
print(self.step(x_batch, y_batch))
def accuracy(self, x_test, y_test):
predictions = kp.softmax(
self.W2
@ kp.relu(self.W1 @ x_test.reshape([-1, self.i, 1]) + self.b), -2)
success = predictions.numpy().argmax(-2) == y_test.argmax(-2)
return success.mean()
def test_broadcast(self):
print('test_broadcast')
a = kp.arr('range', shape=[1, 4])
np.testing.assert_almost_equal(
a.broadcast([3, 4]).numpy(),
np.array([[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3]])
)
def test_init(self):
global v, w, y, z, d
v = kp.arr('randn', shape=(2,))
w = kp.arr('randn', shape=(2,))
y = kp.arr('randn', shape=(2,))
z = kp.arr('randn', shape=(2,))
d = kp.arr([[1, .3], [0.5, -1]])
evaluator = np.random.randn(3, 2)
def f(x):
x = x @ ((d + v - w)* y / z)
return -x
g = kp.graph(f)
result = g.compile(kp.arr(evaluator))
v = v.numpy()
w = w.numpy()
y = y.numpy()
z = z.numpy()
d = d.numpy()
np.testing.assert_almost_equal(
result.numpy(),
f(evaluator),
decimal=5,
err_msg="behavior of graph and function differs"
)
def __init__(self, i, h, o):
self.i = i
self.h = h
self.o = o
self.W1 = kp.arr('rand', shape=[h, i]) - kp.arr(0.5)
self.b = kp.arr('rand', shape=[h, 1]) - kp.arr(0.5)
self.W2 = kp.arr('rand', shape=[o, h]) - kp.arr(0.5)
def test_relu(self):
print('test_relu')
for k in range(nb_random_checks):
shape = rand_shape()
ka = kp.arr('rand', shape=shape)
na = ka.numpy()
np.testing.assert_almost_equal(
kp.relu(ka).numpy(),
na * (na > 0),
err_msg=f"shape = {shape}"
)
def test_reshape(self):
print('test_reshape')
with self.assertRaises(kp.KarrayError):
kp.arr(1).reshape([2])
with self.assertRaises(kp.KarrayError):
kp.arr(1).reshape([])
with self.assertRaises(kp.KarrayError):
kp.arr(1).reshape(np.array([]))
for k in range(nb_random_checks):
shape, size = rand_shape_and_size()
np.testing.assert_almost_equal(
kp.arr('range', shape=[size]).reshape(shape).numpy(),
np.array(range(size)).reshape(shape),
err_msg=f"reshape to {shape}"
)
def test_inplace_add(self):
print('test_inplace_add')
ka = kp.arr(1)
ka += kp.arr(2)
np.testing.assert_almost_equal(
ka.numpy(),
[3]
)
for k in range(nb_random_checks):
shape = rand_shape()
a = np.random.rand(*shape).astype(np.float32)
b = np.random.rand(*shape).astype(np.float32)
ka = kp.arr(a)
ka += kp.arr(b)
np.testing.assert_almost_equal(
ka.numpy(),
a + b
)
for sa, sb in self.pair_shapes_one_side:
na = np.random.rand(*sa)
nb = np.random.rand(*sb)
a = kp.arr(na)
b = kp.arr(nb)
b += a
np.testing.assert_almost_equal(
b.numpy(),
na + nb,
err_msg=f"sa = {sa}, sb = {sb}"
)
def test_add(self):
print('test_add')
with self.assertRaises(TypeError):
kp.arr(1) + ''
with self.assertRaises(TypeError):
kp.arr(1) + '33'
with self.assertRaises(TypeError):
kp.arr(1) + 1
with self.assertRaises(TypeError):
1 + kp.arr(1)
np.testing.assert_almost_equal(
(kp.arr(1) + kp.arr(2)).numpy(),
[3]
)
for k in range(nb_random_checks):
shape = rand_shape()
a = np.random.rand(*shape)
b = np.random.rand(*shape)
np.testing.assert_almost_equal(
(kp.arr(a) + kp.arr(b)).numpy(),
a + b,
err_msg=f"shape = {shape}"
)
for sa, sb in self.pair_shapes:
na = np.random.rand(*sa)
nb = np.random.rand(*sb)
a = kp.arr(na)
b = kp.arr(nb)
np.testing.assert_almost_equal(
(a + b).numpy(),
na + nb,
err_msg=f"sa = {sa}, sb = {sb}"
)
np.testing.assert_almost_equal(
(b + a).numpy(),
na + nb,
err_msg=f"sa = {sa}, sb = {sb}"
)
with np.load("C:/Users/kipr/Downloads/mnist.npz") as data:
train_examples = (data['x_train'].reshape(-1, 28 * 28, 1) / 255).astype(
np.float32)
train_labels = np.zeros((60000, 10))
np.put_along_axis(train_labels, data['y_train'].reshape(-1, 1), 1, 1)
train_labels = train_labels.astype(np.float32).reshape(-1, 10, 1)
test_examples = (data['x_test'].reshape(-1, 28 * 28, 1) / 255).astype(
np.float32)
test_labels = np.zeros((10000, 10))
np.put_along_axis(test_labels, data['y_test'].reshape(-1, 1), 1, 1)
test_labels = test_labels.astype(np.float32).reshape(-1, 10, 1)
nb_examples = len(train_labels)
train = kp.arr(train_examples)
labels = kp.arr(train_labels)
class LinNN:
learning_rate = kp.arr(0.5)
def __init__(self, i, h, o):
self.i = i
self.h = h
self.o = o
self.W1 = kp.arr('rand', shape=[h, i]) - kp.arr(0.5)
self.b = kp.arr('rand', shape=[h, 1]) - kp.arr(0.5)
self.W2 = kp.arr('rand', shape=[o, h]) - kp.arr(0.5)
def test_print(self):
print('test_print')
print(kp.arr(1, shape=[2, 3]))
py
import kipr as kp
W1 = kp.arr('randn', shape=[20, 30])
W2 = kp.arr('randn', shape=[3, 20])
b = kp.arr('randn', shape=[20, 1])
@kp.graph
def f(x):
x = kp.relu(W1 @ x + b)
return kp.softmax(W2 @ x)
f.compile(kp.arr('randn', shape=[12, 30, 1]))
exit()
py
import kipr as kp
v = kp.arr('randn', shape=(2, ))
w = kp.arr('randn', shape=(2, ))
y = kp.arr('randn', shape=(2, ))
z = kp.arr('randn', shape=(2, ))
d = kp.arr([[1, .3], [0.5, -1]])
def f(x):
x = x @ ((d + v - w) * y / z)
return kp.relu(-x)
g = kp.graph(f)
def test_init(self):
print('test_init')
# at least one argument
with self.assertRaises(TypeError):
kp.arr()
# too deep
with self.assertRaises(TypeError):
kp.arr([[[[[[[[[[1]]]]]]]]]])
# data must be a sequence of numbers
with self.assertRaises(TypeError):
kp.arr(['a', 'b'])
# shouldn't be any zeros in shape
with self.assertRaises(kp.KarrayError):
kp.arr(1, shape=[0, 1])
# shape len must be > 1
with self.assertRaises(kp.KarrayError):
kp.arr(1, shape=[])
# shape must be a sequence
with self.assertRaises(kp.KarrayError):
kp.arr(1, shape=2)
# shape must be a sequence
with self.assertRaises(kp.KarrayError):
kp.arr(1, shape=np.array([]))
# BUG
# self.assertTrue(kp.arr(1, shape=(1)))
# sanity check
self.assertTrue(kp.arr(1))
np.testing.assert_almost_equal(
kp.arr(1).numpy(),
np.array([1]),
err_msg="simple 1"
)
np.testing.assert_almost_equal(
kp.arr(range(2), shape=[1, 1, 1, 2]).numpy(),
np.arange(2).reshape([1, 1, 1, 2]),
err_msg="simple 2"
)
for k in range(nb_random_checks):
shape = rand_shape()
np.testing.assert_almost_equal(
kp.arr('range', shape=shape).numpy(),
np.array(range(np.array(shape).prod())).reshape(shape),
err_msg=f"shape = {shape}"
)
for k in range(nb_random_checks):
shape = rand_shape()
a = np.random.rand(*shape)
np.testing.assert_almost_equal(
kp.arr(a).numpy(),
a,
err_msg=f"shape = {shape}"
)
orient="auto-start-reverse">
<path d="M 0 0 L 10 5 L 0 10 z" />
</marker>"""
for op in self.ops:
x, y = op.x * svg_width, (self.depth - op.y) * 100 + 10
width = (len(op.name) + 20) * 4
for c in op.children:
x1, y1 = self.ops[c].x * svg_width, (self.depth -
self.ops[c].y) * 100 + 5
result += f'<line x1="{x + 50}" y1="{y}" x2="{x1 + 50}" y2="{y1}" stroke="black" marker-end="url(#arrow)"/>'
result += f'<rect x="{x}" y="{y}" width="{width}" height="50" rx="15" ry="15" stroke="black" fill="#bdd6ff"/>'
result += f'<text x="{x + width // 2}" y="{y + 25}" text-anchor="middle">{op.name}</text>'
return result + '</svg>'
W1 = kp.arr(1)
W2 = kp.arr(1)
b = kp.arr(1)
@weak_graph
def f(x, p):
y = kp.relu(W1 @ x + b)
y = kp.softmax(W2 @ x + p + y)
return y
f
# for n in G.nodes(data=True):
# print(n)
