public static async Task Main()
{
// Create the network
INeuralNetwork network = NetworkManager.NewSequential(TensorInfo.Image <Alpha8>(28, 28),
NetworkLayers.Convolutional((5, 5), 20, ActivationType.Identity),
NetworkLayers.Pooling(ActivationType.LeakyReLU),
NetworkLayers.FullyConnected(100, ActivationType.LeCunTanh),
NetworkLayers.Softmax(10));
// Prepare the dataset
ITrainingDataset trainingData = await Mnist.GetTrainingDatasetAsync(100); // Batches of 100 samples
ITestDataset testData = await Mnist.GetTestDatasetAsync(p => Printf($"Epoch {p.Iteration}, cost: {p.Result.Cost}, accuracy: {p.Result.Accuracy}"));
if (trainingData == null || testData == null)
{
Printf("Error downloading the datasets");
Console.ReadKey();
return;
}
// Train the network
TrainingSessionResult result = await NetworkManager.TrainNetworkAsync(network,
trainingData,
TrainingAlgorithms.AdaDelta(),
60, 0.5f,
TrackBatchProgress,
testDataset : testData);
Printf($"Stop reason: {result.StopReason}, elapsed time: {result.TrainingTime}");
Console.ReadKey();
}
private void CrearNeuralNetwork()
{
int neuronasOcultas = (int)spinNeuronasOculta.Value;
var activacionOculta = cboFuncionActivacionOculta.SelectedItem as EnumInfo <ActivationType>;
var pesosOculta = cboPesosOculta.SelectedItem as EnumInfo <WeightsInitializationMode>;
var biasOculta = cboBiasOculta.SelectedItem as EnumInfo <BiasInitializationMode>;
var activacionSalida = cboFuncionActivacionSalida.SelectedItem as EnumInfo <ActivationType>;
var funcionCosto = cboFuncionCosto.SelectedItem as EnumInfo <CostFunctionType>;
var pesosSalida = cboPesosSalida.SelectedItem as EnumInfo <WeightsInitializationMode>;
var biasSalida = cboBiasSalida.SelectedItem as EnumInfo <BiasInitializationMode>;
LayerFactory layerSalida;
if (activacionSalida.Valor == ActivationType.Softmax)
{
layerSalida = NetworkLayers.Softmax(3, pesosOculta.Valor, biasOculta.Valor);
}
else
{
layerSalida = NetworkLayers.FullyConnected(3, activacionSalida.Valor, funcionCosto.Valor, pesosSalida.Valor, biasSalida.Valor);
}
_neuralNetwork = NetworkManager.NewSequential(TensorInfo.Linear(4),
NetworkLayers.FullyConnected(neuronasOcultas, activacionOculta.Valor, pesosOculta.Valor, biasOculta.Valor),
layerSalida);
}
public void SetNeuralNetworkInputValues(Glass glass_obj)
{
List <double> glass_values = glass_obj.GetMainValues();
for (int i = 0; i < 9; i++)
{
NetworkLayers.First().NetworkNeurons[i].setValue(glass_values[i]);
}
}
public void UpdateAllSynapsesByAverage()
{
for (int i = 0; i < 7; i++)
{
foreach (var synapse in NetworkLayers.Last().NetworkNeurons[i].Inputs)
{
//synapse.Weight += newWeights[i];
}
}
}
public void AddLayer(int NeuronCount)
{
NetworkLayer newNetworkLayer = new NetworkLayer();
newNetworkLayer.AddLayer(NeuronCount);
if (NetworkLayers.Count > 0)
{
newNetworkLayer.ConnectLayers(NetworkLayers.Last());
}
NetworkLayers.Add(newNetworkLayer);
}
public void Initialization1()
{
INeuralNetwork network = NetworkManager.NewGraph(TensorInfo.Image <Alpha8>(60, 60), root =>
{
var conv1 = root.Layer(NetworkLayers.Convolutional((5, 5), 10, ActivationType.Identity));
var pool1 = conv1.Layer(NetworkLayers.Pooling(ActivationType.LeakyReLU));
var conv2 = pool1.Layer(NetworkLayers.Convolutional((3, 3), 10, ActivationType.Identity));
var pool2 = conv2.Layer(NetworkLayers.Pooling(ActivationType.ReLU));
var fc = pool2.Layer(NetworkLayers.FullyConnected(64, ActivationType.LeCunTanh));
_ = fc.Layer(NetworkLayers.Softmax(10));
});
public List <double> GetOutputs(Glass Input)
{
SetNeuralNetworkInputValues(Input);
List <double> outputValues = new List <double>();
foreach (var layer in NetworkLayers)
{
layer.PerformCalculation();
}
foreach (var neuron in NetworkLayers.Last().NetworkNeurons)
{
outputValues.Add(neuron.getValue());
}
return(outputValues);
}
public void ForwardTest1()
{
INeuralNetwork cpu = NetworkManager.NewGraph(TensorInfo.Image <Alpha8>(28, 28), root =>
{
var fc1 = root.Layer(NetworkLayers.FullyConnected(100, ActivationType.Sigmoid));
fc1.Layer(NetworkLayers.Softmax(10));
});
INeuralNetwork gpu = NetworkManager.NewGraph(TensorInfo.Image <Alpha8>(28, 28), root =>
{
var fc1l = cpu.Layers[0].To <INetworkLayer, FullyConnectedLayer>();
var fc1 = root.Layer(_ => new CuDnnFullyConnectedLayer(fc1l.InputInfo, 100, fc1l.Weights, fc1l.Biases, fc1l.ActivationType));
var sm1l = cpu.Layers[1].To <INetworkLayer, SoftmaxLayer>();
fc1.Layer(_ => new CuDnnSoftmaxLayer(sm1l.InputInfo, sm1l.OutputInfo.Size, sm1l.Weights, sm1l.Biases));
});
ForwardTest(cpu, gpu);
}
public void JsonMetadataSerialization()
{
INeuralNetwork network = NetworkManager.NewSequential(TensorInfo.Image <Rgb24>(120, 120),
NetworkLayers.Convolutional((10, 10), 20, ActivationType.AbsoluteReLU),
NetworkLayers.Convolutional((5, 5), 20, ActivationType.ELU),
NetworkLayers.Convolutional((10, 10), 20, ActivationType.Identity),
NetworkLayers.Pooling(ActivationType.ReLU),
NetworkLayers.Convolutional((10, 10), 20, ActivationType.Identity),
NetworkLayers.Pooling(ActivationType.Identity),
NetworkLayers.BatchNormalization(NormalizationMode.Spatial, ActivationType.ReLU),
NetworkLayers.FullyConnected(125, ActivationType.Tanh),
NetworkLayers.Softmax(133));
string metadata1 = network.SerializeMetadataAsJson();
Assert.IsTrue(metadata1.Length > 0);
Assert.IsTrue(metadata1.Equals(network.Clone().SerializeMetadataAsJson()));
network.Layers.First().To <INetworkLayer, ConvolutionalLayer>().Weights[0] += 0.1f;
Assert.IsFalse(metadata1.Equals(network.SerializeMetadataAsJson()));
}
public TrainingSessionResult Train(ITrainingDataset data, ITestDataset testData)
{
INeuralNetwork net = NetworkManager.NewSequential(TensorInfo.Linear(SubHistory.SubHistoryLength),
NetworkLayers.FullyConnected(SubHistory.SubHistoryLength, ActivationType.LeCunTanh),
NetworkLayers.Softmax(IMoveEngine.Payoffs));
TrainingSessionResult result = NetworkManager.TrainNetwork(net,
data,
TrainingAlgorithms.AdaDelta(),
100, 0.0f,
null,
testDataset: testData);
if (result.StopReason == TrainingStopReason.EpochsCompleted)
{
_storage.Save(net);
_network = net;
}
return(result);
}
public void CalculateNewWeigths(List <double> outputs, List <double> correct_outputs)
{
//double newWeight = weight - LearningRate * ((outputs - correct_outputs)* synpas.fromNeuron.value);
for (int i = 0; i < outputs.Count; i++)
{
foreach (var synape in NetworkLayers.Last().NetworkNeurons[i].Inputs)
{
double curOutput = NetworkLayers.Last().CalcActivation(NetworkLayers.Last().NetworkNeurons[i].CalcOutput());
double delta = synape.NeuronFrom.currentValue * (correct_outputs[i] - curOutput) * LearningRate * curOutput * (1 - curOutput);
synape.Delta = (outputs[i] - correct_outputs[i]) * outputs[i] * (1 - outputs[i]) * synape.NeuronFrom.currentValue;
//if(newWeights.Count <= i)
//{
// newWeights.Add(delta);
//}
//else
//{
// newWeights[i] = (newWeights[i] + delta) / 2;
//}
//var nodeDelta = (correct_outputs[i] - outputs[i]) * outputs[i] * (1 - outputs[i]);
//var delta = -1 * synape.NeuronFrom.currentValue * nodeDelta;
//synape.NewWeight = synape.Weight - LearningRate * nodeDelta;
//synape.NewWeight = synape.Weight - LearningRate * ((outputs[i] - correct_outputs[i]));
//double previouseWeigths = synape.NewWeight;
}
}
for (int j = NetworkLayers.Count - 2; j > 0; j--)
{
foreach (var neuron in NetworkLayers[j].NetworkNeurons)
{
foreach (var synapse in neuron.Inputs)
{
synapse.Delta = synapse.NeuronFrom.currentValue * synapse.NeuronTo.currentValue * (1 - synapse.NeuronTo.currentValue) * GetAllDeltas(synapse);
//synapse.Weight += synapse.NeuronFrom.currentValue * (correct_outputs[i] - outputs[i]) * LearningRate * outputs[i] * (1 - outputs[i]);
//double sumPartial = GetPrSynapsesWeigt(synapse.NeuronTo);
//synapse.NewWeight = synapse.Weight - LearningRate * ((outputs[i] - correct_outputs[i]) * synapse.NeuronFrom.getValue());
//double previouseWeigths = synapse.NewWeight;
}
}
}
}
public void NetworkSerialization()
{
INeuralNetwork network = NetworkManager.NewSequential(TensorInfo.Image <Rgb24>(120, 120),
NetworkLayers.Convolutional((10, 10), 20, ActivationFunctionType.AbsoluteReLU),
NetworkLayers.Convolutional((5, 5), 20, ActivationFunctionType.ELU),
NetworkLayers.Convolutional((10, 10), 20, ActivationFunctionType.Identity),
NetworkLayers.Pooling(ActivationFunctionType.ReLU),
NetworkLayers.Convolutional((10, 10), 20, ActivationFunctionType.Identity),
NetworkLayers.Pooling(ActivationFunctionType.ReLU),
NetworkLayers.FullyConnected(125, ActivationFunctionType.Tanh),
NetworkLayers.Softmax(133));
using (MemoryStream stream = new MemoryStream())
{
network.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
INeuralNetwork copy = NetworkLoader.TryLoad(stream, LayersLoadingPreference.Cpu);
Assert.IsTrue(network.Equals(copy));
}
}
void InitializeUI()
{
var os = Environment.OSVersion;
var pid = os.Platform;
switch (pid)
{
case PlatformID.MacOSX:
this.Title = "DeepLearnUI (OSX, Mono, Beta)";
break;
case PlatformID.Unix:
this.Title = "DeepLearnUI (Unix/Linux/OSX, Mono, Beta)";
break;
case PlatformID.Xbox:
this.Title = "DeepLearnUI (Xbox, Beta)";
break;
case PlatformID.WinCE:
this.Title = "DeepLearnUI (WinCE x86/x64, Beta)";
break;
case PlatformID.Win32NT:
this.Title = "DeepLearnUI (WinNT x86/x64, Beta)";
break;
case PlatformID.Win32Windows:
this.Title = "DeepLearnUI (Win x86/x64, 1.0)";
break;
default:
this.Title = "DeepLearnUI (Unknown OS, Beta)";
break;
}
Confirm = new Dialog(
"Are you sure?",
this,
DialogFlags.Modal,
"Yes", ResponseType.Accept,
"No", ResponseType.Cancel
)
{
Resizable = false,
KeepAbove = true,
TypeHint = WindowTypeHint.Dialog,
WidthRequest = 250
};
Confirm.ActionArea.LayoutStyle = ButtonBoxStyle.Center;
Confirm.WindowStateEvent += OnWindowStateEvent;
ImageLoader = new FileChooserDialog(
"Load image",
this,
FileChooserAction.Open,
"Cancel", ResponseType.Cancel,
"Open", ResponseType.Accept
);
ClearDigit();
CopyDrawing(Digit);
CopyClassification();
ProbabilityZ.IsEditable = false;
Probability1.IsEditable = false;
Probability2.IsEditable = false;
Probability3.IsEditable = false;
Probability4.IsEditable = false;
Probability5.IsEditable = false;
Probability6.IsEditable = false;
Probability7.IsEditable = false;
Probability8.IsEditable = false;
Probability9.IsEditable = false;
ScoreBox.ModifyFont(Pango.FontDescription.FromString("Verdana 16"));
ClassificationBox.ModifyFont(Pango.FontDescription.FromString("Verdana 16"));
for (int i = 0; i < cnn.Layers.Count; i++)
{
switch (cnn.Layers[i].Type)
{
case LayerTypes.Input:
NetworkLayers.AppendText(String.Format("{0} Input", i));
break;
case LayerTypes.Convolution:
NetworkLayers.AppendText(String.Format("{0} Convolution", i));
break;
case LayerTypes.Subsampling:
NetworkLayers.AppendText(String.Format("{0} Subsampling / Pooling", i));
break;
}
}
PrepareImage(ActivationMap);
PrepareImage(FeatureVector);
PrepareImage(Output);
PrepareImage(Weights);
PrepareImage(NetworkBias);
PrepareImage(FeatureMap);
PrepareImage(BiasMap);
NetworkLayers.Sensitive = false;
ActivationMapScroll.Sensitive = false;
HideFeatureMaps();
}
public INeuralNetwork BuildNeuralNetwork() =>
NetworkManager.NewSequential(TensorInfo.Linear(ParametersLength * MemoryStates),
NetworkLayers.FullyConnected(50, ActivationType.ReLU),
NetworkLayers.FullyConnected(20, ActivationType.ReLU),
NetworkLayers.Softmax(EnvInstance.ActionSpace.Shape.Size));
public void Add(NetworkLayer layer)
{
NetworkLayers.Add(layer);
}