public double Predict(double[][] observations, int[] labels)
{
int[] predicted = machine.Decide(observations);
double error = new AccuracyLoss(labels).Loss(predicted);
return(1 - error);
}
public void not_seen_before_test()
{
// DecisionTree chokes on variable values it has never seen before #689
int[][] training =
{
new [] { 0, 2, 4 },
new [] { 1, 5, 2 },
new [] { 1, 5, 6 },
};
int[][] testing =
{
new [] { 99, 2, 4 },
new [] { 1, 5, 17 },
new [] { 1, 15, 6 },
};
int[] outputs =
{
1, 1, 0
};
ID3Learning teacher = new ID3Learning();
DecisionTree tree = teacher.Learn(training, outputs);
int[] train = tree.Decide(training);
int[] test = tree.Decide(testing);
Assert.IsTrue(train.IsEqual(new int[] { 1, 1, 0 }));
Assert.IsTrue(test.IsEqual(new int[] { 1, 0, 0 }));
}
public int[] Predict(List <TrainingValue> predictionData)
{
if (!Trained)
{
throw new Exception("Train must be called first!");
}
double[][] featuresArray = new double[predictionData.Count][];
for (int i = 0; i < featuresArray.Length; i++)
{
featuresArray[i] = predictionData[i].Features;
}
switch (type)
{
case ClassifierType.DecisionTree:
return(tree.Decide(featuresArray));
case ClassifierType.LDA:
return(pipeline.Decide(featuresArray));
case ClassifierType.SVM:
return(convertBoolArray(svm.Decide(featuresArray)));
case ClassifierType.Bayes:
return(bayes.Decide(featuresArray));
}
return(null);
}
public void Probe()
{
pb = csv.ImportFromCsvFile(PROBE);
for (int i = 0; i < pb.Rows.Count; i++)
{
int[] query = codebook.Transform(new[, ]
{
{ "Buying", pb.Rows[i].ItemArray[0].ToString() },
{ "Maint", pb.Rows[i].ItemArray[1].ToString() },
{ "doors", pb.Rows[i].ItemArray[2].ToString() },
{ "persons", pb.Rows[i].ItemArray[3].ToString() },
{ "Lug_boot", pb.Rows[i].ItemArray[4].ToString() },
{ "Safety", pb.Rows[i].ItemArray[5].ToString() }
});
int predicted = tree.Decide(query);
if (predicted != -1)
{
string answer = codebook.Revert("CarType", predicted);
result += "BUYING--" + pb.Rows[i].ItemArray[0].ToString() + "-->" + "MAINT--" + pb.Rows[i].ItemArray[1].ToString() + "-->" + "DOORS--"
+ pb.Rows[i].ItemArray[2].ToString() + "-->" + "PERSONS--" + pb.Rows[i].ItemArray[3].ToString() + "-->" + "LUG_BOOT--" + pb.Rows[i].ItemArray[4].ToString() + "-->" + "SAFETY--" + pb.Rows[i].ItemArray[4].ToString() + "-->" + answer.ToUpper();
result += "\r\n";
}
else
{
result += "BUYING--" + pb.Rows[i].ItemArray[0].ToString() + "-->" + "MAINT--" + pb.Rows[i].ItemArray[1].ToString() + "-->" + "DOORS--"
+ pb.Rows[i].ItemArray[2].ToString() + "-->" + "PERSONS--" + pb.Rows[i].ItemArray[3].ToString() + "-->" + "LUG_BOOT--" + pb.Rows[i].ItemArray[4].ToString() + "-->" + "SAFETY--" + pb.Rows[i].ItemArray[4].ToString() + "-->" + "Not Answer Found";
result += "\r\n";
}
}
}
private List <productos> revisarProductos(DataTable data)
{
var codebook = new Codification(data);
int numCategorias = db.categorias.Count();
DecisionVariable[] attributes =
{
new DecisionVariable("Categoria", numCategorias), // 3 possible values (Sunny, overcast, rain)
new DecisionVariable("Precio", 5), // 3 possible values (Hot, mild, cool)
};
int classCount = 2; // 2 possible output values for playing tennis: yes or no
DecisionTree tree = new DecisionTree(attributes, classCount);
// Create a new instance of the ID3 algorithm
ID3Learning id3learning = new ID3Learning(tree);
// Translate our training data into integer symbols using our codebook:
DataTable symbols = codebook.Apply(data);
int[][] inputs = symbols.ToIntArray("Categoria", "Precio");
int[] outputs = symbols.ToIntArray("recomendar").GetColumn(0);
// Learn the training instances!
id3learning.Run(inputs, outputs);
// Compute the training error when predicting training instances
double error = new ZeroOneLoss(outputs).Loss(tree.Decide(inputs));
// The tree can now be queried for new examples through
// its decide method. For example, we can create a query
List <productos> product = db.productos.ToList();
foreach (productos item in db.productos.ToList())
{
int[] query = codebook.Transform(new[, ] {
{ "Categoria", Convert.ToString(item.fkCategoria) },
{ "Precio", devolverTipoPrecio(item.precio) }
});
// And then predict the label using
int predicted = tree.Decide(query); // result will be 0
// We can translate it back to strings using
string answer = codebook.Revert("recomendar", predicted); // Answer will be: "No"
if (answer.Equals("no"))
{
product.Remove(item);
}
}
return(product);
}
public override Task <List <GeneralConfusionMatrix> > ComputeFoldedConfusionMatrixAsync(ClassificationModel classificationModel, int folds)
{
return(Task.Factory.StartNew(() =>
{
int numFeatures = classificationModel.FeatureVectors.Count;
DecisionVariable[] decisionVariables = Enumerable.ToArray(classificationModel.Bands.Select(b => DecisionVariable.Continuous(b.ToString())));
double[][] input = new double[numFeatures][];
int[] responses = new int[numFeatures];
for (int featureIndex = 0; featureIndex < classificationModel.FeatureVectors.Count; ++featureIndex)
{
var featureVector = classificationModel.FeatureVectors[featureIndex];
input[featureIndex] = Array.ConvertAll(featureVector.FeatureVector.BandIntensities, s => (double)s / ushort.MaxValue);
responses[featureIndex] = featureVector.FeatureClass;
}
List <GeneralConfusionMatrix> confusionMatrices = new List <GeneralConfusionMatrix>();
// Create a new Cross-validation algorithm passing the data set size and the number of folds
var crossvalidation = new CrossValidation(input.Length, folds);
crossvalidation.Fitting = delegate(int k, int[] indicesTrain, int[] indicesValidation)
{
// Lets now grab the training data:
var trainingInputs = input.Get(indicesTrain);
var trainingOutputs = responses.Get(indicesTrain);
// And now the validation data:
var validationInputs = input.Get(indicesValidation);
var validationOutputs = responses.Get(indicesValidation);
var tree = new DecisionTree(decisionVariables, Enum.GetValues(typeof(LandcoverTypeViewModel)).Length);
C45Learning id3Learning = new C45Learning(tree);
id3Learning.Learn(trainingInputs, trainingOutputs);
var predictedTraining = tree.Decide(trainingInputs);
var predictedValidation = tree.Decide(validationInputs);
double trainingError = new ZeroOneLoss(trainingOutputs).Loss(predictedTraining);
double validationError = new ZeroOneLoss(validationOutputs).Loss(predictedValidation);
GeneralConfusionMatrix confusionMatrix = new GeneralConfusionMatrix(Enum.GetValues(typeof(LandcoverTypeViewModel)).Length - 1, validationOutputs, predictedValidation);
confusionMatrices.Add(confusionMatrix);
// Return a new information structure containing the model and the errors achieved.
return new CrossValidationValues(trainingError, validationError);
};
var result = crossvalidation.Compute();
return confusionMatrices;
}));
}
public double Test(DataTable test)
{
DataTable convertedData = codeBook.Apply(test);
//Convierte los valores traducidos a inputs y el output esperado.
double[][] inputs = convertedData.ToJagged(headers);
int[] outputs = convertedData.ToArray <int>("G3");
double error = new ZeroOneLoss(outputs).Loss(tree.Decide(inputs));
return(1 - error);
}
static void Main(string[] args)
{
DataTable table = new Accord.IO.CsvReader("C:\\Users\\michael\\Downloads\\JulyToOct2015Test.csv", true).ToTable();
// Convert the DataTable to input and output vectors
double[][] inputs = table.ToJagged <double>("BookToPrice", "DividendYield", "DebtToEquity", "MarketBeta", "SectorID");
int[] outputs = table.Columns["MonthlyReturn"].ToArray <int>();
//SecurityID BookToPrice DividendYield EarningsYield SalesGrowth AssetsToEquity MarketCap MarketBeta DebtToEquity 1YrVol 5YrVol 3YrVol ExposureToCurrencyGain SectorID countryID
DecisionTree tree = new DecisionTree(
inputs: new List <DecisionVariable>
{
DecisionVariable.Continuous("BookToPrice"),
DecisionVariable.Continuous("DividendYield"),
DecisionVariable.Continuous("DebtToEquity"),
DecisionVariable.Continuous("MarketBeta"),
DecisionVariable.Discrete("SectorID", 11)
},
classes: 2);
C45Learning teacher = new C45Learning(tree);
teacher.Learn(inputs, outputs);
int[] answers = tree.Decide(inputs);
// Plot the results
// ScatterplotBox.Show("Expected results", inputs, outputs);
//ScatterplotBox.Show("Ans", inputs, answers)
// .Hold();
}
static void BestClassificator(RandomForest forest, DecisionTree tree, KNearestNeighbors knn, double[] precision)
{
if (precision[0] > precision[1])
{
Console.WriteLine("Geriausias parinktas klasifikavimo metodas: {0}", "Random Forest");
Console.Write("Iveskite penkiu kortu rinkini, skaicius atskirdamo tarpu: ");
string[] val = Console.ReadLine().Split(' ');
double[] hand = new double[10];
for (int i = 0; i < 10; i++)
{
hand[i] = Convert.ToDouble(val[i]);
}
Console.WriteLine(forest.Decide(hand));
}
else
{
Console.WriteLine("Geriausias parinktas klasifikavimo metodas: %s", "Decision Tree");
Console.Write("Iveskite penkiu kortu rinkini, skaicius atskirdamo tarpu: ");
string[] val = Console.ReadLine().Split(' ');
double[] hand = new double[10];
for (int i = 0; i < 10; i++)
{
hand[i] = Convert.ToDouble(val[i]);
}
Console.WriteLine(tree.Decide(hand));
}
}
public bool classifierDT(data d)
{
int D = d.d;
double[] input = new double[D];
int output;
for (int i = 0; i < D; ++i)
{
input[i] = d.msg[i];
}
output = tree.Decide(input);
return(output == 1);
}
public void ChooseBuilding()
{
StopSound();
_buildingDecision.Reset();
foreach (System.Reflection.MethodInfo method in this.GetType().GetMethods())
{
if (((BuildingChoiceMethod[])method.GetCustomAttributes(typeof(BuildingChoiceMethod), true)).Length > 0)
{
DecisionTree <GameObject> .Percept p = _buildingDecision.GetPercept(method.Name);
if (p != null && ((Func <bool>)Delegate.CreateDelegate(typeof(Func <bool>), this, method))())
{
p.Activate();
}
}
}
GameObject nextBuild = _buildingDecision.Decide();
bool water = (nextBuild.name == "FishermanHut");
_target = _village.AddBuilding(_construction, ChooseEmplacement(water)).GetComponent <ConstructionSite>();
_target.Building = nextBuild;
string[] props = Manager.Instance.Properties.GetElement("BuildingCost." + _target.Building.name).GetElements();
for (int i = 1; i < props.Length; i++)
{
props[i] = props[i].Remove(0, _target.Building.name.Length + 1);
}
for (int i = 1; i < props.Length - 1; i++)
{
_target.Needed[props[i]] = (int)(float)Manager.Instance.Properties.GetElement("BuildingCost." + _target.Building.name + "." + props[i]).Value;
}
_target.Duration = (float)Manager.Instance.Properties.GetElement("BuildingCost." + _target.Building.name + ".Duration").Value;
}
private double computeError()
{
return(new ZeroOneLoss(outputs)
{
Mean = true
}.Loss(tree.Decide(inputs)));
}
/// <summary>
/// Tests the previously created tree into a new set of data.
/// </summary>
///
private void btnTestingRun_Click(object sender, EventArgs e)
{
if (tree == null || dgvTestingSource.DataSource == null)
{
MessageBox.Show("Please create a machine first.");
return;
}
// Creates a matrix from the entire source data table
double[][] table = (dgvLearningSource.DataSource as DataTable).ToJagged(out columnNames);
// Get only the input vector values (first two columns)
double[][] inputs = table.GetColumns(0, 1);
// Get the expected output labels (last column)
int[] expected = table.GetColumn(2).ToInt32();
// Compute the actual tree outputs
int[] actual = tree.Decide(inputs);
// Use confusion matrix to compute some statistics.
ConfusionMatrix confusionMatrix = new ConfusionMatrix(actual, expected, 1, 0);
dgvPerformance.DataSource = new [] { confusionMatrix };
// Create performance scatter plot
CreateResultScatterplot(zedGraphControl1, inputs, expected.ToDouble(), actual.ToDouble());
}
private void ComputeInference()
{
var codebook = new Codification();
codebook.Learn(tradeTable);
DataTable symbols = codebook.Apply(tradeTable);
string[] inputNames = new[] { "Strike", "MarketPrice", "Notional" };
double[][] inputs = tradeTable.ToJagged(inputNames);
int[] outputs = tradeTable.ToArray <int>("Result");
var teacher = new C45Learning()
{
Attributes = DecisionVariable.FromCodebook(codebook, inputNames)
};
DecisionTree tree = teacher.Learn(inputs, outputs);
int[] predicted = tree.Decide(inputs);
double error = new ZeroOneLoss(outputs).Loss(predicted);
DecisionSet rules = tree.ToRules();
var str = rules.ToString();
textBoxInferredRules.Text = str;
}
public void Learn(List <BaseAttribute <T> > attributeColumns, BaseAttribute <T> outputAttributeColumn)
{
// Create a new instance of the ID3 algorithm
ID3Learning id3learning = new ID3Learning(DecisionTree);
// Translate our training data into integer symbols using our codebook:
DataTable symbols = Codebook.Apply(Data);
var columnNames = attributeColumns.Select(attribute => attribute.Name).ToArray();
int[][] inputs = symbols.ToJagged <int>(columnNames);
int[] outputs = symbols.ToJagged <int>(outputAttributeColumn.Name).GetColumn(0);
// Learn the training instances!
DecisionTree = id3learning.Learn(inputs, outputs);
double error = new ZeroOneLoss(outputs).Loss(DecisionTree.Decide(inputs));
Debug.WriteLine(error);
// Moreover, we may decide to convert our tree to a set of rules:
DecisionSet rules = DecisionTree.ToRules();
// And using the codebook, we can inspect the tree reasoning:
string ruleText = rules.ToString(Codebook as Codification <string>, outputAttributeColumn.Name,
System.Globalization.CultureInfo.InvariantCulture);
Debug.WriteLine(ruleText);
}
// Compute car control based on sensor readings
void ComputeControl(float sensorL, float sensorF, float sensorR, float carVelocity, float forward)
{
// Inputs
float[][] inputsT = new float[1][];
inputsT[0] = new float[4];
inputsT[0][0] = sensorL;
inputsT[0][1] = sensorF;
inputsT[0][2] = sensorR;
inputsT[0][3] = carVelocity;
float[][] inputs = new float[1][];
inputs[0] = new float[5];
inputs[0][0] = sensorL;
inputs[0][1] = sensorF;
inputs[0][2] = sensorR;
inputs[0][3] = carVelocity;
inputs[0][4] = forward;
answerThrust = treeThrust.Decide(inputsT);
answerSteer = treeSteer.Decide(inputs);
// Thrust
if (answerThrust[0] == 1)
{
thrust = pod[1];
//Debug.Log("Acelera!");
}
else if (answerThrust[0] == 0)
{
thrust = -pod[2];
//Debug.Log("Freia!");
}
// Steer
if (answerSteer[0] == 1)
{
if (sensorLeft > sensorRight)
{
steer = pod[3];
//Debug.Log("Vire a Esquerda!");
}
else
{
steer = -pod[3];
//Debug.Log("Vire a Direita!");
}
}
else if (answerSteer[0] == 0)
{
steer = 0;
//Debug.Log("Vai reto!");
}
// Command
rb.AddRelativeForce(new Vector2(0f, thrust));
rb.AddTorque(steer);
}
public string getRecommendationsByUsers(string id = "user4")
{
DataTable data = new DataTable("dataTable");
PopulateHead(data);
PopulateTable(data, id);
Codification codification = new Codification(data);
DataTable codifiedData = codification.Apply(data);
int[][] input = codifiedData.ToJagged <int>("Age", "Gender");
int[] predictions = codifiedData.ToArray <int>("Best Genre");
ID3Learning decisionTreeLearningAlgorithm = new ID3Learning {
};
try
{
var customer = _context.Customers.Where(c => c.Username == id).FirstOrDefault();
int[] query;
if (customer.Age <= 12)
{
query = codification.Transform(new[, ] {
{ "Age", "0-12" }, { "Gender", customer.Gender.ToString() }
});
}
else if (12 < customer.Age && customer.Age <= 25)
{
query = codification.Transform(new[, ] {
{ "Age", "13-25" }, { "Gender", customer.Gender.ToString() }
});
}
else if (25 < customer.Age && customer.Age < 40)
{
query = codification.Transform(new[, ] {
{ "Age", "26-39" }, { "Gender", customer.Gender.ToString() }
});
}
else
{
query = codification.Transform(new[, ] {
{ "Age", "40+" }, { "Gender", customer.Gender.ToString() }
});
}
DecisionTree decisionTree = decisionTreeLearningAlgorithm.Learn(input, predictions);
int result = decisionTree.Decide(query);
string diagnosis = codification.Revert("Best Genre", result);
return(diagnosis);
}
catch (Exception)
{
return("Unfortunatly No Matches Were Found");
throw;
}
}
public override Class Classify(TObj obj)
{
if (m_Result == null)
{
throw new MLException("Decision tree is empty");
}
return(m_Result.Decide(obj));
}
public string PredictTopic(DocumentData documentData)
{
ArgumentValidator.ValidateObject(documentData);
var query = codeBook.Transform(input);
decisionTree.Decide(query);
throw new System.NotImplementedException();
}
public string Evaluate(string branch, string cType, string gender, string payment)
{
// The tree can now be queried for new examples through
// its decide method. For example, we can create a query
int[] query = codebook.Transform(new[, ]
{
{ "Branch", branch },
{ "Customer type", cType },
{ "Gender", gender },
{ "Payment", payment }
});
// And then predict the label using
int predicted = tree.Decide(query); // result will be 0
// We can translate it back to strings using
return(codebook.Revert("Product line", predicted)); // Answer will be: "No"
}
public double treeDeciding()
{
double val = tree.Decide(new double[] { lam.Age, lam.Gender, lam.Total_Bilirubin, lam.Direct_Bilirubin
, lam.Alkaline_Phosphotase, lam.Alamine_Aminotransferase
, lam.Aspartate_Aminotransferase, lam.Total_Protiens
, lam.Albumin, lam.Albumin_and_Globulin_Ratio });
return(val);
}
public static void Main(string[] args)
{
//getting example data
Iris iris = new Iris();
//we are creating training data arrays
double[][] input = new double[147][];
int[] output = new int[147];
//we process 'Iris' data and delete 1 from each type for later test purpose
int j = 0;
for (int i = 0; i < 147; i++)
{
if (i != 0 || i != 50 || i != 100)
{
input[j] = new double[4];
output[j] = iris.ClassLabels[i];
for (int k = 0; k < 4; k++)
{
input[j][k] = iris.Instances[i][k];
}
j++;
}
}
//learning algorithm for decision tree
C45Learning teacher = new C45Learning(new[] {
DecisionVariable.Continuous(iris.VariableNames[0]),
DecisionVariable.Continuous(iris.VariableNames[1]),
DecisionVariable.Continuous(iris.VariableNames[2]),
DecisionVariable.Continuous(iris.VariableNames[3]),
});
//model learning
DecisionTree tree = teacher.Learn(input, output);
//If we would have some other irises we could just wrote like this
//DecisionTree tree = teacher.Learn(iris.Instances, iris.ClassLabels);
//but we prefer to left some for test purpose (to check if our programm is working fine)
//testing our model
double[][] test = { iris.Instances[0], iris.Instances[50], iris.Instances[100] };
int[] answers = tree.Decide(test);
Console.WriteLine("Answer should be as follow:\n0,1,2,\nAnswer is:");
foreach (int ans in answers)
{
Console.Write(ans + ",");
}
Console.Write("\nPress any key to continue . . . ");
Console.ReadKey(true);
}
/// <summary>
/// Creates and learns a Decision Tree to recognize the
/// previously loaded dataset using the current settings.
/// </summary>
///
private void btnCreate_Click(object sender, EventArgs e)
{
if (dgvLearningSource.DataSource == null)
{
MessageBox.Show("Please load some data first.");
return;
}
// Finishes and save any pending changes to the given data
dgvLearningSource.EndEdit();
// Creates a matrix from the entire source data table
double[,] table = (dgvLearningSource.DataSource as DataTable).ToMatrix(out columnNames);
// Get only the input vector values (first two columns)
double[][] inputs = table.GetColumns(0, 1).ToJagged();
// Get only the output labels (last column)
int[] outputs = table.GetColumn(2).ToInt32();
// Specify the input variables
DecisionVariable[] variables =
{
new DecisionVariable("x", DecisionVariableKind.Continuous),
new DecisionVariable("y", DecisionVariableKind.Continuous),
};
// Create the C4.5 learning algorithm
var c45 = new C45Learning(variables);
// Learn the decision tree using C4.5
tree = c45.Learn(inputs, outputs);
// Show the learned tree in the view
decisionTreeView1.TreeSource = tree;
// Get the ranges for each variable (X and Y)
DoubleRange[] ranges = table.GetRange(0);
// Generate a Cartesian coordinate system
double[][] map = Matrix.Cartesian(
Vector.Interval(ranges[0], 0.05),
Vector.Interval(ranges[1], 0.05));
// Classify each point in the Cartesian coordinate system
double[,] surface = map.ToMatrix().InsertColumn(tree.Decide(map));
CreateScatterplot(zedGraphControl2, surface);
lbStatus.Text = "Learning finished! Click the other tabs to explore results!";
}
/// <summary>
/// Prepare truth and prediction for given test set
/// </summary>
/// <param name="testData"></param>
/// <param name="decisionTree"></param>
/// <param name="truth"></param>
/// <param name="predictions"></param>
private static void EvaluateDecisionTree(List <double[]> testData, DecisionTree decisionTree, out double[] truth, out double[] predictions)
{
// Prepare test data
var input = testData.ToArray()
.GetColumns(Vector.Range(0, GlobalVariables.Dimensions));
truth = testData.Select(t => t[t.Length - 1]).ToArray();
predictions = decisionTree
.Decide(input)
.To <double[]>();
}
static void Main(string[] args)
{
var data = new ExcelReader(@"c:\temp\accordemo\accordemo\titanic.xls").GetWorksheet("titanic3");
data.Rows.RemoveAt(data.Rows.Count - 1);
var d = new Elimination("age").Apply(data);
var fdata = new Codification(d, "sex").Apply(d);
var outp = fdata.Columns["survived"].ToArray <int>();
var input = fdata.ToArray <double>("pclass", "sex", "age", "parch", "sibsp");
DecisionTree T = new DecisionTree(
DecisionVariable.FromData(input), 2);
var learn = new C45Learning(T);
learn.Run(input, outp);
var r1 = T.Decide(new double[] { 0, 1, 23, 0, 0 });
var r2 = T.Decide(new double[] { 1, 0, 30, 1, 1 });
Console.WriteLine($"Male={r1}, Female={r2}");
Console.ReadKey();
}
public override ClassScore[] PredictTokens(TObj obj, int cnt)
{
if (m_Result == null)
{
throw new MLException("Decision tree is empty");
}
var cls = m_Result.Decide(obj);
var score = new ClassScore(cls, 1);
return(new ClassScore[] { score });
}
// Update is called once per frame
void Update()
{
timer -= Time.deltaTime;
if (timer <= 0f)
{
game_state_representation.state[0] = customvalue;
string result = DecisionModule.Decide(game_state_representation);
Debug.Log(result);
timer = 1;
}
}
public string Decide(List <BaseAttribute <T> > attributes, BaseAttribute <T> attributeColumn)
{
var columnNames = attributes.Select(attribute => attribute.Name).ToArray();
var values = attributes.Select(attribute => attribute.Value).ToArray();
int[] query = Codebook.Transform(columnNames, values);
int output = DecisionTree.Decide(query);
var answer = Codebook.Revert(attributeColumn.Name, output);
return(answer.ToString());
}
private double computeError()
{
int error = 0;
for (int i = 0; i < inputs.Length; i++)
{
int actual = tree.Decide(inputs[i]);
int expected = outputs[i];
if (actual != expected)
{
error++;
}
}
return(error / (double)inputs.Length);
}
void Update()
{
if (GameOver.reset) // Resetando as variáveis caso o jogo seja reiniciado
{
answer = null;
firstKeyCollected = null;
secondKeyCollected = null;
thirdKeyCollected = null;
exit1.GetComponent <MeshRenderer> ().enabled = true;
exit2.GetComponent <MeshRenderer> ().enabled = true;
firstExitOpen = false;
secondExitOpen = false;
PlayerControl.score = 0;
CollisionBehaviors.keyCollected = null;
GameOver.reset = false;
}
if (firstKeyCollected != null && // Quando as três chaves forem coletadas, a condição será atendida
secondKeyCollected != null &&
thirdKeyCollected != null)
{
int[] query = codebook.Transform(new[, ] { // Tabela cujo valor será tratado
{ "First key", firstKeyCollected },
{ "Second key", secondKeyCollected },
{ "Third key", thirdKeyCollected }
});
// Passando a tabela a ser tratada como argumento da árvore treinada | tree.Decide(tabelaParaTratar)
// O resultado tratado (predicted) será em integer symbol
int predicted = tree.Decide(query);
answer = codebook.Revert("Exit", predicted); // Traduzindo o integer symbol para string
Debug.Log(answer);
if (answer == "First")
{
exit1.GetComponent <MeshRenderer> ().enabled = false;
firstExitOpen = true;
}
else if (answer == "Second")
{
exit2.GetComponent <MeshRenderer> ().enabled = false;
secondExitOpen = true;
}
}
}