标签: perceptron

我是matplotlib的新手,正在研究简单的项目以熟悉它.我想知道如何绘制决策边界,它是形式[w1,w2]的权重向量,它基本上将两个类分开,比如说C1和C2,使用matplotlib.

是否像绘制从(0,0)到点(w1,w2)的线一样简单(因为W是权重"向量")如果是这样的话,如果需要,如何在两个方向上扩展它？

现在我所做的只是:

 import matplotlib.pyplot as plt
   plt.plot([0,w1],[0,w2])
   plt.show()

提前致谢.

我是TensorFlow 的新手。我寻找了使用 tensorflow 实现多层感知器的示例，但我只 得到了关于 MNIST 图像数据集的示例，除了 MNIST 之外，我能否使用相同的优化和成本函数构建神经网络模型并训练数据数字格式，意思是，我可以使用 tensorflow 训练我自己的数字数据集吗？

有没有训练新数据集的例子？.

使用PyTorch nn.Sequential模型,我无法学习XOR布尔值的所有四种表示:

import numpy as np

import torch
from torch import nn
from torch.autograd import Variable
from torch import FloatTensor
from torch import optim

use_cuda = torch.cuda.is_available()

X = xor_input = np.array([[0,0], [0,1], [1,0], [1,1]])
Y = xor_output = np.array([[0,1,1,0]]).T

# Converting the X to PyTorch-able data structure.
X_pt = Variable(FloatTensor(X))
X_pt = X_pt.cuda() if use_cuda else X_pt
# Converting the Y to PyTorch-able data structure.
Y_pt = Variable(FloatTensor(Y), requires_grad=False)
Y_pt = Y_pt.cuda() if use_cuda else Y_pt

hidden_dim = …

我理解感知器只能在线性可分离的集合上正常工作,比如NAND,AND和OR函数的输出.我一直在阅读维基百科关于感知器的条目,并开始使用它的代码.

XOR是单层感知器失败的情况,因为它不是线性可分离的集合.

#xor
print ("xor")
t_s           = [((1, 1, 1), 0), ((1, 0, 1), 1), ((1, 1, 0), 1), ((1, 1, 1), 0)] 


threshold     = 0.5
learning_rate = 0.1
w             = [0, 0, 0]

def dot_product(values, weights):
    return sum(value * weight for value, weight in zip(values, weights))

def train_perceptron(threshold, learning_rate, weights, training_set):
    while True:
        #print('-' * 60)
        error_count = 0

        for input_vector, desired_output in training_set:
            #print(weights)
            result = dot_product(input_vector, weights) > threshold
            error  = desired_output - result

            if …

我刚刚开始了一个机器学习课,我们去了Perceptrons.对于家庭作业,我们应该:"选择适当的训练和测试两个维度的数据集(平面).使用10个数据点进行训练,5个进行测试."然后我们应该编写一个程序,使用感知器算法和输出:

• 关于训练数据点是否可线性分离的评论
• 关于测试点是否可线性分离的评论
• 你最初选择的权重和常数
• 最终解方程(决策边界)
• 您的算法所做的权重更新总数
• 在训练集上进行的迭代总数
• 对训练数据以及测试数据的最终错误分类错误(如果有的话)

我已经多次阅读了本书的第一章,但我仍然无法完全理解感知器.

我知道你改变了权重,如果一个点被错误分类,直到没有错误分类,我想我无法理解的是

1. 我如何使用测试数据以及它与训练数据的关系如何？
2. 我怎么知道一个点是否被错误分类？
3. 如何选择测试点,训练点,阈值或偏差？

如果没有我的书提供好的例子,我真的很难知道如何构成其中的一个.你可以告诉我,我很失落,任何帮助都会非常感激.

我有关于NN的训练数据以及预期的输出。每个输入都是10维向量，并具有1个预期输出。我已经使用高斯对训练数据进行了归一化，但是由于它只有一维，所以我不知道如何对输出进行归一化。有任何想法吗？

例：

原始输入向量： -128.91，71.076，-100.75,4.2475，-98.811，77.219，4.4096，-15.382，-6.1477，-361.18

归一化输入向量： -0.6049、1.0412，-0.3731、0.4912，-0.3571、1.0918、0.4925、0.3296、0.4056，-2.5168

上述输入的原始预期输出为1183.6，但我不知道如何将其标准化。我是否应该将预期输出标准化为输入向量的一部分？

代码如下。
问题是，这optimizer.step()部分不起作用。我model.parameters()在训练前后打印，权重不变。

我正在尝试制作一个可以解决 AND 问题的感知器。我已经用我自己的小库成功地做到了这一点，我在其中实现了一个具有两个函数的感知器predict()和train().

澄清一下，我刚刚开始使用 PyTorch 学习深度学习，所以这可能是一个非常新手的问题。我试过寻找解决方案，但没有运气。我还将我的代码与其他有效的代码进行了比较，但我不知道我做错了什么。

import torch
from torch import nn, optim
from random import randint

class NeuralNet(nn.Module):
  def __init__(self):
    super(NeuralNet, self).__init__()
    self.layer1 = nn.Linear(2, 1)

  def forward(self, input):
    out = input
    out = self.layer1(out)
    out = torch.sign(out)
    out = torch.clamp(out, 0, 1) # 0=false, 1=true
    return out

