def wiedemann2(les: LinearEquationSystem):
a, b, p, n = les.a, M.t(les.b)[0], les.p, les.n
a_powers = [M.unit(n, n)]
for i in range(1, 2 * n):
a_powers.append(M.mul(a_powers[-1], a, p))
aib = [M.mul_vec(ai, b, p) for ai in a_powers]
k = 0
gs = [[1]]
uk1 = [0, 1] + ([0] * (n - 2))
while Poly.deg(gs[k]) < n and k < n:
seq = []
for i in range(2 * n - Poly.deg(gs[k])):
gab = M.mul_vec(fa(gs[k], a, p), aib[i], p)
ugab = V.mul_sum(uk1, gab, p)
seq.append(ugab)
assert len(seq)
f = berlekamp(seq, p)
gs.append(Poly.mul(f, gs[k], p))
k += 1
uk1 = ([0] * k) + [1] + ([0] * (n - k - 1))
print('k =', k)
g = gs[-1]
x = V.zero(n)
for i in range(Poly.deg(g)):
x = V.add(x, V.mul_scalar(aib[i], -g[i], p), p)
return x
def method_jacobi_rotations(a, eps):
n_iter = 0
a_k = copy.copy(a)
v = Matrix(a.size, single=True)
while True:
i_max, j_max = find_max(a_k)
fi = 0.5 * math.atan(2 * a_k[i_max][j_max] /
(a_k[i_max][i_max] - a_k[j_max][j_max]))
u = Matrix(a.size, single=True)
u[i_max][i_max] = math.cos(fi)
u[i_max][j_max] = -math.sin(fi)
u[j_max][i_max] = math.sin(fi)
u[j_max][j_max] = math.cos(fi)
u_t = copy.copy(u)
u_t.transpose()
a_k = u_t * a_k * u
v = v * u
n_iter += 1
if t(a_k) < eps:
eigenvalue = Vector(a_k.size)
eigenvalue.vector = [a_k[i][i] for i in range(0, a_k.size)]
print('Итераций: ', n_iter)
return eigenvalue, v
def main():
operation = sys.argv[1]
if operation == '-a':
p, n, a = read('test.txt')
les = LinearEquationSystem(a, p)
test_accuracy(les)
elif operation == '-g':
gen_test(5, 9, 29, '-s' in sys.argv)
elif operation == '-gauss':
p, n, a = read('test.txt')
les = LinearEquationSystem(a, p)
sol, count = gaussian(les)
if count == 0:
x = sol([])
print('Решение:', x)
print('Ответ верный' if M.mul(les.a, M.t([x]), les.p) == les.b else 'Ответ неверный')
return
while True:
t = input('Введите {} чисел в Z_{} через пробел или -1 для выхода\n'.format(count, les.p))
if t == '-1':
return
x = sol(list(map(lambda el: int(el), t.split())))
print('Решение:', x)
print('Ответ верный' if M.mul(les.a, M.t([x]), les.p) == les.b else 'Ответ неверный')
else:
print('Некорректная операция')
def lanczos(les: LinearEquationSystem):
assert les.n == les.m
for row in range(les.n):
for col in range(row + 1):
if les.a[row][col] != les.a[col][row]:
print('Алгоритм Ланцоша : определен только для симмтеричных матриц, '
'см. индексы ({0},{1}) и ({1},{0})'.format(row + 1, col + 1))
return
p = les.p
ws = [M.column(les.b, 0)]
vs = [None, M.mul_vec(les.a, ws[0], p)]
ws.append(V.minus(vs[1],
V.mul_scalar(ws[0],
ratio(V.mul_sum(vs[1], vs[1], p),
V.mul_sum(ws[0], vs[1], p), p), p), p))
for trial in range(max(MAX_TRIALS, les.n)):
if V.mul_sum(ws[-1], M.mul_vec(les.a, ws[-1], p), p) == 0:
if V.is_zero(ws[-1]):
x = V.zero(les.n)
for i in range(len(ws) - 1):
bi = ratio(V.mul_sum(ws[i], ws[0], p),
V.mul_sum(ws[i], vs[i + 1], p), p)
x = V.add(x, V.mul_scalar(ws[i], bi, p), p)
return x
vs.append(M.mul_vec(les.a, ws[-1], p))
w1 = V.mul_scalar(ws[-1], ratio(V.mul_sum(vs[-1], vs[-1], p),
V.mul_sum(ws[-1], vs[-1], p), p), p)
w2 = V.mul_scalar(ws[-2], ratio(V.mul_sum(vs[-1], vs[-2], p),
V.mul_sum(ws[-2], vs[-2], p), p), p)
w_end = V.minus(V.minus(vs[-1], w1, p),
w2, p)
ws.append(w_end)
def wiedemann1(les: LinearEquationSystem):
a, b, p, n = les.a, M.t(les.b)[0], les.p, les.n
for trial in range(MAX_TRIALS):
bs = [b]
ys = [[0] * n]
ds = [0]
k = 0
while bs[k] != V.zero(n):
u = [random.randint(0, p - 1) for _idx in range(n)]
seq = []
for i in range(2 * (n - ds[k])):
ai = M.power(a, i, p)
aib = M.mul_vec(ai, b, p)
uaib = V.mul_sum(u, aib, p)
seq.append(uaib)
if not len(seq):
break
f = berlekamp(seq, p)
if f is None:
break
ys.append(V.add(ys[k], M.mul_vec(f_tilda(f, a, p), b, p), p))
bs.append(V.add(b, M.mul_vec(a, ys[k + 1], p), p))
ds.append(ds[k] + len(f))
k += 1
if bs[k] != V.zero(n):
print(trial, end='\r')
continue
return V.mul_scalar(ys[k], -1, p)
def test_accuracy(les):
for func, func_name in FUNCS:
x = func(les)
if x is None:
print(func_name, ': ответ не найден')
else:
correct = M.mul(les.a, M.t([x]), les.p) == les.b
print(func_name, ':', x, 'Ответ верный' if correct else 'Ответ неверный')
def main(argv):
assert len(argv) == 2, "Vous devez donner le nombre de points"
points = int(argv[1])
assert points > 0, "Le nombre de points doit être > 0"
delta = time.perf_counter()
m = Matrix()
m.fill_matrix(points)
delta = time.perf_counter() - delta
perf_stats(m.approx_pi(), points, delta)
def feed_forward(self,x):
output_data = Matrix(x).transpose()
self.activations =[]
for i in range(len(self.theta)):
self.activations.append(output_data)
input_data = Matrix(output_data.matrix.copy()).transpose()
for j in range(len(input_data.matrix)):
input_data.matrix[j] = [1] + input_data.matrix[j]
output_data = self.sigmoid(self.theta[i] * input_data.transpose())
self.activations.append(output_data)
return output_data
def dimensionality_reduction(embeddings: Matrix, convs: Matrix,
save_loc: str) -> None:
convs = convs.transpose(0, 2, 1)
reduction = PCA(n_components=2)
reduction.fit(embeddings)
embs = reduction.transform(embeddings)
conv_embs = reduction.transform(convs.reshape(-1, convs.shape[-1]))
plt.plot(embs[:, 0], embs[:, 1], '.', label='Embeddings')
plt.plot(conv_embs[:, 0], conv_embs[:, 1], '.', label='Convolutions')
plt.legend()
plt.xlabel('First principle component')
plt.ylabel('Second principle component')
plt.savefig(os.path.join(save_loc, 'dimensionality_reduction.png'))
plt.close()
def lu(a):
size = a.size
l = Matrix(size, single=True)
u = copy.deepcopy(a)
for k in range(0, size - 1):
m_k = Matrix(size, single=True)
for i in range(k + 1, size):
mu_i = -u[i][k] / u[k][k]
m_k[i][k] = mu_i
l[i][k] = -mu_i
u = m_k * u
return l, u
def get_poly_1_deg(points, values):
sum_points = sum(points)
sum_points_2 = sum([point**2 for point in points])
sum_values = sum(values)
sum_v_p = sum([values[i] * points[i] for i in range(0, len(points))])
a = Matrix(2)
a.matrix = [[len(points), sum_points], [sum_points, sum_points_2]]
b = Vector(2)
b.vector = [sum_values, sum_v_p]
l, u, p = lup(a)
coefficients = lup_solve(l, u, p, b).vector
return parse_expr(f'{coefficients[0]} + {coefficients[1]} * x')
def solution(t):
t.insert(s, dlam)
# t[s:s] = dlam
x = V.zero(n)
for sol_i in range(n):
x = V.add(x, V.mul_scalar(M.column(c, sol_i), t[sol_i], p), p)
return x
def all_solutions(a: list, d, p):
if not any(a):
raise ValueError('Найдена линейно-независимая строка')
n = len(a)
a_mat = [a[:]] + M.unit(n, n)
while len(list(filter(lambda el: el != 0, a_mat[0]))) > 1:
ai = min(filter(lambda el: el != 0, a_mat[0]))
i = a_mat[0].index(ai)
j = next(filter(lambda jj: i != jj and a_mat[0][jj] != 0, range(n)))
q, r, = divmod(a_mat[0][j], a_mat[0][i])
for row in range(n + 1):
a_mat[row][j] = (a_mat[row][j] - a_mat[row][i] * q) % p
lam = max(a_mat[0])
s = a_mat[0].index(lam)
dlam = ratio(d, lam, p)
c = a_mat[1:]
def solution(t):
t.insert(s, dlam)
# t[s:s] = dlam
x = V.zero(n)
for sol_i in range(n):
x = V.add(x, V.mul_scalar(M.column(c, sol_i), t[sol_i], p), p)
return x
return solution
def lup(matrix):
size = matrix.size
p = get_matrix_permutations(matrix)
pa = p * matrix
l = Matrix(size, single=True)
u = copy.deepcopy(pa)
for k in range(0, size - 1):
m_k = Matrix(size, single=True)
for i in range(k + 1, size):
mu_i = -u[i][k] / u[k][k]
m_k[i][k] = mu_i
l[i][k] = -mu_i
u = m_k * u
return l, u, p
def conv_knn(embeddings: Matrix, convs: Matrix, dataset: Dataset,
num_trees: int, num_nns: int, save_loc: str,
cache_index: bool) -> None:
index = np.dot(convs.transpose(0, 2, 1), embeddings.transpose(1, 0))
sorted_idxs = np.argsort(index, axis=-1)
def parse_vec(seq_id, filter_id):
v = convs[seq_id, :, filter_id]
idxs = sorted_idxs[seq_id, filter_id][-num_nns:]
words = dataset.decode(idxs, keep_first=True)
return {
'words': words,
'norm': float(np.sqrt(np.sum(v**2))),
}
utils.save_json([[parse_vec(i, j) for i in range(convs.shape[0])]
for j in range(convs.shape[2])], save_loc, 'knns.json')
def t(a, b, n):
a11 = (2**(-n - 1)) * (a * (b**n) + b * ((-a)**n)) / sqrt(5)
a12 = (2**(-n)) * (b**n - ((-a)**n)) / sqrt(5)
a21 = ((2**(-n - 2)) * a * b) * (b**n - ((-a)**n)) / sqrt(5)
a22 = (2**(-n - 1)) * ((b**(n + 1)) + ((-a)**(n + 1))) / sqrt(5)
T = Matrix([[int(a11), int(a12)], [int(a21), int(a22)]])
return T
def get_matrix_permutations(matrix):
size = matrix.size
p = Matrix(size, single=True)
for i in range(0, size):
column = [matrix[j][i] for j in range(i, size)]
row_idx = column.index(max(column, key=abs)) + i
if i != row_idx:
p[i], p[row_idx] = p[row_idx], p[i]
return p
def qr(matrix):
q = Matrix(matrix.size, single=True)
r = copy.copy(matrix)
for i in range(0, matrix.size - 1):
h = get_matrix_householder(r, i)
q = q * h
r = h * r
return q, r
def get_matrix_householder(matrix, col):
v = Vector(matrix.size)
e = Matrix(matrix.size, single=True)
sign = -1 if matrix[col][col] < 0 else 1 if matrix[col][col] > 0 else 0
v[col] = matrix[col][col] + sign * math.sqrt(
sum([matrix[j][col]**2 for j in range(col, matrix.size)]))
for i in range(col + 1, matrix.size):
v[i] = matrix[i][col]
v_vt = Matrix(matrix.size)
for i in range(0, v_vt.size):
for j in range(0, v_vt.size):
v_vt[i][j] = v[i] * v[j]
vt_v = sum([v[i]**2 for i in range(0, v.size)])
h = e - v_vt * (2 / vt_v)
return h
def get_alpha_beta(a, b):
size = a.size
alpha = Matrix(size)
beta = Vector(size)
for i in range(0, size):
beta[i] = b[i] / a[i][i]
for j in range(0, size):
alpha[i][j] = -a[i][j] / a[i][i] if i != j else 0
return alpha, beta
def inverse_matrix(l, u, p):
size = l.size
inv = Matrix(size)
for i in range(0, size):
e = Vector(size)
e[i] = 1
column = lup_solve(l, u, p, e)
for j in range(0, size):
inv[j][i] = column[j]
return inv
def main(argv):
width = int(argv[1])
points = int(argv[2])
rounding = int(argv[3])
m = Matrix(width)
steps = points // 10
delta = time.perf_counter()
fnames = []
for n, p in enumerate(range(steps, points + steps, steps)):
m.fill_matrix(steps)
fname = generate_ppm_file(m, rounding, n)
fnames.append(fname)
print("Generating GIF pi.gif")
subprocess.call(["python", "convert.py"] + fnames + ["pi.gif"])
delta = time.perf_counter() - delta
perf_stats(m.approx_pi(), points, delta)
def get_poly_2_deg(points, values):
sum_points = sum(points)
sum_points_2 = sum([point**2 for point in points])
sum_points_3 = sum([point**3 for point in points])
sum_points_4 = sum([point**4 for point in points])
sum_values = sum(values)
sum_v_p = sum([values[i] * points[i] for i in range(0, len(points))])
sum_v_p2 = sum([values[i] * points[i]**2 for i in range(0, len(points))])
a = Matrix(3)
a.matrix = [[len(points), sum_points, sum_points_2],
[sum_points, sum_points_2, sum_points_3],
[sum_points_2, sum_points_3, sum_points_4]]
b = Vector(3)
b.vector = [sum_values, sum_v_p, sum_v_p2]
l, u, p = lup(a)
coefficients = lup_solve(l, u, p, b).vector
return parse_expr(
f'{coefficients[0]} + {coefficients[1]} * x + {coefficients[2]} * x ** 2'
)
def gen_test(size_row, size_col, p, sym):
a = [[random.randint(0, p - 1) for _j in range(size_col)] for _i in range(size_row)]
if size_row == size_col:
while M.det(a, p) == 0:
a = [[random.randint(0, p - 1) for _j in range(size_col)] for _i in range(size_row)]
if sym:
for i in range(len(a)):
for j in range(i + 1):
a[i][j] = a[j][i]
b = [[random.randint(0, p - 1)] for _i in range(size_row)]
print(size_row, p)
for row, bi in zip(a, b):
print(*row, *bi)
def back_propagation(self, x , y , lambda_r=0):
Delta = [[[0 for i in range(len(self.activations[l].matrix))] for j in range(len(self.activations[l+1].matrix))] for l in range(len(self.activations)-1)]
for m in range(len(x)):
deltas = []
self.feed_forward([x[m]])
deltas.append((self.activations[-1]-Matrix([y[m]])))
for l in range(len(self.theta)-1, 0, -1):
deltas.insert(0,Matrix((self.theta[l].transpose()*deltas[0]).matrix[1:][:]).pw_prod(self.activations[l]).pw_prod(Matrix([1]*len(self.activations[l].matrix))-self.activations[l]))
for l in range(len(self.activations)-1):
for j in range(len(self.activations[l+1].matrix)):
for i in range(len(self.activations[l].matrix)):
Delta[l][j][i] += (self.activations[l].matrix[i][0]*deltas[l].matrix[j][0])
D = [[[0 for i in range(len(self.activations[l].matrix))] for j in range(len(self.activations[l+1].matrix))] for l in range(len(self.activations)-1)]
for l in range(len(self.activations)-1):
for j in range(len(self.activations[l+1].matrix)):
for i in range(len(self.activations[l].matrix)):
if j==0:
D[l][j][i] = (1/len(x))*Delta[l][j][i]
else:
D[l][j][i] = (1/len(x))*Delta[l][j][i] +lambda_r * self.theta[l].matrix[j][i]
return D
def get_matrix_system(points, h, lambda_, k):
size_p = len(points)
A = Matrix(size_p)
for i in range(size_p):
for j in range(size_p):
if i == j:
if j == 0 or j == size_p - 1:
A[i][j] = 1 - lambda_ * h / 2 * k(points[i], points[j])
else:
A[i][j] = 1 - lambda_ * h * k(points[i], points[j])
elif j == 0 or j == size_p - 1:
A[i][j] = -lambda_ * h / 2 * k(points[i], points[j])
else:
A[i][j] = -lambda_ * h * k(points[i], points[j])
return A
def alpha_ij(wi, wj, a, p):
nom = mul_a(M.mul_vec(a, wi, p), wj, a, p)
rat = mul_a(wj, wj, a, p)
return ratio(nom, rat, p)
vectors[i].print_vector()
print('A * x = ', end='')
(matrix * vectors[i]).print_vector()
print('a_k * x = ', end='')
(vectors[i] * eigenvalue[i]).print_vector()
print('-------------------------------------------------------------')
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--input', required=True)
args = parser.parse_args()
with open(args.input, 'r') as f:
data = json.load(f)
n = int(data['size'])
Eps = float(data['eps'])
A = Matrix(n)
A.matrix_read_file(args.input, 'matrix')
Eigenvalue, V = method_jacobi_rotations(A, Eps)
print('Собственные значения: ')
for i in range(0, n):
print('a_{0} = {1:8.5f}'.format(i + 1, Eigenvalue[i]))
print('\nМатрица собственных векторов: ')
V.print_matrix()
test(Eigenvalue, V, A)
handler = logging.StreamHandler()
logger.addHandler(handler)
cf_m = analysis.recognition.CharacterClassifierManager(lbls.lbls)
cf = cf_m.get_classifier()
img = PixelMatrix(Image.open('tmp/1-0_f.bmp').convert('1'))
liste_taux = cf.predire(img)
for taux in liste_taux:
print(taux)
# [DEBUG] Image de correpondance des points
for i in range(3):
matriceCorrespondances = Matrix(28, 28)
taux, lettre = liste_taux[i]
matricePoids = cf.matricesPoids[lettre]
threshold = -math.ceil(matricePoids.sample_count * 0.95)
for index, poids in enumerate(matricePoids):
if img[index] == 0:
matriceCorrespondances[index] = poids
elif poids > threshold:
matriceCorrespondances[index] = -poids
else:
matriceCorrespondances[index] = 0
matriceCorrespondances_np = np.array(matriceCorrespondances._matrix)
fig, ax = plt.subplots()
def init_weights(self):
self.theta = []
layers_range = [self.size[0]]+ self.hidden_size + [self.size[-1]]
for i in range(len(layers_range)-1):
self.theta.append(Matrix([[random() for m in range(layers_range[i] + 1)] for n in range(layers_range[i+1])]))