Python cho AI và ML

Học máy

Học máy là một kỹ thuật trong đó bạn đào tạo hệ thống để giải quyết vấn đề thay vì lập trình các quy tắc một cách rõ ràng. Quay lại ví dụ sudoku trong phần trước, để giải quyết vấn đề bằng cách sử dụng máy học, bạn sẽ thu thập dữ liệu từ các trò chơi sudoku đã giải và đào tạo một mô hình thống kê. Các mô hình thống kê là những cách được hình thức hóa về mặt toán học để tính gần đúng hành vi của một hiện tượng

Một nhiệm vụ học máy phổ biến là học có giám sát, trong đó bạn có một tập dữ liệu với đầu vào và đầu ra đã biết. Nhiệm vụ là sử dụng bộ dữ liệu này để đào tạo một mô hình dự đoán đầu ra chính xác dựa trên các đầu vào. Hình ảnh bên dưới trình bày quy trình đào tạo một mô hình bằng cách sử dụng phương pháp học có giám sát

Sự kết hợp của dữ liệu đào tạo với thuật toán học máy tạo ra mô hình. Sau đó, với mô hình này, bạn có thể đưa ra dự đoán cho dữ liệu mới

Ghi chú. scikit-learning là một thư viện máy học Python phổ biến cung cấp nhiều thuật toán học có giám sát và không giám sát. Để tìm hiểu thêm về nó, hãy xem Split Your Dataset With scikit-learn's train_test_split()

Mục tiêu của các nhiệm vụ học tập có giám sát là đưa ra dự đoán cho dữ liệu mới, chưa nhìn thấy. Để làm điều đó, bạn giả sử rằng dữ liệu không nhìn thấy này tuân theo phân phối xác suất tương tự như phân phối của tập dữ liệu huấn luyện. Nếu trong tương lai, phân phối này thay đổi, thì bạn cần huấn luyện lại mô hình của mình bằng tập dữ liệu huấn luyện mới

Kỹ thuật tính năng

Vấn đề dự đoán trở nên khó khăn hơn khi bạn sử dụng các loại dữ liệu khác nhau làm đầu vào. Vấn đề sudoku tương đối đơn giản vì bạn đang xử lý trực tiếp các con số. Nếu bạn muốn đào tạo một mô hình để dự đoán tình cảm trong một câu thì sao?

Một tên gọi khác của dữ liệu đầu vào là tính năng và kỹ thuật tính năng là quá trình trích xuất các tính năng từ dữ liệu thô. Khi xử lý các loại dữ liệu khác nhau, bạn cần tìm ra cách biểu diễn dữ liệu này để trích xuất thông tin có ý nghĩa từ nó

Một ví dụ về kỹ thuật công nghệ tính năng là, trong đó bạn loại bỏ biến tố khỏi các từ trong câu. Ví dụ: các dạng biến cách của động từ “watch”, như “watches”, “watching” và “watched” sẽ được rút gọn thành bổ đề hoặc dạng cơ sở của chúng. "đồng hồ. ”

Nếu bạn đang sử dụng mảng để lưu trữ từng từ của kho văn bản, thì bằng cách áp dụng từ vựng, bạn sẽ có một ma trận ít thưa thớt hơn. Điều này có thể tăng hiệu suất của một số thuật toán học máy. Hình ảnh sau đây trình bày quá trình từ vựng hóa và biểu diễn bằng mô hình túi từ

Đầu tiên, dạng biến cách của mọi từ được rút gọn thành bổ đề của nó. Sau đó, số lần xuất hiện của từ đó được tính. Kết quả là một mảng chứa số lần xuất hiện của mỗi từ trong văn bản

Học kĩ càng

Học sâu là một kỹ thuật trong đó bạn để mạng thần kinh tự tìm ra tính năng nào là quan trọng thay vì áp dụng các kỹ thuật kỹ thuật tính năng. Điều này có nghĩa là với deep learning, bạn có thể bỏ qua quy trình kỹ thuật tính năng

Không phải đối phó với kỹ thuật tính năng là tốt vì quá trình này trở nên khó khăn hơn khi bộ dữ liệu trở nên phức tạp hơn. Ví dụ: làm thế nào bạn có thể trích xuất dữ liệu để dự đoán tâm trạng của một người khi được chụp ảnh khuôn mặt của cô ấy? . Trong các phần tiếp theo, bạn sẽ tìm hiểu sâu hơn về mạng lưới thần kinh để hiểu rõ hơn về cách thức hoạt động của chúng

Quá trình đào tạo một mạng lưới thần kinh

