Sieci neuronowe - przykładowy algorytm

znalazłem w sieci bardzo ciekawy artykuł nt. Sieci neuronowych:
sonar-psi.googlecode.com/files/fann_pl.pdf

Byłbym niesamowicie wdzięczny gdyby ktoś pomógł mi przetłumaczyć zawarty w artykule kod :

Listing 1. Program mierzący częstotliwość występowania
liter A-Z w pliku tekstowym

#include <vector>
#include <fstream>
#include <iostream>
#include <ctype.h>
void error(const char* p, const char* p2 = "")
{
std::cerr << p << ' ' << p2 << std::endl;
std::exit(1);
}
void generate_frequencies(const char *filename,
float *frequencies)
{
std::ifstream infile(filename);
if(!infile) error(
"Cannot open an input file", filename);
std::vector<unsigned int> letter_count(26, 0);
unsigned int num_characters = 0;
char c;
while(infile.get(c)){
c = tolower(c);
if(c >= 'a' && c <= 'z'){
letter_count[c - 'a']++;
num_characters++;
}
}
if(!infile.eof()) error("Something strange happened");
for(unsigned int i = 0; i != 26; i++){
frequencies[i] =
letter_count[i]/(double)num_characters;
}
}
int main(int argc, char* argv[])
{
if(argc != 2) error(
"Remember to specify an input file");
float frequencies[26];
generate_frequencies(argv[1], frequencies);
for(unsigned int i = 0; i != 26; i++){
std::cout << frequencies[i] << ' ';
}
std::cout << std::endl;
return 0;
}

Nie jestem programistą C/C++, a składnia wygląda na bardzo profesjonalną. Jeśli ktoś mi pomoże spróbuje przenieść algorytm do matlaba.

Na siec neuronowa to to nie wyglada. Siec jest 'troche' bardziej skomplikowana. Oczywiscie dajac odpowiedni zestaw danych testowych i sygnalow wejsciowych mozna nauczyc neurony aby dawaly okreslony output. Sieci sluza bardziej do rozpoznawania pewnych wzorcow np. na podstawie jakichs grafik treningowych po otrzymaniu znieksztalconej beda potrafily w zaleznosci od stopnia znieksztalcenia dojsc do grafiki wyjsciowej.

Twoj problem jest rozwiazany w 1 petli i liczy czestotliwosc prostym wzorem ilosc wystapienia litery / ilosc wszystkich liter. Ot caly kod

tak wiem że ten przykład niewiele wnosi, jednakże chciałbym go przeanalizować dokładnie. Prosiłbym o przetłumaczenie przynajmniej każdej funkcji.

#include <vector>
#include <fstream>
#include <iostream>
#include <ctype.h>

void error(const char* p, const char* p2 = "")
{
   std::cerr << p << ' ' << p2 << std::endl;
   std::exit(1);
}

void generate_frequencies(const char *filename, float *frequencies)
{
   std::ifstream infile(filename);
   if(!infile) error("Cannot open an input file", filename);
   std::vector<unsigned int> letter_count(26, 0);
   
   unsigned int num_characters = 0;
   char c;

   while(infile.get(c))
   {
      c = tolower(c);
      if (c >= 'a' && c <= 'z')
      {
          letter_count[c - 'a']++;
          num_characters++;
      }
   }

   if (!infile.eof())  error("Something strange happened");

   for (unsigned int i = 0; i != 26; i++)
   {
       frequencies[i] = letter_count[i]/(double)num_characters;
   }

}


int main(int argc, char* argv[])
{
   if(argc != 2) error("Remember to specify an input file");

   float frequencies[26];
   generate_frequencies(argv[1], frequencies);
   for (unsigned int i = 0; i != 26; i++)
   {
      std::cout << frequencies[i] << ' ';
   }
   std::cout << std::endl;
   return 0;
}

Gdybys przeczytal kawalek tego pdfa ktory dales to dowiedzialbys sie co dzieje sie w tym kodzie. Z siecia neuronowa on nie ma praktycznie nic wspolnego. Z pdfa:
"Generuje czestotliwosci wystepowania liter w pliku tekstowym". Co znaczy tyle, ze buduje zestaw danych treningowych dla sieci neuronowej, tak by ta potrafila rozpoznac w jakim jezyku jest dany plik. Cala robote odwala 1 petla for ktora liczy to ze wzoru ktory podalem wyzej, reszta to tylko wczytanie danych na podstawie pliku.

Dalej nalezy zbudowac siec skladajaca sie z 26 neuronow w 1 warstwie i 3 w warstwie wyjsciowej. Podac jej zestaw danych treningowych i uczyc dopoki blad nie bedzie < eps.
Ja np. buduje siec tak:

    // Initialize //

    vector<double>x,y,expOut = {1,1,1,1},output;
    int i = 0;
    double error;
    NeuralNetwork network;
    NeuralLayer firstLayer, hiddenLayer, outputLayer;

    // Building network //

    Neuron n1(4),n2(4),n3(4),n4(4);
    n1.setSignal({1,0,0,0});
    n2.setSignal({0,1,0,0});
    n3.setSignal({0,0,1,0});
    n4.setSignal({0,0,0,1});
    firstLayer.addNeuron(n1);
    firstLayer.addNeuron(n2);
    firstLayer.addNeuron(n3);
    firstLayer.addNeuron(n4);
    firstLayer.initLayerWeights({0.472801, 0.935628, -0.491067, 0.372298});

    Neuron n5(4),n6(4);
    hiddenLayer.addNeuron(n5);
    hiddenLayer.addNeuron(n6);
    hiddenLayer.initLayerWeights({-0.100727, 0.297812, -0.615205, -0.153709});

    Neuron n7(2),n8(2),n9(2),n10(2);
    n7.setWeight({0.346888, 0.484956});
    n8.setWeight({0.654139, -0.961072});
    n9.setWeight({0.872161, 0.603206});
    n10.setWeight({0.665244, -0.489092});
    outputLayer.addNeuron(n7);
    outputLayer.addNeuron(n8);
    outputLayer.addNeuron(n9);
    outputLayer.addNeuron(n10);

    network.addLayer(firstLayer);
    network.addLayer(hiddenLayer);
    network.addLayer(outputLayer);
    network.setActivationFunction(new SigmoidalFunction(0.2));
    network.setExpectedOutput(expOut);

    // Processing network //

    output = network.processNetwork();

    while(abs(output[0] - expOut[0]) > 0.01 ||
          abs(output[1] - expOut[1]) > 0.01 ||
          abs(output[2] - expOut[2]) > 0.01 ||
          abs(output[3] - expOut[3]) > 0.01)
    {
        output = network.processNetwork();
        for(double i : output)
            qDebug() << "Output: " << i;
        network.countError(); // back propagation
        error = 0.5 * (((output[0] - expOut[0])*(output[0] - expOut[0])) +
                ((output[1] - expOut[1])*(output[1] - expOut[1])) +
                ((output[2] - expOut[2])*(output[2] - expOut[2])) +
                ((output[3] - expOut[3])*(output[3] - expOut[3]))) ; // least squares method
        y.push_back(error); // for plotting
        x.push_back(i);
        i++;
    }

Ps. Wiem ze mozna zamknac w 1 petli for te bledy, wiec sie nie czepiac ;)

Ale po co tutaj sieć neuronowa? o_O Sieci neuronowe tak jak i algorytmy genetyczne stosuje się tam gdzie nie da się rozwiązać problemu lepiej, a tutaj się da. Zwykła odległość cosinusowa pomiędzy tekstem wejściowym a wektorem dla danych w konkretnym języku da nam rozwiązanie.