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

Question

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

这是输出：

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

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

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

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

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

输出图像是在2张图像的arround 12k epochs后生成的，即学习率为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进展如何
观察损失，它是如何下降的，如果它来回反弹，降低学习率或再次尝试运行 NN（因为局部最小值）
从 2 个样本开始，看看瓶颈层需要多少个神经元。尝试使用圆形和正方形的图像作为训练数据
神经网络区分相似图像需要更长的时间
然后尝试取 3 个样本并查看神经元和层的最佳组合。

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

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

再次感谢您的帮助！

Answer 2

我今天遇到了同样的问题。那么我的解决方法其实很简单。根据函数对您的数据集进行归一化，例如，如果 sigmoid ，将输入数据缩放到范围（1 和 0）。这将自动解决您的问题。例如，

input = (1/255) * pixel_image_value

此处 pixel_image_value 在 0 -255 范围内，然后在获得输出后 x_hat ，在按

显示为图像之前将其缩小

output_pixel_value  = 255 * sigmoid_ouput_value

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

Autoencoder learns average of all samples

java

processing

neural-network

autoencoder