コード例 #1
0
ファイル: __init__.py プロジェクト: dariomalchiodi/yaplf
    def reset(self, **kwargs):
        IterativeAlgorithm.reset(self)
        # memberships = [self.normalize([random() for j in range(self.n_clusters)]) for i in range(len(self.sample))]
        # self.model = FuzzyCMeansClusterer(self.sample, memberships) 

        if self.initializer:
            self.n_clusters = len(self.initializer)
            centroids = self.initializer
            data = array([elem.pattern for elem in self.sample])
            memberships = [self.normalize([random() for j in range(self.n_clusters)]) for i in range(len(self.sample))]
            for j in range(len(centroids)):
                for i in range(len(data)):
                    den = sum([(linalg.norm(data[i] - centroids[j])/
                        linalg.norm(data[i]-centroids[k]))**(2/(self.m-1)) 
                        for k in range(self.n_clusters)])
                    memberships[i][j] = 1/den
        else:
            memberships = [self.normalize([random() for j in range(self.n_clusters)]) for i in range(len(self.sample))]
        
        self.model = FuzzyCMeansClusterer(self.sample, memberships) 
            
            
        # 10 means simply a big value, so that we don't run the risk of erronously stop
        # if we check convergence before first iteration
        
        self.memberships_old = [[10 for j in range(self.n_clusters)] for i in range(len(self.sample))]
コード例 #2
0
ファイル: __init__.py プロジェクト: dariomalchiodi/yaplf
    def __init__(self, sample, **kwargs):
        r"""
        See ``RosenblattPerceptronAlgorithm`` for full definition.

        """

        PerceptronAlgorithm.__init__(self, sample, **kwargs)
        IterativeAlgorithm.__init__(self, sample)
        PerceptronAlgorithm.reset(self, **kwargs)
コード例 #3
0
ファイル: __init__.py プロジェクト: dariomalchiodi/yaplf
    def __init__(self, sample, **kwargs):
        r"""
        See ``GradientPerceptronAlgorithm`` for full documentation.

        """

        PerceptronAlgorithm.__init__(self, sample, **kwargs)
        IterativeAlgorithm.__init__(self, sample)
        # This calms down pylint
        self.beta = None
        self.reset(**kwargs)
コード例 #4
0
ファイル: __init__.py プロジェクト: dariomalchiodi/yaplf
    def __init__(self, sample, n_clusters = 2, m = 2,  **kwargs ):
        
        IterativeAlgorithm.__init__(self, sample)

        try:
            self.initializer = kwargs['initializer']
        except KeyError:
            self.initializer = False
        
        self.n_clusters = n_clusters
        self.m = m
        self.distance = 1.0
        #self.reset(**kwargs)

        self.memberships_old = None
        self.reset(**kwargs)
コード例 #5
0
ファイル: __init__.py プロジェクト: dariomalchiodi/yaplf
    def run(self, **kwargs):
        IterativeAlgorithm.run(self, **kwargs)
        data = array([elem.pattern for elem in self.sample])
        while self.stop_criterion.stop() == False:
            self.memberships_old = self.matrix_copy(self.model.memberships)
            #print self.model.memberships
            centroids = self.model.getCentroids(m= self.m)
            #print centroids
            #exit()

            for j in range(len(centroids)):
                for i in range(len(data)):
                    den = sum([(linalg.norm(data[i] - centroids[j])/
                        linalg.norm(data[i]-centroids[k]))**(2/(self.m-1)) 
                        for k in range(self.n_clusters)])
                    self.model.memberships[i][j] = 1/den
            
        self.notify_observers()