Đào tạo một mạng lưới thần kinh tương tự như quá trình thử và sai. Hãy tưởng tượng bạn đang chơi phi tiêu lần đầu tiên. Trong lần ném đầu tiên, bạn cố gắng ném trúng tâm của bảng phi tiêu. Thông thường, cú đánh đầu tiên chỉ là để biết chiều cao và tốc độ của bàn tay bạn ảnh hưởng đến kết quả như thế nào. Nếu bạn thấy phi tiêu cao hơn tâm điểm thì bạn điều chỉnh tay ném thấp hơn một chút, v.v.

Đây là các bước để cố gắng bắn trúng tâm của bảng phi tiêu

Lưu ý rằng bạn tiếp tục đánh giá lỗi bằng cách quan sát nơi phi tiêu tiếp đất (bước 2). Bạn tiếp tục cho đến khi cuối cùng bạn chạm vào tâm của bảng phi tiêu

Với mạng lưới thần kinh, quá trình này rất giống nhau. bạn bắt đầu với một số trọng số ngẫu nhiên và vectơ độ lệch, đưa ra dự đoán, so sánh nó với đầu ra mong muốn và điều chỉnh vectơ để dự đoán chính xác hơn vào lần tiếp theo. Quá trình tiếp tục cho đến khi sự khác biệt giữa dự đoán và mục tiêu chính xác là tối thiểu

Biết khi nào nên dừng đào tạo và đặt mục tiêu chính xác nào là một khía cạnh quan trọng của việc đào tạo mạng lưới thần kinh, chủ yếu là do các tình huống

Vectơ và trọng số

Làm việc với mạng thần kinh bao gồm thực hiện các thao tác với vectơ. Bạn biểu diễn các vectơ dưới dạng mảng nhiều chiều. Các vectơ hữu ích trong học sâu chủ yếu là do một thao tác cụ thể. sản phẩm chấm. Tích vô hướng của hai vectơ cho bạn biết chúng giống nhau như thế nào về hướng và được chia tỷ lệ theo độ lớn của hai vectơ

Các vectơ chính bên trong mạng nơ-ron là các vectơ trọng số và độ chệch. Nói một cách lỏng lẻo, những gì bạn muốn mạng thần kinh của mình thực hiện là kiểm tra xem đầu vào có giống với các đầu vào khác mà nó đã thấy hay không. Nếu đầu vào mới tương tự như đầu vào đã thấy trước đó, thì đầu ra cũng sẽ tương tự. Đó là cách bạn nhận được kết quả của một dự đoán

Mô hình hồi quy tuyến tính

Hồi quy được sử dụng khi bạn cần ước tính mối quan hệ giữa một biến phụ thuộc và hai hoặc nhiều biến độc lập. Hồi quy tuyến tính là một phương pháp được áp dụng khi bạn tính gần đúng mối quan hệ giữa các biến dưới dạng tuyến tính. Phương pháp này có từ thế kỷ 19 và là phương pháp hồi quy phổ biến nhất

Ghi chú. Mối quan hệ tuyến tính là mối quan hệ có mối quan hệ trực tiếp giữa biến độc lập và biến phụ thuộc

Bằng cách mô hình hóa mối quan hệ giữa các biến dưới dạng tuyến tính, bạn có thể biểu thị biến phụ thuộc dưới dạng tổng trọng số của các biến độc lập. Vì vậy, mỗi biến độc lập sẽ được nhân với một vectơ có tên là

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Như một ví dụ thực tế về cách xây dựng mô hình hồi quy tuyến tính, hãy tưởng tượng bạn muốn đào tạo một mô hình để dự đoán giá nhà dựa trên diện tích và tuổi của ngôi nhà. Bạn quyết định mô hình hóa mối quan hệ này bằng hồi quy tuyến tính. Khối mã sau đây cho thấy cách bạn có thể viết mô hình hồi quy tuyến tính cho vấn đề đã nêu trong mã giả

price = (weights_area * area) + (weights_age * age) + bias

Trong ví dụ trên, có hai trọng số.

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Đây là những điều cơ bản về cách thức hoạt động của cơ chế mạng lưới thần kinh. Bây giờ là lúc xem cách áp dụng các khái niệm này bằng Python

Gói các đầu vào của mạng nơ-ron bằng NumPy

Bạn sẽ sử dụng NumPy để biểu diễn các vectơ đầu vào của mạng dưới dạng mảng. Nhưng trước khi bạn sử dụng NumPy, bạn nên chơi với các vectơ bằng Python thuần túy để hiểu rõ hơn điều gì đang xảy ra

Trong ví dụ đầu tiên này, bạn có một vectơ đầu vào và hai vectơ trọng số khác. Mục tiêu là tìm ra trọng số nào giống với đầu vào hơn, có tính đến hướng và độ lớn. Đây là cách các vectơ trông nếu bạn vẽ chúng

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

