Простая нейронная сеть с использованием линейной алгебры и scala breeze

Ниже моя реализация нейронной сети с 1 входным слоем, двумя скрытыми слоями и 1 выходным слоем:

import breeze.linalg._
import breeze.math._
import breeze.numerics._

object NN extends App {

  //Forward propogation
  val x1 = DenseVector(1.0, 0.0, 1.0)
  val y1 = DenseVector(1.0, 1.0, 1.0)

  val theta1 = DenseMatrix((1.0, 1.0, 1.0), (1.0, 1.0, 0.0), (1.0, 0.0, 0.0));
  val theta2 = DenseMatrix((1.0, 1.0, 1.0), (1.0, 1.0, 0.0), (1.0, 0.0, 0.0));
  val theta3 = DenseMatrix((1.0, 1.0, 1.0), (1.0, 1.0, 0.0), (1.0, 0.0, 0.0));

  val a1 = x1;

  val z2 = theta1 * a1;
  val a2 = (z2.map { x => 1 + sigmoid(x) })

  val z3 = theta2 * a2;
  val a3 = (z3.map { x => 1 + sigmoid(x) })

  val z4 = theta3 * a3;
  val a4 = (z4.map { x => 1 + sigmoid(x) })

  //Back propagation
  val errorLayer4 = a4 - DenseVector(1.0, 1.0, 1.0)
  val errorLayer3 = (theta3.t * errorLayer4) :* (a3 :* (DenseVector(1.0, 1.0, 1.0) - a3))
  val errorLayer2 = (theta2.t * errorLayer3) :* (a2 :* (DenseVector(1.0, 1.0, 1.0) - a2))

  //Compute delta values
  val delta1 = errorLayer2 * a2.t
  val delta2 = errorLayer3 * a3.t
  val delta3 = errorLayer4 * a4.t


  //Gradient descent
  val m = 1
  val alpha = .0001
  val x = DenseVector(1.0, 0.0, 1.0)
  val y = DenseVector(1.0, 1.0, 1.0)

  val pz1 = delta1 - (alpha / m) * (x.t * (delta1 * x - y))
  val p1z1 = (sigmoid(delta1 * x)) + 1.0 
  println(p1z1);

  val pz2 = delta2 - (alpha / m) * (x.t * (delta2 * x - y))
  val p1z2 = (sigmoid(delta2 * p1z1)) + 1.0
  println(p1z2);

  val pz3 = delta3 - (alpha / m) * (x.t * (delta3 * x - y))
  val p1z3 = (sigmoid(delta3 * p1z2)) + 1.0
  println(p1z3);


}

Выход этой сети:

Jun 03, 2016 7:47:50 PM com.github.fommil.netlib.BLAS <clinit>
WARNING: Failed to load implementation from: com.github.fommil.netlib.NativeSystemBLAS
Jun 03, 2016 7:47:50 PM com.github.fommil.jni.JniLoader liberalLoad
INFO: successfully loaded C:\Users\Local\Temp\jniloader3606930058943197684netlib-native_ref-win-x86_64.dll
DenseVector(2.0, 2.0, 1.9999999999946196)
DenseVector(1.0, 1.0, 1.0000000064265646)
DenseVector(1.9971047766732295, 1.9968279599465841, 1.9942769808711798)

Я использую один обучающий пример 101 и выходное значение 111. Прогнозируемое значение, заданное 1,0,1, равно 1.9,1.9,1.9, когда прогнозируемое значение должно быть 1,1,1.

Я думаю, что то, как я вычисляю сигмоид со смещением, неверно, следует ли добавлять значение смещения +1 после вычисления сигмоида для слоя, другими словами, использовать { x => sigmoid(x+1) } вместо { x => 1 + sigmoid(x) }?


scala neural-network linear-algebra scala-breeze
person blue-sky    schedule 03.06.2016    source источник

Ответы (1)


arrow_upward
1
arrow_downward

Выход нейрона в стиле персептрона — сигмоид (сумма (xi * wi)), где вход смещения x0 равен 1, но вес не обязательно равен 1. Вы определенно не суммируете 1 за пределами сигмоида, но вы также не суммируйте это внутри. Вам нужен вес. Таким образом, это должно быть эквивалентно

sigmoid(w0 + w1*x1 + w2*x2 + ...)
person Rex Kerr    schedule 03.06.2016
comment
«сигмоид (w0 + w1 * x1 + w2 * x2 + ...)» должен быть «сигмоид (w0x0 + w1 * x1 + w2 * x2 + ...)», где x0 равно 1, а w0 является случайным значением? Если нет, то где рассчитывается смещение? - person blue-sky; 03.06.2016
comment
@blue-sky - w0 следует выбирать, однако вы выбираете другие начальные веса. w0*x0 = w0*1 = w0, так что не должно быть -- то, что вы написали, есть то, что написал я. - person Rex Kerr; 04.06.2016