コード例 #6
0
ファイル: multilayer.py プロジェクト: dariomalchiodi/yaplf
    def __init__(self, sample, dimensions=None, **kwargs):
        r"""
        See ``BackpropagationAlgorithm`` for full documentation.

        """

        IterativeAlgorithm.__init__(self, sample)

        # dimensions needs to be a named argument in order to be able to
        # cross-validate on it. The default value will correspond to three
        # layers, with the input and output one automatically sized in order
        # to fit the provided data set, and the hidden one containing half of
        # the biggest value between number of input and output units.

        if dimensions is not None:
            self.dimensions = dimensions
        else:
            n_in = len(sample[0].pattern)
            n_out = len(sample[0].label)
            self.dimensions = (n_in, int(max(n_in, n_out) / 2), n_out)

        num_input = self.dimensions[0]
        for example in sample:
            if len(example.pattern) != num_input:
                raise ValueError('Sample incompatible with number of units')

        try:
            self.activations = kwargs['activations']
            if len(self.activations) != len(dimensions):
                raise ValueError(\
                    'Activations incompatible with number of layers')
        except KeyError:
            self.activations = SigmoidActivationFunction()
        except TypeError:
            pass
            # Raised by len if the argument is assigned a single activation
        # this calms down pylint
        self.threshold = None

        self.reset(**kwargs)