Đầu tiên, bạn xác định ba vectơ, một cho đầu vào và hai vectơ còn lại cho trọng số. Sau đó, bạn tính xem

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

1. Nhân chỉ số đầu tiên của

   (my-env) $ python -m pip install ipython numpy matplotlib
   (my-env) $ ipython
   

   1 với chỉ số đầu tiên của

   (my-env) $ python -m pip install ipython numpy matplotlib
   (my-env) $ ipython
   

   2
2. Nhân chỉ số thứ hai của

   (my-env) $ python -m pip install ipython numpy matplotlib
   (my-env) $ ipython
   

   1 với chỉ số thứ hai của

   (my-env) $ python -m pip install ipython numpy matplotlib
   (my-env) $ ipython
   

   0
3. Tổng kết quả của cả hai phép nhân

Bạn có thể sử dụng bảng điều khiển IPython hoặc Notebook Jupyter để theo dõi. Bạn nên tạo một môi trường ảo mới mỗi khi bắt đầu một dự án Python mới, vì vậy bạn nên làm điều đó trước.

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Sử dụng các lệnh trên, trước tiên bạn tạo môi trường ảo, sau đó bạn kích hoạt nó. Bây giờ là lúc cài đặt bảng điều khiển IPython bằng cách sử dụng

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

Bây giờ bạn đã sẵn sàng để bắt đầu viết mã. Đây là mã để tính tích vô hướng của

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

>>>

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

Kết quả của tích vô hướng là

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

>>>

In [9]: import numpy as np

In [10]: dot_product_1 = np.dot(input_vector, weights_1)

In [11]: print(f"The dot product is: {dot_product_1}")
Out[11]: The dot product is: 2.1672

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

>>>

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

Lần này, kết quả là

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

Bằng cách này, bạn có thể xem sản phẩm chấm như một phép đo lỏng lẻo về độ tương tự giữa các vectơ. Mỗi khi kết quả phép nhân là

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

Ghi chú. Nhấp vào dấu nhắc (>>>) ở trên cùng bên phải của mỗi khối mã nếu bạn cần sao chép và dán mã đó

Trong hướng dẫn này, bạn sẽ đào tạo một mô hình để đưa ra dự đoán chỉ có hai kết quả có thể xảy ra. Kết quả đầu ra có thể là

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

Mục tiêu vectơ đầu vào [1. 66, 1. 56]1[2, 1. 5]0

Mục tiêu là biến bạn muốn dự đoán. Trong ví dụ này, bạn đang xử lý một tập dữ liệu bao gồm các số. Điều này không phổ biến trong một kịch bản sản xuất thực tế. Thông thường, khi có nhu cầu về mô hình học sâu, dữ liệu được trình bày dưới dạng tệp, chẳng hạn như hình ảnh hoặc văn bản

Đưa ra dự đoán đầu tiên của bạn

Vì đây là mạng thần kinh đầu tiên của bạn nên bạn sẽ giữ mọi thứ đơn giản và xây dựng một mạng chỉ có hai lớp. Cho đến giờ, bạn đã thấy rằng hai phép toán duy nhất được sử dụng bên trong mạng thần kinh là tích vô hướng và tổng. Cả hai đều hoạt động tuyến tính

Nếu bạn thêm nhiều lớp hơn nhưng chỉ tiếp tục sử dụng các phép toán tuyến tính, thì việc thêm nhiều lớp hơn sẽ không có tác dụng vì mỗi lớp sẽ luôn có một số tương quan với đầu vào của lớp trước đó. Điều này ngụ ý rằng, đối với một mạng có nhiều lớp, sẽ luôn có một mạng có ít lớp hơn dự đoán cùng một kết quả

Điều bạn muốn là tìm một thao tác làm cho các lớp ở giữa đôi khi tương quan với đầu vào và đôi khi không tương quan

Bạn có thể đạt được hành vi này bằng cách sử dụng các hàm phi tuyến tính. Các hàm phi tuyến này được gọi là các hàm kích hoạt. Có nhiều loại hàm kích hoạt. Ví dụ: ReLU (đơn vị tuyến tính được chỉnh lưu) là một hàm chuyển đổi tất cả các số âm thành 0. Điều này có nghĩa là mạng có thể “tắt” một trọng số nếu nó âm, làm tăng tính phi tuyến tính

Mạng bạn đang xây dựng sẽ sử dụng chức năng kích hoạt sigmoid. Bạn sẽ sử dụng nó ở lớp cuối cùng,

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

E là một hằng số toán học được gọi là số Euler và bạn có thể sử dụng

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

