C# 如何用TensorflowSharp训练模型

我是TensorfolwSharp的新手。我看到了一些关于如何使用TensorfolwSharp加载模型和预测的示例。但我找不到使用TensorfolwSharp训练模型的例子。我尝试了一下，现在就被困在Optimizer。ApplyAdam的参数太多，甚至不能确定这是正确的函数

下面是我的工作Tensorflow代码

dataX = pd.read_csv('dataX.csv', sep = ',', header = None)
dataX = pd.read_csv('dataY.csv', sep = ',', header = None)  
x = tf.placeholder(tf.float32, [None, trainX.shape[1]]) 
y = tf.placeholder(tf.float32, [None, 1]) 
W0 = tf.Variable(tf.random_normal([trainX.shape[1], h0size], seed = seed))
b0 = tf.Variable(tf.random_normal([h0size], seed = seed))
h = tf.matmul(x, W0) + b0
pred = tf.sigmoid(h)
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels = y, logits = h))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
with tf.Session() as sess:
    sess.run(init)
    for epoch in range(50):
        _, c = sess.run([optimizer, cost], feed_dict ={x: dataX, y: dataX})

下面是我转换为TensorflowSharp的尝试

        using (var session = new TFSession())
        {
            var graph = session.Graph;
            //dataX = pd.read_csv('dataX.csv', sep = ',', header = None)
            //dataY = pd.read_csv('dataY.csv', sep = ',', header = None)
            float[,] aX = LoadCsv("dataX.csv");
            float[,] aY = LoadCsv("dataY.csv");
            TFTensor dataX = new TFTensor(aX);
            TFTensor dataY = new TFTensor(aY);
            //x = tf.placeholder(tf.float32, [None, trainX.shape[1]]) 
            //y = tf.placeholder(tf.float32, [None, 1]) 
            var x = graph.Placeholder(TFDataType.Float, new TFShape(dataX.Shape));
            var y = graph.Placeholder(TFDataType.Float, new TFShape(dataY.Shape));
            var W0 = graph.Variable(graph.RandomNormal(new TFShape(dataX.Shape[1], 1)));
            var b0 = graph.Variable(graph.RandomNormal(new TFShape(1)));
            var h = graph.Add(graph.MatMul(x, W0), b0);
            var pred = graph.Sigmoid(h);
            var cost = graph.ReduceMean(graph.SigmoidCrossEntropyWithLogits(y,h));
            //optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
            // Too many parameters for ApplyAdam, not even sure this is the right function to use. 
            TFOutput var, m = 0, v = 0, beta1_power, beta2_power, lr = 0.01, beta1 = 0.9, beta2 = 0.999, epsilon = 0.00000001, grad;
            var optimizer = graph.ApplyAdam(var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad);
            for (int i = 0; i < 50 ; i++)
                session.GetRunner().Run(
                    inputs: new[] { optimizer },
                    inputValues: new[] { dataX, dataY }
                    );
}

使用（var session=new TFSession（））
{
var-graph=session.graph；
//dataX=pd.read_csv（'dataX.csv'，sep='，'，header=None）
//dataY=pd.read_csv（'dataY.csv'，sep='，'，header=None）
float[，]aX=LoadCsv（“dataX.csv”）；
float[，]aY=LoadCsv（“dataY.csv”）；
t传感器数据x=新的t传感器（aX）；
t传感器数据y=新的t传感器（aY）；
//x=tf.placeholder（tf.float32，[None，trainX.shape[1]]）
//y=tf.placeholder（tf.float32，[None，1]）
var x=graph.Placeholder（TFDataType.Float，新的TFShape（dataX.Shape））；
var y=graph.Placeholder（TFDataType.Float，新的TFShape（dataY.Shape））；
var W0=graph.Variable（graph.RandomNormal（新的TFShape（dataX.Shape[1]，1））；
var b0=graph.Variable（graph.RandomNormal（新TFShape（1））；
var h=图.Add（图.MatMul（x，W0），b0）；
var pred=图形S形（h）；
var成本=图.约化指数（图.SigmoidCrossEntropyWithLogits（y，h））；
//优化器=tf.train.AdamOptimizer（学习率）。最小化（成本）
//ApplyAdam的参数太多，甚至不能确定这是正确的函数。
TF输出变量，m=0，v=0，β1_功率，β2_功率，lr=0.01，β1=0.9，β2=0.999，ε=0.00000001，梯度；
var optimizer=graph.ApplyAdam（var、m、v、β1_功率、β2_功率、lr、β1、β2、ε、梯度）；
对于（int i=0；i<50；i++）
session.GetRunner（）.Run(
输入：新[]{optimizer}，
inputValues:new[]{dataX，dataY}
);
}

