Neural network C语言中的错误/损失/成本函数列表#

我在代码中找不到列表，而这似乎是正确的位置。 有关激活函数的列表，请参见

从link中函数的翻译开始

以下是我的尝试： （此处相同，不确定所有数学是否正确，因此不作为答案发布）

使用UnityEngine；
使用系统集合；
使用制度；
///
///评价职能来自：
///https://stats.stackexchange.com/questions/154879/a-list-of-cost-functions-used-in-neural-networks-alongside-applications/154880#154880
///D infront表示函数的减额
///错误是一个感知器的结果。
///d_误差是反向传播所需的导数，
///计算网络的增量权重的步骤
///
[系统可序列化]
公共课评价
{
公共错误功能错误功能；
双重错误；
双d_误差；
双td；
双外径；
公众评价（ErrorFunction\u ErrorFunction）
{
errorFunction=\u errorFunction；
}
公共双计算器错误（双t，双o）
{
开关（错误功能）
{
案例错误函数。二次：
返回二次型（t，o）；
case ErrorFunction.CrossEntropy：
返回交叉熵（t，o）；
大小写错误函数。指数：
返回指数（t，o）；
case ErrorFunction.Hellinger：
返回Hellinger（t，o）；
case ErrorFunction.KullbackLeibler：
返回KullbackLeibler（t，o）；
case ErrorFunction.dkl：
返回dkl（t，o）；
案例ErrorFunction.ItakuraSaito：
返回ItakuraSaito（t，o）；
}
返回0；
}
公共双导数错误（双t，双o）
{
开关（错误功能）
{
案例错误函数。二次：
返回d2次方（t，o）；
case ErrorFunction.CrossEntropy：
返回d交叉熵（t，o）；
大小写错误函数。指数：
返回右旋（t，o）；
case ErrorFunction.Hellinger：
返回德林格（t，o）；
case ErrorFunction.KullbackLeibler：
返回DKullbackLeibler（t，o）；
case ErrorFunction.dkl：
返回DGeneralizedKL（t，o）；
案例ErrorFunction.ItakuraSaito：
返回DItakuraSaito（t，o）；
}
返回0；
}
公共双二次型（双t，双o）
{
误差=0.5*数学功率（（o-t），2）；
返回误差；
}
公共双D二次型（双t，双o）
{
d_误差=t-o；
返回d_错误；
}
公共双交叉熵（双t，双o）
{
错误=t*数学日志（o）+（1-t）*数学日志（1-o）；
返回错误；
}
公共双交叉熵（双t，双o）
{
d_误差=（o-t）/（o+1）*o；
返回d_错误；
}
公共双指数（双t，双o）
{
误差=数学功率（（o-t），2）；
返回Math.PI*Math.Exp（1/Math.PI*error）；
}
公共双右旋（双t，双o）
{
d_误差=（2/Math.PI）*（o-t）*指数（t，o）；
返回d_错误；
}
公共双Hellinger（双t，双o）
{
error=Math.Pow（（Math.Sqrt（o）-Math.Sqrt（t）），2）；
返回（1/Math.Sqrt（2））*错误；
}
公共双德林格（双t，双o）
{
d_error=（Math.Sqrt（o）-Math.Sqrt（t））/（Math.Sqrt（2）*Math.Sqrt（o））；
返回d_错误；
}
公共双KullbackLeibler（双t，双o）
{
错误=t*Math.Log（t/o）；
返回误差；
}
公共双D形双t形（双t形，双o形）
{
d_误差=t/o；
返回误差；
}
公共双端口（双t，双o）
{
误差=KullbackLeibler（t，o）-t+o；
返回误差；
}
公共双D通用DKL（双t，双o）
{
d_误差=（t+o）/o；
返回d_错误；
}
公共双ItakuraSaito（双t，双o）
{
错误=t/o-数学日志（t/o）-1；
返回误差；
}
公共双双双双t型（双t型，双o型）
{
d_误差=（t+Math.Pow（o，2））/Math.Pow（o，2）；
返回d_错误；
}
}
公共枚举错误函数
{
没有一个
二次，
交叉熵，
指数，
海林格，
库尔巴克莱布勒，
dkl，
ItakuraSaito
}

我认为“DQuadratic（float t，float o）”应该是“d_error=o-t；”（“d_error=t-o；”的instad），而t是目标输出，o是根据