Các hàm xác suất cung cấp cho bạn xác suất xảy ra đối với các kết quả có thể xảy ra của một sự kiện. Hai đầu ra khả dĩ duy nhất của tập dữ liệu là

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

Vì hàm giới hạn đầu ra trong phạm vi từ

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

In [12]: # Wrapping the vectors in NumPy arrays
In [13]: input_vector = np.array([1.66, 1.56])
In [14]: weights_1 = np.array([1.45, -0.66])
In [15]: bias = np.array([0.0])

In [16]: def sigmoid(x):
   ...:     return 1 / (1 + np.exp(-x))

In [17]: def make_prediction(input_vector, weights, bias):
   ...:      layer_1 = np.dot(input_vector, weights) + bias
   ...:      layer_2 = sigmoid(layer_1)
   ...:      return layer_2

In [18]: prediction = make_prediction(input_vector, weights_1, bias)

In [19]: print(f"The prediction result is: {prediction}")
Out[19]: The prediction result is: [0.7985731]

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

In [12]: # Wrapping the vectors in NumPy arrays
In [13]: input_vector = np.array([1.66, 1.56])
In [14]: weights_1 = np.array([1.45, -0.66])
In [15]: bias = np.array([0.0])

In [16]: def sigmoid(x):
   ...:     return 1 / (1 + np.exp(-x))

In [17]: def make_prediction(input_vector, weights, bias):
   ...:      layer_1 = np.dot(input_vector, weights) + bias
   ...:      layer_2 = sigmoid(layer_1)
   ...:      return layer_2

In [18]: prediction = make_prediction(input_vector, weights_1, bias)

In [19]: print(f"The prediction result is: {prediction}")
Out[19]: The prediction result is: [0.7985731]

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

Các hình lục giác màu vàng biểu thị các chức năng và các hình chữ nhật màu xanh biểu thị các kết quả trung gian. Bây giờ là lúc biến tất cả kiến ​​thức này thành mã. Bạn cũng sẽ cần bọc các vectơ bằng mảng NumPy. Đây là đoạn mã áp dụng các chức năng được trình bày trong hình trên

>>>

In [12]: # Wrapping the vectors in NumPy arrays
In [13]: input_vector = np.array([1.66, 1.56])
In [14]: weights_1 = np.array([1.45, -0.66])
In [15]: bias = np.array([0.0])

In [16]: def sigmoid(x):
   ...:     return 1 / (1 + np.exp(-x))

In [17]: def make_prediction(input_vector, weights, bias):
   ...:      layer_1 = np.dot(input_vector, weights) + bias
   ...:      layer_2 = sigmoid(layer_1)
   ...:      return layer_2

In [18]: prediction = make_prediction(input_vector, weights_1, bias)

In [19]: print(f"The prediction result is: {prediction}")
Out[19]: The prediction result is: [0.7985731]

Kết quả dự đoán thô là

In [12]: # Wrapping the vectors in NumPy arrays
In [13]: input_vector = np.array([1.66, 1.56])
In [14]: weights_1 = np.array([1.45, -0.66])
In [15]: bias = np.array([0.0])

In [16]: def sigmoid(x):
   ...:     return 1 / (1 + np.exp(-x))

In [17]: def make_prediction(input_vector, weights, bias):
   ...:      layer_1 = np.dot(input_vector, weights) + bias
   ...:      layer_2 = sigmoid(layer_1)
   ...:      return layer_2

In [18]: prediction = make_prediction(input_vector, weights_1, bias)

In [19]: print(f"The prediction result is: {prediction}")
Out[19]: The prediction result is: [0.7985731]

In [12]: # Wrapping the vectors in NumPy arrays
In [13]: input_vector = np.array([1.66, 1.56])
In [14]: weights_1 = np.array([1.45, -0.66])
In [15]: bias = np.array([0.0])

In [16]: def sigmoid(x):
   ...:     return 1 / (1 + np.exp(-x))

In [17]: def make_prediction(input_vector, weights, bias):
   ...:      layer_1 = np.dot(input_vector, weights) + bias
   ...:      layer_2 = sigmoid(layer_1)
   ...:      return layer_2

In [18]: prediction = make_prediction(input_vector, weights_1, bias)

In [19]: print(f"The prediction result is: {prediction}")
Out[19]: The prediction result is: [0.7985731]

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

In [12]: # Wrapping the vectors in NumPy arrays
In [13]: input_vector = np.array([1.66, 1.56])
In [14]: weights_1 = np.array([1.45, -0.66])
In [15]: bias = np.array([0.0])

In [16]: def sigmoid(x):
   ...:     return 1 / (1 + np.exp(-x))

