使用Matlab对 P=[0.1 0.7 0.8 0.8 1.0 0.3 0.0 -0.3 -0.5 -1.5; 1.2 1.8 1.6 0.6 0.8 0.5 0.2 0.8 -1.5 -1.3]; T=[ 1 1 1 0 0 1 1 1 0 0; 0 0 0 0 0 1 1 1 1 1]的输入输出矢量进行多神经元分类，采用感知器算法、BP神经网络算法、RBF神经网络算法、和自组织神经网络算法进行多神经元分类，要求画出最后的线形图。不使用工具箱。

感知器算法：

首先，我们需要对 P 和 T 进行归一化处理，将每一列的值都减去该列的平均值，然后除以该列的标准差。这是因为感知器算法对于输入数据的范围很敏感，而归一化处理可以将数据映射到一个相对较小的范围内，有利于算法的收敛。

接着，我们需要初始化感知器的权重矩阵 W 和阈值 b，可以随机生成一些小数作为初始值。然后，我们可以使用以下算法进行训练：

1. 随机从 P 中选取一个样本 x，并将其输入到感知器中，计算输出 y。

2. 如果 y 大于等于 0，则将该样本标记为类别 1，否则标记为类别 0。

3. 如果 y 与该样本的真实类别不一致，则更新权重矩阵和阈值：

W = W + α * x * (t - y)'
b = b + α * (t - y)

其中，α 是学习率，t 是该样本的真实类别。

4. 重复上述步骤，直到所有样本都被正确分类或达到最大迭代次数。

下面是感知器算法的 Matlab 代码实现：

% 归一化处理
P_norm = (P - mean(P, 2)) ./ std(P, 0, 2);

% 初始化权重矩阵和阈值
W = rand(size(T, 1), size(P_norm, 1));
b = rand(size(T, 1), 1);

% 训练感知器
max_iter = 1000;
alpha = 0.1;

for i = 1:max_iter
% 随机选取一个样本
idx = randi(size(P_norm, 2));
x = P_norm(:, idx);
t = T(:, idx);

% 计算输出
y = W * x + b;

% 更新权重矩阵和阈值
if y >= 0
y = 1;
else
y = 0;
end

if sum(abs(y - t)) > 0
W = W + alpha * (t - y) * x';
b = b + alpha * (t - y);
end

% 检查是否所有样本都被正确分类
if sum(abs(sign(W * P_norm + b) - T)) == 0
break;
end
end

% 画出最后的线性分类器
x = linspace(min(P_norm(1, :)), max(P_norm(1, :)), 100);
y = (-b(1) - W(1, 1) * x) / W(1, 2);
plot(x, y, 'r');
hold on;
y = (-b(2) - W(2, 1) * x) / W(2, 2);
plot(x, y, 'b');
title('Perceptron Algorithm');
xlabel('Feature 1');
ylabel('Feature 2');
legend('Class 1', 'Class 2');

BP神经网络算法：

BP神经网络算法需要先设计神经网络的结构，包括输入层、隐藏层和输出层的节点数，以及每个节点之间的连接权重。我们可以随机生成一些小数作为初始权重值。然后，我们可以使用以下算法进行训练：

1. 将一个样本 x 输入到神经网络中，计算输出 y。

2. 计算输出层的误差 E_out：

E_out = (t - y) .* y .* (1 - y)

其中，t 是该样本的真实类别。

3. 反向传播误差，计算隐藏层的误差 E_hid：

E_hid = W_out' * E_out .* y_hid .* (1 - y_hid)

其中，W_out 是输出层和隐藏层之间的连接权重，y_hid 是隐藏层的输出。

4. 更新连接权重：

W_out = W_out + α * y_hid * E_out'
W_hid = W_hid + α * x * E_hid'

其中，α 是学习率。

5. 重复上述步骤，直到所有样本都被正确分类或达到最大迭代次数。

下面是BP神经网络算法的 Matlab 代码实现：

% 归一化处理
P_norm = (P - mean(P, 2)) ./ std(P, 0, 2);

% 设计神经网络结构
n_input = size(P_norm, 1);
n_hidden = 5;
n_output = size(T, 1);

% 初始化连接权重
W_hid = rand(n_hidden, n_input);
W_out = rand(n_output, n_hidden);
b_hid = rand(n_hidden, 1);
b_out = rand(n_output, 1);

% 训练神经网络
max_iter = 1000;
alpha = 0.1;

for i = 1:max_iter
% 随机选取一个样本
idx = randi(size(P_norm, 2));
x = P_norm(:, idx);
t = T(:, idx);

% 计算输出
y_hid = 1 ./ (1 + exp(-(W_hid * x + b_hid)));
y_out = 1 ./ (1 + exp(-(W_out * y_hid + b_out)));

