示例#1
0
def _test_neural_network_methods (ut) :
    # Neural network connection weights are initiated pseudorandomly, this introduces determinism to the randomness.
    random.seed(0)

    nn = NeuralNetwork('abc', 3, 'def', name='foo')

    training_patterns = [('ab', 'f'),
                         ('ac', 'f'),
                         ('b',  'd'),
                         ('c',  'e')]

    error = round(sum(nn.train(inputs, outputs) for _ in range(20) for inputs, outputs in training_patterns), 5)

    ut.assert_equal(error, 10.51832)

    correct_outputs = [('f', 'd', 'e'),
                       ('d', 'e', 'f'),
                       ('e', 'd', 'f'),
                       ('f', 'd', 'e'),
                       ('f', 'e', 'd'),
                       ('d', 'e', 'f')]

    for inputs, correct in zip(['a', 'b', 'c', 'ab', 'ac', 'bc'], correct_outputs) :
        ut.assert_equal(tuple(object for object, score in sorted(nn.predict(inputs), reverse=True)), correct)

    def tests (nn) :
        ut.assert_true('a' in nn)
        ut.assert_true('d' in nn)
        ut.assert_true('z' not in nn)
        ut.assert_true(173 not in nn)

        ut.assert_equal(list(nn.inputs()), list('abc'))
        ut.assert_equal(list(nn.outputs()), list('def'))
        ut.assert_equal(list(nn), list('abcdef'))
        ut.assert_equal([(object, '%.5f' % score) for object, score in nn.scores()],
                        [('d', '0.68689'), ('e', '0.60615'), ('f', '-0.05136')])

    tests(nn)

    db = Database()

    with db as session :
        session.add(nn)

    tests(nn)

    with db as session :
        tests(session.access.nn('foo'))

    tests(nn)
示例#2
0
def __demo__ (ut) :

    from nlplib.data import builtin_db
    from nlplib.core.model import Word, NeuralNetwork

    from nlplib.exterior.train import usable
    from nlplib.exterior.util import plot

    top = 10

    with builtin_db() as session :
        top_words = list(session.access.most_common(Word, top=top)) + [None]

    nn = NeuralNetwork(top_words, int(len(top_words)*2), top_words)

    with builtin_db() as session :
        patterns = usable(nn, list(session.access.all_documents())[:], gram_size=2)

    errors = [nn.train(input_words, output_words, rate=0.1) for input_words, output_words in patterns]

    from nlplib.general.math import avg

    print(avg(errors[:]))

    plot(errors,
         sample_size=100)

    def ask (string) :
        with builtin_db() as session :
            words = session.access.words(string)

        scored = Scored(nn.predict(words)).sorted()

        print('\n'.join(repr(score) for score in list(scored)[:12]))

    return ask