In [17]: def make_prediction(input_vector, weights, bias):
   ...:      layer_1 = np.dot(input_vector, weights) + bias
   ...:      layer_2 = sigmoid(layer_1)
   ...:      return layer_2

In [18]: prediction = make_prediction(input_vector, weights_1, bias)

In [19]: print(f"The prediction result is: {prediction}")
Out[19]: The prediction result is: [0.7985731]

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

>>>

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

Lần này, mạng đã dự đoán sai. Kết quả phải nhỏ hơn

In [12]: # Wrapping the vectors in NumPy arrays
In [13]: input_vector = np.array([1.66, 1.56])
In [14]: weights_1 = np.array([1.45, -0.66])
In [15]: bias = np.array([0.0])

In [16]: def sigmoid(x):
   ...:     return 1 / (1 + np.exp(-x))

In [17]: def make_prediction(input_vector, weights, bias):
   ...:      layer_1 = np.dot(input_vector, weights) + bias
   ...:      layer_2 = sigmoid(layer_1)
   ...:      return layer_2

In [18]: prediction = make_prediction(input_vector, weights_1, bias)

In [19]: print(f"The prediction result is: {prediction}")
Out[19]: The prediction result is: [0.7985731]

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

Tính toán lỗi dự đoán

Để hiểu mức độ của lỗi, bạn cần chọn một cách để đo lường nó. Hàm được sử dụng để đo lỗi được gọi là hàm chi phí hoặc hàm mất mát. Trong hướng dẫn này, bạn sẽ sử dụng lỗi bình phương trung bình (MSE) làm hàm chi phí của mình. Bạn tính toán MSE theo hai bước

1. Tính toán sự khác biệt giữa dự đoán và mục tiêu
2. Nhân kết quả với chính nó

Mạng có thể mắc lỗi khi xuất ra giá trị cao hơn hoặc thấp hơn giá trị chính xác. Vì MSE là bình phương chênh lệch giữa dự đoán và kết quả chính xác, nên với số liệu này, bạn sẽ luôn nhận được giá trị dương

Đây là biểu thức hoàn chỉnh để tính toán lỗi cho dự đoán cuối cùng trước đó

>>>

In [24]: target = 0

In [25]: mse = np.square(prediction - target)

In [26]: print(f"Prediction: {prediction}; Error: {mse}")
Out[26]: Prediction: [0.87101915]; Error: [0.7586743596667225]

Trong ví dụ trên, lỗi là

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

Hiểu cách giảm lỗi

Mục tiêu là thay đổi trọng số và các biến thiên vị để bạn có thể giảm sai số. Để hiểu cách thức hoạt động của điều này, bạn sẽ chỉ thay đổi biến trọng số và giữ nguyên độ lệch hiện tại. Bạn cũng có thể loại bỏ hàm sigmoid và chỉ sử dụng kết quả của

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

Bạn tính toán MSE bằng cách thực hiện

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

Lỗi được đưa ra bởi trục y. Nếu bạn đang ở điểm

In [24]: target = 0

In [25]: mse = np.square(prediction - target)

In [26]: print(f"Prediction: {prediction}; Error: {mse}")
Out[26]: Prediction: [0.87101915]; Error: [0.7586743596667225]

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

In [24]: target = 0

In [25]: mse = np.square(prediction - target)

In [26]: print(f"Prediction: {prediction}; Error: {mse}")
Out[26]: Prediction: [0.87101915]; Error: [0.7586743596667225]

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

Một từ khác cho đạo hàm là gradient. Độ dốc gốc là tên của thuật toán được sử dụng để tìm hướng và tốc độ cập nhật các tham số mạng

Ghi chú. Để tìm hiểu thêm về toán học đằng sau việc giảm dần độ dốc, hãy xem Thuật toán giảm dần độ dốc ngẫu nhiên với Python và NumPy

Trong hướng dẫn này, bạn sẽ không tập trung vào lý thuyết đằng sau các đạo hàm, vì vậy bạn sẽ chỉ cần áp dụng các quy tắc đạo hàm cho từng hàm mà bạn sẽ gặp. Quy tắc lũy thừa nói rằng đạo hàm của xⁿ là nx⁽ⁿ⁻¹⁾. Vậy đạo hàm của _______65_______4 là _______65_______5, và đạo hàm của _______61_______8 là _______26_______0

Hãy nhớ rằng biểu thức lỗi là

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

In [24]: target = 0

In [25]: mse = np.square(prediction - target)

In [26]: print(f"Prediction: {prediction}; Error: {mse}")
Out[26]: Prediction: [0.87101915]; Error: [0.7586743596667225]

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

In [27]: derivative = 2 * (prediction - target)