% 计算误差
E_out = (t - y_out) .* y_out .* (1 - y_out);
E_hid = (W_out' * E_out) .* y_hid .* (1 - y_hid);

% 更新连接权重
W_out = W_out + alpha * y_hid * E_out';
W_hid = W_hid + alpha * x * E_hid';
b_out = b_out + alpha * E_out;
b_hid = b_hid + alpha * E_hid;

% 检查是否所有样本都被正确分类
if sum(abs(sign(W_out * (1 ./ (1 + exp(-(W_hid * P_norm + b_hid)))) + b_out) - T)) == 0
break;
end
end

% 画出最后的线性分类器
x = linspace(min(P_norm(1, :)), max(P_norm(1, :)), 100);
y = (-b_out(1) - W_out(1, 1) * (1 ./ (1 + exp(-(W_hid(1, :) * x + b_hid(1)))))) / W_out(1, 2);
plot(x, y, 'r');
hold on;
y = (-b_out(2) - W_out(2, 1) * (1 ./ (1 + exp(-(W_hid(2, :) * x + b_hid(2)))))) / W_out(2, 2);
plot(x, y, 'b');
title('BP Neural Network Algorithm');
xlabel('Feature 1');
ylabel('Feature 2');
legend('Class 1', 'Class 2');

RBF神经网络算法：

RBF神经网络算法需要先选择一些基函数，比如高斯函数，作为隐藏层节点的函数。我们可以随机选择一些样本作为基函数的中心点，并将每个样本的输出类别作为基函数的权重。然后，我们可以使用以下算法进行训练：

1. 将一个样本 x 输入到神经网络中，计算输出 y。

2. 计算输出层的误差 E_out：

E_out = t - y

其中，t 是该样本的真实类别。

3. 计算隐藏层的输出 y_hid：

y_hid(i) = exp(-||x - c(i)||^2 / (2 * σ^2))

其中，c(i) 是第 i 个基函数的中心点，σ 是高斯函数的标准差。

4. 更新连接权重：

W = pinv(Y) * E_out

其中，Y 是隐藏层的输出矩阵。

5. 重复上述步骤，直到所有样本都被正确分类或达到最大迭代次数。

下面是RBF神经网络算法的 Matlab 代码实现：

% 归一化处理
P_norm = (P - mean(P, 2)) ./ std(P, 0, 2);

% 选择基函数
n_hidden = 5;
idx = randperm(size(P_norm, 2), n_hidden);
c = P_norm(:, idx);

% 初始化连接权重
sigma = 1;
Y = zeros(n_hidden, size(P_norm, 2));
for i = 1:size(P_norm, 2)
for j = 1:n_hidden
Y(j, i) = exp(-norm(P_norm(:, i) - c(:, j))^2 / (2 * sigma^2));
end
end
W = pinv(Y) * T';

% 训练神经网络
max_iter = 1000;
alpha = 0.1;

for i = 1:max_iter
% 随机选取一个样本
idx = randi(size(P_norm, 2));
x = P_norm(:, idx);
t = T(:, idx);

% 计算输出
y_hid = zeros(n_hidden, 1);
for j = 1:n_hidden
y_hid(j) = exp(-norm(x - c(:, j))^2 / (2 * sigma^2));
end
y_out = W' * y_hid;

% 计算误差
E_out = t - y_out;

% 更新连接权重
for j = 1:n_hidden
W(j, :) = W(j, :) + alpha * E_out * y_hid(j);
end

% 检查是否所有样本都被正确分类
if sum(abs(sign(W' * exp(-pdist2(c', P_norm').^2 / (2 * sigma^2))) - T)) == 0
break;
end
end

% 画出最后的线性分类器
x = linspace(min(P_norm(1, :)), max(P_norm(1, :)), 100);
y = (-W(1, 1) - W(2, 1) * exp(-norm(x - c(:, 1))^2 / (2 * sigma^2))) / W(3, 1);
plot(x, y, 'r');
hold on;
y = (-W(1, 2) - W(2, 2) * exp(-norm(x - c(:, 2))^2 / (2 * sigma^2))) / W(3, 2);
plot(x, y, 'b');
title('RBF Neural Network Algorithm');
xlabel('Feature 1');
ylabel('Feature 2');
legend('Class 1', 'Class 2');

自组织神经网络算法：

自组织神经网络算法需要先选择一些节点作为初始网络的节点，并随机生成一些小数作为初始权重值。然后，我们可以使用以下算法进行训练：

1. 将一个样本 x 输入到神经网络中，找到与其最近的节点 i。

2. 更新节点 i 和其周围节点的权重：

W(i) = W(i) + α * (x - W(i))
W(j) = W(j) + β * (x - W(j))

其中，α 和 β 是学习率，j 是与节点 i 相邻的节点。

3. 重复上述步骤，直到所有样本都被正确分类或达到最大迭代次数。

下面是自组织神经网络算法的 Matlab 代码实现：

% 归一化处理
P_norm = (P - mean(P, 2)) ./ std(P, 0, 2);

% 初始化神经网络
n_nodes = 5;
W = rand(n_nodes, size(P_norm, 1));

% 训练神经网络
max_iter = 1000;
alpha = 0.1;
beta = 0.2;
sigma = 1;

for i = 1:max_iter
% 随机选取一个样本
idx = randi(size(P_norm, 2));
x = P_norm(:, idx);

% 找到与 x 最近的节点
dist = pdist2(x', W');
[~, i] = min(dist);

% 更新节点权重
for j = 1:n_nodes
if j == i
W(j, :) = W(j, :) + alpha * (x - W(j, :));
elseif dist(j) < sigma
W(j, :) = W(j, :) + beta * (x - W(j, :));
end
end

% 检查是否所有样本都被正确分类
if sum(abs(sign(W * P_norm') - T)) == 0
break;
end
end

% 画出最后的线性分类器
x = linspace(min(P_norm(1, :)), max(P_norm(1, :)), 100);
y = (-W(1, 1) - W(1, 2) * x) / W(1, 3);
plot(x, y, 'r');
hold on;
y = (-W(2, 1) - W(2, 2) * x) / W(2, 3);
plot(x, y, 'b');
title('SOM Neural Network Algorithm');
xlabel('Feature 1');
ylabel('Feature 2');
legend('Class 1', 'Class 2');