using UnityEngine;
using System.Collections;
using System;

///<summary>
///Evaluation Functions from:
///https://stats.stackexchange.com/questions/154879/a-list-of-cost-functions-used-in-neural-networks-alongside-applications/154880#154880
///D infront means the Deravitive of the function
///error is the result for one perceptron.
///d_error is the derivative needed for backpropagation, 
///to calculate the delta weights for the network
///</summary>
[System.Serializable]
public class Evaluation 
{
    public ErrorFunction errorFunction;
    double error;
    double d_error;
    double td;
    double od;

    public Evaluation(ErrorFunction _errorFunction)
    {
        errorFunction = _errorFunction;
    }
    public double CalculateError(double t, double o)
    {
        switch(errorFunction)
        {
        case ErrorFunction.Quadratic:
            return Quadratic(t,o);
        case ErrorFunction.CrossEntropy:
            return CrossEntropy(t,o);
        case ErrorFunction.Exponentional:
            return Exponentional(t,o);
        case ErrorFunction.Hellinger:
            return Hellinger(t,o);
        case ErrorFunction.KullbackLeibler:
            return KullbackLeibler(t,o);
        case ErrorFunction.GeneralizedKL:
            return GeneralizedKL(t,o);
        case ErrorFunction.ItakuraSaito:
            return ItakuraSaito(t,o);
        }
        return 0;
    }
    public double DerivativeError(double t, double o)
    {
        switch(errorFunction)
        {
        case ErrorFunction.Quadratic:
            return DQuadratic(t,o);
        case ErrorFunction.CrossEntropy:
            return DCrossEntropy(t,o);
        case ErrorFunction.Exponentional:
            return DExponentional(t,o);
        case ErrorFunction.Hellinger:
            return DHellinger(t,o);
        case ErrorFunction.KullbackLeibler:
            return DKullbackLeibler(t,o);
        case ErrorFunction.GeneralizedKL:
            return DGeneralizedKL(t,o);
        case ErrorFunction.ItakuraSaito:
            return DItakuraSaito(t,o);
        }
        return 0;
    }
    public double Quadratic(double t, double o)
    {
        error = 0.5*Math.Pow((o-t),2);
        return error;
    }
    public double DQuadratic(double t, double o)
    {
        d_error = t-o;
        return d_error;
    }
    public double CrossEntropy(double t, double o)
    {
        error = t*Math.Log(o)+(1-t)*Math.Log(1-o);
        return -error;
    }
    public double DCrossEntropy(double t, double o)
    {
        d_error = (o-t)/((o+1)*o);
        return d_error;
    }
    public double Exponentional(double t, double o)
    {
        error = Math.Pow((o-t),2);
        return Math.PI*Math.Exp(1/Math.PI*error);
    }
    public double DExponentional(double t, double o)
    {
        d_error = (2/Math.PI)*(o-t)*Exponentional(t,o);
        return d_error;
    }
    public double Hellinger(double t, double o)
    {
        error = Math.Pow((Math.Sqrt(o)-Math.Sqrt(t)),2);
        return (1/Math.Sqrt(2))*error;
    }
    public double DHellinger(double t, double o)
    {
        d_error = (Math.Sqrt(o)-Math.Sqrt(t))/(Math.Sqrt(2)*Math.Sqrt(o));
        return d_error;
    }
    public double KullbackLeibler(double t, double o)
    {
        error = t*Math.Log(t/o);
        return error;
    }
    public double DKullbackLeibler(double t, double o)
    {
        d_error = t/o;
        return error;
    }
    public double GeneralizedKL(double t, double o)
    {
        error = KullbackLeibler(t,o) - t + o;
        return error;
    }
    public double DGeneralizedKL(double t, double o)
    {
        d_error = (t + o)/o;
        return d_error;
    }
    public double ItakuraSaito(double t, double o)
    {
        error = t/o - Math.Log(t/o) - 1;
        return error;
    }
    public double DItakuraSaito(double t, double o)
    {
        d_error = (t+Math.Pow(o,2))/Math.Pow(o,2);
        return d_error;
    }
}
public enum ErrorFunction
{
    none,
    Quadratic,
    CrossEntropy,
    Exponentional,
    Hellinger,
    KullbackLeibler,
    GeneralizedKL,
    ItakuraSaito
}