In [28]: print(f"The derivative is {derivative}")
Out[28]: The derivative is: [1.7420383]

Khi nói đến mạng thần kinh của bạn, đạo hàm sẽ cho bạn biết hướng bạn nên thực hiện để cập nhật biến trọng số. Nếu đó là một số dương, thì bạn đã dự đoán quá cao và bạn cần giảm trọng số. Nếu đó là một số âm, thì bạn đã dự đoán quá thấp và bạn cần tăng trọng số

Bây giờ là lúc viết mã để tìm ra cách cập nhật

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

>>>

In [27]: derivative = 2 * (prediction - target)

In [28]: print(f"The derivative is {derivative}")
Out[28]: The derivative is: [1.7420383]

Kết quả là ________ 85 ______ 8, một số dương, vì vậy bạn cần giảm trọng số. Bạn làm điều đó bằng cách trừ kết quả đạo hàm của vectơ trọng số. Bây giờ bạn có thể cập nhật

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

>>>

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Lỗi giảm xuống gần như

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

In [24]: target = 0

In [25]: mse = np.square(prediction - target)

In [26]: print(f"Prediction: {prediction}; Error: {mse}")
Out[26]: Prediction: [0.87101915]; Error: [0.7586743596667225]

In [24]: target = 0

In [25]: mse = np.square(prediction - target)

In [26]: print(f"Prediction: {prediction}; Error: {mse}")
Out[26]: Prediction: [0.87101915]; Error: [0.7586743596667225]

Để xác định một phân số để cập nhật trọng số, bạn sử dụng tham số alpha, còn được gọi là tỷ lệ học tập. Nếu bạn giảm tốc độ học tập, thì số gia sẽ nhỏ hơn. Nếu bạn tăng nó, thì các bước cao hơn. Làm thế nào để bạn biết giá trị tỷ lệ học tập tốt nhất là gì?

Ghi chú. Các giá trị tỷ lệ học tập mặc định truyền thống là

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Nếu bạn lấy các trọng số mới và đưa ra dự đoán với vectơ đầu vào đầu tiên, thì bạn sẽ thấy rằng bây giờ nó đưa ra dự đoán sai cho vectơ đó. Nếu mạng thần kinh của bạn đưa ra dự đoán chính xác cho mọi trường hợp trong tập huấn luyện của bạn, thì bạn có thể có một mô hình được trang bị quá mức, trong đó mô hình chỉ ghi nhớ cách phân loại các ví dụ thay vì học cách chú ý các tính năng trong dữ liệu

Có những kỹ thuật để tránh điều đó, bao gồm cả việc chính quy hóa. Trong hướng dẫn này, bạn sẽ sử dụng

Bây giờ bạn đã biết cách tính toán lỗi và cách điều chỉnh trọng số cho phù hợp, đã đến lúc quay lại tiếp tục xây dựng mạng lưới thần kinh của bạn

Áp dụng quy tắc chuỗi

Trong mạng thần kinh của bạn, bạn cần cập nhật cả trọng số và vectơ sai lệch. Hàm bạn đang sử dụng để đo lỗi phụ thuộc vào hai biến độc lập, trọng số và độ lệch. Vì trọng số và độ lệch là các biến độc lập nên bạn có thể thay đổi và điều chỉnh chúng để có được kết quả mong muốn

Mạng bạn đang xây dựng có hai lớp và vì mỗi lớp có các chức năng riêng nên bạn đang xử lý thành phần chức năng. Điều này có nghĩa là hàm lỗi vẫn là

In [24]: target = 0

In [25]: mse = np.square(prediction - target)

In [26]: print(f"Prediction: {prediction}; Error: {mse}")
Out[26]: Prediction: [0.87101915]; Error: [0.7586743596667225]

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

Để trình bày lại vấn đề, bây giờ bạn muốn biết cách thay đổi

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Vì bây giờ bạn đã có thành phần hàm này, để lấy đạo hàm của sai số liên quan đến các tham số, bạn sẽ cần sử dụng quy tắc chuỗi từ phép tính. Với quy tắc dây chuyền, bạn lấy đạo hàm riêng của từng hàm, đánh giá chúng và nhân tất cả các đạo hàm riêng để có được đạo hàm bạn muốn

Bây giờ bạn có thể bắt đầu cập nhật trọng số. Bạn muốn biết cách thay đổi trọng số để giảm sai số. Điều này ngụ ý rằng bạn cần tính đạo hàm của sai số đối với các trọng số. Vì sai số được tính bằng cách kết hợp các hàm khác nhau nên bạn cần lấy đạo hàm riêng của các hàm này