コード例 #7
0
ファイル: multilayer.py プロジェクト: dariomalchiodi/yaplf
    def run(self, **kwargs):
        r"""
        Run the learning algorithm.

        INPUT:

        - ``self`` -- object on which the function is invoked.

        - ``stopping_criterion`` -- ``StoppingCriterion`` instance (default:
          ``FixedIterationsStoppingCriterion()``, amounting to the execution of
          one learning step) describing the criterion to be fulfilled in order
          to stop the training phase.

        - ``batch`` -- boolean (default: ``False``, amounting to online
          learning mode) flag setting batch learning, i.e. model update after
          the presentation of all examples, instead of online learning, i.e.
          model update at each example presentation.

        - ``selector`` -- iterator (default: ``sequential_selector``, amounting
          to cycling through the available examples) selecting the next sample
          to be fed to the learnin algorithm.

        - ``learning_rate`` -- float (default: 0.1) value to be used as
          learning rate.

        - ``momentum_term`` -- float (default: 0) value tu be used as momentum
          term.

        - ``min_error`` -- float (default: 0, which means connections
          and thresholds will always be updated) error value under which no
          update will occur on connections and thresholds.

        OUTPUT:

        No output. After the invocation the inferred model is available through
        the ``model`` field, in form of a ``Perceptron`` instance.

        EXAMPLES:

        Consider the following data set summarizing the binary XOR function,
        and a ``BackpropagationAlgorithm`` instance for it:

        ::

            >>> from yaplf.data import LabeledExample
            >>> xor_sample = [LabeledExample((0, 0), (0,)),
            ... LabeledExample((0, 1), (1,)), LabeledExample((1, 0), (1,)),
            ... LabeledExample((1, 1), (0,))]
            >>> from yaplf.utility import SigmoidActivationFunction
            >>> from yaplf.algorithms.neural import BackpropagationAlgorithm
            >>> alg = BackpropagationAlgorithm(xor_sample, (2, 2, 1),
            ... threshold = True, activations = SigmoidActivationFunction(10))

        In order to actually run the algorithm it is necessary to specify a
        stopping criterion (the default behaviour would only execute a learning
        iteration, probably not going so far). In order to keep it simple, one
        can chose ``FixedIterationsStoppingCriterion`` so as to run a fixed
        number of iterations, say `5000`:

        ::

            >>> from yaplf.utility.stopping import \
            ... FixedIterationsStoppingCriterion
            >>> alg.run(stopping_criterion = \
            ... FixedIterationsStoppingCriterion(5000), learning_rate = .1)

        The inferred model can be inspected through the ``model`` field in the
        ``LearningAlgorithm`` object:

        ::

            >>> alg.model # random
            MultilayerPerceptron((2, 2, 1), [array([[-0.49748418, -0.48592928],
            [-0.72052151, -0.69609958]]), array([[ 0.78258238, -0.84286672]])],
            thresholds = [array([ 0.71869556,  0.24337534]),
            array([-0.36203957])], activations = SigmoidActivationFunction(10))

        One of the ways of assessing the performance of the algorithm is that
        of invoking the ``test`` function inherited from the ``Model`` class in
        order to see how each example has been classified:

        ::

            >>> alg.model.test(xor_sample, verbose = True) # random
            (0, 0) mapped to 0.0279358676426, label is (0,), error
            [ 0.00078041]
            (0, 1) mapped to 0.968320708961, label is (1,), error [ 0.00100358]
            (1, 0) mapped to 0.966511649371, label is (1,), error [ 0.00112147]
            (1, 1) mapped to 0.0429967333857, label is (0,), error
            [ 0.00184872]
            MSE 0.00118854472284
            0.0011885447228408164

        The named argument ``verbose`` activates the verbose output detailing
        how error spreads on each example. Note that the output of ``test`` is
        likely to be different on each run, as when the class constructor is
        called the initial weights are chosen at random.

        Another solution is that of running the algorithm until the error on
        its training set is below a given threshold. This can be easily
        attained using ``TrainErrorStoppingCriterion``:

        ::

            >>> from yaplf.utility.stopping import TrainErrorStoppingCriterion
            >>> alg = BackpropagationAlgorithm(xor_sample, (2, 2, 1),
            ... learning_rate = .1,
            ... activations = SigmoidActivationFunction(10))
            >>> alg.run(stopping_criterion = TrainErrorStoppingCriterion(0.01))

        The argument in the constructor of ``TrainErrorStoppingCriterion`` sets
        the above mentioned threshold. It is also possible (and, besides, more
        correct) to run the learning algorithm using a training set and
        stopping the process when the test error on another data set goes
        below a given threshold. This can be attained using
        ``TestErrorStoppingCriterion`` in package ``yaplf.utility.stopping``.

        Another way of evaluating the inferred model is in this case that of
        graphically visualizing it. As the perceptron has two inputs it is
        indeed possible to call its ``plot`` method specifying a region
        containing all the pattern supplied to the learning algorithm:

        ::

            >>> alg.model.plot((0, 1), (0, 1), shading = True)

        Learning can be also monitored using the class ``ErrorTrajectory`` in
        package ``yaplf.graph.trajectory`` as follows:

       ::

            >>> alg = BackpropagationAlgorithm(xor_sample, (2, 2, 1),
            ... activations = SigmoidActivationFunction(10))
            >>> errObs = ErrorTrajectory(alg)
            >>> alg.run(stopping_criterion = \
            ... FixedIterationsStoppingCriterion(1500))
            >>> errObs.get_trajectory(color='red', joined = True)

        In this way, at each learning iteration the inferred model is tested
        against the training set, so that the ``get_trajectory`` function
        returns a graph of the related error versus the iteration number.

        The ``run`` function has a number of named argument allowing to
        tune how the backpropagation algorithm selects its output, and whose
        meaning requires a bit more information about how the algorithm works:
        basically, during the initialization of ``BackpropagationAlgorithm``
        and at each invokation of ``reset`` a multilayer perceptron is created
        picking its connection weights and its threshold values at random;
        subsequently at each iteration an example is selected and fed to this
        perceptron. The obtained output is compared to the expected one and
        an error is computed. This error, together with other information,
        the computation of a quantity `\Delta w` which will in turn be used
        in order to modify connections and thresholds. More precisely at a
        given time `t`, for each connection weight, say `w_{ij}(t)`, a
        corresponding `\Delta w_{ij}(t)` is computed and the perceptron is
        updated so that `w_{ij}(t+1) = w_{ij}(t) - \eta \Delta w_{ij}(t) +
        \alpha \Delta w_{ij}(t-1)`. This rule implements a local descent in
        the error space so that eventually the obtained minimizes locally the
        training error. The values `\eta` and `\alpha` can be chosen through
        the following named arguments:

        - ``learning_rate`` corresponds to`\eta`, the so-called *learning
          rate*, with a default value of 0.1. The higher this value, the more
          extended will be the local steps of the algorithm. This will improve
          convergence but will also raise the risk of outrunning an optimum
          and starting to oscillate around it.

        - ``momentum_term`` corresponds to `\alpha`, the so-called *momentum
          term* as it features a momentum which increases the actual step
          when the surface is smooth and tends to decrement it otherwise. Its
          default value is 0, corresponding to the original version of the
          backpropagation algorithm.

        The following named argument also affect the learning behaviour:

        - ``selector`` sets an iterator selecting the next example to be fed to
          the learnin algorithm. Its default value cycles through the provided
          sample.

        - ``batch`` -- boolean flag setting batch learning mode, in which the
          update values `\Delta w_{ij}` are cumulated for all example in the
          sample and subsequently used in order to modify the perceptron,
          rather than the standard online mode where the perceptron is updated
          after each single example presentation. Its default value is
          ``False``, corresponding to the online mode previously illustrated.
          It is worth noting that when the algorithm is run for a fixed number
          of iterations (i.e. through ``FixedIterationsStoppingCriterion``),
          an iteration corresponds to one example presentation for online mode
          and to the presentation of the whole sample for batch mode.

        - ``min_error`` -- error value under which no update will occur on
          connections and thresholds. This argument can be used in order to
          avoid that some examples are overlearnt at the expense of the
          remaining ones. The default value is 0, leading to updating the
          perceptron regardless of how small is the error on an example.

        AUTHORS:

        - Dario Malchiodi (2010-03-31)

        """

        IterativeAlgorithm.run(self, **kwargs)
        try:
            # batch or online learning
            batch = kwargs['batch']
        except KeyError:
            batch = False

        try:
            learning_rate = kwargs['learning_rate']
        except KeyError:
            learning_rate = 0.1

        try:
            momentum_term = kwargs['momentum_term']
        except KeyError:
            momentum_term = 0

        try:
            min_error = kwargs['min_error']
        except KeyError:
            min_error = 0

        dims = transpose((self.dimensions[1:], self.dimensions[:-1]))
        last_delta = [zeros(shape) for shape in dims]
        if self.threshold:
            last_delta_threshold = [zeros(shape) \
                for shape in self.dimensions[1:]]
        while self.stop_criterion.stop() == False:
            if batch:
                cumul_delta = last_delta = [zeros(shape) for shape in dims]
                if self.threshold:
                    cumul_delta_thresholds = [zeros(shape) \
                        for shape in self.dimensions[1:]]
                for elem in self.sample:
                    answer = self.model.compute(elem.pattern,
                        full_state=True, show_net=True, no_unbox=True)

                    delta = [[]] * (len(self.dimensions) - 1)

                    error = transpose(answer[-1])[0] - elem.label
                    if abs(error) < min_error:
                        continue
                    derivative = [\
                        self.model.get_activation(-1).compute_derivative(net,
                        func_value=val)
                        for (val, net)  in answer[-1]]

                    delta[-1] = error * derivative

                    for lev in range(1, len(self.dimensions) - 1):
                        derivatives = [self.model.get_activation(-lev - \
                            1).compute_derivative(net, func_value=val) \
                            for (val, net)  in answer[-lev - 1]]

                        prop_delta = \
                            dot(transpose(self.model.connections[-lev]),
                            delta[-lev])
                        delta[-lev - 1] = array(derivatives * prop_delta)

                    for lev in range(1, len(self.dimensions)):
                        new_delta = -learning_rate * outer(delta[-lev],
                           transpose(answer[-lev - 1])[0]) + \
                           momentum_term * last_delta[-lev]
                        cumul_delta[-lev] += new_delta
                        last_delta[-lev] = new_delta

                        if self.threshold:
                            new_delta = -learning_rate * delta[-lev] +\
                                momentum_term * last_delta_threshold[-lev]
                            cumul_delta_thresholds[-lev] += new_delta
                            last_delta_threshold[-lev] = new_delta

                for lev in range(1, len(self.dimensions)):
                    self.model.connections[-lev] += cumul_delta[-lev]

                    if self.threshold:
                        self.model.thresholds[-lev] += \
                            cumul_delta_thresholds[lev]

            else:
                elem = self.sample_selector.next()
                answer = self.model.compute(elem.pattern,
                    full_state=True, show_net=True, no_unbox=True)

                delta = [[]] * (len(self.dimensions) - 1)

                error = transpose(answer[-1])[0] - elem.label
                if abs(error) < min_error:
                    continue
                derivative = [\
                    self.model.get_activation(-1).compute_derivative(net,
                    func_value=val)
                    for (val, net)  in answer[-1]]

                delta[-1] = error * derivative

                for lev in range(1, len(self.dimensions) - 1):
                    derivatives = [self.model.get_activation(-lev - \
                        1).compute_derivative(net, func_value=val) \
                        for (val, net)  in answer[-lev - 1]]

                    prop_delta = dot(transpose(self.model.connections[-lev]),
                        delta[-lev])
                    delta[-lev - 1] = array(derivatives * prop_delta)

                for lev in range(1, len(self.dimensions)):
                    new_delta = -learning_rate * outer(delta[-lev],
                        transpose(answer[-lev - 1])[0]) + \
                        momentum_term * last_delta[-lev]
                    self.model.connections[-lev] += new_delta
                    last_delta[-lev] = new_delta

                    if self.threshold:
                        new_delta = -learning_rate * delta[-lev] +\
                            momentum_term * last_delta_threshold[-lev]
                        self.model.thresholds[-lev] += new_delta
                        last_delta_threshold[-lev] = new_delta

            self.notify_observers()
