private LayerConfiguration GetLayerConfiguration(NumericUpDown neuronCountSelector, ComboBox activationDropdown)
{
int neuronCount = decimal.ToInt32(neuronCountSelector.Value);
string selectedItem = (string)activationDropdown.SelectedItem;
IActivation activation;
if (selectedItem == "Tanh")
{
activation = new HyperbolicTangentActivation();
}
else if (selectedItem == "ReLU")
{
activation = new RectifiedLinearUnitActivation();
}
else if (selectedItem == "Softplus")
{
activation = new SoftplusActivation();
}
else
{
activation = new SigmoidActivation();
}
return(new LayerConfiguration(neuronCount, activation));
}
public void CreateAndCompileModel2()
{
Console.WriteLine("Creating model");
GlobalRandom.InitializeRandom();
int imgSize = 75;
ReluActivation reluActivation = new ReluActivation();
SoftmaxActivation softmaxActivation = new SoftmaxActivation();
SigmoidActivation sigmoidActivation = new SigmoidActivation();
model = new ConvolutionalNeuralNetwork(imgSize, "grayscale");
model.Add(new ConvolutionalLayer(5, 5, reluActivation, "valid"));
model.Add(new MaxPoolingLayer());
model.Add(new ConvolutionalLayer(5, 3, reluActivation, "valid"));
model.Add(new MaxPoolingLayer());
model.Add(new DropoutLayer(0.2));
model.Add(new FlattenLayer());
model.Add(new DropoutLayer(0.5));
model.Add(new DenseLayer(26, sigmoidActivation));
Console.WriteLine("Model created");
model.Compile();
Console.WriteLine("Model compiled");
}
public LstmLayer(RecurentCellParameters[] cellsParameters, SigmoidActivation sigmoid, HyperbolicActivation tanh)
{
InitializeCells(cellsParameters, sigmoid, tanh);
Input = new Vector(cellsParameters.First().LengthOfInput);
Output = new Vector(cellsParameters.Last().LengthOfOutput);
Sigmoid = sigmoid;
}
private void InitializeCells(RecurentCellParameters[] cellsParameters, SigmoidActivation sigmoid, HyperbolicActivation tanh)
{
Cells = new List <LstmCell>();
for (var i = 0; i < cellsParameters.Length; i++)
{
Cells.Add(new LstmCell(cellsParameters[i].LengthOfInput, cellsParameters[i].LengthOfOutput,
sigmoid, tanh));
}
}
private void Calculate()
{
if (Inputs.Zeroed() && InputGateSynapses.Zeroed() && ForgetGateSynapses.Zeroed() && OutputGateSypanses.Zeroed())
{
cellState = (inputGateValue * _value) + (forgetGateValue * cellState);
outputGateValue = SigmoidActivation.Activate(outputGateValue + cellState);
_value = TanHActivation.Activate(cellState) * outputGateValue;
_lastValue = _value;
}
}
public void InputGate(float value)
{
inputGateValue += value;
InputGateSynapses.AccountSignal();
if (InputGateSynapses.CheckCountAndReset())
{
inputGateValue = SigmoidActivation.Activate(inputGateValue + cellState);
Calculate();
}
}
public void ForgetGate(float value)
{
forgetGateValue += value;
ForgetGateSynapses.AccountSignal();
if (ForgetGateSynapses.CheckCountAndReset())
{
forgetGateValue = SigmoidActivation.Activate(forgetGateValue + cellState);
Calculate();
}
}
public XORNetworkLayout()
{
var neuronInitializer = new RandomLayerInitializer();
var outputActivation = new SigmoidActivation();
layers = new List <Layer>
{
new Layer(2, 3, neuronInitializer, outputActivation),
new Layer(3, 1, neuronInitializer, outputActivation),
};
ConnectLayers();
}
/// <summary>
///
/// </summary>
/// <param name="nbInputs"></param>
/// <param name="structure"></param>
/// <param name="learningRate"></param>
public NeuralNetwork(int nbInputs, int[] structure, double learningRate = BASE_LEARNING_RATE)
{
ActivationEquation = new SigmoidActivation();
NbNecessaryInputs = nbInputs;
Layout = structure;
Layers = new Layer[structure.Length];
//On instancie le premier etage des hidden layer.
Layers[0] = new Layer(structure[0], NbNecessaryInputs);
//On instancie les etages suivants on mettant le nombre de connexions pour les neurones au nombre de neurones de letage precedent
for (int i = 1; i < NbLayers; i++)
{
Layers[i] = new Layer(structure[i], structure[i - 1]);
}
}
public string Upload(ImageData upload)
{
string path = Server.MapPath(@"~/App_Data/network.json");
var activation = new SigmoidActivation();
var outputList = Enumerable.Range(0, 10).Select(i => i.ToString(CultureInfo.InvariantCulture)).ToList();
var network = new Network(activation, 784, outputList, path);
string raw = upload.base64Image;
byte[] data = Convert.FromBase64String(raw.Substring(raw.IndexOf(',') + 1));
Bitmap bitmap;
const int imageSize = 28;
using (var inStream = new MemoryStream(data, 0, data.Length))
{
using (var outstream = new MemoryStream())
{
using (var imagefactory = new ImageProcessor.ImageFactory())
{
imagefactory.Load(inStream)
.Resize(new ResizeLayer(new Size(imageSize, imageSize), ResizeMode.Stretch))
.Filter(MatrixFilters.GreyScale)
.Filter(MatrixFilters.Invert)
.Flip(true)
.Rotate(90)
.Save(outstream);
}
outstream.Position = 0;
bitmap = new Bitmap(outstream);
}
}
var inputs = new List <double>();
for (int x = 0; x < imageSize; x++)
{
for (int y = 0; y < imageSize; y++)
{
Color pixel = bitmap.GetPixel(x, y);
inputs.Add(((pixel.R + pixel.G + pixel.B) / 3.0d) / 255.0d);
}
}
network.UpdateNetwork(inputs);
string result = network.GetMostLikelyAnswer();
return(string.Format("I think it looks like a {0}", result));
}
public void SigmoidActivation_Activiation()
{
var actual = new float[] { -20, -10, -5, -1, 0, 1, 5, 10, 20 };
var sut = new SigmoidActivation();
sut.Activation(actual);
var expected = new float[] { 2.06115369E-09f, 4.539787E-05f, 0.006692851f,
0.268941432f, 0.5f, 0.7310586f, 0.9933072f, 0.9999546f, 1 };
Assert.AreEqual(expected[0], actual[0]);
Assert.AreEqual(expected[1], actual[1]);
Assert.AreEqual(expected[2], actual[2]);
Assert.AreEqual(expected[3], actual[3]);
Assert.AreEqual(expected[4], actual[4]);
Assert.AreEqual(expected[5], actual[5]);
Assert.AreEqual(expected[6], actual[6]);
Assert.AreEqual(expected[7], actual[7]);
Assert.AreEqual(expected[8], actual[8]);
}
private void okButton_Click(object sender, RoutedEventArgs e)
{
ActivationFunction activator = new SigmoidActivation();
neuralNetwork = new NeuralNetwork();
neuralNetwork.CreateLayer(activator, inputNeurons, true);
foreach (TextBox textBox in hiddenNeuronTextBoxes)
{
int numberOfNeurons;
if (Int32.TryParse(textBox.Text, out numberOfNeurons))
{
neuralNetwork.CreateLayer(activator, numberOfNeurons, true);
}
}
neuralNetwork.CreateLayer(activator, outputNeurons, false);
Close();
}
public void SigmoidActivation_Derivative()
{
var activatedSigmoid = new float[] { 2.06115369E-09f, 4.539787E-05f, 0.006692851f,
0.268941432f, 0.5f, 0.7310586f, 0.9933072f, 0.9999546f, 1 };
var actual = new float[9];
var sut = new SigmoidActivation();
sut.Derivative(activatedSigmoid, actual);
var expected = new float[] { 2.06115369E-09f, 4.53958055E-05f,
0.00664805667f, 0.196611941f, 0.25f, 0.196611926f, 0.006648033f,
4.54166766E-05f, 1 };
Assert.AreEqual(expected[0], actual[0]);
Assert.AreEqual(expected[1], actual[1]);
Assert.AreEqual(expected[2], actual[2]);
Assert.AreEqual(expected[3], actual[3]);
Assert.AreEqual(expected[4], actual[4]);
Assert.AreEqual(expected[5], actual[5]);
Assert.AreEqual(expected[6], actual[6]);
Assert.AreEqual(expected[7], actual[7]);
Assert.AreEqual(expected[8], actual[8]);
}
// нужно передать значение активации
public LstmCell(int lengthOfInput, int lengthOfOutput, SigmoidActivation sigmoid, HyperbolicActivation tanh)
{
InitializeData(lengthOfInput, lengthOfOutput);
Sigmoid = sigmoid;
Tanh = tanh;
}
public static void TestOpenCLTrainingWithConfig(IErrorFunction errorFunc, TrainingConfig.Regularization regularization, float regularizationLambda, float learningRate, bool mix_activations = false)
{
IActivationFunction alternateActivation = new SigmoidActivation();
if (mix_activations)
{
alternateActivation = new ReLUActivation();
}
int input_neurons = 10;
var layer_config = new List <Tuple <IActivationFunction, int> >();
layer_config.Add(new Tuple <IActivationFunction, int>(new SigmoidActivation(), 512));
layer_config.Add(new Tuple <IActivationFunction, int>(alternateActivation, 12));
layer_config.Add(new Tuple <IActivationFunction, int>(new SigmoidActivation(), 3));
layer_config.Add(new Tuple <IActivationFunction, int>(alternateActivation, 51));
layer_config.Add(new Tuple <IActivationFunction, int>(new SigmoidActivation(), 30));
Network networkReference = Network.CreateNetworkInitRandom(input_neurons, layer_config);
var jsonData = networkReference.ExportToJSON();
Network networkCpuTrained = Network.CreateNetworkFromJSON(jsonData);
Network networkOpenCLTrained = Network.CreateNetworkFromJSON(jsonData);
var cpuCalculator = ComputeDeviceFactory.CreateFallbackComputeDevice();
var openCLCalculator = GetFirstOpenCLDevice();
var rnd = new Random();
List <TrainingSuite.TrainingData> trainingData = new List <TrainingSuite.TrainingData>();
for (int i = 0; i < 1000; i++)
{
float[] input = new float[input_neurons];
float[] output = new float[layer_config.Last().Item2];
var idx = rnd.Next(0, input.Length);
input[rnd.Next(0, input.Length)] = 1.0f;
for (int j = 0; j < 10; j++)
{
output[j * 3 + 0] = idx * 0.1f;
output[j * 3 + 1] = 1.0f - (idx * 0.1f);
output[j * 3 + 2] = idx * 0.05f;
}
trainingData.Add(new TrainingSuite.TrainingData(input, output));
}
TrainingSuite suite = new TrainingSuite(trainingData);
suite.config.epochs = 1;
suite.config.shuffleTrainingData = false;
suite.config.miniBatchSize = 13;
suite.config.costFunction = errorFunc;
suite.config.regularization = regularization;
suite.config.regularizationLambda = regularizationLambda;
suite.config.learningRate = learningRate;
var promise1 = networkCpuTrained.Train(suite, cpuCalculator);
var promise2 = networkOpenCLTrained.Train(suite, openCLCalculator);
promise1.Await();
promise2.Await();
Assert.IsTrue(promise1.IsReady() && promise2.IsReady());
float[] testInput = new float[input_neurons];
var cpuTrainedOutput = networkCpuTrained.Compute(testInput, cpuCalculator);
var openCLTrainedOutput = networkOpenCLTrained.Compute(testInput, cpuCalculator);
ValidateFloatArray(cpuTrainedOutput, openCLTrainedOutput);
}
