public void UpdateFields(DataSetRow row)
{
dorsal.text = row.tag_id.ToString();
distance.text = row.total_distance.ToString();
speed.text = row.speed.ToString();
energy.text = row.energy.ToString();
}
public static DataSet generateTraining()
{
DataSet dataSet = new DataSet(Data.CHAR_WIDTH * Data.CHAR_HEIGHT, Data.DIGITS.Length);
for (int i = 0; i < Data.DIGITS.Length; i++)
{
// setup input
DataSetRow inputRow = Data.convertImageIntoData(Data.DIGITS[i]);
double[] input = inputRow.Input;
// setup output
double[] output = new double[Data.DIGITS.Length];
for (int j = 0; j < Data.DIGITS.Length; j++)
{
if (j == i)
{
output[j] = 1;
}
else
{
output[j] = 0;
}
}
//creating new training element with specified input and output
DataSetRow row = new DataSetRow(input, output);
//adding row to data set
dataSet.addRow(row);
}
return(dataSet);
}
public void DataSetRow_Merge_ValueChanged_OriginalsNotChanged()
{
DataSetRow originalRow = new DataSetRow
{
["UserId"] = 123,
["DomainId"] = 1001
};
DataSetRow newRow = new DataSetRow
{
["DomainId"] = 2001
};
DataSetRow result = originalRow.Merge(newRow);
Assert.AreEqual(2, originalRow.Count);
Assert.AreEqual(123, originalRow["UserId"]);
Assert.AreEqual(1001, originalRow["DomainId"]);
Assert.AreEqual(1, newRow.Count);
Assert.AreEqual(2001, newRow["DomainId"]);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(123, result["UserId"]);
Assert.AreEqual(2001, result["DomainId"]);
}
/// <summary>
/// Used internally to calculate the error for a training set.
/// </summary>
/// <param name="trainingSet"> The training set to calculate for. </param>
/// <returns> The error value. </returns>
private double determineError(DataSet trainingSet)
{
double result = 0d;
IEnumerator <DataSetRow> iterator = trainingSet.iterator();
while (iterator.MoveNext() && !Stopped)
{
DataSetRow trainingSetRow = iterator.Current;
double[] input = trainingSetRow.Input;
Network.Input = input;
Network.calculate();
double[] output = Network.Output;
double[] desiredOutput = trainingSetRow.DesiredOutput;
double[] patternError = ErrorFunction.calculatePatternError(desiredOutput, output);
double sqrErrorSum = 0;
foreach (double error in patternError)
{
sqrErrorSum += (error * error);
}
result += sqrErrorSum / (2 * patternError.Length);
}
return(result);
}
/// <summary>
/// Benchmrk preparation consists of training set and neural networ creatiion.
/// This method generates training set with 100 rows, where every row has 10 input and 5 output elements
/// Neural network has two hiddden layers with 8 and 7 neurons, and runs learning rule for 2000 iterations
/// </summary>
public override void prepareTest()
{
int trainingSetSize = 100;
int inputSize = 10;
int outputSize = 5;
this.trainingSet = new DataSet(inputSize, outputSize);
for (int i = 0; i < trainingSetSize; i++)
{
double[] input = new double[inputSize];
for (int j = 0; j < inputSize; j++)
{
input[j] = new Random(1).NextDouble();
}
double[] output = new double[outputSize];
for (int j = 0; j < outputSize; j++)
{
output[j] = new Random(2).NextDouble();
}
DataSetRow trainingSetRow = new DataSetRow(input, output);
trainingSet.addRow(trainingSetRow);
}
network = new MultiLayerPerceptron(inputSize, 8, 7, outputSize);
((MomentumBackpropagation)network.LearningRule).MaxIterations = 2000;
}
public void UpdatePlayers(int indexUpdate, int nextUpdate)
{
if (indexUpdate > ParseData.rows.Count || nextUpdate > ParseData.rows.Count)
{
Debug.LogError("Incorrect Index Calculation");
return;
}
HashSet <Player> updatedPlayers = new HashSet <Player>();
DateTime dateTime = ParseData.rows[indexUpdate].time;
for (int i = indexUpdate; i < ParseData.rows.Count &&
dateTime == ParseData.rows[i].time; i++)
{
DataSetRow row = ParseData.rows[i];
DataSetRow?nextRow = NextRow(row.tag_id, nextUpdate);
//Debug.Log(row.time.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture));
if (!players.ContainsKey(row.tag_id))
{
SpawnPlayer(row.tag_id);
}
Player player = players[row.tag_id];
player.UpdatePlayer(row, nextRow);
if (/*player.gameObject.activeSelf || */ row.speed >= 0)
{
player.gameObject.SetActive(true);
playersWithoutLog[player] = 0;
updatedPlayers.Add(player);
}
}
UpdateNoLog(updatedPlayers);
}
private void Awake()
{
rows = new List <DataSetRow>();
List <string> row = new List <string>();
using (var reader = new CsvFileReader(pathDataset))
{
while (reader.ReadRow(row))
{
DateTime date = DateTime.Parse(row[0], null, System.Globalization.DateTimeStyles.RoundtripKind);
int tag = Int32.Parse(row[1]);
float x_pos = float.Parse(row[2], CultureInfo.InvariantCulture);
float y_pos = float.Parse(row[3], CultureInfo.InvariantCulture);
float heading = float.Parse(row[4], CultureInfo.InvariantCulture);
float direction = float.Parse(row[5], CultureInfo.InvariantCulture);
float energy = float.Parse(row[6], CultureInfo.InvariantCulture);
float speed = float.Parse(row[7], CultureInfo.InvariantCulture);
float total_distance = float.Parse(row[8], CultureInfo.InvariantCulture);
DataSetRow setRow = new DataSetRow(date, tag, x_pos, y_pos, heading, direction, energy, speed, total_distance);
rows.Add(setRow);
}
}
}
private void learnPattern(DataSetRow dataSetRow, int neighborhood)
{
neuralNetwork.Input = dataSetRow.Input;
neuralNetwork.calculate();
Neuron winner = ClosestNeuron;
if (winner.Output == 0)
{
return; // ako je vec istrenirana jedna celija, izadji
}
Layer mapLayer = neuralNetwork.getLayerAt(1);
int winnerIdx = mapLayer.IndexOf(winner);
adjustCellWeights(winner, 0);
int cellNum = mapLayer.NeuronsCount;
for (int p = 0; p < cellNum; p++)
{
if (p == winnerIdx)
{
continue;
}
if (isNeighbor(winnerIdx, p, neighborhood))
{
Neuron cell = mapLayer.getNeuronAt(p);
adjustCellWeights(cell, 1);
} // if
} // for
}
/// <summary>
/// Trains network with the pattern from the specified training element
/// </summary>
/// <param name="DataSetItem">
/// unsupervised training element which contains network input </param>
protected internal virtual void learnPattern(DataSetRow trainingElement)
{
double[] input = trainingElement.Input;
this.neuralNetwork.Input = input;
this.neuralNetwork.calculate();
this.updateNetworkWeights();
}
public void DataSetRow_Values_CanSetViaIndexInitialiserConstructorAndRetrieveValue()
{
DataSetRow row = new DataSetRow
{
["UserId"] = 123
};
Assert.AreEqual(123, row["UserId"]);
}
public void DataSetRow_Values_CanSetViaConstructorAndRetrieveValue()
{
DataSetRow row = new DataSetRow
{
{ "UserId", 123 }
};
Assert.AreEqual(123, row["UserId"]);
}
public void DataSetRow_Count_OneItem_1()
{
DataSetRow row = new DataSetRow
{
{ "UserId", 123 }
};
Assert.AreEqual(1, row.Count);
}
public void DataSetRow_Values_RetrieveUnsetValue_ThrowException()
{
DataSetRow row = new DataSetRow();
var exception = Assert.Throws <KeyNotFoundException>(() => { object result = row["UserId"]; });
Assert.IsNotNull(exception);
Assert.AreEqual("UserId was not found in the data set", exception.Message);
}
public void DataSetRow_Values_CanSetAndRetrieveValue()
{
#pragma warning disable IDE0028 // Simplify collection initialization
DataSetRow row = new DataSetRow();
#pragma warning restore IDE0028 // Simplify collection initialization
row["UserId"] = 123;
Assert.AreEqual(123, row["UserId"]);
}
public void DataSetRow_Count_TwoItems_2()
{
DataSetRow row = new DataSetRow
{
{ "UserId", 123 },
{ "DomainId", 1001 }
};
Assert.AreEqual(2, row.Count);
}
/// <summary>
/// Asserts that the row matches the expected data. Also asserts that all columns in the expected data exist
/// </summary>
/// <param name="expectedData">The expected data to match. Respects <see cref="Comparisons.Abstract.IComparison"/> objects</param>
/// <returns>Returns the same <see cref="RowResult"/> object</returns>
public RowResult AssertValues(DataSetRow expectedData)
{
expectedData = expectedData ?? new DataSetRow();
foreach (KeyValuePair <string, object> record in expectedData)
{
AssertValue(record.Key, record.Value);
}
return(this);
}
/// <summary>
/// Trains network with the input and desired output pattern from the specified training element
/// </summary>
/// <param name="trainingElement"> supervised training element which contains input and desired output </param>
protected internal virtual void learnPattern(DataSetRow trainingElement)
{
double[] input = trainingElement.Input;
this.neuralNetwork.Input = input;
this.neuralNetwork.calculate();
double[] output = this.neuralNetwork.Output;
double[] desiredOutput = trainingElement.DesiredOutput;
double[] patternError = errorFunction.calculatePatternError(output, desiredOutput);
this.updateNetworkWeights(patternError);
}
/// <summary>
/// This method does one learning epoch for the unsupervised learning rules.
/// It iterates through the training set and trains network weights for each
/// element
/// </summary>
/// <param name="trainingSet">
/// training set for training network </param>
public override void doLearningEpoch(DataSet trainingSet)
{
IEnumerator <DataSetRow> iterator = trainingSet.iterator();
while (iterator.MoveNext() && !Stopped)
{
DataSetRow trainingSetRow = iterator.Current;
learnPattern(trainingSetRow);
}
}
// TODO; remove sampleCount param its ame as list count
private static DataSet createDataSet(List <MNISTImage> imageList, int sampleCount)
{
int pixelCount = imageList[0].Size;
int totalSize = 1024;
DataSet dataSet = new DataSet(totalSize, 10);
for (int i = 0; i < sampleCount; i++)
{
MNISTImage dImage = imageList[i];
double[] input = new double[totalSize];
double[] output = new double[10];
for (int j = 0; j < 10; j++)
{
output[j] = 0;
}
for (int j = 0; j < totalSize; j++)
{
input[j] = 0;
}
output[dImage.Label] = 1;
sbyte[] imageData = dImage.Data;
int k = 66;
for (int j = 0; j < pixelCount; j++)
{
if ((imageData[j] & 0xff) > 0)
{
input[k++] = 255;
}
else
{
k++;
}
if (j % 28 == 27)
{
k += 4;
}
}
DataSetRow row = new DataSetRow(input, output);
dataSet.addRow(row);
}
dataSet.setColumnName(1024, "0");
dataSet.setColumnName(1025, "1");
dataSet.setColumnName(1026, "2");
dataSet.setColumnName(1027, "3");
dataSet.setColumnName(1028, "4");
dataSet.setColumnName(1029, "5");
dataSet.setColumnName(1030, "6");
dataSet.setColumnName(1031, "7");
dataSet.setColumnName(1032, "8");
dataSet.setColumnName(1033, "9");
return(dataSet);
}
public void DataSetRow_Values_CanSetViaDictionaryConstructorAndRetrieveValue()
{
Dictionary <string, object> dictionary = new Dictionary <string, object>
{
["UserId"] = 123
};
DataSetRow row = new DataSetRow(dictionary);
Assert.AreEqual(123, row["UserId"]);
}
public void DataSetRow_ToString_OneValue_ReturnValue()
{
DataSetRow row = new DataSetRow
{
["UserId"] = 123
};
Assert.AreEqual(@"
[UserId, 123]"
, row.ToString());
}
public void DataSetRow_ToString_TwoValues_ReturnValues()
{
DataSetRow row = new DataSetRow
{
["UserId"] = 123,
["DomainId"] = 1001
};
Assert.AreEqual(@"
[UserId, 123]
[DomainId, 1001]", row.ToString());
}
public void DataSetRow_Merge_WithNoOriginalWithNewKey_ReturnOriginalAndNew()
{
DataSetRow row = new DataSetRow();
DataSetRow result = row.Merge(new DataSetRow
{
["AddressId"] = 2001
});
Assert.AreEqual(1, result.Count);
Assert.AreEqual(2001, result["AddressId"]);
}
public void DataSetRow_Merge_WithEmpty_ReturnOriginal()
{
DataSetRow row = new DataSetRow
{
["UserId"] = 123,
["DomainId"] = 1001
};
DataSetRow result = row.Merge(new DataSetRow());
Assert.AreEqual(2, result.Count);
Assert.AreEqual(123, result["UserId"]);
Assert.AreEqual(1001, result["DomainId"]);
}
public async Task IdentityOnlyTable_InsertIdentityManually_DataSet()
{
DataSetRow data1 = await TestRunner.InsertDataAsync(_tableName, new DataSetRow
{
["Id"] = 2004
});
QueryResult results = await TestRunner.ExecuteTableAsync(_tableName);
results
.AssertRowCount(1)
.AssertValue(0, "Id", 2004);
Assert.AreEqual(2004, data1["Id"]);
}
public async Task IdentityOnlyTable_CanInsertDefaultData_Twice_DifferentIds()
{
DataSetRow data1 = await TestRunner.InsertDefaultAsync(_tableName);
DataSetRow data2 = await TestRunner.InsertDefaultAsync(_tableName);
QueryResult results = await TestRunner.ExecuteTableAsync(_tableName);
results
.AssertRowCount(2)
.AssertColumnExists("Id")
.AssertValue(0, "Id", data1["Id"])
.AssertValue(1, "Id", data2["Id"]);
Assert.AreNotEqual(data1["Id"], data2["Id"]);
}
/// <summary>
/// Prints Neuroph data set
/// </summary>
/// <param name="neurophDataset"> Dataset Neuroph data set </param>
public static void printDataset(DataSet neurophDataset)
{
Console.WriteLine("Neuroph dataset");
IEnumerator iterator = neurophDataset.GetEnumerator();
while (iterator.hasNext())
{
DataSetRow row = (DataSetRow)iterator.next();
Console.WriteLine("inputs");
Console.WriteLine(Arrays.ToString(row.Input));
if (row.DesiredOutput.Length > 0)
{
Console.WriteLine("outputs");
Console.WriteLine(Arrays.ToString(row.DesiredOutput));
}
}
}
public void DataSetRow_Merge_WithExistingKeyDifferentType_ReturnNew()
{
DataSetRow row = new DataSetRow
{
["UserId"] = 123,
["DomainId"] = 1001
};
DataSetRow result = row.Merge(new DataSetRow
{
["DomainId"] = DateTime.Parse("01-Mar-2020")
});
Assert.AreEqual(2, result.Count);
Assert.AreEqual(123, result["UserId"]);
Assert.AreEqual(DateTime.Parse("01-Mar-2020"), result["DomainId"]);
}
public void DataSetRow_Merge_WithExistingKeyNullValue_ReturnNew()
{
DataSetRow row = new DataSetRow
{
["UserId"] = 123,
["DomainId"] = 1001
};
DataSetRow result = row.Merge(new DataSetRow
{
["DomainId"] = null
});
Assert.AreEqual(2, result.Count);
Assert.AreEqual(123, result["UserId"]);
Assert.AreEqual(null, result["DomainId"]);
}
public void UpdatePlayer(DataSetRow row, DataSetRow?nextRow)
{
lastRow = row;
nextPos = pos = new Vector3(row.x_pos, 0, row.y_pos);
//this.transform.position = new Vector3(row.x_pos, 0, row.y_pos);
if (nextRow != null)
{
nextPos = nextRow.Value.GetPos();
Vector3 currentPos = row.GetPos();
this.transform.LookAt(nextPos);
//Vector3 direction = Vector3.Lerp(currentPos, nextPos, 0.6f);
Vector3 move = nextPos - currentPos;
thirdPerson.Move(move, false, false);
}
}
