public static void GoOverfit()
{
PointsGeneration.PointGeneration form = new PointsGeneration.PointGeneration();
form.Hide();
form.GenerateLinearSeparable();
MultidimensionalPoint[] testArray = new MultidimensionalPoint[100];
MultidimensionalPoint[] points = PointsGeneration.PointGeneration.points;
Random rand = new Random();
for (int i = 0; i < 5; ++i)
{
for (int j = 0; j < 20; ++j)
{
testArray[i * 20 + j] = new MultidimensionalPoint(2, 0);
do
{
testArray[i * 20 + j].coordinates[0] = points[i * 100].coordinates[0] + rand.NextDouble() * points[i * 100].radius * 1.5;
testArray[i * 20 + j].coordinates[1] = points[i * 100].coordinates[1] + rand.NextDouble() * points[i * 100].radius * 1.5;
}while(form.Distance(testArray[i * 20 + j], points[i * 100]) > points[i * 100].radius &&
form.Distance(testArray[i * 20 + j], points[i * 100]) < points[i * 100].radius * 1.5);
testArray[i * 20 + j].pointClass = i;
}
}
NeuralNetwork nn = new NeuralNetwork(points, new int[4] {
2, 15, 15, 15
}, 1, 0, 0.7, 0.01, 2, 1, 0.1);
nn.TrainNetwork(150, testArray);
}
public MultidimensionalPoint[] ReadFisher(string path, string[] splitPointsString, char[] splitCoordinatesString)
{
StreamReader sr = new StreamReader(path);
string rawData = sr.ReadToEnd();
string[] notParsedPoints = rawData.Split(splitPointsString, StringSplitOptions.RemoveEmptyEntries);
MultidimensionalPoint[] result = new MultidimensionalPoint[notParsedPoints.Length];
// Iterate over all array
int dimensions = notParsedPoints[0].Count(c => c == splitCoordinatesString[0]);
for (int j = 0; j < notParsedPoints.Length; ++j)
{
string[] oneString = notParsedPoints[j].Split(splitCoordinatesString, StringSplitOptions.None);
for (int i = 0; i < oneString.Length; ++i)
{
oneString[i] = oneString[i].Replace('.', ',');
}
double[] oneStringConverted = new double[oneString.Length];
for (int i = 0; i < oneString.Length - 1; ++i)
{
oneStringConverted[i] = Convert.ToDouble(oneString[i]);
}
switch (oneString[oneString.Length - 1])
{
case "setosa": oneStringConverted[oneString.Length - 1] = 0; break;
case "versicolor": oneStringConverted[oneString.Length - 1] = 1; break;
case "virginica": oneStringConverted[oneString.Length - 1] = 2; break;
}
result[j] = new MultidimensionalPoint(oneStringConverted);
}
return(result);
}
public MultidimensionalPoint[] ReadData(string path, string[] splitPointsString, char[] splitCoordinatesString)
{
StreamReader sr = new StreamReader(path);
string rawData = sr.ReadToEnd();
string[] notParsedPoints = rawData.Split(splitPointsString, StringSplitOptions.None);
MultidimensionalPoint[] result = new MultidimensionalPoint[notParsedPoints.Length];
// Iterate over all array
int dimensions = notParsedPoints[0].Count(c => c == splitCoordinatesString[0]);
for (int j = 0; j < notParsedPoints.Length; ++j)
{
string[] oneString = notParsedPoints[j].Split(splitCoordinatesString, StringSplitOptions.None);
for (int i = 0; i < oneString.Length; ++i)
{
oneString[i] = oneString[i].Replace('.', ',');
}
double[] oneStringConverted = new double[oneString.Length];
for (int i = 0; i < oneString.Length; ++i)
{
oneStringConverted[i] = Convert.ToDouble(oneString[i]);
}
result[j] = new MultidimensionalPoint(oneStringConverted);
}
return(result);
}
public void InitializeDataArray(int size)
{
points = new MultidimensionalPoint[userPointsCountInClass * size];
for (int i = 0; i < points.Length; ++i)
{
points[i] = new MultidimensionalPoint(userNumberOfDimensions, 0);
}
}
public static MultidimensionalPoint[] InitializeArrayOfPoints(int size)
{
MultidimensionalPoint[] result = new MultidimensionalPoint[size];
for (int i = 0; i < result.Length; ++i)
{
result[i] = new MultidimensionalPoint(2, 0);
}
return(result);
}
public int CalcTrueResultForExitNode(MultidimensionalPoint point, int nodeIndex)
{
int result = 0;
if (nodeIndex == point.pointClass)
{
result = 1;
}
return(result);
}
public double Distance(MultidimensionalPoint a, MultidimensionalPoint b)
{
double sum = 0;
Debug.Assert(a.coordinates.Length == b.coordinates.Length);
for (int i = 0; i < a.coordinates.Length; ++i)
{
sum += Math.Pow(a.coordinates[i] - b.coordinates[i], 2);
}
return(Math.Sqrt(sum));
}
public void GeneratePointsOfClass(int startingIndex_, int pointClass_, Random random)
{
int sign = 1;
int length = points[startingIndex_].coordinates.Length;
if (thoroughGenerationOfPoints || userNumberOfDimensions < 4)
{
for (int i = 1; i < userPointsCountInClass; ++i)
{
points[startingIndex_ + i].pointClass = pointClass_;
do
{
for (int j = 0; j < points[startingIndex_].coordinates.Length; ++j)
{
sign = (random.NextDouble() > 0.5) ? 1 : -1;
points[startingIndex_ + i].coordinates[j] = points[startingIndex_].coordinates[j] + sign * random.NextDouble() * points[startingIndex_].radius;
}
double dist = Distance(points[startingIndex_], points[startingIndex_ + i]);
double rad = points[startingIndex_].radius;
}while(Distance(points[startingIndex_], points[startingIndex_ + i]) > points[startingIndex_].radius);
}
}
else
{
MultidimensionalPoint a = new MultidimensionalPoint(userNumberOfDimensions, 0);
MultidimensionalPoint b = new MultidimensionalPoint(userNumberOfDimensions, points[startingIndex_].radius);
double dist = Distance(a, b);
double transformingValue = points[startingIndex_].radius / dist;
for (int j = 1; j < userPointsCountInClass; ++j)
{
points[startingIndex_ + j].pointClass = pointClass_;
for (int i = 0; i < points[startingIndex_].coordinates.Length; ++i)
{
sign = (random.NextDouble() > 0.5) ? 1 : -1;
points[startingIndex_ + j].coordinates[i] = sign * random.NextDouble() * points[startingIndex_].radius * transformingValue + points[startingIndex_].coordinates[i];
}
Debug.Assert(Distance(points[startingIndex_ + j], points[startingIndex_]) <= points[startingIndex_].radius);
}
}
}
public int CalcTrueOverallResult(MultidimensionalPoint point)
{
return(point.pointClass);
}
