Files
ai_lessons/pr03/task.ipynb
T
2026-10-29 23:24:10 +05:00

106 KiB

In [5]:
import numpy as np
import matplotlib.pyplot as plt

class Perceptron:
    def __init__(self, eta=0.1, n_iter=100, random_state=1):
        self.eta = eta
        self.n_iter = n_iter
        self.random_state = random_state

    def fit(self, X, y):
        rgen = np.random.RandomState(self.random_state)
        self.w_ = rgen.normal(loc=0.0, scale=0.01, size=X.shape[1])
        self.b_ = 0.0
        self.errors_ = []

        for _ in range(self.n_iter):
            errors = 0
            for xi, target in zip(X, y):
                y_pred = 1 if self.net_input(xi) >= 0.0 else 0
                update = self.eta * (target - y_pred)

                self.w_ += update * xi
                self.b_ += update

                if update != 0.0:
                    errors += 1

            self.errors_.append(errors)
            if errors == 0:
                break

        return self

    def net_input(self, X):
        return np.dot(X, self.w_) + self.b_

    def predict(self, X):
        return np.where(self.net_input(X) >= 0.0, 1, 0)


X = np.array([
    [0,0],
    [0,1],
    [1,0],
    [1,1]
])

y_and = np.array([0,0,0,1])
y_or = np.array([0,1,1,1])
y_xor = np.array([0,1,1,0])

for name, y in [('AND', y_and), ('OR', y_or), ('XOR', y_xor)]:
    ppn = Perceptron(eta=0.1, n_iter=20, random_state=1)
    ppn.fit(X,y)

    print(f'--- {name} ---')
    print('Веса:', ppn.w_)
    print('Смещение:', ppn.b_)
    print('Предсказание:', ppn.predict(X))
    print('Ошибки по эпохам:', ppn.errors_)
    print()
--- AND ---
Веса: [0.11624345 0.09388244]
Смещение: -0.2
Предсказание: [0 0 0 1]
Ошибки по эпохам: [2, 3, 1, 0]

--- OR ---
Веса: [0.11624345 0.19388244]
Смещение: -0.1
Предсказание: [0 1 1 1]
Ошибки по эпохам: [2, 2, 2, 1, 0]

--- XOR ---
Веса: [-0.08375655 -0.00611756]
Смещение: 0.0
Предсказание: [1 0 0 0]
Ошибки по эпохам: [3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]

In [7]:
ppn = Perceptron(eta=0.1, n_iter=20, random_state=1)
ppn.fit(X, y_xor)

plt.plot(range(1, len(ppn.errors_) + 1), ppn.errors_, marker='o')
plt.xlabel("Epoch")
plt.ylabel("Error figures")
plt.title("Обучение перцептрона для OR")
plt.grid(True)
plt.show()
In [10]:
def plot_decision_boundary(X,y,model):

    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5

    xx, yy = np.meshgrid(
        np.arange(x_min, x_max, 0.02),
        np.arange(y_min, y_max, 0.02)
    )

    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    plt.contourf(xx, yy, Z, alpha=0.3, cmap='bwr')
    plt.scatter(X[:,0], X[:,1], c=y, cmap='bwr', edgecolors='k')
    plt.xlabel('x1')
    plt.ylabel('x2')
    plt.title("Разделяющая граница")

    plt.show()

ppn = Perceptron(eta=0.1, n_iter=20, random_state=1)
ppn.fit(X, y_or)
plot_decision_boundary(X, y_or, ppn)
In [11]:
from sklearn.datasets import make_blobs

X_blobs, y_blobs = make_blobs(
    n_samples=100,
    centers=[[0,0], [2,2]],
    cluster_std=0.5,
    random_state=1
)

ppn = Perceptron(eta=0.1, n_iter=50, random_state=1)
ppn.fit(X_blobs, y_blobs)

plot_decision_boundary(X_blobs, y_blobs, ppn)

Контрольные вопросы

  1. Однослойный перцептрон - самая простая модель искуственной нейронной сети, предназначенная для решения задачи бинарной классификации (разделение на два класса)
  2. Сначала ищет взвешенную сумму весов (w) и входноых данных (x) и передает их в функцию активации.
  3. Используется жёсткая пороговая функция. f(z) = 1 если z>=0, 0 если z<0
  4. Как и всегда - вычисляется предсказание, вычислается ошибка, веса и смещения корректируются.
  5. Скорость обучения это параметр, который задает величину шага корректировки весов на каждой ошибке. Черезмерно большой шаг ведет к расходимости, слишком маленький к увеличению времени обучения и риску застрять в области неоптимальных значений
  6. Потому что однослойный перцептрон может построить только одну разделяющую границу (как на графике сверху). В XOR невохможно разделить 0,1 1,0 от 1,1 0,0 одной линией.
  7. Если данные не линейно разделимы то перцептрон не сойдется, т.е цикл обновления весов бут бесконечным.
  8. Смещение позволяет двигаться относительно начала координат ( в нашем случае сдвиг вверх), если не будет смещения то прямая будет проходить точно через центр координат (0,0), а если классы будут требовать разделения не от начала координат, то перцептрон не сможет их разделить.
  9. если на обучении не будет ошибок, провести вычисление метрик Acc, Precision и Recall с F1 мерой для валидационных (тестовых) данных, которых модель не видела.