Αναμείνατε.

#include "GeneticSoup.hpp"

και είτε χρησιμοποιείται τους διαφορετικούς τύπους Genome (NaturalNumber, RealNumber, κτλ) που παρέχονται είτε εύκολα μπορείτε να φτιάξετε τους δικούς σας.
Τέλος, θα πρέπει να ορίσετε την μέθοδο που θα αξιολογεί τα genomes.

Μαζί με τον επιβλέπων καθηγητή, παρατηρήσαμε το φαινόμενο “catastrophic fogetting” που χαρακτηρίζει τα νευρωνικά δίκτυα χωρίς επίβλεψη (unsupervised), δοκιμάσαμε την τεχνική “rehearsal” καθώς και κάποιες άλλες δικές μας λύσεις.

Επιπλέον, δοκιμάσαμε κάποιες βελτιστοποιήσεις στην υλοποίηση των αλγορίθμων προκειμένου να επιτευχθεί κάποια μείωση στον χρόνο εκτέλεσης. Για παράδειγμα, δοκιμάσαμε την προσθήκη threads ώστε μερικά τμήματα των αλγορίθμων να εκτελούνται παράλληλα. Ακόμα, δοκιμάσαμε την υλοποίηση σε CUDA™ (ώστε να τρέχει πάνω σε κάρτες γραφικών της NVIDIA) και κάναμε κάποιες παρατηρήσεις.

Τέλος, υλοποιήσαμε κάποιες εφαρμογές που χρησιμοποιούν το Meteor, όπως color reduction, similar images και model visualization σε Qt. Παραθέτω κάποια videos που ανεβάσαμε στο youtube:

Σκοπός είναι η δημιουργία μιας βιβλιοθήκης η οποία θα υλοποιεί τους παρακάτω τύπους Neural Gas: Neural Gas [1], Growing Neural Gas[2] και Instantaneous Topological Map[3].

Αποφασίσαμε να χρησιμοποιήσουμε C++ ώστε να είναι γρήγορο. Και πραγματικά είναι. Η τρέχουσα υλοποίηση του GNG σε C++ είναι περίπου 10 φορές γρηγορότερη από μία προηγούμενη σε C# (προφανώς με τις ίδιες ρυθμίσεις).

Ακόμη, χρησιμοποιώντας το CMake για το building της βιβλιοθήκης, την καθιστά crossplatform, που σημαίνει ότι τρέχει σε Linux (GCC)  και Windows (VS C++ 2009). Στο Linux παράγει μια static library, ενώ στα Windows ένα dll.

Τέλος, θα προστεθεί υποστήριξη multithreading (όταν υπάρχουν πολλοί cores) και ίσως εκτέλεση μερικών αλγορίθμων σε Shaders πάνω στην κάρτα γραφικών.

