class MatrixTest(TestBase):
"""
This class tests the functionality of the Matrix model.
This test suite can be ran with:
python -m unittest -q tests.MatrixTest
"""
def setUp(self):
"""
This method calls the setUp of the superclass and defines the specific composition model as a property of this
testclass. The composition model of this test class is the Matrix model.
"""
super(MatrixTest, self).setUp()
self._comp_model = Matrix(embedding_size=self._embedding_dim,
nonlinearity=tf.identity,
dropout_rate=0.0)
def test_composition(self):
"""
Tests if the composition method itself is correct. The composition method is
p = W[u;v] + b
"""
u = np.array([[1.0, 1.0], [2.0, 2.0], [1.0, 2.0]])
v = np.array([[2.0, 1.0], [2.0, 2.0], [1.0, 2.0]])
W = np.full(shape=(4, 2), fill_value=2.0)
W[1][0] = 1
W[2][0] = 3
W[3][0] = 5
b = np.array([3.0, 3.0])
result = np.array([[17, 13], [25, 19], [20, 15]])
with tf.Session() as sess:
comp = sess.run(self._comp_model.compose(u, v, W, b, 1))
np.testing.assert_allclose(comp, result)
def testDefaultRegularizer(self):
"""test if a normal composition model has a default regularizer of 0.0 which
leads to no change between normal loss and regularized loss"""
matrix_model = Matrix(embedding_size=2,
nonlinearity=tf.identity,
dropout_rate=0.0)
training_graph = self.get_train_model(model=matrix_model, alpha=0.5)
with tf.Session() as sess:
sess.run(
tf.global_variables_initializer(),
feed_dict={training_graph.model.lookup_init: self._lookup})
for epoch in range(3):
for tidx in range(self._db.no_batches):
loss, reg_loss, _ = sess.run(
[
training_graph.loss, training_graph.reg_loss,
training_graph.train_op
],
feed_dict={
training_graph.original_vector:
self._db.compound_batches[tidx],
training_graph.model._u:
self._db.modifier_batches[tidx],
training_graph.model._v:
self._db.head_batches[tidx]
})
np.testing.assert_equal(loss, reg_loss)
def test_mul(self):
matrix_test = Matrix(
data=[[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0]])
matrix_expected = Matrix(
data=[[53.5, 53.5], [60.0, 60.0], [100.0, 100.0]])
matrix_expected_scalar = Matrix(
data=[[41.25, 9.9, 29.7, 6.6], [13.2, 16.5, 19.8, 23.1],
[26.4, 29.7, 33, 36.3]])
ans_matrix = self.matrix * matrix_test
ans_matrix_scalar = self.matrix * 3.3
round(ans_matrix_scalar, 2)
self.assertEqual(ans_matrix, matrix_expected)
self.assertEqual(ans_matrix_scalar, matrix_expected_scalar)
def test_loss_matrix(self):
"""Test if the loss decreases for the Matrix model"""
with tf.Session() as sess:
composition_model = Matrix(embedding_size=2,
nonlinearity=tf.identity,
dropout_rate=0.0)
train_model = self.get_train_model(composition_model, alpha=0.0)
losses = self.run_model(train_model, sess)
np.testing.assert_equal(losses[0] > losses[9], True)
def test_init(self):
tmp = [[12.5, 3.0, 9.0, 2.0], [4.0, 5.0, 6.0, 7.0],
[8.0, 9.0, 10.0, 11.0]]
matrix_test = Matrix(data=tmp)
self.assertEqual(self.matrix, matrix_test)
def test_lu_pivot_zero(self):
matrix_test_A = Matrix(data=[[1, 1, 1], [1, 1, 3], [1, 3, 3]])
matrix_test_b = Matrix(data=[[0.5], [2], [1]])
self.assertRaises(ArithmeticError, matrix_test_A.lu)
def setUp(self):
self.matrix = Matrix.fromtextfile("../test_files/test.txt")
demographic.viscode = row["VISCODE"]
demographic.dx_bl = row["DX_bl"]
demographic.age = float(row["AGE"])
demographic.ptgender = row["PTGENDER"]
demographic.pteducat = int(row["PTEDUCAT"])
demographic.ptethcat = row["PTETHCAT"]
demographic.ptraccat = row["PTRACCAT"]
demographic.ptmarry = row["PTMARRY"]
demographic.cdrsb = float(
row["CDRSB"]) if row["CDRSB"] != "NA" else None
demographic.mmse = float(row["MMSE"]) if row["MMSE"] != "NA" else None
demographic.save()
print("Completed importing the Longitudinal_Network_Demographic.csv file.")
for filename in listdir(DIRECTORY_PATH):
#print(f"filename: {filename}.")
with open(DIRECTORY_PATH + "/" + filename) as file:
content = ""
for row in file:
row = row.rstrip("\n").rstrip()
content += row.replace(" ", ",")
content += ";"
content = content[0:-1]
matrix = Matrix()
matrix.subject = filename.split("_")[0]
matrix.content = content
matrix.save()
print("Completed importing all the matrix files in the Network-Data folder.")
from models import Matrix
eq_cnt, var_cnt = [int(i) for i in input().split()]
tmp = []
data = []
for i in range(eq_cnt):
tmp = [int(i) for i in input().split()]
data.append(tmp)
matrix = Matrix(data=data)
print("A:")
print(str(matrix))
matrix.lup()
print("A after LUP:")
print(str(matrix))
print("L:")
print(str(matrix.get_l()))
print("U:")
print(str(matrix.get_u()))
print("P:")
print(str(matrix.p))
def init(height, width, n_threads):
height = int(height)
width = int(width)
n_threads = int(n_threads)
clear_all()
h_classes = []
t_start = time.time()
for h in range(1, height + 1):
for w in range(1, width + 1):
matrices = []
print(f'Initialization {1 << w * h} {w}x{h} matrices...')
for b in range(0, 1 << w * h):
matrix = get_matrix(h, w, b)
matrices.append(matrix)
alchemy_matrix = Matrix(width=w, height=h, body=b)
db.session.add(alchemy_matrix)
print(f'Computing H-classes for {w}x{h} matrices...')
if n_threads < 1 << w * h and n_threads > 1:
n_matrices = 1 << w * h
s_batch = int(n_matrices / n_threads)
jobs = []
for idx in range(n_threads):
matrix_from = s_batch * idx
matrix_to = min((idx + 1) * s_batch, n_matrices)
jobs.append(
queue.enqueue(partial_h_class,
matrices[matrix_from:matrix_to]))
while any([job.result is None for job in jobs]):
continue
size_h_classes = []
for job in jobs:
size_h_classes.append(job.result)
while len(size_h_classes) > 1:
jobs = []
for idx in range(0, len(size_h_classes), 2):
jobs.append(
queue.enqueue(reduce_h_classes,
size_h_classes[idx],
size_h_classes[idx + 1]))
while any([job.result is None for job in jobs]):
continue
reduced_h_classes = []
for job in jobs:
reduced_h_classes.append(job.result)
size_h_classes = reduced_h_classes
size_h_classes = size_h_classes[0]
else:
size_h_classes = partial_h_class(matrices)
h_classes.extend(size_h_classes)
print('Computing L-classes...')
l_classes = []
for h_class in h_classes:
matrix = h_class[0]
for l_class in l_classes:
class_matrix = l_class[0]
if l_equivalent(matrix, class_matrix):
l_class.extend(h_class)
break
else:
l_class = []
l_class.extend(h_class)
l_classes.append(l_class)
print('Computing R-classes...')
r_classes = []
for h_class in h_classes:
matrix = h_class[0]
for r_class in r_classes:
class_matrix = r_class[0]
if r_equivalent(matrix, class_matrix):
r_class.extend(h_class)
break
else:
r_class = []
r_class.extend(h_class)
r_classes.append(r_class)
print('Computing D-classes...')
d_classes = []
for l_class in l_classes:
matrix = l_class[0]
for d_class in d_classes:
class_matrix = d_class[0]
r_class = next(
filter(lambda r_class: class_matrix in r_class, r_classes))
if as_set(l_class) & as_set(r_class):
d_class.extend(l_class)
break
else:
d_class = []
d_class.extend(l_class)
d_classes.append(d_class)
print('Storing H-classes in database...')
for h_class in h_classes:
cls = H_class()
for matrix in h_class:
mtx = find_alchemy_matrix(matrix)
mtx.h_class = cls
print('Storing L-classes in database...')
for l_class in l_classes:
cls = L_class()
for matrix in l_class:
mtx = find_alchemy_matrix(matrix)
mtx.l_class = cls
print('Storing R-classes in database...')
for r_class in r_classes:
cls = R_class()
for matrix in r_class:
mtx = find_alchemy_matrix(matrix)
mtx.r_class = cls
print('Storing D-classes in database...')
for d_class in d_classes:
cls = D_class()
for matrix in d_class:
mtx = find_alchemy_matrix(matrix)
mtx.d_class = cls
db.session.commit()
t_end = time.time()
print(f'Estimated time: {t_end - t_start} s.')
from models import Matrix
from pathlib import Path
a_matrix = [
"zad1_a.txt", "zad2_a.txt", "zad3_a.txt", "zad4_a.txt", "zad5_a.txt"
]
b_matrix = [
"zad1_b.txt", "zad2_b.txt", "zad3_b.txt", "zad4_b.txt", "zad5_b.txt"
]
for i in range(len(a_matrix)):
'''
For all matrices calculate LU, LUP, forward and backward substitution
'''
try:
matrix = Matrix.fromtextfile(Path("test_files/") / a_matrix[i])
b = Matrix.fromtextfile(Path("test_files/") / b_matrix[i])
except FileNotFoundError:
print("Missing file(s) {}, {}...\n".format(a_matrix[i], b_matrix[i]))
continue
print("\n\n**********{} + {}**********\n".format(a_matrix[i], b_matrix[i]))
try:
print("############LU:############")
matrix.lu()
print("A:")
print(str(matrix))
matrix.forward_substitution(b)
print("\n############LU: Forward substitution:####")
print("Y:")
print(str(b))