public void linear_fit_regression()
{
_isRunning = true;
if (model != System.IntPtr.Zero)
{
Debug.Log("linear_fit_regression");
double[] inputs = new double[inputSize * baseApprentissage.Length];
double[] outputs = new double[baseApprentissage.Length];
getInputsOutputs(baseApprentissage, inputs, outputs, nbOutputNeuron);
int learningResponse;
Debug.Log("Start learning regression with baseApprentissage...");
learningResponse = LibWrapperMachineLearning.linear_fit_regression(model, inputs, inputSize * baseApprentissage.Length, inputSize, outputs, iterationNumber, learning_rate);
if (learningResponse == -1)
{
Debug.Log("C++ >Aucun modèle en mémoire<");
}
else if (learningResponse == 0)
{
Debug.Log("Learning stop by iterations");
}
else
{
Debug.Log("Learning stop beacause all case were correctly classified");
}
}
else
{
Debug.Log("Aucun modèle en mémoire");
}
_isRunning = false;
}
public void linear_fit_classification_rosenblatt()
{
_isRunning = true;
if (model != System.IntPtr.Zero)
{
Debug.Log("linear_fit_classification_rosenblatt with a learning base of " + baseApprentissage.Length + " marbles");
double[] inputs = new double[inputSize * baseApprentissage.Length];
double[] outputs = new double[baseApprentissage.Length * nbOutputNeuron];
getInputsOutputs(baseApprentissage, inputs, outputs, nbOutputNeuron);
int learningResponse;
learningResponse = LibWrapperMachineLearning.linear_fit_classification_rosenblatt(model, inputs, inputSize * baseApprentissage.Length, inputSize, outputs, nbOutputNeuron, iterationNumber, step);
if (learningResponse == -1)
{
Debug.Log("C++ >Aucun modèle en mémoire<");
}
else if (learningResponse == 0)
{
Debug.Log("Leaning stop by iterations");
}
else
{
Debug.Log("Learning stop beacause all case were correctly classified");
}
}
else
{
Debug.Log("Aucun modèle en mémoire");
}
_isRunning = false;
}
public void predict()
{
_isRunning = true;
if (model != System.IntPtr.Zero)
{
generateBaseTest(baseTest, 10);
double[] input = new double[inputSize];
double[] outputs = new double[baseTest.Length];
Debug.Log("Starting predicting outputs of baseTest...");
int i = 0;
foreach (var data in baseTest)
{
getInput(data, input);
outputs[i] = LibWrapperMachineLearning.linear_predict(model, input, inputSize);
i++;
}
serialiseData2(outputs);
for (i = 0; i < 100; i++)
{
baseTest[i].position = new Vector3(baseTest[i].position.x, (float)outputs [i], baseTest[i].position.z);
}
}
else
{
Debug.Log("Aucun modèle en mémoire");
}
_isRunning = false;
}
public void create_linear_model()
{
_isRunning = true;
if (model == System.IntPtr.Zero)
{
model = LibWrapperMachineLearning.linear_create_model(inputSize, nbOutputNeuron);
Debug.Log("Model created !");
}
else
{
Debug.Log("A model has been created, please delete it if you want to create another one ");
}
_isRunning = false;
}
public void erase_model()
{
_isRunning = true;
if (model != System.IntPtr.Zero)
{
LibWrapperMachineLearning.linear_remove_model(model);
model = System.IntPtr.Zero;
Debug.Log("Model removed !" + model);
}
else
{
Debug.Log("There is no model in memory");
}
_isRunning = false;
}
public void classify()
{
_isRunning = true;
if (model != System.IntPtr.Zero)
{
generateBaseTest(baseTest, 10);
Debug.Log("Classification with a test base of " + baseTest.Length + " marbles");
double[] input = new double[inputSize];
double[] outputs = new double[nbOutputNeuron];
foreach (var unityObject in baseTest)
{
getInput(unityObject, input);
if (testWithColor)
{
LibWrapperMachineLearning.linear_classify(model, input, inputSize, outputs, nbOutputNeuron);
for (int i = 0; i < outputs.Length; i++)
{
if (outputs[i] == 1)
{
if (i % nbColor == colorBlue)
{
unityObject.GetComponent <Renderer>().material.color = UnityEngine.Color.blue;
}
else if (i % nbColor == colorRed)
{
unityObject.GetComponent <Renderer>().material.color = UnityEngine.Color.red;
}
else
{
unityObject.GetComponent <Renderer>().material.color = UnityEngine.Color.green;
}
// Just to position the balls somewhere we can see them
unityObject.position = new Vector3(unityObject.position.x, 2, unityObject.position.z);
}
}
}
else
{
unityObject.position = new Vector3(unityObject.position.x, (float)LibWrapperMachineLearning.linear_classify(model, input, inputSize, outputs, nbOutputNeuron), unityObject.position.z);
}
}
}
else
{
Debug.Log("Aucun modèle en mémoire");
}
_isRunning = false;
}
/// <summary>
/// Méthode utilisée pour gérer les informations et
/// boutons de l'interface utilisateur
/// </summary>
public void OnGUI()
{
// Démarrage d'une liste de composants visuels verticale
GUILayout.BeginVertical();
step = GUI.VerticalScrollbar(new Rect(1000, 25, 10, 500), (float)step, 0.08F, 1.08F, 0.0F);
iterationNumber = (int)GUI.VerticalScrollbar(new Rect(1025, 25, 250, 500), iterationNumber, 0.1F, 10000, 0);
if (model == System.IntPtr.Zero)
{
nbOutputNeuron = (int)GUI.HorizontalScrollbar(new Rect(15, 420, 175, 50), nbOutputNeuron, 0.1F, 1, 20);
GUI.TextArea(new Rect(15, 440, 175, 25), "output neurons scrollbar");
}
GUI.TextArea(new Rect(950, 475, 40, 30), " step");
GUI.TextArea(new Rect(1050, 475, 75, 30), "iterations");
if (GUILayout.Button("Create Model"))
{
if (!_isRunning)
{
create_linear_model();
}
}
if (GUILayout.Button("Erase Model"))
{
if (!_isRunning)
{
erase_model();
}
}
if (GUILayout.Button("Linear_fit_classification_rosenblatt"))
{
if (!_isRunning)
{
StartCoroutine("linear_fit_classification_rosenblatt");
}
}
if (GUILayout.Button("Classify"))
{
if (!_isRunning)
{
classify();
}
}
if (GUILayout.Button("Linear_fit_regression"))
{
if (!_isRunning)
{
linear_fit_regression();
}
}
if (GUILayout.Button("Predict"))
{
if (!_isRunning)
{
predict();
}
}
if (GUILayout.Button("Clean"))
{
if (!_isRunning)
{
clean();
}
}
if (GUILayout.Button("TEST"))
{
if (!_isRunning)
{
Debug.Log("Return 42");
Debug.Log(LibWrapperMachineLearning.return42());
System.IntPtr toto;
toto = LibWrapperMachineLearning.createToto();
Debug.Log("Titi" + LibWrapperMachineLearning.getTiti(toto));
int[] test = new int[2] {
2, 2
};
System.IntPtr model = LibWrapperMachineLearning.createMlp(test, 2);
Debug.Log("REP" + LibWrapperMachineLearning.getOutputsforClassif(model));
Debug.Log("Testing Linear Classification");
int linear_inputSize = 2;
int linear_outputSize = 1;
int linear_nbData = 4;
double[] linear_inputs = new double[linear_inputSize * linear_nbData];
double[] linear_input = new double[linear_inputSize];
double[] linear_outputs = new double[linear_outputSize * linear_nbData];
double[] linear_output = new double[linear_outputSize];
int linear_maxIterations = 10000;
double linear_step = 0.01;
linear_inputs[0] = 0;
linear_inputs[1] = 0;
linear_outputs[0] = -1;
linear_inputs[2] = 0;
linear_inputs[3] = 1;
linear_outputs[1] = -1;
linear_inputs[4] = 1;
linear_inputs[5] = 1;
linear_outputs[2] = 1;
linear_inputs[6] = 1;
linear_inputs[7] = 0;
linear_outputs[3] = 1;
System.IntPtr linearModel = LibWrapperMachineLearning.createLinearModel(linear_inputSize, linear_outputSize);
LibWrapperMachineLearning.linearFitClassificationRosenblatt(linearModel, linear_inputs, linear_nbData * linear_inputSize, linear_inputSize, linear_outputs, linear_outputSize, linear_maxIterations, linear_step);
linear_input[0] = 0;
linear_input[1] = 0;
LibWrapperMachineLearning.linearClassify(linearModel, linear_input, linear_inputSize, linear_output, linear_outputSize);
Debug.Log("Return of linear classification for input[" + linear_input[0] + "][" + linear_input[1] + "] >" + linear_output[0] + "< expected -1");
linear_input[0] = 0;
linear_input[1] = 1;
LibWrapperMachineLearning.linearClassify(linearModel, linear_input, linear_inputSize, linear_output, linear_outputSize);
Debug.Log("Return of linear classification for input[" + linear_input[0] + "][" + linear_input[1] + "] >" + linear_output[0] + "< expected -1");
linear_input[0] = 1;
linear_input[1] = 1;
LibWrapperMachineLearning.linearClassify(linearModel, linear_input, linear_inputSize, linear_output, linear_outputSize);
Debug.Log("Return of linear classification for input[" + linear_input[0] + "][" + linear_input[1] + "] >" + linear_output[0] + "< expected 1");
linear_input[0] = 1;
linear_input[1] = 0;
LibWrapperMachineLearning.linearClassify(linearModel, linear_input, linear_inputSize, linear_output, linear_outputSize);
Debug.Log("Return of linear classification for input[" + linear_input[0] + "][" + linear_input[1] + "] >" + linear_output[0] + "< expected 1");
Debug.Log("Testing MLP Classification");
int testClassifMLP_nbLayer = 2;
int[] testClassifMLP_modelStruct = new int[2] {
2, 1
};
int testClassifMLP_inputSize = 2;
int testClassifMLP_outputSize = 1;
int testClassifMLP_nbData = 4;
double[] testClassifMLP_inputs = new double[testClassifMLP_inputSize * testClassifMLP_nbData];
double[] testClassifMLP_expectedOutputs = new double[testClassifMLP_outputSize * testClassifMLP_nbData];
double[] testClassifMLP_oneInput = new double[testClassifMLP_inputSize];
System.IntPtr mlpModel = LibWrapperMachineLearning.createMlp(testClassifMLP_modelStruct, testClassifMLP_nbLayer);
testClassifMLP_inputs[0] = 0;
testClassifMLP_inputs[1] = 0;
testClassifMLP_inputs[2] = 0;
testClassifMLP_inputs[3] = 1;
testClassifMLP_inputs[4] = 1;
testClassifMLP_inputs[5] = 1;
testClassifMLP_inputs[6] = 1;
testClassifMLP_inputs[7] = 0;
testClassifMLP_expectedOutputs[0] = 1;
testClassifMLP_expectedOutputs[1] = 1;
testClassifMLP_expectedOutputs[2] = -1;
testClassifMLP_expectedOutputs[3] = -1;
Debug.Log("Fitting Classification model with linear inputs");
LibWrapperMachineLearning.fitClassification(mlpModel, testClassifMLP_inputs, testClassifMLP_inputSize, testClassifMLP_inputSize * testClassifMLP_nbData,
testClassifMLP_expectedOutputs, testClassifMLP_outputSize);
testClassifMLP_oneInput[0] = 0;
testClassifMLP_oneInput[1] = 0;
LibWrapperMachineLearning.classify(mlpModel, testClassifMLP_oneInput, testClassifMLP_inputSize);
Debug.Log("Response for input = [" + testClassifMLP_oneInput[0] + "][" + testClassifMLP_oneInput[1] +
"] ->" + LibWrapperMachineLearning.getOutputsforClassif(mlpModel) + "< expected : 1");
testClassifMLP_oneInput[0] = 0;
testClassifMLP_oneInput[1] = 1;
LibWrapperMachineLearning.classify(mlpModel, testClassifMLP_oneInput, testClassifMLP_inputSize);
Debug.Log("Response for input = [" + testClassifMLP_oneInput[0] + "][" + testClassifMLP_oneInput[1] +
"] ->" + LibWrapperMachineLearning.getOutputsforClassif(mlpModel) + "< expected : 1");
testClassifMLP_oneInput[0] = 1;
testClassifMLP_oneInput[1] = 1;
LibWrapperMachineLearning.classify(mlpModel, testClassifMLP_oneInput, testClassifMLP_inputSize);
Debug.Log("Response for input = [" + testClassifMLP_oneInput[0] + "][" + testClassifMLP_oneInput[1] +
"] ->" + LibWrapperMachineLearning.getOutputsforClassif(mlpModel) + "< expected : -1");
testClassifMLP_oneInput[0] = 1;
testClassifMLP_oneInput[1] = 0;
LibWrapperMachineLearning.classify(mlpModel, testClassifMLP_oneInput, testClassifMLP_inputSize);
Debug.Log("Response for input = [" + testClassifMLP_oneInput[0] + "][" + testClassifMLP_oneInput[1] +
"] ->" + LibWrapperMachineLearning.getOutputsforClassif(mlpModel) + "< expected : -1");
Debug.Log("Testing MLP Regression");
int testRegressionMLP_nbLayer = 3;
int[] testRegressionMLP_modelStruct = new int[3] {
2, 2, 1
};
int testRegressionMLP_inputSize = 2;
int testRegressionMLP_outputSize = 1;
int testRegressionMLP_nbData = 3;
double[] testRegressionMLP_inputs = new double[testRegressionMLP_inputSize * testRegressionMLP_nbData];
double[] testRegressionMLP_expectedOutputs = new double[testRegressionMLP_outputSize * testRegressionMLP_nbData];
double[] testRegressionMLP_oneInput = new double[testRegressionMLP_inputSize];
System.IntPtr testRegressionMLP = LibWrapperMachineLearning.createMlp(testRegressionMLP_modelStruct, testRegressionMLP_nbLayer);
testRegressionMLP_inputs[0] = 0;
testRegressionMLP_inputs[1] = 0;
testRegressionMLP_inputs[2] = 0;
testRegressionMLP_inputs[3] = 1;
testRegressionMLP_inputs[4] = 1;
testRegressionMLP_inputs[5] = 1;
testRegressionMLP_expectedOutputs[0] = 0;
testRegressionMLP_expectedOutputs[1] = 0;
testRegressionMLP_expectedOutputs[2] = 0.5;
Debug.Log("Fitting regression model...");
LibWrapperMachineLearning.fitRegression(testRegressionMLP, testRegressionMLP_inputs, testRegressionMLP_inputSize, testRegressionMLP_inputSize * testRegressionMLP_nbData,
testRegressionMLP_expectedOutputs, testRegressionMLP_outputSize);
testRegressionMLP_oneInput[0] = 0;
testRegressionMLP_oneInput[1] = 0;
LibWrapperMachineLearning.predict(testRegressionMLP, testRegressionMLP_oneInput, testRegressionMLP_inputSize);
Debug.Log("Response for input = [" + testRegressionMLP_oneInput[0] + "][" + testRegressionMLP_oneInput[1] + "]" + LibWrapperMachineLearning.getOutputsforRegression(testRegressionMLP) + "< expected : 0");
testRegressionMLP_oneInput[0] = 0;
testRegressionMLP_oneInput[1] = 1;
LibWrapperMachineLearning.predict(testRegressionMLP, testRegressionMLP_oneInput, testRegressionMLP_inputSize);
Debug.Log("Response for input = [" + testRegressionMLP_oneInput[0] + "][" + testRegressionMLP_oneInput[1] + "]" + LibWrapperMachineLearning.getOutputsforRegression(testRegressionMLP) + "< expected : 0");
testRegressionMLP_oneInput[0] = 1;
testRegressionMLP_oneInput[1] = 1;
LibWrapperMachineLearning.predict(testRegressionMLP, testRegressionMLP_oneInput, testRegressionMLP_inputSize);
Debug.Log("Response for input = [" + testRegressionMLP_oneInput[0] + "][" + testRegressionMLP_oneInput[1] + "]" + LibWrapperMachineLearning.getOutputsforRegression(testRegressionMLP) + "< expected : 0.5");
double[] inputs = new double[inputSize * baseApprentissage.Length];
double[] outputs = new double[baseApprentissage.Length];
int outputSize = 1;
getInputsOutputs(baseApprentissage, inputs, outputs, outputSize);
generateBaseTest(baseTest, 10);
double[] input = new double[inputSize];
System.IntPtr testRegressionMLP2 = LibWrapperMachineLearning.createMlp(testRegressionMLP_modelStruct, testRegressionMLP_nbLayer);
LibWrapperMachineLearning.fitRegression(testRegressionMLP2, inputs, inputSize, inputSize * baseApprentissage.Length, outputs, outputSize);
foreach (var data in baseTest)
{
getInput(data, input);
LibWrapperMachineLearning.predict(testRegressionMLP2, input, inputSize);
data.position = new Vector3(data.position.x, (float)LibWrapperMachineLearning.getOutputsforRegression(testRegressionMLP2), data.position.z);
}
Debug.Log("Testing RBF Classification");
int naiveRbfNbRepresentatives = 4;
double naiveRbfGamma = 0.1;
int naiveRbfInputSize = 2;
int naiveRbfOutputSize = 2;
double[] naiveRbfInputs = new double[naiveRbfNbRepresentatives * naiveRbfInputSize];
double[] naiveRbfInput = new double[naiveRbfInputSize];
double[] naiveRbfOutput = new double[naiveRbfOutputSize];
double[] naiveRbfOutputs = new double[naiveRbfNbRepresentatives * naiveRbfOutputSize];
System.IntPtr naiveRbfModel = LibWrapperMachineLearning.createRbfModel(naiveRbfNbRepresentatives);
naiveRbfInputs[0] = 0;
naiveRbfInputs[1] = 0;
naiveRbfOutputs[0] = -1;
naiveRbfInputs[2] = 0;
naiveRbfInputs[3] = 1;
naiveRbfOutputs[1] = -1;
naiveRbfInputs[4] = 1;
naiveRbfInputs[5] = 1;
naiveRbfOutputs[2] = 1;
naiveRbfInputs[6] = 1;
naiveRbfInputs[7] = 0;
naiveRbfOutputs[3] = 1;
LibWrapperMachineLearning.naiveLearnModel(naiveRbfModel, naiveRbfNbRepresentatives, naiveRbfGamma, naiveRbfInputs, naiveRbfInputSize, naiveRbfOutputs);
naiveRbfInput[0] = 0;
naiveRbfInput[1] = 0;
LibWrapperMachineLearning.getRbfResponse(naiveRbfModel, naiveRbfGamma, naiveRbfInput, inputSize, naiveRbfOutputs, naiveRbfInputs, naiveRbfNbRepresentatives);
Debug.Log("Response for input = [" + naiveRbfInput[0] + "][" + naiveRbfInput[1] + "]" + naiveRbfOutputs[0] + "< expected : -1");
naiveRbfInput[0] = 0;
naiveRbfInput[1] = 1;
LibWrapperMachineLearning.getRbfResponse(naiveRbfModel, naiveRbfGamma, naiveRbfInput, inputSize, naiveRbfOutputs, naiveRbfInputs, naiveRbfNbRepresentatives);
Debug.Log("Response for input = [" + naiveRbfInput[0] + "][" + naiveRbfInput[1] + "]" + naiveRbfOutputs[0] + "< expected : -1"); naiveRbfInput[0] = 0;
naiveRbfInput[0] = 1;
naiveRbfInput[1] = 1;
LibWrapperMachineLearning.getRbfResponse(naiveRbfModel, naiveRbfGamma, naiveRbfInput, inputSize, naiveRbfOutputs, naiveRbfInputs, naiveRbfNbRepresentatives);
Debug.Log("Response for input = [" + naiveRbfInput[0] + "][" + naiveRbfInput[1] + "]" + naiveRbfOutputs[0] + "< expected : 1"); naiveRbfInput[0] = 0;
naiveRbfInput[0] = 1;
naiveRbfInput[1] = 0;
LibWrapperMachineLearning.getRbfResponse(naiveRbfModel, naiveRbfGamma, naiveRbfInput, inputSize, naiveRbfOutputs, naiveRbfInputs, naiveRbfNbRepresentatives);
Debug.Log("Response for input = [" + naiveRbfInput[0] + "][" + naiveRbfInput[1] + "]" + naiveRbfOutputs[0] + "< expected : 1");
}
}
if (GUILayout.Button(colorButtonString))
{
if (!_isRunning)
{
if (testWithColor)
{
testWithColor = false;
colorButtonString = "Use color";
}
else
{
testWithColor = true;
colorButtonString = "Use height";
}
}
}
if (GUILayout.Button(transformButtonString))
{
if (!_isRunning)
{
if (transformInput)
{
transformInput = false;
transformButtonString = "Use Transformation";
}
else
{
transformInput = true;
transformButtonString = "Don't Use Transformation";
}
}
}
if (GUILayout.Button("Switch Cam"))
{
if (!_isRunning)
{
if (cam1.enabled == true)
{
cam1.enabled = false;
cam2.enabled = true;
}
else
{
cam1.enabled = true;
cam2.enabled = false;
}
}
}
GUILayout.TextArea(" step >" + step + "<");
GUILayout.TextArea(" iterations >" + iterationNumber + "<");
GUILayout.TextArea(" size of input >" + inputSize + "<");
GUILayout.TextArea(" size of output >" + nbOutputNeuron + "<");
if (testWithColor && model == System.IntPtr.Zero)
{
if (GUILayout.Button(nbColorButtonString))
{
if (nbColor == 2)
{
nbColor = 3;
nbColorButtonString = "Change to 2 colors";
}
else
{
nbColor = 2;
nbColorButtonString = "Change to 3 colors";
}
}
}
// Fin de la liste de composants visuels verticale
GUILayout.EndVertical();
}
