grid=mode)
high_order_5 = MultilayerPerceptron(5,
5,
35,
learning_rate=lrate,
momentum=momentum,
grid=mode)
networks[i] = {
'first_order': first_order,
'high_order_10': high_order_10,
'high_order_5': high_order_5
}
#create inputs/outputs to learn
examples = DataFile("digit_shape.txt", mode)
#3 curves
rms_plot = {'first_order': [], 'high_order_10': [], 'high_order_5': []}
err_plot = {'first_order': [], 'high_order_10': [], 'high_order_5': []}
#learning
for epoch in range(nbEpoch):
sum_rms = {'first_order': 0., 'high_order_10': 0., 'high_order_5': 0.}
err_one_network = {
'first_order': 0.,
'high_order_10': 0.,
'high_order_5': 0.
}
for network in networks:
def data():
return DataFile("digit_shape.txt", mode)
def data():
return DataFile("digit_handwritten_16.txt", mode)
nbTry = 10
display_interval = range(nbEpoch)[::6]
# print(discretis([0,0,0,0,0.88]))
# print(discretis([0.25,0,0,0,0.]))
# print(discretis([0,0.25,0,0,0.]))
# print(discretis([0,0,0.44,0.55,0.45]))
# print(nbdis(0.2))
# print(nbdis(0.4))
# print(nbdis(0.6))
# print(nbdis(0.8))
#
# exit()
#create inputs/outputs to learn
examples = DataFile("digit_handwritten_16.txt", mode)
# examples = DataFile("digit_shape.txt", mode)
# examples = DataFile("digit_shape_16.txt", mode)
# examples = DataFileR("iris.txt")
momentum = 0.9
nbInputs = len(examples.inputs[0])
nbHidden = 10
nbOutputs = len(examples.outputs[0])
nbShape = nbOutputs
#create all networks
networks = [{} for _ in range(nbr_network)]
for i in range(nbr_network):
def data():
# return DataFile("digit_handwritten_16.txt", mode)
return DataFile("digit_shape.txt", mode)
Created on 24 February 2012
@author: Matthieu Zimmer
'''
from data import DataFile
from random import shuffle
from multilayerp import MultilayerPerceptronXT
from perceptron import Perceptron, PerceptronN0to1, PerceptronR0to1
from utils import index_max
import matplotlib.pyplot as plt
if __name__ == '__main__':
r = {'x': (0, 1), '.': (0, ), '?': (0, 0.02), '!': (1, )}
samples = DataFile("../data/blindslight.txt", rules=r)
first_order = MultilayerPerceptronXT(100, 60, 100, 0, 0.9, 0., 2, False,
True)
first_order.init_weights_randomly(-0.6, 0.6)
# high_order = [PerceptronR0to1(100, 0.1, 0., 1., Perceptron.OUTPUT, False, True) for _ in range(2)]
high_order = [PerceptronN0to1(100, 0.1, 0., False) for _ in range(2)]
high_order[0].init_weights_randomly(0., 0.1)
high_order[1].init_weights_randomly(0., 0.1)
err = 0.
the = 0.
rms = []
rms2 = []
def probfoil(**kwargs):
args = kwargs
if 'seed' in args:
seed = args['seed']
else:
seed = str(random.random())
args['seed'] = seed
random.seed(seed)
logger = 'probfoil'
if 'log' not in args:
args['log'] = None
logfile = None
else:
logfile = open(args['log'], 'w')
if 'verbose' not in args:
args['verbose'] = 0
if 'm' not in args:
args['m'] = 1
if 'beam_size' not in args:
args['beam_size'] = 5
if 'p' not in args:
args['p'] = None
if 'l' not in args:
args['l'] = None
if 'target' not in args:
args['target'] = None
if 'symmetry_breaking' not in args:
args['symmetry_breaking'] = True
if 'settings' in args:
settings = args['settings']
del args['settings']
else:
settings = None
if 'train' in args:
train = args['train']
del args['train']
else:
train = None
if 'test' in args:
test = args['test']
del args['test']
else:
test = None
#settings = args['settings']
#train = args['train']
log = init_logger(verbose=args['verbose'], name=logger, out=logfile)
log.info('Random seed: %s' % seed)
# Load input files
#data = DataFile(*(PrologFile(source) for source in args['files']))
data = DataFile(*(PrologString(source) for source in [settings, train]))
if 'probfoil1' in args:
learn_class = ProbFOIL
else:
learn_class = ProbFOIL2
time_start = time.time()
learn = learn_class(data,
logger=logger,
seed=seed,
log=args['log'],
verbose=args['verbose'],
m=args['m'],
beam_size=args['beam_size'],
p=args['p'],
l=args['l'])
hypothesis = learn.learn()
time_total = time.time() - time_start
# Store scores
train_accuracy = accuracy(hypothesis)
train_precision = precision(hypothesis)
train_recall = recall(hypothesis)
# Load test data
if test != None:
test_data = DataFile(*(PrologString(source)
for source in [settings, test]))
test = learn_class(test_data,
logger=logger,
seed=seed,
log=args['log'],
verbose=args['verbose'],
m=args['m'],
beam_size=args['beam_size'],
p=args['p'],
l=args['l'])
test_hypothesis = test.test_rule(hypothesis)
# Store scores
test_accuracy = accuracy(test_hypothesis)
test_precision = precision(test_hypothesis)
test_recall = recall(test_hypothesis)
print('================ SETTINGS ================')
#for kv in vars(args).items():
for kv in args.items():
print('%20s:\t%s' % kv)
if learn.interrupted:
print('================ PARTIAL THEORY ================')
else:
print('================= FINAL THEORY =================')
rule = hypothesis
rules = rule.to_clauses(rule.target.functor)
# First rule is failing rule: don't print it if there are other rules.
if len(rules) > 1:
for rule in rules[1:]:
print(rule)
else:
print(rules[0])
print('==================== SCORES ====================')
print(' Train Set')
print(' Accuracy:\t', train_accuracy)
print(' Precision:\t', train_precision)
print(' Recall:\t', train_recall)
if test != None:
print(' Test Set')
print(' Accuracy:\t', test_accuracy)
print(' Precision:\t', test_precision)
print(' Recall:\t', test_recall)
print('================== STATISTICS ==================')
for name, value in learn.statistics():
print('%20s:\t%s' % (name, value))
print(' Total time:\t%.4fs' % time_total)
if logfile:
logfile.close()
#def main(argv=sys.argv[1:]):
# args = argparser().parse_args(argv)
#
# if args.seed:
# seed = args.seed
# else:
# seed = str(random.random())
# random.seed(seed)
#
# logger = 'probfoil'
#
# if args.log is None:
# logfile = None
# else:
# logfile = open(args.log, 'w')
#
# log = init_logger(verbose=args.verbose, name=logger, out=logfile)
#
# log.info('Random seed: %s' % seed)
#
# # Load input files
# data = DataFile(*(PrologFile(source) for source in args.files))
#
# if args.probfoil1:
# learn_class = ProbFOIL
# else:
# learn_class = ProbFOIL2
#
# time_start = time.time()
# learn = learn_class(data, logger=logger, **vars(args))
#
# hypothesis = learn.learn()
# time_total = time.time() - time_start
#
# print ('================ SETTINGS ================')
# for kv in vars(args).items():
# print('%20s:\t%s' % kv)
#
# if learn.interrupted:
# print('================ PARTIAL THEORY ================')
# else:
# print('================= FINAL THEORY =================')
# rule = hypothesis
# rules = rule.to_clauses(rule.target.functor)
#
# # First rule is failing rule: don't print it if there are other rules.
# if len(rules) > 1:
# for rule in rules[1:]:
# print (rule)
# else:
# print (rules[0])
# print ('==================== SCORES ====================')
# print (' Accuracy:\t', accuracy(hypothesis))
# print (' Precision:\t', precision(hypothesis))
# print (' Recall:\t', recall(hypothesis))
# print ('================== STATISTICS ==================')
# for name, value in learn.statistics():
# print ('%20s:\t%s' % (name, value))
# print (' Total time:\t%.4fs' % time_total)
#
# if logfile:
# logfile.close()
#
#def argparser():
# parser = argparse.ArgumentParser()
# parser.add_argument('files', nargs='+')
# parser.add_argument('-1', '--det-rules', action='store_true', dest='probfoil1',
# help='learn deterministic rules')
# parser.add_argument('-m', help='parameter m for m-estimate', type=float,
# default=argparse.SUPPRESS)
# parser.add_argument('-b', '--beam-size', type=int, default=5,
# help='size of beam for beam search')
# parser.add_argument('-p', '--significance', type=float, default=None,
# help='rule significance threshold', dest='p')
# parser.add_argument('-l', '--length', dest='l', type=int, default=None,
# help='maximum rule length')
# parser.add_argument('-v', action='count', dest='verbose', default=None,
# help='increase verbosity (repeat for more)')
# parser.add_argument('--symmetry-breaking', action='store_true',
# help='avoid symmetries in refinement operator')
# parser.add_argument('--target', '-t', type=str,
# help='specify predicate/arity to learn (overrides settings file)')
# parser.add_argument('-s', '--seed', help='random seed', default=None)
# parser.add_argument('--log', help='write log to file', default=None)
#
# return parser
#
#
#if __name__ == '__main__':
# main()