Κάποια στιγμή θα ανεβάσω videos με την εκτέλεση των αλγορίθμων (πιθανόν αυτό σε C#).

Αναφορές:

[1] http://en.wikipedia.org/wiki/Neural_gas και
http://www.neuroinformatik.ruhr-uni-bochum.de/VDM/research/gsn/JavaPaper/node16.html
[2] http://en.wikipedia.org/wiki/Growing_neural_gas και
http://www.neuroinformatik.ruhr-uni-bochum.de/VDM/research/gsn/JavaPaper/node19.html
[3] “Lectures Notes for Neural Networks II, University Bielefeld”

Καταρχήν χρειάζεστε το Git και μετά μπορείτε να αποκτήσετε τον κώδικα δίνοντας την εντολή:

git clone git://github.com/makism/spiral.git

Το προφίλ μου στο GitHub είναι: http://github.com/makism. Τέλος, ήδη έχω ξεκινήσει το port του Spiral σε C++ για την πλατφόρμα ARM (μην ρωτάτε γιατί).

"""
    The input layer has three input neurons.
    The first and second hidden layer are made
    of two neurons each.
    The output layer contains only one neuron.
    All the above layers are connected in a
    "feedforward" manner.

    Notice, that the number of inputs for each
    neuron is calculated dynamically,
    and changed whenever a new
    synapse-connection is created.
"""

# batteries
import sys
sys.path.append ("../../src/")
# spiral framework
from spiral.nn import globals
from spiral.nn.generic import Neuron
from spiral.helper import colored 

if __name__ == "__main__":
    globals.runInDebug = True

    n1 = Neuron (Id=1, LayerId=0)
    n2 = Neuron (Id=2, LayerId=0)
    n3 = Neuron (Id=3, LayerId=0)

    n4 = Neuron (Id=4, LayerId=1)
    n5 = Neuron (Id=5, LayerId=1)

    n6 = Neuron (Id=6, LayerId=2)
    n7 = Neuron (Id=7, LayerId=2)

    n8 = Neuron (Id=8, LayerId=3)

    # Create the synapses for input layer
    n1.createSynapse (1, n4)
    n1.createSynapse (1, n5)
    n2.createSynapse (1, n4)
    n2.createSynapse (1, n5)
    n3.createSynapse (1, n4)
    n3.createSynapse (1, n5)
    # Create the synapses for the first hidden layer
    n4.createSynapse (2, n6)
    n4.createSynapse (2, n7)
    n5.createSynapse (2, n6)
    n5.createSynapse (2, n7)
    # Create the synapses for the second hidden layer
    n6.createSynapse (3, n8)
    n7.createSynapse (3, n8)

    # Put the weights
    n1.putWeights ( (0.3  ,  0.4) )
    n2.putWeights ( (-0.1 , -0.8) )
    n3.putWeights ( (-0.25,  0.25))

    n4.putWeights ( (1.0, 0.8) )
    n5.putWeights ( (0.7, 0.1) )

    n6.putWeights ( (0.1 ,) )
    n7.putWeights ( (0.2 ,) )

    # Insert the inputs
    n1.putInput (1.0)
    n2.putInput (2.0)
    n3.putInput (3.0)

    print colored ("Output value: %r", fg="yellow") % \
            n8.getValue ()

Μερικά σχόλια.
Καταρχήν, προφανώς το αποτελέσματα θα είναι ακριβώς το ίδιο.
Ακόμη, σε αυτήν την περίπτωση και να θέλουμε, δεν έχουμε τη δυνατότητα να ορίσουμε κάποιο Bias, μιας και αυτό είναι χαρακτηριστικό της κλάσης NeuronLayer την οποία δεν χρησιμοποιούμε εδώ.
Τέλος, όπως βλέπετε, ο υπολογισμός της εξόδου, γίνεται αυτόματα χωρίς να καλέσουμε κάποια μέθοδο. Αυτό γιατί το framework, είναι καθοδηγούμενο από γεγονότα. Όταν αλλάζουν οι τιμές, τα βάρη, οι καταστάσεις, κτλ, εκπέμπονται αντίστοιχα σήματα σε όλα τα αντικείμενα που έχουν δηλώσει ενδιαφέρον γι`αυτά και πράττουν ανάλογα σε κάθε σήμα από αυτά.
Βέβαια, αυτό έχει και το μειονέκτημα ότι για να υλοποιήσεις για παράδειγμα ένα Backpropagation δίκτυο, θα πρέπει να ελέγχεις εσύ το πότε για γίνετε activate ένας νευρώνας και πότε όχι. Και προς το παρόν, αυτό είναι λίγο δύσκολο στο Spiral, ωστόσο υπάρχει μία δοκιμαστική υλοποίηση

Ο κώδικας του φτάνει περίπου τις 170 χιλιάδες γραμμές και τα modules που περιέχει καλύπτουν από την απλή επικοινωνία με sockets εώς και τα πρωτόκολλα των MSN και SSH, “σπαζμένα” σε ξεχωριστά πακέτα (twisted-conch, twisted-lore, twisted-mail, twisted-names, twisted-news, twisted-runner, twisted-web, twisted-words και twistedsnmp). Αυτό όμως δεν σημαίνει ότι και πάλι δεν χρειάζεται να γράψουμε κώδικα, απλά κάποια πράγματα έχουνε ήδη διευθετηθεί από κάποιους άλλους για εμάς και μας παρέχει ένα πραγματικά ευέλικτο περιβάλλον ανάπτυξης εφαρμογών.
Τέλος, από την στιγμή που το Twisted, είναι ασύγχρονο, σημαίνει ότι συνήθως δεν χρειάζεται ποτέ να ασχοληθούμε με threading, εκτός και εάν πρόκειται για κάτι πολύ ιδιότροπο (που και πάλι προσφέρει κάποιες δικές του λύσεις και προτάσεις ώστε να μην μπλέξουμε μετα modules threading, thread κτλ). Ενώ αφού είναι καθοδηγούμενο από γεγονότα, σημαίνει ότι παράγονται και εκπέπονται σήματα για καθένα από τα γεγονότα που συμβαίνουν και το μόνο που έχουμε να κάνουμε είναι απλά να ορίσουμε κάποια callback μέθοδο για να εκτελεστεί (συνήθως στην πραγματικότητα ορίζουμε lambdas). Σε λίγο πιο τεχνικό επίπεδο, συνήθως, κάθε κλήση που γίνεται στο Twisted, είναι “Deferred” (από το manual: …Deferred is a promise that a function will at some point have a result…), έτσι δεν κάνουμε block ή select κανένα socket, απλά αναθέτουμε την (όχι απαραίτητα μία) callback μέθοδο (ακόμη και για error/success handling) και συνεχίζει η εκτέλεση του προγραμματός μας. Όλα ασύγχρονα και καθοδηγούμενα από γεγονότα

Το module που μου τράβηξε την προσοχή μιας και θα το χρειαστώ στην πτυχιακή μου εργασία, είναι το “Perspective Broker”, δίνει δηλαδή την δυνατότητα να γίνονται κλήσεις μεθόδων μέσω δικτύου εύκολα και native, χωρίς να εμπλέκονται στο ενδιάμεσο άλλα πρωτόκολλα επικοινωνίας όπως το XML-RPC ή SOAP…
Σε πρώτη φάση θα παραθέσω τον κώδικα για τον εξυπηρετητή.

#!/usr/bin/env python

from twisted.spread import pb
from twisted.internet import reactor

class SimplePb (pb.Root):

    MAX_CLIENTS = 25

    def __init__ (self):
        self.numberOfClients = 0
        self.clientsList = list ()

    def remote_Register (self, name):
        if self.numberOfClients < SimplePb.MAX_CLIENTS:
            if name not in self.clientsList:
                print "New client, \"%s\"." % name

                self.numberOfClients += 1
                self.clientsList.append (name)

                return "Done"

    def remote_KeepAlive (self, name):
        print "Client \"%s\", is alive." % name

        return "Done"

if __name__ == "__main__":
    f = pb.PBServerFactory (SimplePb ())
    reactor.listenTCP (9999, f)
    reactor.run ()

σχόλια:

1. Αν και δεν είναι εμφανές από τον κώδικα, ο εξυπηρετητής μας μπορεί να ανταποκρίνεται σε ταυτόχρονα requests.
2. “Ακούει” για εισερχόμενες συνδέσεις στην θύρα 9999.
3. Ουσιαστικά, δηλώνουμε ότι πρόκειται για εξυπηρετητή από την στιγμή που κληρονωμούμε από το pb.Root. Και αυτό το αντικείμενο θα αποτελεί το Root object (θα το δούμε στην υλοποίηση του Client).
4. Αφού συνδεθεί ένας πελάτης, ο πελάτης, μπορεί να καλέσει μία από τις μεθόδους “Register” ή “KeepAlive”.
5. Την μέθοδο “KeepAlive”, μπορεί να την καλέσει ο πελάτης όσες φορές θέλει.
6. Αν μία κλήση μια μεθόδου είναι επιτυχής, τότε επιστρέφει το string “Done”. Δώστε σημασία εδώ γιατί θα το δούμε στην υλοποίηση του Client.
7. Δεν υπάρχει κανένας έλεγχος για τις συνδέσεις και το δίκτυο, οπότε με το παραμικρό υπάρχει περίπτωση να καταρρεύσει (bad programming practice
8. Οι διάφοροι άλλοι έλεγχοι που υπάρχουν είναι straightforward, οπότε δεν μπαίνω στην διαδικασία.

σύνδεσμοι:

1. http://twistedmatrix.com/
2. http://twistedmatrix.com/documents/current/api/
3. http://stackoverflow.com/questions/tagged/twisted (ερωτήσεις/απαντήσεις)

υποσημείωση #1: Σκοπός του framework είναι να παρέχει υλοποιήσεις των παραπάνω μοντέλων δικτύων καθώς επίσης την δυνατότητα επέκτασης των βασικώ κλάσεων σε περίπτωση που οι bundled υλοποιήσεις δεν καλύπτουν τις ανάγκες σας, ή απλά θέλετε να πειραματιστείτε. Ακόμη, ένας από τους πρωταρχικούς στόχους ήταν να γραφτεί το API έτσι ώστε να είναι straightforward.

Προφανώς προκειμένου να δοκιμάζω και να βλέπω την εξέλιξη και πόσο τελικά γενικό είναι το framework, έπρεπε να υλοποιήσω και ένα δίκτυο. Έτσι, για αρχή υλοποίησα το Feedforward μοντέλο καθώς επίσης και ένα δοκιμαστικό πρόγραμμα (demo).

υποσημείωση #2: Οι βασικές γενικές γνώσεις πάνω στα βιολογικά νευρωνικά δίκτυα είναι τελικά χρήσιμες.

Παραθέτω το πρώτο πρόγραμμα (example1.py).

#!/usr/bin/env python
"""
    Demonstrating a simple feedforward
    neural network.
    The hidden layers have the same
    number of neurons.

    We have 3 inputs, 1 output
    and 2 hidden layers with 2 neurons each.
"""

# batteries
import sys
sys.path.append ("../../src/")
# spiral framework
from spiral.helper import colored
from spiral.nn import globals
from spiral.nn.impl import Feedforward

if __name__ == "__main__":
    globals.runInDebug = True

    settings = {
        "Inputs" : 3,
        "Outputs": 1,
        "Layers" : 2,
        "NeuronsPerLayer": 2
    }

    nn = Feedforward (**settings)
    nn.createNet ()
    nn.createDefaultSynapses ()

    inputs = [ 1.0, 2.0, 3.0 ]
    weights= [ 0.3, 0.4, -0.1, -0.8, -0.25, 0.25, \
               1.0, 0.8,  0.7,  0.1, \
               0.1, 0.2 ]

    nn.update (inputs, weights)    

    print colored (
        "Neural Network output: %r", fg="yellow"
    ) % nn.output (0)

και εδώ είναι η έξοδος:

η εικόνα αποτελείται από δύο screenshots, απλά για να δείτε πόσα πολλά events γίνονται triggered.(κλίκ για πλήρες μέγεθος)

παρατηρήσεις:

1. Εάν παρατηρήσατε στον κώδικα, στις ρυθμίσεις του δικτύου ορίζουμε τον αριθμό των νευρώνων που θα έχει το κάθε κρυφό-ενδιάμεσο layer. Δηλαδή το δίκτυο είναι συμμετρικό ως προς τον αριθμό των νευρώνων.
   Προφανώς, προκειμένου να υποστηριχτούν και οι άλλοι τύποι των δικτύων αυτό είναι περιοριστικό. Στο επόμενο post θα αναφέρω πως μπορούμε να φτιάξουμε ένα δίκτυο με άνισο αριθμό νευρώνων ανά hidden layer.
2. Ο αριθμός των βαρών θα έπρεπε να ήταν 17, εάν είχαμε δώσει την επιλογή: AddBias=True , στις ρυθμίσεις του νευρωνικού δικτύου.

Τέλος, επειδή το framework είναι σε πρώιμο στάδιο και υπάρχουν κάποιες ιδέες/σκέψεις ενδέχεται μερικά εσωτερικά πράγματα να αλλάξουν προς το καλύτερο, αλλά αυτό δεν πρόκειτα να επηρεάσει τον απλό χρήστη.

Ας υποθέσουμε ότι ένα είδος καταλαμβάνει ένα μεγάλο αριθμό λόφων. Ξαφνικά η στάθμη της θάλασσας αυξάνει δραματικά σε τέτοιο επίπεδο ώστε οι κορυφές των λόφων να θεωρούνται πλέον νησιά. Εάν οι λόφοι είναι κοντά ο ένας στον άλλον και τα υπόγεια θαλάσσια ρεύματα είναι ευνοϊκά τότε συχνά-πυκνά θα έχουμε αποδημήσεις στους πληθυσμούς. Αντίθετα, εάν οι αποστάσεις είναι πολύ μεγάλες οι πιθανότητες για αποδήμηση είναι πάρα πολύ μικρή και έτσι σε κάθε νησί οι υπό πληθυσμοί αρχίζουν να εξελίσσονται με πολύ διαφορετικούς ρυθμούς και δημιουργούνται νέα είδη σε κάθε νησί.

Κοινώς υπάρχουν τοπολογίες που θα πρέπει να λάβουμε υπόψιν μας όταν παράλληλα εξελίσσουμε πληθυσμούς γονιδίων. Στην ουσία οι τοπολογίες καθορίζουν τα γειτονικά νησιά από τα οποία μπορούν να δεχθούν ή/και να αποστείλουν γονίδια. Παρακατω παραθετω δυο απο τις πιο γνωστες τοπολογιες

τοπολογία δακτυλίου, τα γονίδια ενός νησιού μπορούν να αποδημήσουν μόνο στο αμέσως επόμενο

σε αυτή τη περίπτωση ένα νησί επικοινωνεί με τα νησί που βρίσκονται δεξιά και αριστερά του.

πηγή: A Field Guide to Genetic Programming (των Riccardo Poli, William B. Langdon, και Nicholas F. McPhee), το οποίο εκδίδεται κάτω από την άδεια Creative Commons Attribution-Noncommercial-No Derivative Works 2.0

Το δεύτερο μέρος, εντός των επόμενων ημερών, ώστε να κλείσει προς το παρόν το θέμα “Parallel Evolution”.