Dưới đây là phần trình bày trực quan về cách bạn áp dụng quy tắc dây chuyền để tìm đạo hàm của sai số đối với các trọng số

Mũi tên đậm màu đỏ hiển thị đạo hàm bạn muốn,

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Trong hình trên, mỗi hàm được biểu thị bằng các hình lục giác màu vàng và các đạo hàm riêng được biểu thị bằng các mũi tên màu xám ở bên trái. Áp dụng quy tắc chuỗi, giá trị của

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Để tính đạo hàm, bạn nhân tất cả các đạo hàm riêng theo đường dẫn từ hình lục giác sai số (hình màu đỏ) với hình lục giác nơi bạn tìm thấy trọng số (hình lục giác ngoài cùng bên trái)

Bạn có thể nói rằng đạo hàm của

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Con đường ngược lại này được gọi là đường chuyền ngược. Trong mỗi lần quay ngược, bạn tính đạo hàm riêng của từng hàm, thay thế các biến bằng giá trị của chúng và cuối cùng nhân mọi thứ

Phần “lấy đạo hàm riêng, đánh giá và nhân” này là cách bạn áp dụng quy tắc dây chuyền. Thuật toán này để cập nhật các tham số mạng thần kinh được gọi là backpropagation

Điều chỉnh các tham số bằng Backpropagation

Trong phần này, bạn sẽ hướng dẫn từng bước quy trình lan truyền ngược, bắt đầu với cách bạn cập nhật xu hướng. Bạn muốn lấy đạo hàm của hàm sai số theo độ lệch,

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Vì bạn đang bắt đầu từ cuối và đi ngược lại, trước tiên bạn cần lấy đạo hàm riêng của sai số đối với dự đoán. Đó là

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Hàm tạo ra lỗi là một hàm bình phương và đạo hàm của hàm này là

In [24]: target = 0

In [25]: mse = np.square(prediction - target)

In [26]: print(f"Prediction: {prediction}; Error: {mse}")
Out[26]: Prediction: [0.87101915]; Error: [0.7586743596667225]

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Dự đoán là kết quả của hàm sigmoid. Bạn có thể lấy đạo hàm của hàm sigmoid bằng cách nhân

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Bây giờ bạn sẽ lấy đạo hàm của

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

>>>

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Để cập nhật các trọng số, bạn làm theo quy trình tương tự, đi ngược lại và lấy đạo hàm riêng cho đến khi bạn tìm được biến trọng số. Vì bạn đã tính một số đạo hàm riêng nên bạn chỉ cần tính

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Tạo lớp mạng thần kinh

Bây giờ bạn đã biết cách viết các biểu thức để cập nhật cả trọng số và độ chệch. Đã đến lúc tạo một lớp cho mạng lưới thần kinh. Các lớp là khối xây dựng chính của lập trình hướng đối tượng (OOP). Lớp

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Khi khởi tạo một đối tượng

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Ở đó bạn có nó. Đó là mã của mạng lưới thần kinh đầu tiên của bạn. Xin chúc mừng. Mã này chỉ tập hợp tất cả các phần bạn đã thấy cho đến nay. Nếu bạn muốn đưa ra dự đoán, trước tiên bạn tạo một thể hiện của

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

>>>

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Đoạn mã trên đưa ra dự đoán, nhưng bây giờ bạn cần học cách đào tạo mạng. Mục tiêu là làm cho mạng tổng quát hóa trên tập dữ liệu huấn luyện. Điều này có nghĩa là bạn muốn nó thích ứng với dữ liệu mới, chưa thấy, tuân theo phân phối xác suất giống như tập dữ liệu huấn luyện. Đó là những gì bạn sẽ làm trong phần tiếp theo

Đào tạo mạng với nhiều dữ liệu hơn

Bạn đã điều chỉnh trọng số và độ lệch cho một phiên bản dữ liệu, nhưng mục tiêu là làm cho mạng tổng quát hóa trên toàn bộ tập dữ liệu. Giảm dần độ dốc ngẫu nhiên là một kỹ thuật trong đó, ở mỗi lần lặp lại, mô hình đưa ra dự đoán dựa trên một phần dữ liệu đào tạo được chọn ngẫu nhiên, tính toán lỗi và cập nhật các tham số

Bây giờ là lúc để tạo phương thức

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Có rất nhiều thứ đang diễn ra trong khối mã trên, vì vậy đây là bảng phân tích từng dòng

• Dòng 8 chọn một phiên bản ngẫu nhiên từ tập dữ liệu

• Dòng 14 đến 16 tính đạo hàm riêng và trả về đạo hàm cho độ chệch và trọng số. Họ sử dụng

  $ python -m venv ~/.my-env
  $ source ~/.my-env/bin/activate
  

  41 mà bạn đã xác định trước đó

