Question

我正在尝试教授简单的单神经元感知器以识别1的重复序列。

这是我用来教它的数据：

learning_signals = [
  [[1, 1, 0, 0], 1],
  [[1, 1, 0, 1], 1],
  [[1, 1, 1, 0], 1],

  [[0, 1, 1, 0], 1],
  [[0, 1, 1, 1], 1],


  [[0, 0, 1, 1], 1],
  [[1, 0, 1, 1], 1],

  [[0, 0, 0, 0], 0],
  [[1, 0, 0, 0], 0],
  [[0, 1, 0, 0], 0],
  [[0, 0, 1, 0], 0],
  [[0, 0, 0, 1], 0],

  [[1, 0, 1, 0], 0],
  [[1, 0, 0, 1], 0],
  # [[0, 1, 0, 1], 0],

这是学习模板的数组，每个模板都是数据数组和该数据的正确结果。

如你所见。最后一行评论 - 如果我取消注释 - perceptron将无法学习。没有它感知器在“0101”的情况下不能正常工作。所以问题是：

这个任务可以用单个神经元感知器来解决，还是应该使用少量分层感知器？
如何通过如此简单的感知器确定哪些任务可以解决？是否有任何规则可以应用于我的任务，并说可以用简单的感知器来完成？

这是用coffeescript写的感知器代码：

class window.Perceptron
  weights: []
  calc: (signal) ->
    @neuron.calc signal
  adjust: ->
  foo: 0.1
  calc: (signal) ->
    sum = 0
    for s, i in signal
      sum += s*@weights[i]
    if sum>0.5 then return 1 else return 0
    sum
  learn: (templates) ->
    @weights = []
    for i in [1..templates[0][0].length]
      @weights.push Math.random()

    li = 0
    max_li = 50000
    console.log @weights
    while true
      gerror = 0
      li++
      for template, i in templates
        res = @calc template[0]
        # console.log "result: #{res}"
        error = template[1] - res
        gerror += Math.abs error
        for weight, i in @weights
          @weights[i] += @foo*error*template[0][i]
      if ((gerror == 0) || li > max_li) then break
    if gerror == 0
      console.log "Learned in #{li} iterations"
    else
      console.log "Learning failed after #{max_li} iterations"
    console.log @weights

哪些任务可以简单的感知器执行？

0 个答案: