C. Short Sieci neuronowe: algorytm odwrotnej rozprzestrzeniania W tym artykule opisano algorytm na szkolenia z wykorzystaniem sieci neuronowych proliferacji procedurę, opisaną klasy biblioteki dla C + +. Wśród różnych modeli sieci neuronowych (NA), jeden z najbardziej znanych jest wielowarstwową strukturę, w której każdy neuron arbitralne warstwy jest połączony ze wszystkimi axons neuronów poprzedniej warstwy, lub w przypadku pierwszej warstwy, z wszystkich wejściach bd. Są to tak zwane NS polnosvyaznymi. Gdy sieć jest tylko jedna warstwa, jej algorytm uczenia się z nauczycielem raczej oczywiste, jak również prawidłowego stanu wyjście z pojedynczej warstwy neuronów świadomie, wykrawania i połączeń synaptycznych w kierunku, który minimalizuje błąd na wyjściu z sieci. Zgodnie z tą zasadą, na przykład, algorytm uczenia się jednym pertseptrona [1]. W tym samym wielowarstwową sieci optymalnej wartości wyjściowych neuronów wszystkich segmentów z wyjątkiem ostatniego, na ogół nie są znane, a dwóch lub więcej warstw pertseptron nie można już nauczać, kierować tylko wartości błędów w terminalach Zgromadzenia Narodowego. Jednym z rozwiązań tego problemu - rozwój produkcji zestawów sygnałów wejściowych odpowiadające dla każdej warstwy Zgromadzenia Narodowego, które, oczywiście, jest bardzo intensywna praca i działanie nie zawsze jest możliwe. Druga opcja - dynamiczne synapsach korekta wag, które są wybrane, zazwyczaj najsłabszy linki i niewielkie zmiany w wartości jednej stronie lub innej, ale zapisuje tylko zmiany, które spowodowały zmniejszenie błędów w produkcji globalnej sieci. Oczywiście, ta metoda "grzebać", pomimo pozornej prostoty, wymaga uciążliwych rutynowych obliczeń. I wreszcie po trzecie, bardziej akceptowalne opcja - rozprzestrzenianie się sygnał błędu NA wyjścia do jej wejście w kierunku przeciwnym do bezpośredniego rozpowszechniania sygnałów w trybie normalnym. Ten algorytm jest nazywany reverse NS szkolenia procedur obiegu. On będzie dalej. Zgodnie z metodą najmniejszych kwadratów, docelowej funkcji błędów minimiziruemoy NA jest wielkości:    (1) gdzie - rzeczywisty stan emeryturę neuron j N warstwy wyjściowej sieci neuronowych w zgłoszeniu jego wejściach p-sekundowy obraz; djp - idealne (pożądany) wyjściowego stanu neuronu. Sumowanie jest dla wszystkich neuron wyjściowy warstwy, a wszystkie obrazy przetworzone przez sieć. Minimalizacji jest metoda gradientem zniżania, co oznacza, że wykończeń wagi w następujący sposób:    (2) Tutaj Wij - waga synaptycznych połączeń łączących i-tego neuronu - wskaźnik prędkości szkoleń,warstwy n-1 z j-tego neuronu warstwy n, 0 < <1. Jak pokazano w [2]   (3) Tutaj, pod YJ, jak poprzednio, oznacza wycofanie neuron j, ale pod sj - ważoną sumą jego sygnałów wejściowych, który jest argumentem funkcji aktywacji. Ponieważ mnożnik dyj / dsj jest pochodną funkcji argument, wynika, że pochodna funkcji aktywacji musi być określony na całej osi odciętych. W związku z funkcją jednym skok, i innych funkcji aktywacji nieprawidłowości nie są odpowiednie dla obecnego Zgromadzenia Narodowego. Sprawnego ich wykorzystania funkcji takich jak tangens hiperboliczny lub klasyczne sigmoid z wystawcami. W przypadku gdy tangens hiperboliczny    (4) wij, oczywiście, jest wejście do poprzedniego poziomu neuron Yi (n-1). sj / Trzeci czynnik Jeśli chodzi o pierwszy mnożnik (3), jest łatwy do usunięcia przeczytać [2]:

  (5) Tutaj sumowanie k wykonywane wśród neuronów warstwy n +1. Wpisz nową zmienną   (6) k (n +1) starsze warstwy n +1. j (n) n warstwą wartości mamy rekurencyjnego wzoru do obliczania wartości   (7) Do tej samej warstwy wyjściowej   (8) Teraz możemy napisać (2) otworzył w następujący sposób:   (9) Czasami proces korygowania niektórych bezwładności masy, wygładzanie ostrych skoków podczas ruchu na powierzchni docelowej funkcji (9) jest uzupełniana przez zmiany wartości masy ciała w ciągu poprzednich iteracji   (10) - współczynnik bezwładności, t - numer bieżącego iteracji.gdzie Tak więc, kompletny algorytm uczenia się przy wykorzystaniu procedury odwrotnej NA rozprzestrzeniania się zbudowany w taki sposób: . 1. Prześlij wpisy do sieci, jednym z możliwych, a normalnego funkcjonowania Zgromadzenia Narodowego, gdzie sygnały są rozprowadzane od wejścia do wyjścia, obliczyć wartości z przeszłości. Przypomnijmy, że   (11) gdzie M - liczba neuronów w warstwie n-1, biorąc pod uwagę neuron ze stałym +1 stan wyjściowy, który zwrócił się do przejścia; Yi (n-1) = xij (n) - i-th warstwy obsługi wej ¶ cia do neuronu j n. YJ (n) = f (sj (n)), gdzie f () - sigmoid (12) YQ (0) = Iq, (13) gdzie Iq - q-tego elementu wektora obrazu wejściowego. (N) dla warstwy wyjściowej na wzór (8).. 2. Oblicz (N) warstwy N.Obliczana jako (9), lub (10) zmianę wag w w (n) dla wszystkich innych sektorów, n = N-1 ... 1. (n) i . 3. Obliczana jako (7) i (9) (lub (7) i (10)) odpowiednio . 4. Regulować wszystkie obciążenia w bd   (14) . 5. Jeśli ta sieć jest niezbędna, przejdź do Krok 1. Inaczej - koniec.   Rys. 1 Rysunek sygnałów w sieci przez algorytm uczenia się, aby odwrócić rozprzestrzeniania Sieci w kroku 1, przemiennie w kolejności losowej są wszystkie szkolenia obrazów do sieci, że tak powiem, nie zapomnij zapamiętać kilka innych. Algorytm jest zilustrowane przez rysunek 1. Z wypowiedzi (9) wykazały, że w przypadku gdy wartość wyjściową Yi (n-1) ma tendencję do zera, skuteczność nauczania znacznie obniżona. Gdy binarnych wektorów wejściowych, średnio o połowę wagi nie będzie korrek ¬ gwarancji [3], a więc obszar możliwych wartości wyjściowych neuronów [0,1] pożądane, aby przejść do [-0.5, +0.5], która jest osiągana poprzez proste modyfikacje funkcji logistycznych. Na przykład, gwałtowny sigmoid z zamieniane na uwadze   (15) Teraz chodzi o zdolności Zgromadzenia Narodowego, szereg obrazów prezentowanych na jego wejście, które jest w stanie nauczyć się rozpoznawać. Dla sieci z kilku segmentów

więcej niż dwa, pozostaje otwartą kwestią. Jak wykazano w [4], do Zgromadzenia Narodowego z dwóch warstw, np. w weekendy, i jedna warstwa ukryta, deterministycznych sieci Cd szacuje się następująco: Nw / Ny <Cd < dziennika (NW / NY) (16)Nw / Ny gdzie NW - reguluje liczbę odważników, NY - liczba neuronów w warstwie wyjściowej. Należy zauważyć, że zwrot otrzymanych z pewnymi ograniczeniami. Po pierwsze, liczba wejść i Nx neuronów w warstwie ukrytej Nh muszą spełniać nierówności Nx + Nh> Ny. Po drugie, NW / Ny> 1000. Jednakże powyższe ocena została przeprowadzona dla sieci z funkcji aktywacji neuronów w postaci progu i pojemności sieci z gładką aktywacji funkcji, na przykład - (15), powszechnie [4]. Także wymienionych w tytule zbiorników przymiotnik "deterministyczny" oznacza, że otrzymanie oceny zdolności nadaje się do wszystkich możliwych wzorców wejściowych, które mogą być prezentowane Nx wejściach. W rzeczywistości, dystrybucji obrazów wejściowych mają pewne regularności, które pozwala Zgromadzenia Narodowego w celu przeprowadzenia syntezy, a tym samym zwiększenie realnej możliwości. Ponieważ dystrybucji obrazów, w ogóle, nie wiadomo z góry, możemy mówić o takiej możliwości jedynie spodziewać, ale zazwyczaj jest dwa razy większa niż pojemność deterministycznego. Kontynuacja rozmowy na temat zdolności logicznego NA do poruszenia kwestii wymaganej mocy wyjściowej warstwy sieci, obsługujących końcowej klasyfikacji obrazów. Faktem jest, że podział na wielu wejściowych, na przykład, dwóch klas jest tylko jedno wyjście. W ten sposób każdy poziom logiczny - "1" i "0" - będzie oznaczać oddzielną klasę. Dwa wyjścia mogą być zakodowane posiada 4 klasy i tak dalej. Jednakże, wyniki sieci zorganizowane w taki sposób, można by powiedzieć - "pod łańcuch" - nie bardzo wiarygodne. Aby zwiększyć niezawodność klasyfikacji pożądane jest wprowadzenie zwolnień poprzez przydział każdej klasie jeden neuron w warstwie wyjściowej, lub, jeszcze lepiej, kilka, z których każda jest wyszkolony do wykrywania zdjęcie klasy z jego stopień, na przykład: wysokiej, średniej i niskiej. Takie NA pozwalają klasyfikacji obrazów wejściowych, składający się z niejasne (niewyraźne lub pokrywania) zestaw. Funkcja ta sprowadza się do takich NA rzeczywistych warunków życia. Zgromadzenie Narodowe jest uważana za liczbę "wąskich gardeł". Po pierwsze, w procesie uczenia się może zdarzyć, gdy dużą dodatnią lub ujemną obciążniki do zmiany miejsca pracy w wielu sigmoid neuronów w obszarze nasycenia. Niewielkie ilości pochodzą z funkcji logistycznych zgodnie z ołowiu (7) i (8) do zatrzymać uczenia się, że sparaliżowany Zgromadzenia Narodowego. Po drugie, korzystanie z gradientem zniżania nie gwarantuje, że znajdzie globalne niż lokalne cel minimum funkcji. Ten problem jest inny - a mianowicie, z Wybór wartości prędkości szkolenia. Dowód zbieżności procesu uczenia się w odwracalnych opartych na pochodnych, czyli zwiększa wagi, a tym samym szybkość uczenia się nieskończenie mały, ale w takim przypadku będzie badań niedopuszczalnie powoli. Z drugiej strony, zbyt wiele korekta wag może prowadzić do stałego niestabilność procesu uczenia się. Dlatego, jak zwykle wybrana liczba jest mniejsza niż 1, ale nie zbyt małych, na przykład, 0.1, i jest, ogólnie rzecz biorąc, może stopniowo słabła w proces uczenia się. Ponadto, aby wykluczyć losowego trafienia w lokalnej bardzo krótko,minimalne czasem, po wartości wag zastabiliziruyutsya, aby rozpocząć wzrost gradientu zejście z nowego punktu. Jeśli powtórzenia tej procedury prowadzące algorytmu kilka razy w tym samym stanie Zgromadzenia Narodowego, mogą być mniej lub bardziej pewnie powiedzieć, że znalezione globalne maksymalnej, a nie inny. Istnieje kilka metod wyjątkiem lokalnych minimów, a jednocześnie, i paraliżu Zgromadzenia Narodowego, jest użycie stochastycznych NS, ale lepiej mówić o nich osobno. Teraz możemy zastosować bezpośrednio do programowania Zgromadzenia Narodowego. Należy zauważyć, że liczba zagranicznych publikacji związanych z realizacją polityki sieci,

znikome w porównaniu z całkowitą liczbą prac na sieciach neuronowych, i to pomimo faktu, że wielu autorów przetestowaniu ich obliczenia teoretyczne go programowo, a nie za pomocą Neurocomputers i neyroplat, głównie ze względu na ich wysoki koszt. Być może wynika to z faktu, że programowanie na zachodzie są traktowane jak sztuka, a nie nauki. Jednak w wyniku tego rodzaju dyskryminacji pozostaje nerazobrannymi bardzo ważne kwestie. Jak wykazano w formułach, które opisują algorytm do pracy i szkoleń Zgromadzenia Narodowego, cały proces może być rejestrowane, a następnie zaprogramowane w zakresie operacji i wykorzystanie algebry macierzy zostało wykonane, na przykład, [5]. Najwyraźniej, takie podejście jest szybszy i bardziej kompaktowych wdrażanie Zgromadzenia Narodowego, a nie oparty na wcielenie jej koncepcji obiektowych (OO) programowania. Ostatnio jednak, że jest zdominowany przez OO podejście, często opracowane specjalne OO języków programowania do Zgromadzenia Narodowego [6], chociaż, moim zdaniem, powszechne OO języków takich jak C + + i Pascal, powstawały precyzyjne, aby wyeliminować potrzebę rozwoju, co OO wszelkich innych językach, w jakiejkolwiek dziedzinie nie zamierzają stosować. NA jeszcze programowania za pomocą OO podejście ma swoje plusy. Po pierwsze, pozwoli to na utworzenie elastycznych, łatwych NS perestraivaemuyu hierarchii modeli. Po drugie, taki realizacji najbardziej przejrzysty dla programisty, i pozwala konstruować Zgromadzenia Narodowego nawet neprogrammistam. Trzeciego poziomu abstrakcja programowania związanego z OO języki, w przyszłości prawdopodobnie wzrośnie, a wdrożenie Zgromadzenia Narodowego z OO podejście przyczyni się do wzmocnienia ich możliwości. Na podstawie powyższych rozważań, jak pokazano w aukcji biblioteki klas i programów, które wdraża polnosvyaznye NA algorytm uczenia się, aby odwrócić rozprzestrzeniania się za pomocą OO podejście. Oto główne punkty, które wymagają wyjaśnienia. Na wstępie należy zauważyć, że biblioteki został skompilowany i wykorzystywane do rozpoznawania obrazów, ale odnosi się do innych aplikacji. Plik neuro.h w Listing 1 określa dwa podstawowe i pięć pochodne (pracy) klas: Neuron, SomeNet i NeuronFF, NeuronBP, LayerFF, LayerBP, NetBP, jak również opisy wspólnych narzędziowy kilka funkcji zawartych w pliku subfun.cpp ( sm.listing 4). Metody pracy z pięciu do klasy pliki neuro_ff.cpp i neuro_bp.cpp, przedstawione w aukcji 2 i 3. Ta, na pierwszy rzut oka sztuczne, podział ze względu na fakt, że zajęcia z koncówka _ff, opisujące pryamopotochnye sieci neuronowe (feedforward), są nie tylko do odwrócenia rozprzestrzeniania sieci - _bp (backpropagation), ale inne, takie jak szkolenia bez nauczycieli, które zostaną omówione dalej. Hierarchii klas danej bibliotece jest na rysunku 2. ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐ ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐ Neuron │ │ │ │ SomeNet └ ─ ─ ─ ─ ┬ ─ ─ ─ ─ ─ ┘ └ ─ ─ ─ ─ ┬ ─ ─ ─ ─ ┘       │ │ ┌ ─ ─ ─ ─ ┴ ─ ─ ─ ─ ─ ┐ │ NeuronFF │ │ │ └ ─ ─ ─ ─ ┬ ╥ ─ ─ ─ ─ ┘ │       │ ╚ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ╗ │ ┌ ─ ─ ─ ─ ┴ ─ ─ ─ ─ ─ ┐ ┌ ─ ─ ─ ─ ╨ ─ ─ ─ ─ ┐ │ NeuronBP │ │ │ │ │ LayerFF └ ─ ─ ─ ─ ╥ ─ ─ ─ ─ ─ ┘ └ ─ ─ ─ ─ ┬ ─ ─ ─ ─ ┘ │       ╚ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ╗ │ │                ┌ ─ ─ ─ ╨ ┴ ─ ─ ─ ─ ┐ │                LayerBP │ │ │                └ ─ ─ ─ ┬ ─ ─ ─ ─ ─ ┘ │                    │ ┌ ─ ─ ─ ─ ─ ─ ─ ┘

                ┌ ─ ─ ┴ ┴ ─ ─ ─ ┐                 │ │ NetBP                 └ ─ ─ ─ ─ ─ ─ ─ ┘ Rys.2 Hierarchia klasy biblioteki w celu odwrócenia rozprzestrzeniania sieci (jednej linii - dziedziczenie, podwójne - wejście) Na koszt zasad programowania OO, sześciu głównych parametrów charakteryzujących sieci, wykonane na poziomie globalnym, co ułatwia z nimi transakcji. Wartość SigmoidType rodzaj funkcji aktywacji. W metodzie NeuronFF: Sigmoid wymienione niektóre z jego znaczenia, makro języki są w nagłówku pliku. Przedmioty HARDLIMIT i progiem do wspólnoty, ale nie mogą być wykorzystywane w algorytmie odwrócenia obiegu, jak odpowiadające im funkcje aktywacji pochodzą ze specjalnych punktów. Znajduje to odzwierciedlenie w sposobie obliczania pochodnych NeuronFF: D_Sigmoid, z których te dwie sprawy są wyłączone. Zmienna stoku w sigmoid ORYGINALNE (15). MiuParm iSigmoidAlfa zadawane z wzoru (10). Wartości graniczne NiuParm - odpowiednio ustawienia i IsConverged metod stosowanych do określenia, kiedy w sieci, aby dowiedzieć się, lub uzyskać w paraliżu. W tych przypadkach, zmiany w masie są niższe niż wartości dopuszczalne niskie. Wartość dSigma emuluje gęstość hałasu dodany do obrazu w czasie nauki w Zgromadzeniu Narodowym. Umożliwia to skończony zbiór "czystych" obrazów wejściowych do generowania niemal nieograniczonej liczby "noisy" obrazy. Chodzi o to, że w celu znalezienia najlepszej wartości wag liczbę stopni swobody NS - Nw powinna być znacznie mniejsza niż liczba nałożonych ograniczeń NP, gdzie Np - liczba obrazów prezentowanych w Zgromadzeniu- Ny Narodowym w trakcie szkolenia. W rzeczywistości, dSigma parametrem jest liczba wejść, które będą w przypadku odwrócony do binarnego obrazu. Jeśli dSigma = 0, hałas nie jest wprowadzony. Randomize zezwolenia przed metod nauczania, aby ustawić obciążniki do losowych wartości w zakresie [zasięgu, zakresu +]. Propagowanie metody wykonywania obliczeń w sprawie wzorów (11) i (12). Metoda NetBP: CalculateError poprzez przekazywane jako argument dla .wiernych array (pożądany) NA oblicza wartość wyjściową wartość Metoda NetBP:: Dowiedz się oczekuje, aby zmienić równowagę wzoru (10), praktyki Aktualizacja aktualizacja wag. Metoda NetBP: Cykl łączy w sobie wszystkie procedury z cyklu, w tym instalacji sygnałów wejściowych NetBP: SetNetInputs. Różnych metod PrintXXX i LayerBP: Pokaż umożliwia kontrolę nad procesami Zgromadzenia Narodowego, ale ich realizacja nie jest niezbędna, i prostych procedur z biblioteki mogą być zapisane w razie potrzeby, na przykład, do grafiki. Jest to uzasadnione faktem, że w trybie alfanumerycznym mieści się na ekranie informacji o stosunkowo dużych NA nie udało. Sieci mogą być zbudowane przez NetBP (niepodpisane), po którym muszą one być tak zaprojektowane, aby wypełnić w poprzednich warstw za pomocą NetBP: SetLayer, albo poprzez NetBP (niepodpisane, niepodpisane ,...). W tym ostatnim przypadku, projektanci są wyzwalane automatycznie segmenty. Do ustanowienia połączeń synaptycznych pomiędzy warstwami spowodowanych przez metodę NetBP: FullConnect. Raz w sieci szkoleń, a jego obecny status może zostać zapisana w pliku (metoda NetBP: SaveToFile), a następnie odzyskane za pomocą programu NetBP: LoadFromFile, która ma zastosowanie tylko do nowo wybudowanego na NetBP (void) sieci. Aby wejść w sieci obrazów wejściowych, a także w procesie kształcenia - i na zakończenie pracy, napisana przez trzy metody: SomeNet: OpenPatternFile, SomeNet: ClosePatternFile i NetBP: LoadNextPattern. Jeżeli plik obrazów wszelkich ekspansji, wejście i wyjście wektor rejestrowane naprzemiennie: ciąg wejściowy z wektora, zgodnie z ideą jego weekendy, itp. Każdy wektor jest ciągiem liczb rzeczywistych w zakresie [-0,5, +0.5], oddzielone przez arbitralne liczba spacji (patrz Listing 7). Jeśli plik ma rozszerzenie IMG, wejście wektor jest reprezentowany jako znak wielkości matrycy dx dy * (dx dy i wartości powinny zostać

ustalone z góry przez LayerFF: SetShowDim do zera warstwy) z symbolem "x" odpowiada poziom 0.5, punkt - poziom -0,5, Czyli plików IMG, co najmniej - w wersji biblioteki, binarne (patrz Listing 8). Gdy sieć działa normalnie, ale nie włączono, z linii wyjściowej nosicieli może być pusta. Metoda SomeNet: SetLearnCycle określa liczbę przejazdów do obrazu, który, wraz z dodatkiem hałasu sprawia, że możliwe jest uzyskanie zestawu kilkadziesiąt, a nawet setek tysięcy różnych obrazów. W aukcji, 5 i 6 są programy, projekty i szkolenia NA, jak również przy użyciu operacyjnych uznawania obrazów. Szczególnie zwrócić uwagę, jest niuans, że w tej klasie biblioteki realizacji brakuje NS reguluje próg dla każdego neuronu. Sieci, ogólnie rzecz biorąc, może działać bez niego, ale proces uczenia się od tego spowalnia [3]. Proste, ale nie najbardziej skuteczny sposób, aby przejść do neuronów w każdej warstwie regulowane przesunięcie jest dodawany do klasy NeuronFF Nasycać metoda, która zmusi wyjściowa neuronu w stanie nasycenia axon = 0,5, z wyzwaniem tej metody dla każdego, na przykład, ostatnio neuron warstwy po zakończeniu funkcji LayerFF: propagowanie. Oczywiste jest natomiast, że w trakcie budowy w każdej warstwy z NA, oprócz produkcji należy dodać jeden dodatkowy neuron. Jest to w zasadzie nie może mieć żadnego synapsach, tablicy lub zmienić ich ciężary i nie wywoływać metody propagowanie wewnątrz LayerFF: propagowanie. Zbadane i wdrożyć algorytmu w programie jest, możemy powiedzieć klasycznej wersji procedurę odwrotnego obiegu, ale wiadomo, że wiele jego modyfikacji. Zmiany odnoszą się do sposobu obliczania metody [7] [8], oraz konfiguracji sieci [9] [5]. W szczególności, w [5] posloynaya sieci zastąpione kręgosłup, neuronów, gdy wszystkie są zagadnieniem i wszystkich związanych z wszystkich poprzednich. Sieci, zaprojektowany jako przykład programu, pokazano w Listing 5 został wyszkolony, aby rozpoznać dziesięć listów, schematycznie zdefiniowane matryce 6 * 5 punktów za kilkaset cykli do wykonania na komputerze 386DX40 czasie krótszym niż minuta. Wyszkolonych sieci z powodzeniem rozpoznaje obrazy, hałas w większym stopniu niż obrazy, na których jest badane. Program skompilowany z pomocą Borland C + + 3.1 w modelach dużych i małych. Proponowane klasy biblioteki do tworzenia sieci zdolnych do szerokiej gamy zadań, takich jak budowanie systemów eksperckich, kompresji i wiele innych warunków początkowych, które mogą być dostosowane do wielu par wejściowych i wyjściowych, zbiorów danych.

