Я написал программу нейронной сети. Он работает для логических ворот, но когда я пытаюсь использовать его для распознавания рукописных цифр - он просто не учится.
Введите код ниже:
//Это единственный нейрон; это может потребоваться, чтобы понять оставшийся код
typedef struct SingleNeuron
{
double outputValue;
std::vector<double> weight;
std::vector<double> deltaWeight;
double gradient;
double sum;
}SingleNeuron;
Затем я инициализирую сеть. Я устанавливаю весы как случайное значение от -0,5 до +0,5, сумма до 0, deltaWeight до 0
Затем идет FeedForward:
for (unsigned i = 0; i < inputValues.size(); ++i)
{
neuralNet[0][i].outputValue = inputValues[i];
neuralNet[0][i].sum = 0.0;
// std::cout << "o/p Val = " << neuralNet[0][i].outputValue << std::endl;
}
for (unsigned i = 1; i < neuralNet.size(); ++i)
{
std::vector<SingleNeuron> prevLayerNeurons = neuralNet[i - 1];
unsigned j = 0;
double thisNeuronOPVal = 0;
// std::cout << std::endl;
for (j = 0; j < neuralNet[i].size() - 1; ++j)
{
double sum = 0;
for (unsigned k = 0; k < prevLayerNeurons.size(); ++k)
{
sum += prevLayerNeurons[k].outputValue * prevLayerNeurons[k].weight[j];
}
neuralNet[i][j].sum = sum;
neuralNet[i][j].outputValue = TransferFunction(sum);
// std::cout << neuralNet[i][j].outputValue << "\t";
}
// std::cout << std::endl;
}
Моя передаточная функция и ее производная упоминаются в конце.
После этого я пытаюсь выполнить обратное распространение, используя:
// calculate output layer gradients
for (unsigned i = 0; i < outputLayer.size() - 1; ++i)
{
double delta = actualOutput[i] - outputLayer[i].outputValue;
outputLayer[i].gradient = delta * TransferFunctionDerivative(outputLayer[i].sum);
}
// std::cout << "Found Output gradients "<< std::endl;
// calculate hidden layer gradients
for (unsigned i = neuralNet.size() - 2; i > 0; --i)
{
std::vector<SingleNeuron>& hiddenLayer = neuralNet[i];
std::vector<SingleNeuron>& nextLayer = neuralNet[i + 1];
for (unsigned j = 0; j < hiddenLayer.size(); ++j)
{
double dow = 0.0;
for (unsigned k = 0; k < nextLayer.size() - 1; ++k)
{
dow += nextLayer[k].gradient * hiddenLayer[j].weight[k];
}
hiddenLayer[j].gradient = dow * TransferFunctionDerivative(hiddenLayer[j].sum);
}
}
// std::cout << "Found hidden layer gradients "<< std::endl;
// from output to 1st hidden layer, update all weights
for (unsigned i = neuralNet.size() - 1; i > 0; --i)
{
std::vector <SingleNeuron>& currentLayer = neuralNet[i];
std::vector <SingleNeuron>& prevLayer = neuralNet[i - 1];
for (unsigned j = 0; j < currentLayer.size() - 1; ++j)
{
for (unsigned k = 0; k < prevLayer.size(); ++k)
{
SingleNeuron& thisNeueon = prevLayer[k];
double oldDeltaWeight = thisNeueon.deltaWeight[j];
double newDeltaWeight = ETA * thisNeueon.outputValue * currentLayer[j].gradient + (ALPHA * oldDeltaWeight);
thisNeueon.deltaWeight[j] = newDeltaWeight;
thisNeueon.weight[j] += newDeltaWeight;
}
}
}
Это TransferFuntion и его производная;
double TransferFunction(double x)
{
double val;
//val = tanh(x);
val = 1 / (1 + exp(x * -1));
return val;
}
double TransferFunctionDerivative(double x)
{
//return 1 - x * x;
double val = exp(x * -1) / pow((exp(x * -1) + 1), 2);
return val;
}
Одна вещь, которую я наблюдал Если я использую стандартную сигмоидную функцию, чтобы быть моей передаточной функцией И если я передаю вывод нейрона для передачи функции - результат INFINITY. Но tanh (x) отлично работает с этим значением
Итак, если я использую 1/1 + e ^ (- x) в качестве передаточной функции, я должен пройти Sum of Net Inputs и с tanh, являющейся моей передаточной функцией, я должен пройти output текущего нейрона.
Я не совсем понимаю, почему так оно и есть, может быть, это требует другого вопроса.
Но этот вопрос действительно о чем-то другом: СЕТЬ РАБОТАЕТ ДЛЯ ЛОГИСКИХ ВОРОТ, НО НЕ ДЛЯ ПРИЗНАНИЯ ХАРАКТЕРА
Я пробовал много вариантов/комбинаций Learning Rate и Acceleration и # hidden layers и their sizes. Ниже приведен список результатов:
AvgErr: 0.299399 #Pass799
AvgErr : 0.305071 #Pass809
AvgErr : 0.303046 #Pass819
AvgErr : 0.299569 #Pass829
AvgErr : 0.30413 #Pass839
AvgErr : 0.304165 #Pass849
AvgErr : 0.300529 #Pass859
AvgErr : 0.302973 #Pass869
AvgErr : 0.299238 #Pass879
AvgErr : 0.304708 #Pass889
AvgErr : 0.30068 #Pass899
AvgErr : 0.302582 #Pass909
AvgErr : 0.301767 #Pass919
AvgErr : 0.303167 #Pass929
AvgErr : 0.299551 #Pass939
AvgErr : 0.301295 #Pass949
AvgErr : 0.300651 #Pass959
AvgErr : 0.297867 #Pass969
AvgErr : 0.304221 #Pass979
AvgErr : 0.303702 #Pass989
Посмотрев на результаты, вы можете почувствовать, что этот парень просто застрял в локальных минимумах, но, пожалуйста, подождите и прочитайте:
Input = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
Output = 0.0910903, 0.105674, 0.064575, 0.0864824, 0.128682, 0.0878434, 0.0946296, 0.154405, 0.0678767, 0.0666924
Input = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Output = 0.0916106, 0.105958, 0.0655508, 0.086579, 0.126461, 0.0884082, 0.110953, 0.163343, 0.0689315, 0.0675822
Input = [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
Output = 0.105344, 0.105021, 0.0659517, 0.0858077, 0.123104, 0.0884107, 0.116917, 0.161911, 0.0693426, 0.0675156
Input = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
Output = , 0.107113, 0.101838, 0.0641632, 0.0967766, 0.117149, 0.085271, 0.11469, 0.153649, 0.0672772, 0.0652416
Выше - выход эпох # 996, # 997, # 998 и # 999
Так просто сеть не учится. Для этого, например, Я использовал ALPHA = 0,4, ETA = 0,7, 10 скрытых слоев каждый из 100 нейронов, а средний - более 10 эпох. Если вы беспокоитесь о том, что уровень обучения составляет 0,4 или около того многих скрытых слоев, я уже пробовал их варианты. Напр. для скорости обучения - 0,1 и 4 скрытых слоя - каждый из 16
Input = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
Output = 0.0883238, 0.0983253, 0.0613749, 0.0809751, 0.124972, 0.0897194, 0.0911235, 0.179984, 0.0681346, 0.0660039
Input = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Output = 0.0868767, 0.0966924, 0.0612488, 0.0798343, 0.120353, 0.0882381, 0.111925, 0.169309, 0.0676711, 0.0656819
Input = [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
Output = 0.105252, 0.0943837, 0.0604416, 0.0781779, 0.116231, 0.0858496, 0.108437, 0.1588, 0.0663156, 0.0645477
Input = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
Output = 0.102023, 0.0914957, 0.059178, 0.09339, 0.111851, 0.0842454, 0.104834, 0.149892, 0.0651799, 0.063558
Я так чертовски уверена, что что-то пропустила. Я не могу понять это. Я много раз читал алгоритм Тома Митчела, но я не знаю, что не так. Какой бы ни был пример, который я решаю руками! (Пожалуйста, не просите меня разрешить образы данных MNIST вручную;)) Я не знаю, где изменить код, что делать.. пожалуйста, помогите..
EDIT - добавление дополнительных данных в соответствии с предложениями в комментариях
1 Скрытый слой 32 - до сих пор нет обучения.
Ожидаемый результат: ввод - это изображения между 0-9, поэтому простой вектор, описывающий текущий образ, этот бит равен 1, остальные - 0. Поэтому мне хотелось бы, чтобы результат был как можно ближе к 1 для этого конкретного бита и другие близки к 0. Например, если input Input = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0], я бы хотел, чтобы результат был чем-то вроде Output = 0.002023, 0.0914957, 0.059178, 0.09339, 0.011851, 0.0842454, 0.924834, 0.049892, 0.0651799, 0.063558 (это смутно, сгенерировано вручную)
Вот ссылки других исследователей.
SourceForge - это скорее библиотека
Не только эти 2, есть так много сайтов, показывающих демонстрации.
Все работает для них очень хорошо. Если я задаю параметры своей сети (Alpha, ETA), как они, я не получаю таких результатов, как это, поэтому это подтверждает, что с моим кодом что-то не так.
EDIT 2
Добавление дополнительных случаев сбоев
Accelaration - 0,7, скорость обучения 0.1
Accelaration - 0,7, скорость обучения 0,6
В обоих случаях вышеуказанные случаи Скрытые слои были 3, каждый из 32 нейронов.
