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

Question

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

这是输出:

如果你想看它的培训视频，就在这里: https://youtu.be/w8mPVj_lQWI

如果我添加所有其他 17 个样本(另一批数字 1 和 2)，它会变得模糊，结果也很平均:

我把我的网络设计成3层，有64个输入神经元(输入是4096维 vector ，指的是64x64的图像样本)，瓶颈部分(第二层)8个神经元，输出4096个神经元，每个最终输出的一维。

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

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

输出图像是在 2 个图像的大约 12k 个 epoch 后生成的，即学习率为 5*10-e6。

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

我可以尝试在 5 层神经网络上进行训练，但效果相同。

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

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);
      }

    }

  }

如有任何帮助，我将不胜感激。

Answer 1

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

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

总而言之，大部分都是靠运气(尽管您仍然有很大的机会在第三次尝试时获得良好的培训类(class))，也就是说，如果您是从头开始实现的话。我敢肯定还有其他方法可以帮助 NN 跳出局部最小值、不同的梯度下降等等。这是我的自动编码器(5 层，16、8、8、16、4096 个神经元)的最终结果，它可以编码 Ariana Grande、Tom Cruise 和 Saber Norris 的面部(来源:faminatedbirthdays.com)。上面的图像当然是我的解码器生成的重建图像。

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

再次感谢您的帮助!