using Keras.Layers;

using NumSharp;

using System;

using System.Collections.Generic;

using System.Text;

using Tensorflow;

using static Keras.Keras;

using static Tensorflow.Python;

namespace Keras

{

public class Model

{

public Tensor Flow;

List<ILayer> layer_stack;

public TensorShape InputShape;

public Model()

{

layer_stack = new List<ILayer>();

}

public Model Add(ILayer layer)

{

layer_stack.Add(layer);

return this;

}

public Model Add(IEnumerable<ILayer> layers)

{

layer_stack.AddRange(layers);

return this;

}

public Tensor getFlow()

{

try

{

return Flow;

}

catch (Exception ex)

{

return null;

}

}

public (Operation, Tensor, Tensor) make_graph(Tensor features, Tensor labels)

{

// TODO : Creating Loss Functions And Optimizers.....

#region Model Layers Graph

/*

var stddev = 1 / Math.Sqrt(2);

var d1 = new Dense(num_hidden);

d1.__build__(features.getShape());

var hidden_activations = tf.nn.relu(d1.__call__(features));

var d1_output = d1.output_shape(features.getShape());

var d2 = new Dense(1);

d2.__build__(d1.output_shape(features.getShape()), seed: 17, stddev: (float)(1/ Math.Sqrt(num_hidden)));

var logits = d2.__call__(hidden_activations);

var predictions = tf.sigmoid(tf.squeeze(logits));

*/

#endregion

#region Model Graph Form Layer Stack

var flow_shape = features.GetShape();

Flow = features;

for (int i = 0; i < layer_stack.Count; i++)

{

layer_stack[i].__build__(flow_shape);

flow_shape = layer_stack[i].output_shape(flow_shape);

Flow = layer_stack[i].__call__(Flow);

}

var predictions = tf.sigmoid(tf.squeeze(Flow));

#endregion

#region loss and optimizer

var loss = tf.reduce_mean(tf.square(predictions - tf.cast(labels, tf.float32)), name: "loss");

var gs = tf.Variable(0, trainable: false, name: "global_step");

var train_op = tf.train.GradientDescentOptimizer(0.2f).minimize(loss, global_step: gs);

#endregion

return (train_op, loss, gs);

}

public float train(int num_steps, (NDArray, NDArray) training_dataset)

{

var (X, Y) = training_dataset;

var x_shape = X.shape;

var batch_size = x_shape[0];

var graph = tf.Graph().as_default();

var features = tf.placeholder(tf.float32, new TensorShape(batch_size, 2));

var labels = tf.placeholder(tf.float32, new TensorShape(batch_size));

var (train_op, loss, gs) = this.make_graph(features, labels);

var init = tf.global_variables_initializer();

float loss_value = 0;

with(tf.Session(graph), sess =>

{

sess.run(init);

var step = 0;

while (step < num_steps)

{

var result = sess.run(

new ITensorOrOperation[] { train_op, gs, loss },

new FeedItem(features, X),

new FeedItem(labels, Y));

loss_value = result[2];

step = result[1];

if (step % 1000 == 0)

Console.WriteLine($"Step {step} loss: {loss_value}");

}

Console.WriteLine($"Final loss: {loss_value}");

});

return loss_value;

}

}

}