data = torch.Tensor([[0, 0], [0, 1], [1, 0], [1, 1]])
target = torch.Tensor([0, 0, 0, 1])
model = NeuralNet()
epochs = …

我正在尝试使用Perceptron执行监督分类,从而执行句子的POS标记.我现在假设每个单词的标签都是独立的.(即我只使用这个词作为一个特征).我对机器学习算法相当新,所以我无法弄清楚如何为每个单词表示特征函数.

我有一个100个句子的训练集,每个单词都有一个特定的标签(比如N,V,J(形容词)等等).例如,

Jack(N)和(&)Jill(N)去了(PR)秘鲁(N)

标签在括号中的位置.假设我总共有10个可能的标签.现在我的问题是杰克这个词的特征向量是怎样的？

我非常感兴趣将它作为向量实现,因为我的代码将更好地匹配符号.一旦我弄清楚功能函数的外观,我将能够实现Perceptron算法!

另外,我想添加像(a)首字母大写的功能吗？(b)单词是否连字符等,如何将其合并到我的特征向量中？

直观地说,我可以看到向量只需要二进制值,但我无法超越它.

如果可能的话,请尝试用具体的例子来解释!

如果不存在偏差,通过原点的线应该能够线性分离两个数据集,这不是真的吗？

但最受欢迎的答案是这个 - >> 问题说

y                             
^                              
|  - + \\  +                   
| -    +\\ +   +               
| - -    \\ +                  
| -  -  + \\  +                
---------------------> x       
    stuck like this            

我很困惑.你是说上图中的原点是在x轴和y轴中间的某个位置吗？有人可以帮助我澄清一下吗？

在大多数关于感知器的学习材料中，感知器是这样定义的。

如果 w ，则输出 = 1。x + b > 0 输出 = 0 如果 w 。x + b <= 0

（上面公式中的点“.”代表点积。）

在我见过的大多数 NAND 感知器示例中，NAND 感知器的定义如下：

• w = [-2, -2], b = 3（来源：http : //neuralnetworksanddeeplearning.com/chap1.html）
• w = [-1, -1], b = 1.5（来源：http : //users.monash.edu/~app/CSE5301/Lnts/LbD.pdf）
• w = [-0.6, -0.6], b = 1（来源：http : //toritris.weebly.com/perceptron-2-logical-operations.html）

我将我的 NAND 感知器定义如下。

• w = [-1, -1], b = 2

这是它像 NAND 感知器一样工作的证据。

x0 x1 | w0 * x0 + w1 * …

在构建简单的感知器神经网络时，我们通常将格式输入的二维矩阵传递给二维权(batch_size,features)重矩阵，类似于numpy 中的这个简单神经网络。我一直假设神经网络的感知器/密集/线性层只接受 2D 格式的输入并输出另一个 2D 输出。但是最近我遇到了这个 pytorch 模型，其中一个 Linear 层接受一个 3D 输入张量并输出另一个 3D 张量 ( o1 = self.a1(x))。

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.a1 = nn.Linear(4,4)
        self.a2 = nn.Linear(4,4)
        self.a3 = nn.Linear(9,1)
    def forward(self,x):
        o1 = self.a1(x)
        o2 = self.a2(x).transpose(1,2)
        output = torch.bmm(o1,o2)
        output = output.view(len(x),9)
        output = self.a3(output)
        return output

x = torch.randn(10,3,4)
y = torch.ones(10,1)

net = Net()

criterion …

以下文字来自HalDaumé三世的" 机器学习课程 "在线教科书(第41页).

据我所知,D=输入向量的大小.

(1)这是什么样的Perceptron算法？二级/多级？在线/离线？

(2)这是什么y？偏置/重量/样品/ class_label？

(3)测试ya<=0更新砝码的理由是什么？

编辑.

y 是class_label.

对于单层神经网络的实现,我有两个数据文件.

In:
    0.832 64.643
    0.818 78.843

Out:
    0 0 1
    0 0 1

以上是2个数据文件的格式.

目标输出为"1表示相应输入所属的特定类,"0表示其余2个输出.

问题如下:

您的单层神经网络将在Y = A*X + b中找到A(3乘2矩阵)和b(3乘1矢量),其中Y是[C1,C2,C3]',X是[x1,x2]' .

为了用神经网络解决上述问题,我们可以重新编写如下公式:Y = A'*X'其中A'= [A b](3乘3矩阵),X'是[x1,x2, 1]"

现在您可以使用具有三个输入节点(分别用于x1,x2和1)和三个输出(C1,C2,C3)的神经网络.

由此产生的9(因为我们在3个输入和3个输出之间有9个连接)权重将等同于A'矩阵的元素.

基本上,我试图做这样的事情,但它不起作用:

function neuralNetwork   
    load X_Q2.data
    load T_Q2.data
    x = X_Q2(:,1);
    y = X_Q2(:,2);

    learningrate = 0.2;
    max_iteration = 50;

    % initialize parameters
    count = length(x);
    weights = rand(1,3); % creates a 1-by-3 array with random weights
    globalerror = 0;
    iter = 0;
    while globalerror ~= 0 && iter <= max_iteration …