Melaksanakan Perceptron dari Scratch dalam Python

Hai dev,

Perceptron ialah salah satu konsep yang paling mudah dan paling asas dalam pembelajaran mesin. Ia adalah pengelas linear binari yang membentuk asas rangkaian saraf. Dalam siaran ini, saya akan melalui langkah-langkah untuk memahami dan melaksanakan Perceptron dari awal dalam Python.

Jom selami!

---

Apakah Perceptron?

A Perceptron ialah algoritma asas untuk pembelajaran penyeliaan pengelas binari. Memandangkan ciri input, Perceptron mempelajari pemberat yang membantu memisahkan kelas berdasarkan fungsi ambang mudah. Begini cara ia berfungsi secara ringkas:

1. Input: Vektor ciri (cth., [x1, x2]).
2. Berat: Setiap ciri input mempunyai berat, yang model laraskan berdasarkan prestasi model.
3. Fungsi Pengaktifan: Mengira jumlah wajaran ciri input dan menggunakan ambang untuk memutuskan sama ada hasilnya tergolong dalam satu kelas atau kelas yang lain.

Secara matematik, ia kelihatan seperti ini:

f(x) = w1*x1 w2*x2 ... wn*xn b

Di mana:

• f(x) ialah output,
• w mewakili pemberat,
• x mewakili ciri input dan
• b ialah istilah berat sebelah.

Jika f(x) lebih besar daripada atau sama dengan ambang, output ialah kelas 1; jika tidak, ia adalah kelas 0.

---

Langkah 1: Import Perpustakaan

Kami hanya akan menggunakan NumPy di ​​sini untuk operasi matriks bagi memastikan perkara itu ringan.

import numpy as np

---

Langkah 2: Tentukan Kelas Perceptron

Kami akan membina Perceptron sebagai kelas untuk memastikan semuanya teratur. Kelas akan merangkumi kaedah untuk latihan dan ramalan.

class Perceptron:
    def __init__(self, learning_rate=0.01, epochs=1000):
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.weights = None
        self.bias = None

    def fit(self, X, y):
        # Number of samples and features
        n_samples, n_features = X.shape

        # Initialize weights and bias
        self.weights = np.zeros(n_features)
        self.bias = 0

        # Training
        for _ in range(self.epochs):
            for idx, x_i in enumerate(X):
                # Calculate linear output
                linear_output = np.dot(x_i, self.weights) + self.bias
                # Apply step function
                y_predicted = self._step_function(linear_output)

                # Update weights and bias if there is a misclassification
                if y[idx] != y_predicted:
                    update = self.learning_rate * (y[idx] - y_predicted)
                    self.weights += update * x_i
                    self.bias += update

    def predict(self, X):
        # Calculate linear output and apply step function
        linear_output = np.dot(X, self.weights) + self.bias
        y_predicted = self._step_function(linear_output)
        return y_predicted

    def _step_function(self, x):
        return np.where(x >= 0, 1, 0)

Dalam kod di atas:

• fit: Kaedah ini melatih model dengan melaraskan berat dan berat sebelah apabila ia salah mengelaskan sesuatu mata.
• ramal: Kaedah ini mengira ramalan pada data baharu.
• _step_function: Fungsi ini menggunakan ambang untuk menentukan kelas output.

---

Langkah 3: Sediakan Set Data Mudah

Kami akan menggunakan set data kecil untuk memudahkan anda memvisualisasikan output. Berikut ialah set data get AND yang mudah:

# AND gate dataset
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])  # Labels for AND gate

---

Langkah 4: Latih dan Uji Perceptron

Sekarang, mari kita latih Perceptron dan uji ramalannya.

# Initialize Perceptron
p = Perceptron(learning_rate=0.1, epochs=10)

# Train the model
p.fit(X, y)

# Test the model
print("Predictions:", p.predict(X))

Output yang dijangkakan untuk get AND:

import numpy as np

---

Penjelasan Proses Pembelajaran Perceptron

1. Memulakan Berat dan Berat sebelah: Pada permulaan, pemberat ditetapkan kepada sifar, yang membolehkan model mula belajar dari awal.
2. Kira Output Linear: Untuk setiap titik data, Perceptron mengira jumlah wajaran input ditambah pincang.
3. Pengaktifan (Fungsi Langkah): Jika output linear lebih besar daripada atau sama dengan sifar, ia memberikan kelas 1; jika tidak, ia memberikan kelas 0.
4. Peraturan Kemas Kini: Jika ramalan tidak betul, model melaraskan berat dan berat sebelah ke arah yang mengurangkan ralat. Peraturan kemas kini diberikan oleh: berat = kadar_pembelajaran * (y_benar - y_pred) * x

Ini menjadikan kemas kini Perceptron hanya untuk mata tersalah klasifikasi, secara beransur-ansur menolak model lebih dekat kepada sempadan keputusan yang betul.

---

Menggambarkan Sempadan Keputusan

Visualkan sempadan keputusan selepas latihan. Ini amat membantu jika anda menggunakan set data yang lebih kompleks. Buat masa ini, kami akan memastikan perkara mudah dengan get AND.

---

Melanjutkan kepada Multi-Layer Perceptrons (MLPs)

Walaupun Perceptron terhad kepada masalah yang boleh dipisahkan secara linear, ia merupakan asas kepada rangkaian saraf yang lebih kompleks seperti Multi-Layer Perceptrons (MLP). Dengan MLP, kami menambah lapisan tersembunyi dan fungsi pengaktifan (seperti ReLU atau Sigmoid) untuk menyelesaikan masalah bukan linear.

---

Ringkasan

Perceptron ialah algoritma pembelajaran mesin yang mudah tetapi asas. Dengan memahami cara ia berfungsi dan melaksanakannya dari awal, kami mendapat cerapan tentang asas pembelajaran mesin dan rangkaian saraf. Keindahan Perceptron terletak pada kesederhanaannya, menjadikannya titik permulaan yang sempurna untuk sesiapa yang berminat dengan AI.

Atas ialah kandungan terperinci Melaksanakan Perceptron dari Scratch dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!