java - 自动编码器学习所有样本的平均值

问题描述

我是一名编程爱好者，正在学习如何从头开始编写自动编码器。我已经尝试为线性回归问题和非线性数据分类制作简单的神经网络，所以我认为这不会那么难。我到了我的自动编码器学习它最好的地步，但输出是所有输入的平均值，比如这两个：

这是输出：

如果您想观看它的培训视频，请点击此处： https ://youtu.be/w8mPVj_lQWI

如果我添加所有其他 17 个样本（另一批数字 1 和 2），它也会变成涂片，看起来也很平均：

我将我的网络设计为 3 层，有 64 个输入神经元（输入是一个 4096 维向量，指的是 64x64 图像样本），瓶颈部分有 8 个神经元（第二层），输出 4096 个神经元，一个一个对应一个最终输出的维度。

我使用 tanh 作为我的激活函数（最后一层除外，它使用线性激活）和反向传播作为学习算法，从输出层神经元计算偏导数，返回到输入神经元。

左上角是输入图像，中间是输出图像。所有值的范围从 -1 到 1（由于 tanh 激活），其中 1 表示白色，0 及以下表示黑色。

输出图像是在 2 张图像的 12k epochs 之后生成的，即学习率为 5*10-e6。

一个有趣的发现是，如果我将学习率提高到 0.001，输出显然会变成 1 或 2，但顺序错误。看看这个视频：https ://youtu.be/LyugJx8RiJ8

我可以尝试在 5 层神经网络上进行训练，但它做同样的事情。

您能想到我编写的代码可能存在的任何问题吗？我没有使用任何预制库，一切从头开始，读取像素和东西。如果有帮助，这是我在处理中的代码（尽管它很多而且有点混乱）：

class Nevron{

    public double w[];
    public double a;
    public double z;
    public double b;
    public double der;
    public double derW;
    public double derB;
    public double lr = 0.00001;

    public Nevron(int stVhodov){
      w = new double[stVhodov];
      a = 0;
      z = 0;
      der = 0;
      for(int i = 0; i < w.length; i++){
        w[i] = random(-1, 1);
      }
      b = random(-1, 1);
    }

    public void answer(double []x){
      a = 0;
      z = 0;
      for(int i = 0; i < x.length; i++){
        z = z + x[i]*w[i];
      }
      z += b;
      a = Math.tanh(z);
    }


    public void answer(layer l){
      a = 0;
      z = 0;
      for(int i = 0; i < l.nevron.length; i++){
          z = z + l.nevron[i].a*w[i];
      }
      z += b;
      a = Math.tanh(z);
    }

    public void answerOut(layer l){
      a = 0;
      z = 0;
      for(int i = 0; i < l.nevron.length; i++){
          z = z + l.nevron[i].a*w[i];
      }
      z += b;
      a = z;
    }

    public void changeWeight(layer l){
      for(int i = 0; i < l.nevron.length; i++){
        w[i] = w[i] - der * lr * l.nevron[i].a;
        b = b - der * lr;
      }
      der = 0;
    }

    public void changeWeight(double []x){
      for(int i = 0; i < x.length; i++){
        w[i] = w[i] - der * lr * x[i];
        b = b - der * lr;
      }
      der = 0;
    }

    public double MSE(double odg){
      return (odg-a)*(odg-a);
    }

    public double derOut(double odg, double wl){
      der = 2*(a-odg);
      return 2*(a-odg)* wl;
    }

    public double derHid(double wl){
      return der * (1-Math.pow(Math.tanh(z), 2)) * wl;
    }
  }

  class layer{

    public Nevron nevron[];

    public layer(int stNevronov, int stVhodov){
      nevron = new Nevron[stNevronov];
      for(int i = 0; i < stNevronov; i++){
        nevron[i] = new Nevron(stVhodov);
      }
    }
    public void answer(double []x){
      for(int i = 0; i < nevron.length; i++){
        nevron[i].answer(x);
      }
    }
    public void answer(layer l){
      for(int i = 0; i < nevron.length; i++){
        nevron[i].answer(l);
      }
    }

    public void answerOut(layer l){
      for(int i = 0; i < nevron.length; i++){
        nevron[i].answerOut(l);
      }
    }

    public double[] allanswers(){
      double answerOut[] = new double[nevron.length];
      for(int i = 0; i < nevron.length; i++){
        answerOut[i] = nevron[i].a;
      }
      return answerOut;
    }

  }

  class Perceptron{

    public layer layer[];
    public double mse = 0;

    public Perceptron(int stVhodov, int []layeri){
      layer = new layer[layeri.length];
      layer[0] = new layer(layeri[0], stVhodov);
      for(int i = 1; i < layeri.length; i++){
        layer[i] = new layer(layeri[i], layeri[i-1]);
      }
    }
    public double [] answer(double []x){
      layer[0].answer(x);
      for(int i = 1; i < layer.length-1; i++){
        layer[i].answer(layer[i-1]);
      }
      layer[layer.length-1].answerOut(layer[layer.length-2]);
      return layer[layer.length-1].allanswers();
    }

    public void backprop(double ans[]){
      mse = 0;
      //hid-out calculate derivatives
      for(int i = 0; i < layer[layer.length-1].nevron.length; i++){
        for(int j = 0; j < layer[layer.length-2].nevron.length; j++){
          layer[layer.length-2].nevron[j].der += layer[layer.length-1].nevron[i].derOut(ans[i], layer[layer.length-1].nevron[i].w[j]);
          mse += layer[layer.length-1].nevron[i].MSE(ans[i]);
        }
      }
      //hid - hid && inp - hid calculate derivatives
      //println(mse);
      for(int i = layer.length-2; i > 0; i--){
        for(int j = 0; j < layer[i].nevron.length-1; j++){
          for(int k = 0; k < layer[i-1].nevron.length; k++){
            layer[i-1].nevron[k].der += layer[i].nevron[j].derHid(layer[i].nevron[j].w[k]);
          }
        }
      }
      //hid-out change weights
      for(int i = layer.length-1; i > 0; i--){
        for(int j = 0; j < layer[i].nevron.length; j++){
          layer[i].nevron[j].changeWeight(layer[i-1]);
        }
      }
      //hid-out change weights
      for(int i = 0; i < layer[0].nevron.length; i++){
        layer[0].nevron[i].changeWeight(ans);
      }

    }

  }

我会感谢任何帮助。

标签： javaneural-networkprocessingautoencoder

最后，我花了大部分时间找出参数的最佳组合，并发现：

不要着急，慢慢来看看NN进展如何
观察损失，它如何下降，如果它来回反弹，降低学习率或尝试再次运行 NN（因为局部最小值）
从 2 个样本开始，看看瓶颈层需要多少个神经元。尝试使用圆形和正方形的图像作为训练数据
区分相似图像需要更长的时间
然后尝试取 3 个样本，看看神经元和层的最佳组合。

总而言之，大部分都是基于运气的（尽管您仍然很有可能在第三次尝试时获得良好的培训课程），也就是说，如果您从头开始实施它。我确信还有其他方法可以帮助 NN 跳出局部最小值、不同的梯度下降等等。这是我的自动编码器的最终结果（5 层，有 16、8、8、16、4096 个神经元），它可以对 Ariana Grande、Tom Cruise 和 Saber Norris 的面孔进行编码（来源：着名的birthdays.com）。上面的图像当然是我的解码器生成的重建。

我还制作了一个简单的编辑器，您可以在其中弄乱解码器的输入并设法制作 Stephen Fry 的脸：

再次感谢你的帮助！

java - 自动编码器学习所有样本的平均值

问题描述

解决方案

推荐阅读