コード例 #8
0
ファイル: __init__.py プロジェクト: dariomalchiodi/yaplf
    def run(self, **kwargs):
        r"""
        Run the learning algorithm.

        INPUT:

        - ``self`` -- object on which the function is invoked.

        - ``stopping_criterion`` -- ``StoppingCriterion`` instance (default:
          ``FixedIterationsStoppingCriterion()``, amounting to the execution of
          one learning step) describing the criterion to be fulfilled in order
          to stop the training phase.

        - ``batch`` -- boolean (default: ``False``, amounting to online
          learning mode) flag setting batch learning, i.e. model update after
          the presentation of all examples, instead of online learning, i.e.
          model update at each example presentation.

        - ``selector`` -- iterator (default: ``sequential_selector``, amounting
          to cycling through the available examples) selecting the next sample
          to be fed to the learnin algorithm.

        - ``learning_rate`` -- float (default: 0.1) value to be used as
          learning rate.

        OUTPUT:

        No output. After the invocation the inferred model is available through
        the ``model`` field, in form of a ``Perceptron`` instance.

        EXAMPLES:

        Consider the following data set summarizing the binary AND function,
        and an instance of ``GradientPerceptronAlgorithm``:

        ::

            >>> from yaplf.data import LabeledExample
            >>> and_sample = [LabeledExample((1, 1), (1,)),
            ... LabeledExample((0, 0), (0,)), LabeledExample((0, 1), (0,)),
            ... LabeledExample((1, 0), (0,))]
            >>> from yaplf.algorithms.neural import GradientPerceptronAlgorithm
            >>> alg = GradientPerceptronAlgorithm(and_sample, threshold = True,
            ... weight_bound = 0.1, beta = 0.8)

        In order to actually run the algorithm it is necessary to specify a
        stopping criterion (the default behaviour would only execute a learning
        iteration, probably not going so far). In order to keep it simple, one
        can chose ``FixedIterationsStoppingCriterion`` so as to run a fixed
        number of iterations, say `5000`:

        ::

            >>> from yaplf.utility.stopping import \
            ... FixedIterationsStoppingCriterion
            >>> alg.run(stopping_criterion = \
            .... FixedIterationsStoppingCriterion(5000), batch = False,
            ... learning_rate = .1)

        The inferred model can be inspected through the ``model`` field in the
        ``LearningAlgorithm`` object:

        ::

             >>> alg.model # random
            Perceptron([array([ 4.01133491,  4.00742238])], threshold =
            [6.1595362999239365], activation =
            SigmoidActivationFunction(0.800000000000000))

        A better way of assessing the performance of the algorithm is that of
        invoking the ``test`` function inherited from the ``Model`` class in
        order to see how each example has been classified:

        ::

            >>> from yaplf.utility.error import MaxError
            >>> alg.model.test(and_sample, MaxError(), verbose = True) # random
            (1, 1) mapped to 0.81568421764, label is (1,), error 0.033972307625
            (0, 0) mapped to 0.00719156413, label is (0,), error 5.17185946e-05
            (0, 1) mapped to 0.15165346334, label is (0,), error 0.022998772945
            (1, 0) mapped to 0.1520565945, label is (0,), error 0.0231212079
            Maximum error: 0.0339723076259
            0.033972307625870855

        The second argument in ``test`` is an object subclassing
        ``ErrorModel``, allowing to specify a given metric in order to compute
        the distance between expected and actual output. The argument's
        default, amounting to the mean square error, has been in this case
        overridden to ``MaxError()``, thus computing the maximum error.

        As a final remark, it should be highlighted that these examples are
        shown for illustrative purpose. The suitable way of assessing a learnt
        model performance involves more complex techniques involving the use of
        a test set possibly coupled with a cross validation procedure (see
        function ``cross_validation`` in package ``yaplf.utility.validation``.)

        AUTHORS:

        - Dario Malchiodi (2010-02-22)

        """

        IterativeAlgorithm.run(self, **kwargs)
        try:
            # batch or online learning
            batch = kwargs["batch"]
        except KeyError:
            batch = False

        try:
            learning_rate = kwargs["learning_rate"]
        except KeyError:
            learning_rate = 0.1

        while self.stop_criterion.stop() == False:
            if batch:
                delta = array([[0.0] * len(self.sample[0].pattern) + 1] * len(self.sample[0].label))
                for elem in self.sample:
                    answer = self.model.compute(elem.pattern)
                    if type(answer) != type(()):
                        answer = (answer,)
                    delta += [
                        2
                        * self.beta
                        * learning_rate
                        * array(
                            [
                                (answer[s] - elem.label[s])
                                * answer[s]
                                * (1 - answer[s])
                                * hstack((elem.pattern, (-1 if self.threshold else 0)))[t]
                                for t in range(len(self.sample[0].pattern) + 1)
                            ]
                        )
                        for s in range(len(self.sample[0].label))
                    ]
                delta = delta.tolist()
            else:
                elem = self.sample_selector.next()
                answer = self.model.compute(elem.pattern)
                if type(answer) != type(()):
                    answer = (answer,)
                delta = [
                    2
                    * self.beta
                    * learning_rate
                    * array(
                        [
                            (answer[s] - elem.label[s])
                            * answer[s]
                            * (1 - answer[s])
                            * hstack((elem.pattern, (-1 if self.threshold else 0)))[t]
                            for t in range(len(self.sample[0].pattern) + 1)
                        ]
                    )
                    for s in range(len(self.sample[0].label))
                ]
            self.model.weights = [self.model.weights[i] - delta[i] for i in range(len(delta))]
            self.notify_observers()