Literatura . 1. C. Short, sieci neuronowe: podstawowe przepisy. . 2. Sankar K. Pal, Sushmita Mitra, Perceptron wielowarstwowy, Fuzzy Sets, a Klasyfikacja / / IEEE Transactions na Neural Networks, Vol.3, N5, 1992, pp.683-696. . 3. F. Uossermen, Neyrokompyuternaya Technology, Moskwa, Mir, 1992. . 4. Bernard Widrow, Michael A. Lehr, 30 lat Adaptive NeuralNetworks: Perceptron, Madaline i Backpropagation / / Artificial neuronowe Sieci: Pojęcia i Teorii, IEEE Computer Society Press, 1992, pp.327-354. . 5. Paul J. Werbos, Backpropagation w czasie: czym się zajmuje i jak to zrobić / / Artificial neuronowe Sieci: Pojęcia i Teorii, IEEE Computer Society Press, 1992, pp.309-319. . 6. Gael de La Croix Vaubois, Catherine Moulinoux, Benolt Derot, N Programming Language / / Neurocomputing, NATO ASI serii vol.F68, pp.89-92. 7. HAMalki, A. Moghaddamjoo, Korzystanie z Karhunen-Więcej.International `ve Transformacji w Back-Propagation Szkolenia Algorytm / / IEEE Transactions na Neural Networks, Vol.2, N1, 1991, pp.162-165. 8. Harris Drucker, Yann Le CUN, uogólnienie Poprawa wydajności Korzystanie Backpropagation / / IEEE Transactions na Neural Networks, Vol.3, N5, 1992, pp.991-997.

9. Alain Petrowski, Gerard Dreyfus, Claude Girault, Performance Analysis z potoku Backpropagation Parallel Algorithm / / IEEE Transactions na Neural Networks, Vol.4, N6, 1993, pp.970-981.

   Listing 1

/ / FILE neuro.h # Include <stdio.h> # Define OK, 0 / / obiekty # Define Error 1

# Define ORYGINAŁ 0 / / rodzaje funkcji aktywacji # Define HYPERTAN 1 # Define HARDLIMIT 2 # 3 zdefiniowanie PRÓG

# Define INNER 0 / / rodzaj alokacji pamięci # Define extern 1

# Define HORYZONTALNE 1 # Define PIONOWE 0

# Ifndef max # Define max (a, b) (((a)> (b))? (A): (b)) # Define min (a, b) (((a) <(b))? (A): (b)) # Endif

/ / Klasy bazowej neuronów w większości sieci Klasa Neuron ( chronionych:    float państwa; / / stanu    float axon; / / wynik    int status; / / podpisania błąd publicznych:    Neuron (nieważne) (stan = 0.; Axon = 0.; Status = OK;);    virtual float Sigmoid (void) = 0;    int GetStatus (nieważne) (return status;); );

Klasa SomeNet ( chronionych:    FILE * pf;    int Imgfile; / / 0 - numer 1 - 2D; 2 - Emulacja    unsigned rang;    int status;    unsigned learncycle;    int (* emuf) (int n, float * w _FAR, float * _FAR ou);

publicznych:    SomeNet (void)    (PF = NULL; Imgfile = 0; Rang = 0, status = OK; learncycle = 0;);    unsigned GetRang (nieważne) (powrót Rang;);    nieważne SetLearnCycle (unsigned l) (l = learncycle;);    int OpenPatternFile (unsigned char * plik);    int ClosePatternFile (void);    nieważne EmulatePatternFile (int (* p) (int n,         float * _FAR, _FAR float *))         (p = emuf; Imgfile = 2;);    int GetStatus (nieważne) (return status;); );

LayerBP klasy; NetBP klasy;

/ / Neuron polnosvyaznoy sieci bezpośredniej rozpowszechniania NeuronFF klasy: public Neuron ( chronionych:    unsigned Rang; / / liczba wag    float * _FAR synapsach; / / waga    float _FAR * * _FAR nakładów;    / / Tablica z odnosniki do wcześniejszych neuronów wyjściowych. warstwa    nieważne _allocateNeuron (niepodpisane);    nieważne _deallocate (void); publicznych:    NeuronFF (niepodpisane num_inputs);    NeuronFF (nieważne) (Rang = 0; synapsach = NULL;    Wejścia = NULL; status = OK;);    ~ NeuronFF ();    virtual void propagowanie (void);    nieważne SetInputs (float * masowe);    nieważne InitNeuron (niepodpisane numsynapses);    wirtualny nieważne RandomizeAxon (void);    virtual void Randomize (float);    virtual float Sigmoid (void);    virtual float D_Sigmoid (void);    virtual void PrintSynapses (int, int);    virtual void PrintAxons (int, int); );

Klasa NeuronBP: publiczne NeuronFF (Friend LayerBP;                                   NetBP przyjaciela;    float błąd;    float _FAR * delta; / / zmiana salda    nieważne _allocateNeuron (niepodpisane);    nieważne _deallocate (void); publicznych:

   NeuronBP (niepodpisane num_inputs);    NeuronBP (nieważne) (delta = NULL; błędu = 0.;);    ~ NeuronBP ();    nieważne InitNeuron (niepodpisane numsynapses);    int IsConverged (void); );

Klasa LayerFF ( chronionych:    unsigned rang;    int status;    int x, y, dx, dy;    unsigned char * nazwa; / / nazwa warstwy publicznych:    LayerFF (nieważne) (Rang = 0; name = NULL; status = OK;);    unsigned GetRang (nieważne) (powrót Rang;);    nieważne SetShowDim (int _x, int _y, _dx int, int _dy)    (x = _x, y = _y; dx = _dx, D = _dy;);    nieważne ustawNazwe (unsigned char * s) (name = s;);    unsigned char * GetName (void)    (if (nazwa) return nazwa;     else return (unsigned char *)&(" NoName ");};    int GetStatus (nieważne) (return status;);    int GetX (nieważne) (return x;);    int GetY (nieważne) (return y;);    int GetDX (nieważne) (powrót dx;);    int GetDY (nieważne) (powrót D;); );

Klasa LayerBP: publiczne LayerFF (Friend NetBP; chronionych:    unsigned neuronrang; / / liczba w synapsach neuronów    int przydziału;    NeuronBP _FAR * neuronów; publicznych:    LayerBP (niepodpisane nRang, niepodpisane nSinapses);    LayerBP (NeuronBP _FAR * Neu, niepodpisane nRang, unsigned nSinapses);    LayerBP (void)    (neuronów = NULL; neuronrang = 0; przydział = extern;);    ~ LayerBP ();    nieważne propagowanie (void);    nieważne Randomize (float);    nieważne RandomizeAxons (void);    void Normalizuje (void);    void Update (void);    int IsConverged (void);    virtual void Show (void);

   virtual void PrintSynapses (int, int);    virtual void PrintAxons (int x, int y, int kierunek); );

Klasa NetBP: publiczne SomeNet (    LayerBP _FAR * * _FAR warstw;    / / Zero Warstwa neuronów bez synapsach realizuje wejściach publicznych:    NetBP (nieważne) (warstw = NULL;);    NetBP (niepodpisane nLayers);    NetBP (unsigned n, niepodpisane N1, ...);    ~ NetBP ();    int SetLayer (unsigned n, LayerBP _FAR * PL);    LayerBP * GetLayer (unsigned n)     (if (n <rang) return warstw [n]; else return NULL;)    nieważne propagowanie (void);    int FullConnect (void);    nieważne SetNetInputs (float _FAR * mvalue);    nieważne CalculateError (float * _FAR TARGET);    Dowiedz się nieważne (void);    void Update (void);    nieważne Randomize (float);    Cykl nieważne (float * _FAR Inp, float _FAR * Out);    int SaveToFile (unsigned char * plik);    int LoadFromFile (unsigned char * plik);    LoadNextPattern int (float * W _FAR, float * _FAR OU);    int IsConverged (void);    nieważne AddNoise (void);    virtual void PrintSynapses (int x = 0 ,...){};    Zmiana wirtualnych float (float W); );

/ / Funkcje serwisu nieważne out_char (int x, int y, int c, int w); nieważne out_str (int x, int y, unsigned char * s, unsigned col); nieważne ClearScreen (void);

/ / Globalne parametry dla rozprzestrzeniania się SetSigmoidType int (int st); SetSigmoidAlfa float (float Al); SetMiuParm float (float Mi); SetNiuParm float (float Ni); SetLimit float (float Li); unsigned SetDSigma (unsigned d);

/ / Grafika # Define GRAFCHAR_UPPERLEFTCORNER 218 # Define GRAFCHAR_UPPERRIGHTCORNER 191 # Define GRAFCHAR_HORIZONTALLINE 196

# Define GRAFCHAR_VERTICALLINE 179 # Define GRAFCHAR_BOTTOMLEFTCORNER 192 # Define GRAFCHAR_BOTTOMRIGHTCORNER 217

# Define GRAFCHAR_EMPTYBLACK 32 # Define GRAFCHAR_DARKGRAY 176 # Define GRAFCHAR_MIDDLEGRAY 177 # Define GRAFCHAR_LIGHTGRAY 178 # Define GRAFCHAR_SOLIDWHITE 219

Listing 2

/ / FILE neuro_ff.cpp DLA neuro1.prj & neuro2.prj # Include <stdlib.h> # Include <math.h> # Include "neuro.h"

statycznych int SigmoidType = ORIGINAL; statycznych float SigmoidAlfa = 2.; / /> 4 == HARDLIMIT

SetSigmoidType int (int st) ( int i;    i = SigmoidType;    SigmoidType = st;    return i; )

SetSigmoidAlfa float (float Al) ( float a;    a = SigmoidAlfa;    SigmoidAlfa = Al;    zwrotu; )

nieważne NeuronFF: Randomize (float range) (    for (unsigned i = 0; i <Rang; i + +)     synapsach [i] = zakres * ((float) rand () / RAND_MAX-0.5); )

nieważne NeuronFF: RandomizeAxon (void) (    axon = (float) rand () / RAND_MAX-0.5; )

float NeuronFF: D_Sigmoid (void) (

   switch (SigmoidType)    (     przypadku HYPERTAN: powrót (1.-axon * axon);     ORYGINALNE przypadku: powrót SigmoidAlfa * (axon +0,5) *                           (1,5-axon);     default: return 1.;    ) )

float NeuronFF: Sigmoid (void) (    switch (SigmoidType)    (     przypadku HYPERTAN: return 0.5 * TanH (państwa);     ORYGINALNE przypadku: powrót -0,5 +1. /                    (1 + exp (-SigmoidAlfa * stan));     przypadku HARDLIMIT: if (stan> 0) return 0.5; else if (stan <0) return -0.5; else return stan;     PRÓG przypadku: if (stan> 0.5) return 0.5; else if (stan <-0,5) return -0.5;                    else return stan;     default: return 0.;    ) )

nieważne NeuronFF: _allocateNeuron (niepodpisane num_inputs) (    synapsach = NULL; nakłady = NULL; status = OK; Rang = 0;    if (num_inputs == 0) return;    synapsach = new float [num_inputs];    if (synapsach == NULL) status = Błąd;    w przeciwnym razie    (     Wejścia _FAR = new float * [num_inputs];     if (nakłady == NULL) status = Błąd;     w przeciwnym razie     (      Rang = num_inputs;      for (unsigned i = 0; i <Rang; i + +)      (Synapsach [i] = 0.; Wejścia [i] = NULL;)     )    ) )

NeuronFF: NeuronFF (niepodpisane num_inputs) (    _allocateNeuron (num_inputs); )

nieważne NeuronFF: _deallocate (void) (    if (Rang & & (status == OK))    (usuń [] synapsach; usunąć [] nakładów;     synapsach = NULL; nakłady = NULL;) )

NeuronFF: ~ NeuronFF () (    _deallocate (); )

nieważne NeuronFF: propagowanie (void) (    stan = 0.;    for (unsigned i = 0; i <Rang; i + +)     stan + = (* inputs [i] * 2) * (synapsach [i] * 2);    stan / = 2;    axon = Sigmoid (); )

nieważne NeuronFF: SetInputs (float * vm) (    for (unsigned i = 0; i <Rang; i + +) inputs [i] = & vm [i]; )

nieważne NeuronFF: InitNeuron (niepodpisane num_inputs) (    if (Rang & & (status == OK))    (usuń [] synapsach; usunąć [] wejść;)    _allocateNeuron (num_inputs); )

nieważne NeuronFF: PrintSynapses (int x = 0, int y = 0) ( unsigned char buf [20];    for (unsigned i = 0; i <Rang; i + +)    (     sprintf (buf, "+7.2% f", synapsach [i]);     out_str (X +8 * i, y, buf, 11);    ) )

nieważne NeuronFF: PrintAxons (int x = 0, int y = 0) ( unsigned char buf [20];    sprintf (buf, "+7.2% f", axon);    out_str (x, y, buf, 11); )

Listing 3

/ / FILE neuro_bp.cpp DLA neuro1.prj & neuro2.prj # Include <stdlib.h> # Include <alloc.h> # Include <math.h> # Include <string.h> # Include <stdarg.h> # Include <values.h>

# Include "neuro.h"

statycznych MiuParm float = 0.0; statycznych NiuParm float = 0.1; statycznych float limit = 0.000001; statycznych niepodpisane dSigma = 0;

SetMiuParm float (float Mi) ( float a;    a = MiuParm;    MiuParm = Mi;    zwrotu; )

SetNiuParm float (float Ni) ( float a;    a = NiuParm;    NiuParm = Ni;    zwrotu; )

SetLimit float (float Li) ( float a;    a = limit;    Limit = Li;    zwrotu; )

unsigned SetDSigma (unsigned d) ( unsigned u;    U = dSigma;    dSigma = d;    return u; )

nieważne NeuronBP: _allocateNeuron (niepodpisane num_inputs)

(    delta = NULL;    if (num_inputs == 0) return;    delta = new float [num_inputs];    if (delta == NULL) status = Błąd;    else for (unsigned i = 0; i <Rang; i + +) delta [i] = 0.; )

NeuronBP: NeuronBP (niepodpisane num_inputs)            : NeuronFF (num_inputs) (    _allocateNeuron (num_inputs); )

nieważne NeuronBP: _deallocate (void) (    if (delta & & (status == OK))    (usuń [] delta, delta = NULL;) )

NeuronBP: ~ NeuronBP () (    _deallocate (); )

nieważne NeuronBP: InitNeuron (niepodpisane num_inputs) (    NeuronFF: InitNeuron (num_inputs);    if (delta & & (status == OK)) usunąć [] delta;    _allocateNeuron (num_inputs); )

int NeuronBP: IsConverged (void) (    for (unsigned i = 0; i <Rang; i + +)     if (Fabs (delta [i])> limit) return 0;    return 1; )

/ /

LayerBP: LayerBP (niepodpisane nRang, niepodpisane nSynapses) (    = przydział extern; status = Błąd; neuronrang = 0;    if (nRang == 0) return;    neuronów = new NeuronBP [nRang];    if (neuronów == NULL) return;    for (unsigned i = 0; i <nRang; i + +)     neuronów [i]. InitNeuron (nSynapses);    Rang = nRang;

   neuronrang = nSynapses;    = przydział wewnętrznych;    name = NULL; status = OK; )

LayerBP: LayerBP (NeuronBP _FAR * Neu, niepodpisane nRang, unsigned nSynapses) (    neuronów = NULL; neuronrang = 0; przydział = zewnętrzny;    for (unsigned i = 0; i <nRang; i + +)     if (Neu [i]. Rang! = nSynapses) status = Błąd;    if (status == OK)    (     = Neu neuronów;     Rang = nRang;     neuronrang = nSynapses;    ) )

LayerBP: ~ LayerBP (void) (    jeśli (przydziału == INNER)    (     for (unsigned i = 0; i <Rang; i + +)      neuronów [i]. _deallocate ();     delete [] neuronów; neuronów = NULL;    ) )

nieważne LayerBP: propagowanie (void) (    for (unsigned i = 0; i <Rang; i + +)     neuronów [i]. propagowanie (); )

nieważne LayerBP: Aktualizacja (void) (    for (unsigned i = 0; i <Rang; i + +)    (     for (unsigned j = 0; j <neuronrang; j + +)     neuronów [i]. synapsach [j] -= neuronów [i]. delta [j];    ) )

nieważne LayerBP: Randomize (float range) (    for (unsigned i = 0; i <Rang; i + +)     neuronów [i]. Randomize (zakres); )

nieważne LayerBP: RandomizeAxons (void) (    for (unsigned i = 0; i <Rang; i + +)     neuronów [i]. RandomizeAxon (); )

nieważne LayerBP: Normalizuje (void) ( float suma; unsigned i;    for (i = 0; i <Rang; i + +)     suma + = neuronów [i]. axon * neuronów [i]. axon;    suma = sqrt (suma);    for (i = 0; i <Rang; i + +) neuronów [i]. axon / = suma; )

nieważne LayerBP: Pokaż (void) ( unsigned char SYM [5] = (GRAFCHAR_EMPTYBLACK, GRAFCHAR_DARKGRAY, GRAFCHAR_MIDDLEGRAY, GRAFCHAR_LIGHTGRAY, GRAFCHAR_SOLIDWHITE); int i, j;    if (y & & nazwa) for (i = 0; i <strlen (nazwa); i + +)     out_char (i + x, y-1, nazwa [i], 3);    out_char (x, y, GRAFCHAR_UPPERLEFTCORNER, 15);    for (i = 0; i <2 * dx; i + +)     out_char (x +1 + i, y, GRAFCHAR_HORIZONTALLINE, 15);    out_char (x +1 + i, y, GRAFCHAR_UPPERRIGHTCORNER, 15);

   for (j = 0; j <D; j + +)    (     out_char (x, y +1 + j, GRAFCHAR_VERTICALLINE, 15);     for (i = 0; i <2 * dx; i + +) out_char (x +1 + i, y +1 + j,     SYM [(int) ((neuronów [j * dx i + / 2]. axon +0,4999) * 5)], 15);     out_char (x +1 + i, y +1 + j, GRAFCHAR_VERTICALLINE, 15);    )

   out_char (x, y + j +1, GRAFCHAR_BOTTOMLEFTCORNER, 15);    for (i = 0; i <2 * dx; i + +)     out_char (i + x +1, y + j +1, GRAFCHAR_HORIZONTALLINE, 15);    out_char (x +1 + i, y + j +1, GRAFCHAR_BOTTOMRIGHTCORNER, 15); )

nieważne LayerBP: PrintSynapses (int x, int y) (    for (unsigned i = 0; i <Rang; i + +)     neuronów [i]. PrintSynapses (x, y + i); )

nieważne LayerBP: PrintAxons (int x, int y)

(    for (unsigned i = 0; i <Rang; i + +)     neuronów [i]. PrintAxons (x, y + i); )

int LayerBP: IsConverged (void) (    for (unsigned i = 0; i <Rang; i + +)     if (neuronów [i]. IsConverged () == 0) return 0;    return 1; )

/ /

NetBP: NetBP (niepodpisane nLayers) (    Warstwy = NULL;    if (nLayers == 0) (stan = Błąd; powrotu;)    Warstwy = new LayerBP _FAR * [nLayers];    if (warstw == NULL) status = Błąd;    w przeciwnym razie    (     Rang = nLayers;     for (unsigned i = 0; i <Rang; i + +) Warstwy [i] = NULL;    ) )

NetBP: ~ NetBP () (    if (rang)    (     for (unsigned i = 0; i <rang;i++) layers[i]-> ~ LayerBP ();     delete [] warstw, warstw = NULL;    ) )

int NetBP: SetLayer (unsigned n, LayerBP _FAR * pl) ( unsigned i, p;

   if (n> = rang) return 1;    p = pl-> rang;    if (p == 0) return 2;    if (n) / / jeśli nie pierwsza warstwa    (     if (warstw [n-1]! = NULL)              / / Jeśli poprzednia warstwa została podłączona, pro --     (/ / Niewiary, ani tego, czy liczba synaps każdego              / / Jej neuron liczby neuronów przed. warstwa      for (i = 0; i <p; i + +)

     if ((* pl). neuronów [i]. Rang! warstw = [n-1] -> rang)       return 3;     )    )

   if (n <Rang-1) / / jeśli nie ostatniej warstwy    (     if (warstw [n +1])     for (i = 0; i <layers[n+1]-> Rang; i + +)     if (p! warstw = [n +1] -> neuronów [i]. rang) return 4;    )

   warstw [n] = pl;    return 0; )

nieważne NetBP: propagowanie (void) (    for (unsigned i = 1; i <Rang; i + +)     Warstwy [i] -> propagowanie (); )

int NetBP: FullConnect (void) ( LayerBP * l; unsigned i, j, k, n;    for (i = 1; i <Rang; i + +) / / z wyjątkiem warstwy obsługi wej ¶ cia    (/ / Dla wszystkich segmentach     l = Warstwy [i];     if (l-> Rang == 0) return 1;     n = (* warstwy [i-1]). rang;     if (n == 0) return 2;     for (j = 0; j <l-> Rang; j + +) / / by-layer neuron     (      for (k = 0; k <n; k + +) / / synapsach na neuron      (       l-> neuronów [j]. nakłady [k] =        & (Warstw [i-1] -> neuronów [k]. Axon);      )     )    )    return 0; )

nieważne NetBP: SetNetInputs (float * _FAR mv) (    for (unsigned i = 0; i <layers[0]-> Rang; i + +)     warstw [0] -> neuronów [i]. axon = mv [i]; )

nieważne NetBP: CalculateError (float * _FAR docelowy) ( NeuronBP * n; float suma; unsigned i; int j;    for (i = 0; i <layers[rang-1]-> Rang; i + +)    (     n = & (warstw [Rang-1] -> neuronów [i]);     n-> error = (n-> axon-docelowy [i]) * n-> D_Sigmoid ();    )    for (j = Rang-2; j> 0; j -) / / dla warstw ukrytych    (     for (i = 0; i <layers[j]-> Rang; i + +) / / na neuron     (      suma = 0.;      for (unsigned k = 0; k <layers[j+1]-> Rang; k + +)      suma + = Warstwy [j +1] -> neuronów [k]. błąd          * Warstwy [j +1] -> neuronów [k]. Synapsach [i];      warstw [j] -> neuronów [i]. błędu =      * suma warstw [j] -> neuronów [i]. D_Sigmoid ();     )    ) )

nieważne NetBP: Nauka (void) (    for (int j = Rang-1; j> 0; j -)    (     for (unsigned i = 0; i <layers[j]-> Rang; i + +)     (/ / Przez neuron      for (unsigned k = 0; k <layers[j]-> neuronrang; k + +)                                       / / W synapsach      warstw [j] -> neuronów [i]. delta [k] = NiuParm *      (* MiuParm warstw [j] -> neuronów [i]. Delta [k] +       (1.-MiuParm) * warstwy [j] -> neuronów [i]. Błąd       * Warstwy [j-1] -> neuronów [k]. Axon);     )    ) )

nieważne NetBP: Aktualizacja (void) (    for (unsigned i = 0; i <rang;i++) layers[i]-> Update (); )

nieważne NetBP: Randomize (float range) (    for (unsigned i = 0; i <Rang; i + +)     Warstwy [i] -> Randomize (zakres);

)

nieważne NetBP: Cykl (float * _FAR Inp, float * _FAR Out) (    SetNetInputs (Inp);    if (dSigma) AddNoise ();    Propagowanie ();    CalculateError (Out);    Dowiedz się ();    Update (); )

int NetBP: SaveToFile (unsigned char * plik) ( FILE * fp;    fp = fopen (plik, "wt");    if (fp == NULL) return 1;    fprintf (fp, "% u", zarówno);    for (unsigned i = 0; i <Rang; i + +)    (     fprintf (fp, "\ n +% u", warstw [i] -> rang);     fprintf (fp, "\ n |% u", warstw [i] -> neuronrang);     for (unsigned j = 0; j <layers[i]-> Rang; j + +)     (      fprintf (fp, "\ n | +% f", warstw [i] -> neuronów [j]. państwowych);      fprintf (fp, "\ n | |% f", warstw [i] -> neuronów [j]. axon);      fprintf (fp, "\ n | |% f", warstw [i] -> neuronów [j]. błąd);      for (unsigned k = 0; k <layers[i]-> neuronrang; k + +)      (       fprintf (fp, "\ n | |% f",                  Warstwy [i] -> neuronów [j]. synapsach [k]);      )      fprintf (fp, "\ n |+");     )     fprintf (fp, "\ n +");    )    fclose (fp);    return 0; )

int NetBP: LoadFromFile (unsigned char * plik) ( FILE * fp; unsigned i, r, Nr; unsigned char BF [12];

   if (warstwy) return 1; / / mogą korzystać tylko     / / Kopiowanie z klasy, zbudowane domyślnie     / / Użycie NetBP (nieważne).

   fp = fopen (plik, "rt");    if (fp == NULL) return 1;    fscanf (fp, "% u \ n", & r);

   if (r == 0) goto allerr;    Warstwy = new LayerBP _FAR * [r];    if (warstw == NULL)    (Allerr: status = Błąd; fclose (fp); return 2;)    w przeciwnym razie    (     Rang = r;     for (i = 0; i <Rang; i + +) Warstwy [i] = NULL;    )

   for (i = 0; i <Rang; i + +)    (     fgets (BF, 10, fp);     r = atoi (bf +1);     fgets (BF, 10, fp);     nr = atoi (bf +1);     Warstwy [i] = new LayerBP (r, nr);     for (unsigned j = 0; j <layers[i]-> Rang; j + +)     (      fscanf (fp ,"|+% f \ n ", & (Warstwy [i] -> neuronów [j]. państwowych));      fscanf (fp ,"||% f \ n ", & (Warstwy [i] -> neuronów [j]. axon));      fscanf (fp ,"||% f \ n ", & (Warstwy [i] -> neuronów [j]. błąd));      for (unsigned k = 0; k <layers[i]-> neuronrang; k + +)      (       fscanf (fp ,"||% f \ n ",                 & (Warstwy [i] -> neuronów [j]. Synapsach [k]));      )      fgets (BF, 10, fp);     )     fgets (BF, 10, fp);    )    fclose (fp);    return 0; )

NetBP: NetBP (unsigned n, niepodpisane n1, ...) ( unsigned i, num, prenum; va_list varlist;

   status = OK; Rang = 0; pf = NULL; learncycle = 0; warstw = NULL;    Warstwy = new LayerBP _FAR * [n];    if (warstw == NULL) (allerr: status = Błąd;)    w przeciwnym razie    (     Rang = n;

    for (i = 0; i <Rang; i + +) Warstwy [i] = NULL;

    num = n1;     warstw [0] = new LayerBP (num, 0);     va_start (varlist, n1);     for (i = 1; i <Rang; i + +)     (      prenum = num;      num = va_arg (varlist, unsigned);      Warstwy [i] = new LayerBP (num, prenum);     )     va_end (varlist);    ) )

int NetBP: LoadNextPattern (float _FAR * W,                              float * _FAR OU) ( unsigned char buf [256]; unsigned char * s, * ps; int i;    if (pf == NULL) return 1;    if (Imgfile)    (     restart:     for (i = 0; i <layers[0]-> D; i + +)     (      if (fgets (buf, 256, pf) == NULL)      (       if (learncycle)       (        do tyłu (PF);        learncycle -;        Idz restart;       )       else return 2;      )

     for (int j = 0; j <layers[0]-> dx; j + +)      (       if (buf [j] == 'x') w [* i warstw [0] -> dx + j] = 0.5;       else if (buf [j ]=='.') W [* i warstw [0] -> dx + j] =- 0.5;      )     )

    if (fgets (buf, 256, pf) == NULL) return 3;     for (i = 0; i <layers[rang-1]-> Rang; i + +)     (      if (buf [i ]!='.') OU [i] = 0.5;      else OU [i] =- 0.5;

    )     return 0;    )

   / / "Scanf często prowadzi do nieoczekiwanych rezultatów    / / Jeśli odbiegać od oczekiwanego wzorca. "(!)    / / Borland C pomocy on-line    Start:    if (fgets (buf, 250, pf) == NULL)    (     if (learncycle)     (      do tyłu (PF);      learncycle -;      goto start;     )     else return 2;    )    s = buf;    for (; * s ==''; s + +);    for (i = 0; i <layers[0]-> Rang; i + +)    (     ps = strchr (s,'');     if (ps) * ps = 0;     W [i] = atof (s);     s = ps +1; for (; * s ==''; s + +);    )    if (fgets (buf, 250, pf) == NULL) return 4;    s = buf;    for (; * s ==''; s + +);    for (i = 0; i <layers[rang-1]-> Rang; i + +)    (     ps = strchr (s,'');     if (ps) * ps = 0;     OU [i] = atof (s);     s = ps +1; for (; * s ==''; s + +);    )    return 0; )

int NetBP: IsConverged (void) (    for (unsigned i = 1; i <Rang; i + +)     if (Warstwy [i] -> IsConverged () == 0) return 0;    return 1; )

float NetBP:: Zmiana (float W) ( / / W przypadku binarnego

   if (w == 0.5) return -0.5;    else return 0.5; )

nieważne NetBP: AddNoise (void) ( unsigned i, k;    for (i = 0; i <dSigma; i + +)    (     k = random (warstw [0] -> rang);     warstw [0] -> neuronów [k]. axon =     Zmiana (warstw [0] -> neuronów [k]. Axon);    ) )

Listing 4

/ / FILE subfun.cpp DLA neuro1.prj & neuro2.prj # Include <string.h> # Include <math.h> # Include <values.h> # Include "neuro.h"

# Define vad (x, y) ((Y) * 160 + (x) * 2)

nieważne out_char (int x, int y, int c, int w) ( unsigned far * p;    p = (unsigned far *) (+ 0xB8000000L      (unsigned long) vad (x, y));    * P = (c & 255) | (w <<8); )

nieważne out_str (int x, int y, unsigned char * s, unsigned col) (    for (int i = 0; i <strlen (s); i + +) out_char (i + x, y, s [i], col); )

nieważne ClearScreen (void) (    for (int i = 0; i <80; i + +) for (int j = 0; j <25; j + +)     out_char (I, J,'', 7); )

int matherr (struct * wyjątkiem PE) (    if (strcmp (PE-> nazwa, "exp") == 0)    (     if (PE-> type == overflow) PE-> retval = MAXDOUBLE;     if (PE-> type == niedopełnienia) PE-> retval = MINDOUBLE;

    return 10;    )    w przeciwnym razie    (     if (PE-> type == niedopełnienia | | pe-> type == TLOSS) return 1;     else return 0;    ) )

int SomeNet: OpenPatternFile (unsigned char * plik) (    pf = fopen (plik, "rt");    if (strstr (plik. "img")) Imgfile = 1;    else Imgfile = 0;    wrócić! ((int) pf); )

int SomeNet: ClosePatternFile (void) ( int i;    if (PF)    (     i = fclose (PF);     pf = NULL;     return i;    )    return 0; )

Listing 5

/ / FILE neuman1.cpp DLA neuro1.prj # Include <string.h> # Include <conio.h> # Include "neuro.h"

# Define N0 30 # Define N1 10 # Define N2 10

void main () ( float Inp [N0] Out [N2]; unsigned count; unsigned char buf [256]; int i;    NetBP N (3, N0, N1, N2);    / * Pierwszy sposób projektowania sieci * /

   / *** Drugi sposób budowy sieci

   NeuronBP _FAR * H0, _FAR * H1, H2 * _FAR;    H0 = new NeuronBP [N0];    H1 = new NeuronBP [N1];    H2 = new NeuronBP [N2];

   for (i = 0; I <N1; i + +) H1 [i]. InitNeuron (N0);    for (i = 0; i <N2; i + +) H2 [i]. InitNeuron (N1);

   LayerBP L0 (H0, N0, 0);    LayerBP L1 (H1, N1, N0);    LayerBP L2 (H2, N2, N1);

   NetBP N (3);    i = N. SetLayer (0, & L0);    N. SetLayer i = (1, & L1);    i = N. SetLayer (2 & L2); / / tutaj można sprawdzić i    *** /

   / * Trzeci sposób tworzenia sieci, patrz Listing 6 * /

   ClearScreen ();    N. FullConnect ();    N. GetLayer (0) -> ustawNazwe ( "input");    N. GetLayer (0) -> SetShowDim (1,1,5,6);    N. GetLayer (1) -> ustawNazwe ( "Ukryte");    N. GetLayer (1) -> SetShowDim (15,1,2,5);    N. GetLayer (2) -> ustawNazwe ( "Out");    N. GetLayer (2) -> SetShowDim (23,1,10,1);

/ / Srand (1); / / Jestem szczególnie losowej struktury sieci    SetSigmoidType (HYPERTAN);    SetNiuParm (0.1);    SetLimit (0,001);    SetDSigma (1);    N. Randomize (1);    N. SetLearnCycle (64000U);

   N. OpenPatternFile ( "char1.img");    do (count = 0; count + +)    (     sprintf (buf, "Cykl% u", licznik);     out_str (1,23, buf, 10 | (1 <<4));     out_str (1,24, "ESC przerw", 11 | (1 <<4));     if (kbhit () | | i == 13) i = getch ();     if (i == 27) break;     if (i == 's' | | i ==' S ') goto zapisać;     if (N. LoadNextPattern (Inp, Out)) break;     Cykl N. (Inp, Out); / / Propagowanie N. (); / / "poprzez kanał"

    N. GetLayer (0) -> Show ();     N. GetLayer (1) -> Show ();     N. GetLayer (2) -> Show ();     N. GetLayer (2) -> PrintAxons (47,0);     if (count & & N. IsConverged ())     (      zapisać:      out_str (40,24, "FileConf:" 15 | (1 <<4));      gotoxy (50,25);      gets (buf);      if (strlen (buf)) N. SaveToFile (buf);      break;     )    )    N. ClosePatternFile (); )

Listing 6

/ / FILE neuman2.cpp DLA neuro2.prj # Include <string.h> # Include <conio.h> # Include "neuro.h"

# Define N0 30 # Define N1 10 # Define N2 10

main (int argc, char * argv []) ( NetBP N; statycznych float Inp [N0] Out [N2];

   if (argc! = 2) return 1;    ClearScreen ();    if (N. LoadFromFile (argv [1])) return 1;    if (N. FullConnect ()) return 1;    N. GetLayer (0) -> ustawNazwe ( "input");    N. GetLayer (0) -> SetShowDim (1,1,5,6);    N. GetLayer (1) -> ustawNazwe ( "Ukryte");    N. GetLayer (1) -> SetShowDim (15,1,2,5);    N. GetLayer (2) -> ustawNazwe ( "Out");    N. GetLayer (2) -> SetShowDim (23,1,10,1);    SetSigmoidType (HYPERTAN);

   if (N. OpenPatternFile ( "charnois.img")) return 1;    for (;)    (     if (N. LoadNextPattern (Inp, Out)) break;     / / Jeśli wszystkie zdjęcia ran out, get out

    N. SetNetInputs (Inp);     Propagowanie N. ();     N. GetLayer (0) -> Show ();     N. GetLayer (1) -> Show ();     N. GetLayer (2) -> Show ();     N. GetLayer (2) -> PrintAxons (47,0);     getch ();    )    N. ClosePatternFile ();    return 0; )

Listing 7 Plik char1.pat (Przeniesienie długich linii '\' dokonane w ogłoszeniu)

-0,5 -0,5 0,5 -0,5 -0,5 -0,5 0,5 -0,5 0,5 -0,5 -0,5 \    0,5 -0,5 0,5 -0,5 0,5 -0,5 -0,5 -0,5 0,5 0,5 0,5 \    0,5 0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5    0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5    0,5 -0,5 -0,5 -0,5 0,5 0,5 0,5 -0,5 0,5 0,5 0,5 \    0,5 -0,5 0,5 0,5 0,5 -0,5 0,5 -0,5 0,5 0,5 -0,5 \    0,5 -0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5    0,5 -0,5 -0,5 -0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 0,5 \    0,5 0,5 0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 0,5 -0,5 \ -0,5 -0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5    0,5 -0,5 -0,5 -0,5 0,5 0,5 -0,5 -0,5 0,5 0,5 0,5 \ -0,5 0,5 -0,5 0,5 0,5 -0,5 0,5 -0,5 0,5 0,5 0,5 \ -0,5 -0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5    0,5 -0,5 -0,5 0,5 0,5 0,5 -0,5 0,5 -0,5 -0,5 0,5 \    0,5 -0,5 -0,5 -0,5 0,5 -0,5 0,5 -0,5 -0,5 0,5 -0,5 \ -0,5 0,5 -0,5 0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 0,5 -0,5 0,5 -0,5 \    0,5 -0,5 -0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 0,5 -0,5 \ -0,5 -0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 0,5 0,5 0,5 -0,5 0,5 -0,5 -0,5 -0,5 0,5 0,5 \ -0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 0,5 -0,5 \ -0,5 -0,5 0,5 -0,5 0,5 0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5    0,5 0,5 0,5 0,5 0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 \ -0,5 0,5 -0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 \    0,5 -0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5    0,5 0,5 0,5 0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 0,5 \ -0,5 -0,5 -0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 0,5 -0,5 \

-0,5 -0,5 0,5 0,5 -0,5 -0,5 -0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 0,5 -0,5    0,5 0,5 0,5 0,5 -0,5 0,5 -0,5 -0,5 -0,5 0,5 0,5 \    0,5 0,5 0,5 -0,5 0,5 -0,5 -0,5 -0,5 0,5 0,5 -0,5 \ -0,5 -0,5 0,5 0,5 0,5 0,5 0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 -0,5 0,5Листинг 8 Файл char1.img

..x..

.x.x.

.x.x. x...x xxxxx x...x A......... x...x xx.xx xx.xx x.x.x x.x.x x...x .M........ x...x x...x xxxxx x...x x...x x...x ..H....... x...x x..xx x.x.x x.x.x xx..x x...x ...N...... x..xx x.x.. xx... x.x.. x..x. x...x ....K..... ...x. ..x.x .x..x x...x x...x x...x

.....L....

.xxx. x...x x.... x.... x...x .xxx ......C... xxxxx ..x.. ..x.. ..x.. ..x.. ..x.. .......T.. xxxxx x...x x...x x...x x...x x...x ........P. xxxx. x...x xxxx x..xx x...x xxxx. .........B