Демонстрация работы приложения для классификации цвета
Заключение
В курсовом проекте было проведено изучение алгоритмов классификации. Реализованные приложения позволяют провести сравнительный анализ качества и времени работы на различных типах выборки.
В настоящее время крупные компании вкладывают большие средства (инвестиции доходят до 500 млн.долларов) в машинное обучение, потому что данная технология по-настоящему окупается. Через 5 лет это показатель может увеличиться в 10 раз.
С каждым годом большие данные становятся все более сложнее и человеку становится уже недостаточно своих аналитических способностей. Некоторые задачи перейдут к искусственному интеллекту, который справится с ними лучше и быстрее,чем человек.
Списоклитературы
1. Упрощенныйбайесовскийклассификатор[Электронныйресурс].–Режимдоступа:https://habrahabr.ru(Датаобращения13.10.2017).
2. К.В.ВоронцовЛекциипостатистическим(байесовским)алгоритмамклассификации16апреля2008г.
3. Упрощенныйбайесовскийклассификатор[Электронныйресурс].–Режимдоступаhttp://alglib.sources.ru.(Датаобращения13.12.2017).
4. Линейная регрессия[Электронный ресурс]. – Режим доступа: https://tproger.ru/(Дата обращения 23.12.2017).
5. Линейная регрессия [Электронный ресурс]. – Режим доступа: https://basegroup.ru (Дата обращения 23.12.2017).
6. Линейная регрессия [Электронный ресурс]. – Режим доступа: https://linis.hse.ru(Дата обращения 23.12.2017).
7. М. В. Бураков. Нейронные сети и нейроконтроллеры. Учеб. Пособие.СПб. ГУАП, 2013. – 284 с.
|
|
|
8. Алгоритмы Машинного обучения [Электронный ресурс].- Режим доступа:https://msdn.microsoft.com/ru-ru/magazine/mt149362?author=James%20McCaffrey
(Дата обращения 10.01.2018).
Приложение 1
Используемые методы в классификации упрощенного байесовского алгоритма на C#
staticint Classify(string occupation, string dominance, string height, int[][][] jointCounts, int[] dependentCounts, boolwithSmoothing, intxClasses)
{
doublepartProbMale = PartialProbability("мужчина", occupation, dominance, height, jointCounts, dependentCounts, withSmoothing, xClasses);
doublepartProbFemale = PartialProbability("женщина", occupation, dominance, height, jointCounts, dependentCounts, withSmoothing, xClasses);
double evidence = partProbMale + partProbFemale;
doubleprobMale = partProbMale / evidence;
doubleprobFemale = partProbFemale / evidence;
Console.WriteLine("Вероятномужчина = " + probMale.ToString("F4"));
Console.WriteLine("Вероятноженщина = " + probFemale.ToString("F4"));
if (probMale>probFemale) // возвращаемое значение вероятности пола
return 0;
else
return 1;
}
staticint[][][] MakeJointCounts(string[] binnedData, string[] attributes, string[][] attributeValues)
{
// предполагается, хранимые данные - это занятие, доминантность, высота, пол
// result [] [] [] -> [attribute] [att value] [sex]
// ex: result [0] [3] [1] - подсчет (профессия) (технология) (женщина), то есть количество технологий & женщина
int[][][] jointCounts = newint[attributes.Length-1 ][][]; // -1 (безпола)
jointCounts[0] = newint[4][]; // 4 профессиональных сферы
|
|
|
jointCounts[1] = newint[2][]; // 2 варианта доминирования: правша/левша
jointCounts[2] = newint[3][]; // 3 высоты
jointCounts[0][0] = newint[2]; // 2 поладляадминистривной
jointCounts[0][1] = newint[2]; // строительной
jointCounts[0][2] = newint[2]; // образовательной
jointCounts[0][3] = newint[2]; // технологическойсферы
jointCounts[1][0] = newint[2]; // левша
jointCounts[1][1] = newint[2]; // правша
jointCounts[2][0] = newint[2]; // низкий
jointCounts[2][1] = newint[2]; // средний
jointCounts[2][2] = newint[2]; // высокий
for (inti = 0; i<binnedData.Length; ++i)
{
string[] tokens = binnedData[i].Split(',');
intoccupationIndex = AttributeValueToIndex(0, tokens[0]);
intdominanceIndex = AttributeValueToIndex(1, tokens[1]);
intheightIndex = AttributeValueToIndex(2, tokens[2]);
intsexIndex = AttributeValueToIndex(3, tokens[3]);
++jointCounts[0][occupationIndex][sexIndex]; // профессияипол (счетчик)
++jointCounts[1][dominanceIndex][sexIndex];
++jointCounts[2][heightIndex][sexIndex];
}
returnjointCounts;
}
staticintAttributeValueToIndex(int attribute, stringattributeValue)
{
if (attribute == 0)
{
if (attributeValue == "административный") return 0;
elseif (attributeValue == "строительство") return 1;
elseif (attributeValue == "образование") return 2;
elseif (attributeValue == "технология") return 3;
}
elseif (attribute == 1)
{
if (attributeValue == "левша") return 0;
elseif (attributeValue == "правша") return 1;
}
elseif (attribute == 2)
{
if (attributeValue == "низкий") return 0;
elseif (attributeValue == "средний") return 1;
|
|
|
elseif (attributeValue == "высокий") return 2;
}
elseif (attribute == 3)
{
if (attributeValue == "мужчина") return 0;
elseif (attributeValue == "женщина") return 1;
}
return -1; // ошибка
}
staticint[] MakeDependentCounts(int[][][] jointCounts, intnumDependents)
{
int[] result = newint[numDependents];
for (int k = 0; k <numDependents; ++k)
for (int j = 0; j <jointCounts[0].Length; ++j)
result[k] += jointCounts[0][j][k];
returnresult;
}
Приложение 2
Используемые методы в прогнозировании результата при помощи линейной регрессии на C#
staticdouble Income(double x1, double x2, double x3, double[] coef)
{
// x1 = образование, x2 = работа, x3 = пол
double result;
result = coef[0] + (x1 * coef[1]) + (x2 * coef[2]) + (x3 * coef[3]);
returnresult;
}
staticdoubleRSquared(double[][] data, double[] coef)
{
int rows = data.Length;
int cols = data[0].Length;
// 1. среднее значение y
doubleySum = 0.0;
for (inti = 0; i< rows; ++i)
ySum += data[i][cols - 1]; // последняя колонна// зависимый предиктор
doubleyMean = ySum / rows;
// 2. сумма квадратов остатков и сумма чисел квадратов
doublessr = 0.0;
doublesst = 0.0;
double y; // актуальноезначение
doublepredictedY; // использованиекоэффициентов[]
for (inti = 0; i< rows; ++i)
{
y = data[i][cols - 1]; // получить значение y
predictedY = coef[0];
for (int j = 0; j < cols - 1; ++j) // j - количестводанных
predictedY += coef[j + 1] * data[i][j];
ssr += (y - predictedY) * (y - predictedY);
sst += (y - yMean) * (y - yMean);
}
|
|
|
if (sst == 0.0)
thrownew Exception("все y равны");
else
return 1.0 - (ssr / sst);
}
staticdouble[][] DummyData(int rows, int seed)
{
double b0 = 15.0;
double b1 = 0.8; // уровень образования
double b2 = 0.5; // стаж работы
double b3 = -3.0; // пол = 0 мужской, 1 женский
Random rnd = new Random(seed);
double[][] result = newdouble[rows][];
for (inti = 0; i< rows; ++i)
result[i] = newdouble[4];
for (inti = 0; i< rows; ++i)
{
inted = rnd.Next(12, 17);
int work = rnd.Next(10, 31);
int sex = rnd.Next(0, 2);
double y = b0 + (b1 * ed) + (b2 * work) + (b3 * sex);
y += 10.0 * rnd.NextDouble() - 5.0; // random [-5 +5]
result[i][0] = ed;
result[i][1] = work;
result[i][2] = sex;
result[i][3] = y; // доход
}
return result;
}
staticdouble[][] Design(double[][] data)
{
// добавление колонны для значений b0 коэффициента
int rows = data.Length;
int cols = data[0].Length;
double[][] result = MatrixCreate(rows, cols + 1);
for (inti = 0; i< rows; ++i)
result[i][0] = 1.0;
for (inti = 0; i< rows; ++i)
for (int j = 0; j < cols; ++j)
result[i][j + 1] = data[i][j];
returnresult;
}
staticdouble[] Solve(double[][] design)
{
// нахождение коэффициентов линейной регрессии
int rows = design.Length;
int cols = design[0].Length;
double[][] X = MatrixCreate(rows, cols - 1);// определение матрицы для независимых переменных
double[][] Y = MatrixCreate(rows, 1); // определение вектора, хранит значения зависимой переменной
int j;
for (inti = 0; i< rows; ++i)
{
for (j = 0; j < cols - 1; ++j)
{
X[i][j] = design[i][j];
}
Y[i][0] = design[i][j]; //годовойдоход
}
// B = inv(Xt * X) * Xt * y
double[][] Xt = MatrixTranspose(X);
double[][] XtX = MatrixProduct(Xt, X);
double[][] inv = MatrixInverse(XtX);
double[][] invXt = MatrixProduct(inv, Xt);
double[][] mResult = MatrixProduct(invXt, Y);
double[] result = MatrixToVector(mResult);
return result;
}
staticdouble[][] MatrixDecompose(double[][] matrix, outint[] perm, outint toggle)
{
//обращениематрицы
int rows = matrix.Length;
int cols = matrix[0].Length;
if (rows != cols)
thrownew Exception("Неквадратичнаяматрица");
int n = rows;
double[][] result = MatrixDuplicate(matrix);
perm = newint[n];
for (inti = 0; i< n; ++i) { perm[i] = i; }
toggle = 1;
for (int j = 0; j < n - 1; ++j)
{
doublecolMax = Math.Abs(result[j][j]);
intpRow = j;
for (inti = j + 1; i< n; ++i)
{
if (Math.Abs(result[i][j]) >colMax)
{
colMax = Math.Abs(result[i][j]);
pRow = i;
}
}
if (pRow != j)
{
double[] rowPtr = result[pRow];
result[pRow] = result[j];
result[j] = rowPtr;
inttmp = perm[pRow];
perm[pRow] = perm[j];
perm[j] = tmp;
toggle = -toggle;
}
if (result[j][j] == 0.0)
{
intgoodRow = -1;
for (int row = j + 1; row < n; ++row)
{
if (result[row][j] != 0.0)
goodRow = row;
}
if (goodRow == -1)
thrownew Exception("нельзяиспользоватьметод Doolittle");
double[] rowPtr = result[goodRow];
result[goodRow] = result[j];
result[j] = rowPtr;
inttmp = perm[goodRow];
perm[goodRow] = perm[j];
perm[j] = tmp;
toggle = -toggle;
}
for (inti = j + 1; i< n; ++i)
{
result[i][j] /= result[j][j];
for (int k = j + 1; k < n; ++k)
{
result[i][k] -= result[i][j] * result[j][k];
}
}
}
returnresult;
}
Приложение 3
Используемые методы в классификации цвета при помощи нейронной сети на C#
staticvoidMakeData(stringdataFile, intnumLines)
{
double[] weights = newdouble[] { -0.1, 0.2, -0.3, 0.4, -0.5,
0.6, -0.7, 0.8, -0.9, 1.0,
-1.1, 1.2, -1.3, 1.4, -1.5,
1.6, -1.7, 1.8, -1.9, 2.0,
-0.5, 0.6, -0.7, 0.8, -0.9,
1.5, -1.4, 1.3,
-1.2, 1.1, -1.0,
0.9, -0.8, 0.7,
-0.6, 0.5, -0.4,
0.3, -0.2, 0.1,
0.1, -0.3, 0.6 };
NeuralNetworknn = newNeuralNetwork(4, 5, 3);
nn.SetWeights(weights);
FileStreamofs = newFileStream(dataFile, FileMode.Create);
StreamWritersw = newStreamWriter(ofs);
for (inti = 0; i<numLines; ++i)
{
double[] inputs = newdouble[4];
for (int j = 0; j <inputs.Length; ++j)
inputs[j] = rnd.Next(1, 10);
double[] outputs = nn.ComputeOutputs(inputs);
string color = "";
intidx = Helpers.IndexOfLargest(outputs);
if (idx == 0) { color = "красный"; }
elseif (idx == 1) { color = "зеленый"; }
elseif (idx == 2) { color = "синий"; }
sw.WriteLine(inputs[0].ToString("F1") + " " + inputs[1].ToString("F1") + " " + inputs[2].ToString("F1") + " " + inputs[3].ToString("F1") + " " + color);
}
sw.Close(); ofs.Close();
}
staticvoidMakeTrainAndTest(string file, outdouble[][] trainMatrix, outdouble[][] testMatrix)
{
intnumLines = 0;
FileStream ifs = newFileStream(file, FileMode.Open);
StreamReadersr = newStreamReader(ifs);
while (sr.ReadLine() != null)
++numLines;
sr.Close(); ifs.Close();
intnumTrain = (int)(0.80 * numLines);
intnumTest = numLines - numTrain;
double[][] allData = newdouble[numLines][];
for (inti = 0; i<allData.Length; ++i)
allData[i] = newdouble[7]; // (x0, x1, x2, x3), (y0, y1, y2) //4 входных 3 выходных
string line = "";
string[] tokens = null;
ifs = newFileStream(file, FileMode.Open);
sr = newStreamReader(ifs);
int row = 0;
while ((line = sr.ReadLine()) != null)
{
tokens = line.Split(' ');
allData[row][0] = double.Parse(tokens[0]);
allData[row][1] = double.Parse(tokens[1]);
allData[row][2] = double.Parse(tokens[2]);
allData[row][3] = double.Parse(tokens[3]);
for (inti = 0; i< 4; ++i)
allData[row][i] = 0.25 * allData[row][i] - 1.25; // масштабирование [-1.0, +1.0]
if (tokens[4] == "красный") { allData[row][4] = 1.0; allData[row][5] = 0.0; allData[row][6] = 0.0; }
elseif (tokens[4] == "зеленый") { allData[row][4] = 0.0; allData[row][5] = 1.0; allData[row][6] = 0.0; }
elseif (tokens[4] == "синий") { allData[row][4] = 0.0; allData[row][5] = 0.0; allData[row][6] = 1.0; }
++row;
}
sr.Close(); ifs.Close();
Helpers.ShuffleRows(allData);
trainMatrix = Helpers.MakeMatrix(numTrain, 7);
testMatrix = Helpers.MakeMatrix(numTest, 7);
for (inti = 0; i<numTrain; ++i)
{
allData[i].CopyTo(trainMatrix[i], 0);
}
for (inti = 0; i<numTest; ++i)
{
allData[i + numTrain].CopyTo(testMatrix[i], 0);
}
}
classNeuralNetwork
{
privateintnumInput;
privateintnumHidden;
privateintnumOutput;
privatedouble[] inputs;
privatedouble[][] ihWeights; // входныевскрытые
privatedouble[] ihSums;
privatedouble[] ihBiases;
privatedouble[] ihOutputs;
privatedouble[][] hoWeights; // скрытыеввыходные
privatedouble[] hoSums;
privatedouble[] hoBiases;
privatedouble[] outputs;
static Random rnd = null;
publicNeuralNetwork(intnumInput, intnumHidden, intnumOutput)
{
this.numInput = numInput;
this.numHidden = numHidden;
this.numOutput = numOutput;
inputs = newdouble[numInput];
ihWeights = Helpers.MakeMatrix(numInput, numHidden);
ihSums = newdouble[numHidden];
ihBiases = newdouble[numHidden];
ihOutputs = newdouble[numHidden];
hoWeights = Helpers.MakeMatrix(numHidden, numOutput);
hoSums = newdouble[numOutput];
hoBiases = newdouble[numOutput];
outputs = newdouble[numOutput];
rnd = new Random(0);
}
publicvoidSetWeights(double[] weights)
{
intnumWeights = (numInput * numHidden) + (numHidden * numOutput) + numHidden + numOutput;
if (weights.Length != numWeights)
thrownew Exception("Длинамассивавесов: " + weights.Length + " несоответствуетобщемуколичествувесовисмещений: " + numWeights);
int k = 0; // указание на весовые параметры
for (inti = 0; i<numInput; ++i)
for (int j = 0; j <numHidden; ++j)
ihWeights[i][j] = weights[k++];
for (inti = 0; i<numHidden; ++i)
ihBiases[i] = weights[k++];
for (inti = 0; i<numHidden; ++i)
for (int j = 0; j <numOutput; ++j)
hoWeights[i][j] = weights[k++];
for (inti = 0; i<numOutput; ++i)
hoBiases[i] = weights[k++];
}
publicdouble[] Train(double[][] trainMatrix) // искатьивозвращатьлучшиевеса
{
intnumWeights = (this.numInput * this.numHidden) + (this.numHidden * this.numOutput) + this.numHidden + this.numOutput;
//double[] currWeights = new double[numWeights];
// PSO для нахождения лучших весов
intnumberParticles = 10;
intnumberIterations = 500;
int iteration = 0;
int Dim = numWeights; // числорешенийсучетомвсехвесов
doubleminX = -5.0;
doublemaxX = 5.0;
Particle[] swarm = new Particle[numberParticles];
double[] bestGlobalPosition = newdouble[Dim]; //лучшее решение, найденное любой частицей в рое, неявная инициализация для всех 0.0
doublebestGlobalFitness = double.MaxValue; // меньшиезначениялучше
doubleminV = -0.1 * maxX; // скорость
doublemaxV = 0.1 * maxX;
for (int i = 0; i <swarm.Length; ++i) //инициализировать каждую частицу в рое со случайными позициями и скоростями
{
double[] randomPosition = newdouble[Dim];
for (int j = 0; j <randomPosition.Length; ++j)
{
double lo = minX;
double hi = maxX;
randomPosition[j] = (hi - lo) * rnd.NextDouble() + lo;
}
double fitness = CrossEntropy(trainMatrix, randomPosition); // меньшезначениелучше
double[] randomVelocity = newdouble[Dim];
for (int j = 0; j <randomVelocity.Length; ++j)
{
double lo = -1.0 * Math.Abs(maxX - minX);
double hi = Math.Abs(maxX - minX);
randomVelocity[j] = (hi - lo) * rnd.NextDouble() + lo;
}
swarm[i] = new Particle(randomPosition, fitness, randomVelocity, randomPosition, fitness);
// действительно ли текущая частица имеет глобальное лучшее положение?
if (swarm[i].fitness <bestGlobalFitness)
{
bestGlobalFitness = swarm[i].fitness;
swarm[i].position.CopyTo(bestGlobalPosition, 0);
}
}
double w = 0.729; // инерционный вес
double c1 = 1.49445; // когнитивный / местный вес
double c2 = 1.49445; // социальный / глобальный вес
double r1, r2; // когнитивные и социальные рандомизации
Console.WriteLine("Вход в основной цикл обработки оценки PSO");
while (iteration <numberIterations)
{
++iteration;
double[] newVelocity = newdouble[Dim];
double[] newPosition = newdouble[Dim];
doublenewFitness;
for (inti = 0; i<swarm.Length; ++i) // каждаячастица
{
Particle currP = swarm[i];
for (int j = 0; j <currP.velocity.Length; ++j) // каждоезначение x скорости
{
r1 = rnd.NextDouble();
r2 = rnd.NextDouble();
newVelocity[j] = (w * currP.velocity[j]) +
(c1 * r1 * (currP.bestPosition[j] - currP.position[j])) +
(c2 * r2 * (bestGlobalPosition[j] - currP.position[j])); //новая скорость зависит от старой скорости, лучшего положения частицы и наилучшего положения любой частицы
if (newVelocity[j] <minV)
newVelocity[j] = minV;
elseif (newVelocity[j] >maxV)
newVelocity[j] = maxV; // сохранение скорости в радиусе действия
}
newVelocity.CopyTo(currP.velocity, 0);
for (int j = 0; j <currP.position.Length; ++j)
{
newPosition[j] = currP.position[j] + newVelocity[j]; // вычислениеновойпозиции
if (newPosition[j] <minX)
newPosition[j] = minX;
elseif (newPosition[j] >maxX)
newPosition[j] = maxX;
}
newPosition.CopyTo(currP.position, 0);
newFitness = CrossEntropy(trainMatrix, newPosition); // вычислениекроссэнтропийнойошибкиположениячастицы
currP.fitness = newFitness;
if (newFitness<currP.bestFitness) // новоеположениечастицылучше?
{
newPosition.CopyTo(currP.bestPosition, 0);
currP.bestFitness = newFitness;
}
if (newFitness<bestGlobalFitness) // новоеглобальноеположение?
{
newPosition.CopyTo(bestGlobalPosition, 0);
bestGlobalFitness = newFitness;
}
}
//Console.WriteLine(swarm[0].ToString());
//Console.ReadLine();
}
Console.Write("кросс-энтропийнаяошибка = ");
Console.WriteLine(bestGlobalFitness.ToString("F4"));
returnbestGlobalPosition;
}
Дата добавления: 2018-05-01; просмотров: 89; Мы поможем в написании вашей работы! |
Мы поможем в написании ваших работ!