コード例 #9
0
ファイル: __init__.py プロジェクト: dariomalchiodi/yaplf
    def run(self, **kwargs):
        r"""
        Run the Rosenblatt learning algorithm.

        INPUT:

        - ``self`` -- object on which the function is invoked.

        - ``stopping_criterion`` -- ``StoppingCriterion`` object (default:
          ``FixedIterationsStoppingCriterion()``, amounting to the execution of
          one iteration step) to be used in order to decide when learning
          should be stopped.

        - ``selector`` -- iterator (default: ``sequential_selector``) yielding
          the examples to be fed to the learning algorithm.

        OUTPUT:

        No output. After the invocation the inferred model is available through
        the ``model`` field, in form of a ``Perceptron`` instance.

        EXAMPLES:

        Consider the following linearly separable data set summarizing the
        binary AND function, and a ``RosenblattPerceptronAlgorithm`` instance:

        ::

            >>> from yaplf.data import LabeledExample
            >>> and_sample = [LabeledExample((1, 1), (1,)),
            ... LabeledExample((0, 0), (0,)), LabeledExample((0, 1), (0,)),
            ... LabeledExample((1, 0), (0,))]
            >>> from yaplf.algorithms.neural import \
            ... RosenblattPerceptronAlgorithm
            >>> alg = RosenblattPerceptronAlgorithm(and_sample,
            ... threshold = True, weight_bound = 0.1)

        In order to actually run the algorithm it is necessary to specify a
        stopping criterion (the default behaviour would only execute a learning
        iteration, probably not going so far). In order to keep it simple, one
        can chose ``FixedIterationsStoppingCriterion`` so as to run a fixed
        number of iterations, say `100`:

        ::

            >>> from yaplf.utility.stopping import \
            ... FixedIterationsStoppingCriterion
            >>> alg.run(stopping_criterion = \
            ... FixedIterationsStoppingCriterion(100))

        Another possible variation is that modifying the way examples are
        chosen and fed to the learning algorithm at each iteration. The default
        choice cycles between available examples, but it possible for instance
        to pick examples at random. This requires to specify a value for the
        ``selector`` named argument:

        ::

            >>> alg.reset()
            >>> from yaplf.utility.selection import random_selector
            >>> alg.run(stopping_criterion = \
            ... FixedIterationsStoppingCriterion(100),
            ... selector = random_selector)

        Note how, in order to restart the learning rocedure from fresh, the
        ``reset`` function was called. In this way the inferred model is
        initialized using randomly picked values.

        The inferred model is available through the ``model`` field. In order
        to get some information about its the performance is that of invoking
        the ``test`` function inherited from the ``Model`` class so as to get
        the mean approximation error, evaluated on all fed examples:

        ::

            >>> alg.model.test(and_sample)
            0.0

        As a final remark, it should be highlighted that these examples are
        shown for illustrative purpose. The suitable way of assessing a learnt
        model performance involves more complex techniques involving the use of
        a test set possibly coupled with a cross validation procedure (see
        function ``cross_validation`` in package ``yaplf.utility.validation``.)

        AUTHORS:

        - Dario Malchiodi (2010-02-22)

        """

        IterativeAlgorithm.run(self, **kwargs)
        while self.stop_criterion.stop() == False:
            elem = self.sample_selector.next()
            answer = self.model.compute(elem.pattern)

            if type(answer) != type(()):
                answer = (answer,)

            #            for i in range(len(self.sample[0].label)):
            #                if answer[i] == 1 and elem.label[i] == 0:
            #                    self.model.weights[i] -= hstack((elem.pattern,
            #                        (-1 if self.threshold else 0)))
            #
            #                if answer[i] == 0 and elem.label[i] == 1:
            #                    self.model.weights[i] += hstack((elem.pattern,
            #                        (-1 if self.threshold else 0)))

            temporary_weights = self.model.weights
            temporary_threshold = self.model.threshold
            for i in range(len(self.sample[0].label)):
                if answer[i] != elem.label[i]:
                    temporary_weights[i] += [(elem.label[i] - answer[i]) * p for p in elem.pattern]
                    temporary_threshold[i] += (elem.label[i] - answer[i]) * (-1 if self.threshold else 0)

            self.model.set_weights_and_threshold(temporary_weights, temporary_threshold)

            self.notify_observers()