1

嘿，我正在尝试为学校做一个简单的机器学习应用程序，但由于某种我什至无法理解的原因，我不断获得双倍免费。

float * evaluate(Network net,float * in)
{
    int i,j;
    float * out;
    Neuron cur_neu;

    for(i=0,j=0;i<net.n_lay;i++) j = net.lay_sizes[i]>j?net.lay_sizes[i]:j; //Calculating the maximum lay size for output storage
    out = (float *) malloc(j*sizeof(float));


    for(i=0;i<net.n_lay;i++)                                                //Cycling through layers
    {
        for(j=0;j<net.lay_sizes[i];j++)                                     //Cycling through Neurons
        {
            cur_neu=net.matrix[i][j];
            out[j] = cur_neu.af(cur_neu.w,in,net.lay_sizes[i-1]);        //Storing each answer in out
        }

        for(j=0;j<net.lay_sizes[i];j++) in[j] = out[j];                     //Transfering answers to in
    }

    return out;
}

float loss(Network net, float **ins_orig, int t_steps)
{
    float **profecies;
    float st = .5f;
    int d_steps = 4;
    int t, i, j;
    int out_size = net.lay_sizes[net.n_lay - 1];
    int in_size = net.lay_sizes[0];
    float out = 0.0f;
    float **ins;
    /*
    d_steps = Divination Steps: Number of time steps forward the network has to predict.
    The size of the output layer must be d_steps*#ins (deconsidering any conceptual i/os) 

    t_steps = Total of Steps: Total number of time steps to simulate.
    */
    //Copying ins
    ins = (float **)malloc(t_steps * sizeof(float *));
    for (i = 0; i < t_steps; i++)  //I allocate memory for and copy ins_orig to ins here
    {
        ins[i] = (float *)malloc(in_size * sizeof(float));
        for (j = 0; j < in_size; j++)
            ins[i][j] = ins_orig[i][j];
    }
    //
    profecies = (float **)malloc(t_steps * sizeof(float *));
    for (t = 0; t < t_steps; t++)
    {
        profecies[t] = evaluate(net, ins[t]);
        /*
        Profecy 0:
        [[a1,b1,c1,d1]
         [e1,f1,g1,h1]
         [i1,j1,k1,l1]]
         Profecy 1:
        [[e2,f2,g2,h2]
         [i2,j2,k2,l2]
         [m2,n2,o2,q2]]

         Verification for:
         t=0:
         loss+= abs(a1-ins[t][0]+b2-ins[t][1]...)
         t=1:
         t=0:
         loss+= abs(e1-ins[t][0]+f2-ins[t][1]...)
        */
        for (i = 0; i < d_steps; i++)      //i is distance of prediction
        {
            if (i <= t)                    // stops negative profecy indexing
            {
                for (j = 0; j < in_size; j++)
                {
                    out += (ins[t][j] - profecies[t-i][j+in_size*i]) * (ins[t][j] - profecies[t-i][j+in_size*i]) * (1 + st*i); //(1+st*i) The further the prediction, the bigger reward
                }
            }
        }
    }
    //Free ins
   
    for (i = 0; i < t_steps; i++)        //I try to free it here, but to no avail
    {
        free(ins[i]);
    }
    free(ins);

    return out;
}

我意识到这可能是非常明显的事情，但是我一生都无法弄清楚，并希望得到帮助。

可能不需要的额外细节：评估只是将输入传递给网络（存储在 ins 中）并返回输出输入和输出都存储在浮点“矩阵”中

编辑：添加评估

4

1 回答 1

2

在您loss()中，您为每个分配相同数量的浮点数ins：

ins[i] = (float *)malloc(in_size * sizeof(float));

在evaluate()你计算最长的lay_size，表明它可能不是net.lay_sizes[0]：

for(i=0,j=0;i<net.n_lay;i++) j = net.lay_sizes[i]>j?net.lay_sizes[i]:j; //Calculating the maximum lay size for output storage

然后你在这里写越界：

for(j=0;j<net.lay_sizes[i];j++) in[j] = out[j];                     //Transfering answers to in

从那时起，你的记忆就被破坏了。

于 2021-03-25T00:51:25.347 回答