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])]))