单层感知器python

单层感知器，也称为阈值逻辑单元（Threshold Logic Unit）或线性可分神经网络，是最简单的神经网络模型之一。在Python中，我们可以使用像`scikit-learn`这样的库来实现单层感知器。它是监督学习中的基本分类算法，主要用于二分类问题。

以下是使用`scikit-learn`实现单层感知器的基本步骤：

1. 导入所需的库：

from sklearn.linear_model import Perceptron
from sklearn.model_selection import train_test_split
import numpy as np

2. 准备数据（假设有一个二维特征数组X和对应的标签y）：

X = ... # 输入特征数据
y = ... # 输出标签数据

3. 划分训练集和测试集：

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

4. 创建并训练模型：

model = Perceptron(random_state=42)
model.fit(X_train, y_train)

5. 预测和评估性能：

y_pred = model.predict(X_test)
accuracy = model.score(X_test, y_test)

相关问题

机器学习单层感知器网络

### 单层感知器网络的概念

单层感知器是一种基本的人工神经网络模型，用于解决线性分类问题。这种类型的网络模仿生物神经系统的工作方式，其中每个神经元接收多个输入并产生一个输出[^2]。

### 工作原理

在一个简单的单层感知器中，信号通过权重连接从输入节点传递至输出节点。这些权重代表了不同特征的重要性程度。一旦所有加权后的输入被汇总起来之后，会应用激活函数来决定最终的输出值。对于二分类任务来说，通常采用的是阶跃函数作为激活函数：

\[
f(x)= \begin{cases}
1 & x >= 0 \\
0 & x < 0
\end{cases}
\]

这意味着如果总输入大于或等于零，则输出为正类；反之则属于负类[^3]。

### Python 实现示例

下面给出了一段基于上述理论构建单层感知器的学习算法Python代码：

import numpy as np

class Perceptron(object):

    def __init__(self, eta=0.01, n_iter=50, 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=1 + X.shape[1])
        self.errors_ = []

        for _ in range(self.n_iter):
            errors = 0
            for xi, target in zip(X, y):
                update = self.eta * (target - self.predict(xi))
                self.w_[1:] += update * xi
                self.w_[0] += update
                errors += int(update != 0.0)
            self.errors_.append(errors)
        return self

    def net_input(self, X):
        """Calculate net input"""
        return np.dot(X, self.w_[1:]) + self.w_[0]

    def predict(self, X):
        """Return class label after unit step"""
        return np.where(self.net_input(X) >= 0.0, 1, -1)

# Example usage:
# from sklearn import datasets
# iris = datasets.load_iris()
# X = iris.data[:100, [0, 2]] # we only take the first two features.
# y = iris.target[:100]
# ppn = Perceptron(eta=0.1, n_iter=10)
# ppn.fit(X, y)

这段代码定义了一个`Perceptron`类，它实现了单层感知器的功能，并提供了拟合(`fit`)和预测(`predict`)的方法。这里还展示了如何计算净输入以及更新权重的过程[^1]。

实现了单层感知器，用于多类分类。

在文档《俄罗斯联邦交通部.docx》中，确实实现了一个单层感知器，用于多类分类。以下是该部分的详细内容：

### 感知器实现

#### 1. 导入库
使用 `numpy` 和 `random` 库进行数学计算和随机值生成：

import numpy as np
import random

#### 2. 激活函数
使用 `sigmoid` 函数及其导数：

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

#### 3. 感知器类
实现用于多类分类的单层感知器：

class Perceptron:
    def __init__(self, input_size, output_size, lr=0.1):
        self.weights = np.random.rand(input_size, output_size)
        self.bias = np.random.rand(output_size)
        self.lr = lr

    def predict(self, inputs):
        weighted_sum = np.dot(inputs, self.weights) + self.bias
        output = sigmoid(weighted_sum)
        return output

    def train(self, training_inputs, labels, epochs=10000):
        for _ in range(epochs):
            for inputs, label in zip(training_inputs, labels):
                prediction = self.predict(inputs)
                error = label - prediction
                self.weights += self.lr * np.outer(inputs, error * sigmoid_derivative(prediction))
                self.bias += self.lr * (error * sigmoid_derivative(prediction))

#### 4. 数字的参考图像
每个数字表示为 15 长的一维数组：

digits = {
    0: np.array([1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1]),
    1: np.array([0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1]),
    2: np.array([1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0]),
    3: np.array([1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1]),
    4: np.array([1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0]),
    5: np.array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1]),
    6: np.array([1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1]),
    7: np.array([1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0]),
    8: np.array([1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1]),
    9: np.array([1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1])
}

#### 5. 添加噪声
随机反转一定数量的像素，以创建有噪点的图像：

def add_noise(digit, noise_level):
    noisy_digit = digit.copy()
    noise_indices = random.sample(range(len(digit)), noise_level)
    for idx in noise_indices:
        noisy_digit[idx] = 1 - noisy_digit[idx]
    return noisy_digit

#### 6. 准备用于训练的数据
输入数据是从 0 到 9 的数字数组，标签以 one-hot 编码格式创建：

training_inputs = np.array([digits[i] for i in range(10)])
labels = np.eye(10)

#### 7. 感知器训练
创建并训练 `Perceptron` 类的实例：

perceptron = Perceptron(input_size=15, output_size=10)
perceptron.train(training_inputs, labels)

#### 8. 噪点图像检测
向图像添加噪声，并使用经过训练的感知器进行分类：

def recognize_digit_with_noise(digit_index, noise_level):
    original_digit = digits[digit_index]
    noisy_digit = add_noise(original_digit, noise_level)
    prediction = perceptron.predict(noisy_digit)
    recognized_digit = np.argmax(prediction)
    return recognized_digit

#### 9. 基本测试
用户输入一个数字进行识别，程序会执行一系列测试，以评估网络对图像的噪声版本的抵抗力：

reps = 1000
goals = 0
noise_level = 1
test_digit = int(input("输入你想要识别的数字\n"))
for i in range(reps):
    recognized_digit = recognize_digit_with_noise(test_digit, noise_level)
    if recognized_digit == test_digit:
        goals += 1
print(f"C 干扰水平 {noise_level} 由 {reps} 中的 {goals} 精确确定")

这个实现展示了如何使用单层感知器进行多类分类，并评估其在有噪声条件下的性能。