TensorFlow API尚未提供优化器类。所以，为了最小化成本函数，您应该使用API计算梯度，然后手动更新模型的可训练参数。下面是一个示例，其中包含单独的类以方便使用：

class Model : IDisposable
{
    TFSession _session;

    TFGraph _graph;

    TFOutput _input;

    TFOutput _output;

    LinearLayer _y_out;

    TFOutput _cost;

    TFTensor _dataX;

    TFTensor _dataY;

    GradientDescentOptimizer _gradientDescentOptimizer;


    public Model()
    {
        float[,] aX = LoadCsv("dataX.csv");
        float[,] aY = LoadCsv("dataY.csv");
        _dataX = new TFTensor(aX);
        _dataY = new TFTensor(aY);

        _session = new TFSession();

        _graph = _session.Graph;

        _input = _graph.Placeholder(TFDataType.Float);
        _output = _graph.Placeholder(TFDataType.Float);

        _y_out = new LinearLayer(_graph, _input, (int)_dataX.Shape[0], 1);

        cost = _graph.ReduceMean(_graph.SigmoidCrossEntropyWithLogits(_y_out.Result, _output));

        _gradientDescentOptimizer = new GradientDescentOptimizer(_graph, _cost, _y_out.W, _y_out.b);
        _gradientDescentOptimizer.ApplyGradientDescent(_graph);

        var runner = _session.GetRunner();


        runner.AddTarget(_y_out.InitB.Operation);

        runner.Run();
    }

    public void TrainModelIteration()
    {
        var runner = _session.GetRunner();

        runner.AddInput(_input, _dataX);
        runner.AddInput(_output, _dataY);


        for (int i = 0; i < 2; i++)
        {
            runner.Fetch(_gradientDescentOptimizer.Updates[i]);
        }

        runner.Run();
    }


    public void Dispose()
    {
        _graph.Dispose();
        _session.Dispose();
    }
}


class LinearLayer
{
    public TFOutput Result { get; set; }

    public TFOutput W { get; set; }

    public TFOutput b { get; set; }

    public TFOutput InitW { get; set; }

    public TFOutput InitB { get; set; }

    public LinearLayer(TFGraph graph, TFOutput x, int inSize, int outSize)
    {
        var wShape = new TFShape(inSize, outSize);

        W = graph.VariableV2(wShape, TFDataType.Float);

        TFOutput tfOutputWShape = graph.Const(wShape);
        TFOutput initialW = graph.RandomUniform(tfOutputWShape, TFDataType.Float);

        InitW = graph.Assign(W, initialW);


        var bShape = new TFShape(outSize);

        b = graph.VariableV2(bShape, TFDataType.Float);

        TFOutput tfOutputBShape = graph.Const(bShape);
        TFOutput initialB = graph.RandomUniform(tfOutputBShape, TFDataType.Float);

        InitB = graph.Assign(b, initialB);

        var matMul = graph.MatMul(x, W);

        Result = graph.Add(matMul, b);
    }
}


class GradientDescentOptimizer
{
    private TFOutput[] _variables;

    public TFOutput[] Updates { get; set; }

    private TFOutput[] _gradients;

    public GradientDescentOptimizer(TFGraph graph, TFOutput grad, TFOutput w, TFOutput b)
    {
        _variables = new TFOutput[4];

        _variables[0] = w;

        _variables[1] = b;

        _gradients = graph.AddGradients(new TFOutput[] { grad }, new TFOutput[] { w, b });

        Updates = new TFOutput[4];
    }

