Hướng dẫn how do i return a matrix without numpy in python? - làm cách nào để trả về một ma trận không có numpy trong python?

Bạn có thể sử dụng danh sách hiểu biết:

>>> li= ['a','b','c','d','e','f','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
>>> [li[i:i+5] for i in range(0,len(li),5)]
[['a', 'b', 'c', 'd', 'e'], ['f', 'h', 'i', 'j', 'k'], ['l', 'm', 'n', 'o', 'p'], ['q', 'r', 's', 't', 'u'], ['v', 'w', 'x', 'y', 'z']]

Hoặc, nếu bạn không bận tâm đến các bộ dữ liệu, hãy sử dụng zip:

>>> zip(*[iter(li)]*5)
[('a', 'b', 'c', 'd', 'e'), ('f', 'h', 'i', 'j', 'k'), ('l', 'm', 'n', 'o', 'p'), ('q', 'r', 's', 't', 'u'), ('v', 'w', 'x', 'y', 'z')]

Hoặc áp dụng

>>> zip(*[iter(li)]*5)
[('a', 'b', 'c', 'd', 'e'), ('f', 'h', 'i', 'j', 'k'), ('l', 'm', 'n', 'o', 'p'), ('q', 'r', 's', 't', 'u'), ('v', 'w', 'x', 'y', 'z')]

>>> map(list, zip(*[iter(li)]*5))
[['a', 'b', 'c', 'd', 'e'], ['f', 'h', 'i', 'j', 'k'], ['l', 'm', 'n', 'o', 'p'], ['q', 'r', 's', 't', 'u'], ['v', 'w', 'x', 'y', 'z']]

Vui lòng tìm mã cho bài đăng này trên github. & Nbsp; như mọi khi, tôi hy vọng bạn sẽ sao chép nó và biến nó thành của riêng bạn. Mô -đun chính trong repo chứa tất cả các mô -đun mà chúng tôi bao gồm có tên là tuyến tính. Có một tệp Python đơn giản có tên BasictoolSpractice.py nhập mô -đun chính đó và minh họa các hàm mô -đun. Thật tuyệt vời nếu bạn có thể sao chép hoặc tải xuống đầu tiên để có ích khi chúng tôi đi qua bài đăng này.GitHub. As always, I hope you’ll clone it and make it your own. The main module in the repo that holds all the modules that we’ll cover is named LinearAlgebraPurePython.py. There’s a simple python file named BasicToolsPractice.py that imports that main module and illustrates the modules functions. It’d be great if you could clone or download that first to have handy as we go through this post.

Tại sao bài viết này?

Nhắc nhở: Mục tiêu của chúng tôi là hiểu rõ hơn các nguyên tắc của các công cụ học máy bằng cách khám phá cách tự mã hóa chúng Our goal is to better understand principles of machine learning tools by exploring how to code them ourselves …

Những nỗ lực này sẽ cung cấp những hiểu biết và sự hiểu biết tốt hơn, nhưng những hiểu biết đó có thể bay ra ở chúng tôi mỗi bài. Thay vào đó, chúng tôi đang xây dựng một nền tảng sẽ hỗ trợ những hiểu biết đó trong tương lai.provide insights and better understanding, but those insights won’t likely fly out at us every post. Rather, we are building a foundation that will support those insights in the future.

Để hợp lý hóa một số bài viết sắp tới, tôi muốn bao gồm một số chức năng cơ bản sẽ giúp các bài đăng trong tương lai dễ dàng hơn. Rõ ràng, nếu chúng ta đang tránh sử dụng Numpy và Scipy, chúng ta sẽ phải tạo ra các chức năng / công cụ tiện lợi của riêng mình. Bài đăng này bao gồm các công cụ tiện lợi đó. & NBSP;

Ở một đầu của quang phổ, nếu bạn chưa quen với đại số tuyến tính hoặc python hoặc cả hai, tôi tin rằng bạn sẽ thấy bài đăng này hữu ích trong số, tôi hy vọng, một nhóm liên kết đã lưu tốt.

Ở đầu kia của quang phổ, nếu bạn có nền tảng với Python và Đại số tuyến tính, lý do của bạn để đọc bài đăng này sẽ là & nbsp; để so sánh cách tôi đã làm điều đó với cách bạn làm điều đó. Đánh giá có thể cung cấp cho bạn một số ý tưởng mới, hoặc nó có thể xác nhận rằng bạn vẫn thích cách của bạn hơn. & NBSP;

Công cụ

Bạn sẽ tìm thấy tài liệu và nhận xét trong tất cả các chức năng này. Khi nhiều mô tả được bảo hành, tôi sẽ cung cấp hoặc cung cấp hướng dẫn cho các tài nguyên khác để mô tả nó chi tiết hơn. Nếu có một phần cụ thể mà bạn không hiểu, tôi rất háo hức để bạn hiểu rõ hơn. Những gì cách tốt nhất để làm điều đó? Xây dựng lại các chức năng này từ hầu hết các hoạt động bên trong và thử nghiệm chúng ở cấp độ đó cho đến khi bạn hiểu chúng, sau đó thêm lớp lặp tiếp theo hoặc mã lặp lại hoạt động bên trong đó và hiểu rằng, v.v.

Đầu tiên là Zeros_Matrix. Khi chúng ta chỉ cần một ma trận mới, hãy để Lôi tạo một cái và lấp đầy nó bằng số không.zeros_matrix. When we just need a new matrix, let’s make one and fill it with zeros.

def zeros_matrix(rows, cols):
    """
    Creates a matrix filled with zeros.
        :param rows: the number of rows the matrix should have
        :param cols: the number of columns the matrix should have

        :return: list of lists that form the matrix
    """
    M = []
    while len(M) < rows:
        M.append([])
        while len(M[-1]) < cols:
            M[-1].append(0.0)

    return M

Như bạn đã thấy từ các bài viết trước, ma trận và vectơ đều được xử lý trong Python dưới dạng mảng hai chiều. Do đó, mảng các hàng chứa một mảng của các giá trị cột và mỗi giá trị cột được khởi tạo thành 0. Lưu ý chỉ số -1 cho hàng ma trận trong vòng thứ hai trong khi vòng lặp. Đây là một cách đơn giản để tham khảo phần tử cuối cùng của một mảng và trong trường hợp này, nó là mảng cuối cùng (hàng) mà Lừa được nối với mảng.

Hàm trợ giúp thứ hai của chúng tôi là Identity_Matrix được sử dụng để tạo ma trận nhận dạng. Và, như một lập trình viên lười biếng xây dựng tốt nên làm, tôi đã tận dụng rất nhiều cuộc gọi ban đầu đến Zeros_Matrix. Tất cả những gì còn lại một khi chúng ta có một ma trận nhận dạng là thay thế các phần tử chéo bằng 1.identity_matrix used to create an identity matrix. And, as a good constructively lazy programmer should do, I have leveraged heavily on an initial call to zeros_matrix. All that’s left once we have an identity matrix is to replace the diagonal elements with 1.

def identity_matrix(n):
    """
    Creates and returns an identity matrix.
        :param n: the square size of the matrix

        :return: a square identity matrix
    """
    IdM = zeros_matrix(n, n)
    for i in range(n):
        IdM[i][i] = 1.0

    return IdM

Thứ ba là Copy_Matrix cũng phụ thuộc rất nhiều vào Zeros_Matrix. Chúng tôi muốn điều này cho những thời điểm mà chúng tôi cần làm việc trên một bản sao và bảo tồn ma trận ban đầu. Ở đây, chúng ta chỉ đơn giản là có được kích thước của ma trận gốc và sử dụng các kích thước đó để tạo ma trận Zeros và sau đó sao chép các phần tử của ma trận gốc sang phần tử ma trận mới theo phần tử.copy_matrix also relying heavily on zeros_matrix. We want this for those times where we need to work on a copy and preserve the original matrix. Here, we are simply getting the dimensions of the original matrix and using those dimensions to create a zeros matrix and then copying the elements of the original matrix to the new matrix element by element.

def copy_matrix(M):
    """
    Creates and returns a copy of a matrix.
        :param M: The matrix to be copied

        :return: A copy of the given matrix
    """
    # Section 1: Get matrix dimensions
    rows = len(M)
    cols = len(M[0])

    # Section 2: Create a new matrix of zeros
    MC = zeros_matrix(rows, cols)

    # Section 3: Copy values of M into the copy
    for i in range(rows):
        for j in range(cols):
            MC[i][j] = M[i][j]

    return MC

Thứ tư là print_matrix để chúng ta có thể xem liệu chúng ta có bị rối hay không trong các hoạt động đại số tuyến tính của chúng ta! Ở đây, chúng tôi chỉ đang in ma trận, hoặc vector, một hàng cùng một lúc. Phần mềm +0 trong danh sách hiểu được đề cập trong một bài viết trước. Hãy thử danh sách hiểu biết có và không có điều đó +0 và xem điều gì sẽ xảy ra. & NBSP;print_matrix so that we can see if we’ve messed up or not in our linear algebra operations! Here, we are just printing the matrix, or vector, one row at a time. The “+0” in the list comprehension was mentioned in a previous post. Try the list comprehension with and without that “+0” and see what happens. 

def print_matrix(M, decimals=3):
    """
    Print a matrix one row at a time
        :param M: The matrix to be printed
    """
    for row in M:
        print([round(x,decimals)+0 for x in row])

Trong trường hợp bạn không biết các kỹ thuật hiểu danh sách Python, chúng đáng để học. Có rất nhiều blog và trang web tốt dạy nó. Như tôi luôn luôn, tôi khuyên bạn nên tham khảo ít nhất ba nguồn khi chọn bất kỳ kỹ năng mới nào nhưng đặc biệt là khi học một kỹ năng Python mới. Một số ví dụ ngắn gọn sẽ làworth learning. There are tons of good blogs and sites that teach it. As I always, I recommend that you refer to at least three sources when picking up any new skill but especially when learning a new Python skill. Some brief examples would be …

some_new_list = [ for x in list if  else ]
# or
another_list = [s.method() for s in string_list if ]
# or
one_more_list = [ for x in list]

Điểm hiển thị One_More_List là làm cho nó rõ ràng rằng bạn không thực sự cần phải có bất kỳ điều kiện nào trong danh sách hiểu và phương pháp bạn áp dụng có thể là một phương pháp bạn viết.one_more_list is to make it abundantly clear that you don’t actually need to have any conditionals in the list comprehension, and the method you apply can be one that you write.

Thứ năm là chuyển vị. Việc chuyển một ma trận chỉ đơn giản là hành động di chuyển các phần tử từ một hàng và cột ban đầu nhất định sang A & NBSP; hàng = cột gốc và một cột = hàng gốc. Nghĩa là, nếu một phần tử nhất định của m là m_ {i, j}, nó sẽ chuyển sang m_ {j, i} trong ma trận chuyển vị, được hiển thị dưới dạngtranspose. Transposing a matrix is simply the act of moving the elements from a given original row and column to a  row = original column and a column = original row. That is, if a given element of M is m_{i,j}, it will move to m_{j,i} in the transposed matrix, which is shown as

MT[j][i] = M[i][j]

trong mã. Liên quan đến nguyên tắc này, lưu ý rằng ma trận Zeros được tạo với số lượng cột ma trận ban đầu cho số lượng hàng ma trận chuyển đổi và số lượng hàng ma trận ban đầu cho số lượng cột ma trận được chuyển đổi. Thật là một miệng!

Lưu ý rằng trong Phần 1 dưới đây, trước tiên chúng tôi đảm bảo rằng M là mảng Python hai chiều. Sau đó, chúng tôi lưu trữ các kích thước của M trong Phần 2. Tiếp theo, trong Phần 3, chúng tôi sử dụng các kích thước đó để tạo ma trận Zeros có kích thước ma trận chuyển vị và gọi nó là MT. Cuối cùng, trong Phần 4, chúng tôi chuyển các giá trị từ M sang MT theo cách được chuyển đổi như được mô tả trước đây.section 1 below, we first make sure that M is a two dimensional Python array. Then we store the dimensions of M in section 2. Next, in section 3, we use those dimensions to create a zeros matrix that has the transposed matrix’s dimensions and call it MT. Finally, in section 4, we transfer the values from M to MT in a transposed manner as described previously.

def transpose(M):
    """
    Returns a transpose of a matrix.
        :param M: The matrix to be transposed

        :return: The transpose of the given matrix
    """
    # Section 1: if a 1D array, convert to a 2D array = matrix
    if not isinstance(M[0],list):
        M = [M]

    # Section 2: Get dimensions
    rows = len(M)
    cols = len(M[0])

    # Section 3: MT is zeros matrix with transposed dimensions
    MT = zeros_matrix(cols, rows)

    # Section 4: Copy values from M to it's transpose MT
    for i in range(rows):
        for j in range(cols):
            MT[j][i] = M[i][j]

    return MT

Thứ sáu và thứ bảy là Matrix_addition và Matrix_SubTraction. Tôi đang giải thích chúng cùng một lúc, bởi vì về cơ bản chúng giống hệt nhau ngoại trừ dòng mã duy nhất trong đó phần tử bằng cách bổ sung hoặc phép trừ phần tử. Trong Phần 1 của mỗi hàm, bạn thấy rằng chúng ta kiểm tra xem mỗi ma trận có kích thước giống hệt nhau, nếu không, chúng ta không thể thêm chúng. Phần 2 của mỗi hàm tạo ra một ma trận Zeros để giữ ma trận kết quả. Phần 3 của mỗi hàm thực hiện phần tử bằng hoạt động phần tử của phép cộng hoặc phép trừ, tương ứng. & NBSP;matrix_addition and matrix_subtraction. I am explaining them at the same time, because they are essentially identical with the exception of the single line of code where the element by element additions or subtractions take place. In section 1 of each function, you see that we check that each matrix has identical dimensions, otherwise, we cannot add them. Section 2 of each function creates a zeros matrix to hold the resulting matrix. Section 3 of each function performs the element by element operation of addition or subtraction, respectively. 

>>> zip(*[iter(li)]*5)
[('a', 'b', 'c', 'd', 'e'), ('f', 'h', 'i', 'j', 'k'), ('l', 'm', 'n', 'o', 'p'), ('q', 'r', 's', 't', 'u'), ('v', 'w', 'x', 'y', 'z')]

Thứ tám là Matrix_Multiply. Quy tắc đầu tiên trong phép nhân ma trận là nếu bạn muốn nhân ma trận một lần ma trận B, thì số cột của A phải bằng số lượng hàng của B. Do đó, nếu A có kích thước của các hàng m và cột N (M \, X \, N, hãy viết tắt là B phải có n hàng và nó có thể có 1 hoặc nhiều cột. Hãy nói rằng nó có K cột. Do đó, sản phẩm kết quả của hai ma trận sẽ là ma trận m \, x \, k hoặc ma trận kết quả có số lượng hàng của a và số cột của B. & nbsp; Do đó, chúng tôi tạo một ma trận Zeros để giữ sản phẩm kết quả của hai ma trận có kích thước của hàng_a \, x \, cols_b trong mã. Ngoài ra, nếu A và B có cùng kích thước của các hàng n và các cột N, đó là chúng là ma trận vuông, a \ cdot B không bằng b \ cdot A. Hãy nhớ rằng thứ tự của phép nhân khi nhân ma trận. Cuối cùng, kết quả cho mỗi phần tử mới c_ {i, j} trong C, sẽ là kết quả của A \ cdot B, được tìm thấy như sau sử dụng ma trận 3 \, x \, 3 làm ví dụ:matrix_multiply. The first rule in matrix multiplication is that if you want to multiply matrix A times matrix B, the number of columns of A MUST equal the number of rows of B. Thus, if A has dimensions of m rows and n columns (m\,x\,n for short) B must have n rows and it can have 1 or more columns. Let’s say it has k columns. Thus, the resulting product of the two matrices will be an m\,x\,k matrix, or the resulting matrix has the number of rows of A and the number of columns of B.  Hence, we create a zeros matrix to hold the resulting product of the two matrices that has dimensions of rows_A \, x \, cols_B in the code. Also, IF A and B have the same dimensions of n rows and n columns, that is they are square matrices, A \cdot B does NOT equal B \cdot A. Remember that the order of multiplication matters when multiplying matrices. Finally, the result for each new element c_{i,j} in C, which will be the result of A \cdot B, is found as follows using a 3\,x\,3 matrix as an example:

c_ {i, j} = a_ {i, 0} \ cdot b_ {0, j} + a_ {i, 1} \ cdot b_ {1, j} + a_ {i, 2} \ cdot b_ {2, j }

Nghĩa là, để có được c_ {i, j}, chúng tôi đang nhân mỗi phần tử cột trong mỗi hàng I của một lần mỗi phần tử hàng trong mỗi cột J của B và thêm các sản phẩm đó. Phew!c_{i,j} we are multiplying each column element in each row i of A times each row element in each column j of B and adding up those products. Phew!

>>> zip(*[iter(li)]*5)
[('a', 'b', 'c', 'd', 'e'), ('f', 'h', 'i', 'j', 'k'), ('l', 'm', 'n', 'o', 'p'), ('q', 'r', 's', 't', 'u'), ('v', 'w', 'x', 'y', 'z')]

Thứ chín là một hàm, nhân lên, để nhân danh sách ma trận bằng Matrix_Multiply. Lưu ý rằng chúng tôi chỉ cần thiết lập sản phẩm đang chạy làm ma trận đầu tiên trong danh sách, và sau đó vòng lặp FOR bắt đầu ở phần tử thứ hai (của danh sách ma trận) để lặp qua ma trận và tạo sản phẩm đang chạy, Matrix_product, lần Ma trận tiếp theo trong danh sách. & nbsp;multiply_matrices, to multiply out a list of matrices using matrix_multiply. Note that we simply establish the running product as the first matrix in the list, and then the for loop starts at the second element (of the list of matrices) to loop through the matrices and create the running product, matrix_product, times the next matrix in the list. 

>>> zip(*[iter(li)]*5)
[('a', 'b', 'c', 'd', 'e'), ('f', 'h', 'i', 'j', 'k'), ('l', 'm', 'n', 'o', 'p'), ('q', 'r', 's', 't', 'u'), ('v', 'w', 'x', 'y', 'z')]

Thứ mười, và tôi thú nhận rằng tôi không chắc chắn khi nào tốt nhất để trình bày cái này, là Check_matrix_equality. Sẽ có những lúc kiểm tra sự bình đẳng giữa hai ma trận là cách tốt nhất để xác minh kết quả của chúng tôi. Tuy nhiên, các hoạt động đó sẽ có một số lỗi làm tròn cho các ma trận giành được chính xác bằng nhau, nhưng về cơ bản chúng sẽ bằng nhau. Do đó, lưu ý rằng có một TOL (tham số dung sai), có thể được đặt. Nếu mặc định được sử dụng, hai ma trận dự kiến ​​sẽ chính xác bằng nhau. Nếu một dung sai được đặt, giá trị của TOL là số lượng các vị trí thập phân, các giá trị phần tử được làm tròn để kiểm tra trạng thái cơ bản bằng nhau.check_matrix_equality. There will be times where checking the equality between two matrices is the best way to verify our results. However, those operations will have some amount of round off error to where the matrices won’t be exactly equal, but they will be essentially equal. Thus, note that there is a tol (tolerance parameter), that can be set. If the default is used, the two matrices are expected to be exactly equal. If a tolerance is set, the value of tol is the number of decimal places the element values are rounded off to to check for an essentially equal state.

>>> zip(*[iter(li)]*5)
[('a', 'b', 'c', 'd', 'e'), ('f', 'h', 'i', 'j', 'k'), ('l', 'm', 'n', 'o', 'p'), ('q', 'r', 's', 't', 'u'), ('v', 'w', 'x', 'y', 'z')]

Sản phẩm DOT giữa hai vectơ hoặc ma trận về cơ bản là phép nhân ma trận và phải tuân theo các quy tắc tương tự. Điều quan trọng cần lưu ý là thói quen nhân ma trận của chúng tôi có thể được sử dụng để nhân hai vectơ có thể dẫn đến một ma trận giá trị duy nhất. Trong những trường hợp như vậy, kết quả đó được coi là không phải là một vectơ hoặc ma trận, nhưng nó là giá trị đơn hoặc tỷ lệ. Tuy nhiên, sử dụng các thói quen của chúng tôi, nó vẫn sẽ là một mảng với một mảng có giá trị bên trong nó. Để đọc một tài liệu tham khảo khác, hãy kiểm tra tại đây và tôi sẽ lưu liên kết đó dưới dạng dấu trang - đó là một tài nguyên tuyệt vời.HERE, and I would save that link as a bookmark – it’s a great resource.

Hàm thứ mười một là hàm actitize_vector. Hãy để bước qua các phần của nó. Phần 1 đảm bảo rằng một vectơ là đầu vào có nghĩa là một trong các kích thước nên là 1. Ngoài ra, nó đảm bảo rằng mảng là 2 chiều. Bộ công cụ này muốn tất cả các ma trận và vectơ là 2 chiều cho tính nhất quán. Phần 2 sử dụng Định lý Pythagore để tìm độ lớn của vectơ. & NBSP; Phần 3 tạo một bản sao của vectơ gốc (hàm copy_matrix hoạt động tốt, vì nó vẫn hoạt động trên các mảng 2D) và Phần 4 chia mỗi phần tử cho độ lớn xác định của vectơ để tạo một vectơ đơn vị. & Nbsp;unitize_vector function. Let’s step through its sections. Section 1 ensures that a vector was input meaning that one of the dimensions should be 1. Also, it makes sure that the array is 2 dimensional. This tool kit wants all matrices and vectors to be 2 dimensional for consistency. Section 2 uses the Pythagorean theorem to find the magnitude of the vector.  Section 3 makes a copy of the original vector (the copy_matrix function works fine, because it still works on 2D arrays), and Section 4 divides each element by the determined magnitude of the vector to create a unit vector. 

>>> zip(*[iter(li)]*5)
[('a', 'b', 'c', 'd', 'e'), ('f', 'h', 'i', 'j', 'k'), ('l', 'm', 'n', 'o', 'p'), ('q', 'r', 's', 't', 'u'), ('v', 'w', 'x', 'y', 'z')]

Sử dụng Numpy cho các hoạt động trên

Làm thế nào chúng ta sẽ làm tất cả những hành động này với Numpy? Nó rất đơn giản và thanh lịch. Mã dưới đây tuân theo cùng một thứ tự các chức năng mà chúng tôi vừa đề cập ở trên nhưng chỉ ra cách thực hiện từng thứ trong Numpy. Mã bên dưới nằm trong tệp numpytoolspractice.py trong repo. Sao chép mã bên dưới hoặc lấy nó từ repo, nhưng tôi thực sự khuyến khích bạn chạy nó và chơi với nó.NumpyToolsPractice.py in the repo. Copy the code below or get it from the repo, but I strongly encourage you to run it and play with it.

>>> zip(*[iter(li)]*5)
[('a', 'b', 'c', 'd', 'e'), ('f', 'h', 'i', 'j', 'k'), ('l', 'm', 'n', 'o', 'p'), ('q', 'r', 's', 't', 'u'), ('v', 'w', 'x', 'y', 'z')]

Đóng cửa

Đó là nó ngay bây giờ. Thư viện này sẽ phát triển tất nhiên với mỗi bài mới. Illll giới thiệu các chức năng trợ giúp mới nếu và khi chúng cần thiết trong các bài đăng trong tương lai và có các bài đăng riêng cho những bổ sung đó đòi hỏi nhiều giải thích hơn. Nhưng những chức năng này là những chức năng cơ bản nhất. Một số trong số này cũng hỗ trợ công việc cho bài đăng ma trận nghịch đảo và để giải một hệ thống các phương trình bài. & NBSP;inverse matrix post and for the solving a system of equations post. 

Làm thế nào để bạn có được một hàng và cột của một ma trận mà không có Numpy trong Python?

Làm thế nào để bạn tạo ra một ma trận bằng không mà không bị numpy trong Python?

Có chức năng ma trận trong Python không?

Làm thế nào để bạn tìm thấy yếu tố quyết định của một ma trận mà không bị numpy trong Python?