• Dòng 18 cập nhật độ lệch và trọng số bằng cách sử dụng

  $ python -m venv ~/.my-env
  $ source ~/.my-env/bin/activate
  

  34 mà bạn đã xác định trong khối mã trước đó

• Dòng 21 kiểm tra xem chỉ số lặp hiện tại có phải là bội số của

  $ python -m venv ~/.my-env
  $ source ~/.my-env/bin/activate
  

  43 không. Bạn làm điều này để quan sát lỗi thay đổi như thế nào sau mỗi lần lặp lại

  $ python -m venv ~/.my-env
  $ source ~/.my-env/bin/activate
  

  43

• Dòng 24 bắt đầu vòng lặp đi qua tất cả các phiên bản dữ liệu

• Dòng 28 tính kết quả

  $ python -m venv ~/.my-env
  $ source ~/.my-env/bin/activate
  

  45

• Dòng 29 tính toán

  In [27]: derivative = 2 * (prediction - target)
  
  In [28]: print(f"The derivative is {derivative}")
  Out[28]: The derivative is: [1.7420383]
  

  3 cho mọi trường hợp

• Dòng 31 là nơi bạn tích tổng số lỗi bằng cách sử dụng biến

  $ python -m venv ~/.my-env
  $ source ~/.my-env/bin/activate
  

  47. Bạn làm điều này bởi vì bạn muốn vẽ một điểm có lỗi cho tất cả các trường hợp dữ liệu. Sau đó, ở dòng 32, bạn nối

  In [27]: derivative = 2 * (prediction - target)
  
  In [28]: print(f"The derivative is {derivative}")
  Out[28]: The derivative is: [1.7420383]
  

  3 với

  $ python -m venv ~/.my-env
  $ source ~/.my-env/bin/activate
  

  49, mảng lưu trữ các lỗi. Bạn sẽ sử dụng mảng này để vẽ biểu đồ

Nói tóm lại, bạn chọn một phiên bản ngẫu nhiên từ tập dữ liệu, tính toán độ dốc và cập nhật trọng số và độ lệch. Bạn cũng tính toán lỗi tích lũy sau mỗi 100 lần lặp lại và lưu các kết quả đó vào một mảng. Bạn sẽ vẽ mảng này để hình dung lỗi thay đổi như thế nào trong quá trình đào tạo

Ghi chú. Nếu bạn đang chạy mã trong Jupyter Notebook, thì bạn cần khởi động lại kernel sau khi thêm

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Để mọi thứ bớt phức tạp hơn, bạn sẽ sử dụng tập dữ liệu chỉ có tám trường hợp, mảng

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

>>>

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Bạn khởi tạo lớp

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

Lỗi tổng thể đang giảm, đó là những gì bạn muốn. Hình ảnh được tạo trong cùng thư mục nơi bạn đang chạy IPython. Sau khi giảm nhiều nhất, lỗi tiếp tục tăng và giảm nhanh chóng từ tương tác này sang tương tác khác. Đó là bởi vì tập dữ liệu là ngẫu nhiên và rất nhỏ, vì vậy mạng thần kinh khó có thể trích xuất bất kỳ tính năng nào

Nhưng không nên đánh giá hiệu suất bằng chỉ số này vì bạn đang đánh giá nó bằng cách sử dụng các phiên bản dữ liệu mà mạng đã thấy. Điều này có thể dẫn đến trang bị quá mức, khi mô hình phù hợp với tập dữ liệu đào tạo đến mức nó không khái quát hóa thành dữ liệu mới

Thêm nhiều lớp hơn vào mạng lưới thần kinh

Tập dữ liệu trong hướng dẫn này được giữ ở mức nhỏ cho mục đích học tập. Thông thường, các mô hình học sâu cần một lượng lớn dữ liệu vì bộ dữ liệu phức tạp hơn và có nhiều sắc thái

Vì các bộ dữ liệu này có nhiều thông tin phức tạp hơn nên chỉ sử dụng một hoặc hai lớp là không đủ. Đó là lý do tại sao các mô hình deep learning được gọi là “deep learning. ” Họ thường có một số lượng lớn các lớp

Bằng cách thêm nhiều lớp hơn và sử dụng các chức năng kích hoạt, bạn tăng sức mạnh biểu đạt của mạng và có thể đưa ra các dự đoán ở cấp độ rất cao. Một ví dụ về các loại dự đoán này là nhận dạng khuôn mặt, chẳng hạn như khi bạn chụp ảnh khuôn mặt của mình bằng điện thoại và điện thoại sẽ mở khóa nếu nhận dạng được hình ảnh đó là bạn.