    public void ApplyGradientDescent(TFGraph graph, float alpha = 0.01f)
    {
        TFOutput tfAlpha = graph.Const(alpha);

        for (int i = 0; i < 2; i++)
        {
            Updates[i] = graph.ApplyGradientDescent(_variables[i], tfAlpha, _gradients[i]);
        }
    }
}

类模型：IDisposable
{
TFSession(tfu session),；
TFGraph\u图；
TFOutput\u输入；
TFOutput\u输出；
线性层(y)out ;；
产出成本；
TFT传感器dataX；
TFensor_-dataY；
GradientDescentOptimizer\u GradientDescentOptimizer；
公共模型（）
{
float[，]aX=LoadCsv（“dataX.csv”）；
float[，]aY=LoadCsv（“dataY.csv”）；
_dataX=新的TFT传感器（aX）；
_dataY=新的TFT传感器（aY）；
_会话=新的TFSession（）；
_graph=\u session.graph；
_输入=_graph.Placeholder（TFDataType.Float）；
_输出=_graph.Placeholder（TFDataType.Float）；
_y_out=新的LinearLayer（_graph，_input，（int）_dataX.Shape[0]，1）；
成本=_graph.ReduceMean（_graph.SigmoidCrossEntropyWithLogits（_y_out.Result，_output））；
_gradientDescentOptimizer=新的gradientDescentOptimizer（_graph，_cost，_y_out.W，_y_out.b）；
_gradientDescentOptimizer.ApplyGradientDescent（_图）；
var runner=_session.GetRunner（）；
runner.AddTarget（_y_out.InitB.Operation）；
runner.Run（）；
}
公共无效TrainModelIteration（）
{
var runner=_session.GetRunner（）；
runner.AddInput（_input，_dataX）；
runner.AddInput（_output，_dataY）；
对于（int i=0；i<2；i++）
{
Fetch（_gradientDescentOptimizer.Updates[i]）；
}
runner.Run（）；
}
公共空间处置（）
{
_graph.Dispose（）；
_session.Dispose（）；
}
}
类线性层
{
公共TFOutput结果{get；set；}
公共TFW输出{get；set；}
公共TFB输出{get；set；}
公共TFOutput InitW{get；set；}
公共TFOutput InitB{get；set；}
public LinearLayer（TFGraph图形、TFX输出、int inSize、int outSize）
{
var wShape=新的TFShape（inSize，特大型）；
W=graph.VariableV2（wShape，TFDataType.Float）；
TFOUTPUTTFOUTPUTWSHAPE=graph.Const（wShape）；
TFOutput initialW=graph.RandomUniform（tfOutputWShape，TFDataType.Float）；
InitW=graph.Assign（W，initialW）；
var bShape=新的TFShape（特大型）；
b=graph.VariableV2（b形状，TFDataType.Float）；
TFOutput tfOutputBShape=图形常量（bShape）；
TFOutput initialB=graph.RandomUniform（tfOutputBShape，TFDataType.Float）；
InitB=graph.Assign（b，initialB）；
var matMul=图.matMul（x，W）；
结果=图.Add（matMul，b）；
}
}
类GradientDescentOptimizer
{
私有TFOutput[]_变量；
public TFOutput[]更新{get；set；}
专用TFOutput[]_梯度；
公共GradientDescentOptimizer（TFGraph graph、TFOutput grad、TFOutput w、TFOutput b）
{
_变量=新的TFOutput[4]；
_变量[0]=w；
_变量[1]=b；
_gradients=graph.AddGradients（新TFOutput[]{grad}，新TFOutput[]{w，b}）；
更新=新的TFOutput[4]；
}
公共无效ApplyGradientDescent（TFGraph图形，浮点alpha=0.01f）
{
TFOutput tfAlpha=图形常数（alpha）；
对于（int i=0；i<2；i++）
{
更新[i]=graph.ApplyGradientDescent（_变量[i]，tfAlpha，_梯度[i]）；
}
}
}

您卡在哪里了？你面临什么问题？仅仅通过查看代码，我们无法了解您所面临的问题。您需要提供适当的详细信息。我尝试将AdamOptimizer python代码翻译成tensorflowsharp ApplyAdam是我能找到的最接近的，但AdamOptimizer只接受两个参数，而ApplyAdam接受10个参数。我尽我所能去做一种菲古