def begin1():
cbf = readFromCsv("cbf2")
numdataset = np.array(cbf, dtype=np.float64)
#训练数据，验证数据，今天的数据
tgdataset, vadataset, tydata = dataSplit(numdataset)
#归一的参数
gydata, dmean, dstd = gyData(tgdataset)
#验证和今天的数据
gyvadata = calFeature(vadataset, dmean, dstd)
gytydata = calFeature(tydata, dmean, dstd)
#神经网络
trainingset = buildTrainingSet(gydata)
for i in range(1000):
net = buildNetwork(15,
8,
1,
bias=True,
hiddenclass=TanhLayer,
outclass=TanhLayer)
trainer = BackpropTrainer(net, trainingset)
trainer.trainEpochs(epochs=100)
rate = va.calRightRate(gyvadata, net)
if rate > 0.6:
NetworkWriter.writeToFile(
net, '../netv3/zxtx_8l_100t_6_' + str(rate) + ".xml")
print(va.calRightRate(gyvadata, net))
print(va.calRightRate(gytydata, net))
print(str(i) + " times " + str(rate))
# begin1();
def main ( ) :
# criando os dados para treino
datasetTreino = montaDados ()
# criando os dados para teste
datasetTeste = montaDados()
# definindo a estrutura de como será a rede neural
# a entrada será a dimensão de entrada do dataset = 3
# terá 6 neurônios na primeira camada intermediária
# terá 6 neurônios na segunda camada escondida
# terá como dimensão de saída o tamanho do dado de saída = 1
# terá a função de autocorreção para melhor adaptação da rede
network = buildNetwork( datasetTreino.indim, 12, 6, datasetTreino.outdim, bias=True )
# criando a rede neural
# terá como estrutura de rede neural definida no objeto network
# utilizará os dados do dataset para treino
neuralNetwork = BackpropTrainer ( network, datasetTreino, learningrate=0.01, momentum=0.9 )
# treinando a rede
neuralNetwork.trainEpochs ( 1500 )
# validando a rede
neuralNetwork.testOnData ( datasetTeste, verbose=True )
def train(self, players=2, games=300, epochs=50, print_fitness=False):
"""
nn = Coup_NN()
nn.train(2, print_fitness=True)
"""
from pybrain.tools.shortcuts import buildNetwork
from pybrain import SigmoidLayer
from pybrain.supervised.trainers.backprop import BackpropTrainer
from pybrain.datasets import SupervisedDataSet
from simulations import simulations
from collections import Counter
INPUT_NEURONS_PER_PLAYER = 5
OUTPUT_NEURONS = 5
HIDDEN_NEURONS = 10
ds = SupervisedDataSet(players * INPUT_NEURONS_PER_PLAYER, OUTPUT_NEURONS)
self.NETS[players] = buildNetwork(players * INPUT_NEURONS_PER_PLAYER, HIDDEN_NEURONS, OUTPUT_NEURONS, bias=True, outputbias= True, hiddenclass=SigmoidLayer)
trainer = BackpropTrainer(self.NETS[players], ds, learningrate= 0.1)
WINS = []
POSITIONS = []
for _ in range(games):
game_result = simulations.duel(Play_Coup(2))
WINS.append(game_result.winner.alpha)
POSITIONS.append(game_result.influence_binary)
ds.addSample(game_result.influence_binary, game_result.winner.influence_binary)
trainer.trainEpochs(epochs)
if print_fitness:
norm_results = dict(Counter(WINS).most_common())
nn_results = dict(Counter(self.game_winner(self.NETS[players].activate(p)) for p in POSITIONS).most_common())
print(''.ljust(25), 'normal', 'nn')
for pair in set(nn_results.keys() + norm_results.keys()):
print(pair.ljust(25), str(norm_results.get(pair,0)).ljust(6), str(nn_results.get(pair,0)).ljust(6))
with open('coup_nn-{0}'.format(players), 'w') as neunet:
pickle.dump(self.NETS[players], neunet)
def begin2():
cbf = readFromCsv("cbf2")
numdataset = np.array(cbf, dtype=np.float64)
#训练数据，验证数据，今天的数据
tgdataset, vadataset, tydata = dataSplit(numdataset)
#归一的参数
gydata, dmean, dstd = gyData(tgdataset)
#验证和今天的数据
gyvadata = calFeature(vadataset, dmean, dstd)
gytydata = calFeature(tydata, dmean, dstd)
tset = buildTrainingSet(gyvadata)
net = NetworkReader.readFrom("../netv3/zxtx_8l_100t_6_0.785714285714.xml")
trainer = BackpropTrainer(net, tset)
trainer.trainEpochs(epochs=100)
li = []
for ele in gytydata[0]:
li.append(ele)
print(dec2int(net.activate(li[:-1])))
net.reset()
for i, t in seq:
res = net.activate(i)
if verbose:
print(t, res)
r += sum((t-res)**2)
samples += 1
if verbose:
print('-'*20)
r /= samples
if not silent:
print('MSE:', r)
return r
if __name__ == "__main__":
N = buildParityNet()
DS = ParityDataSet()
evalRnnOnSeqDataset(N, DS, verbose = True)
print('(preset weights)')
N.randomize()
evalRnnOnSeqDataset(N, DS)
print('(random weights)')
# Backprop improves the network performance, and sometimes even finds the global optimum.
N.reset()
bp = BackpropTrainer(N, DS, verbose = True)
bp.trainEpochs(5000)
evalRnnOnSeqDataset(N, DS)
print('(backprop-trained weights)')
return ls;
#读入字符串
dataset = readFromCsv("cbf");
#化为float
numdataset = np.array(dataset,dtype=np.float64);
#原始分割为两组
trainingset,vdataset = dataSplit(numdataset);
# print(len(trainingset),len(vdataset));
#分别归一化
gytdataset = gyData(trainingset);
gyvdataset = gyData(vdataset);
#下面的是训练神经网络
# #最终的训练集,用归一化的数据来构成训练集
bts = buildTrainingSet(gytdataset);
# ll = [3382.9879,3384.0262,3358.7953,3373.3446,179423841,2.31148615058,4.4,4.4,4.35,4.36,0.4556,4518585,19794038.0,4363744000.0,4363744000.0];
# print(calTodayFeature(ll,trainingset));
net = buildNetwork(15, 4, 2, bias=True,hiddenclass=SigmoidLayer,outclass=SigmoidLayer)
trainer = BackpropTrainer(net, bts)
trainer.trainEpochs(epochs=100);
NetworkWriter.writeToFile(net, '../net/jxkj_4l_100t.xml')
#
print(ve.calRightRate(gyvdataset,net));
#PYBRAIN
from pybrain.tools.shortcuts import buildNetwork
from pybrain import LinearLayer, SigmoidLayer, FeedForwardNetwork, FullConnection, BiasUnit, SoftmaxLayer
from pybrain.supervised.trainers.backprop import BackpropTrainer
from pybrain.structure.modules.tanhlayer import TanhLayer
from pybrain.datasets import SupervisedDataSet
ds = SupervisedDataSet(2, 1)
ds.addSample((0, 0), (0, ))
ds.addSample((0, 1), (1, ))
ds.addSample((1, 0), (1, ))
ds.addSample((1, 1), (0, ))
net = buildNetwork(2,
2,
1,
bias=True,
outputbias=True,
hiddenclass=SigmoidLayer)
trainer = BackpropTrainer(net, ds, learningrate=0.1)
t1 = time()
trainer.trainEpochs(2000)
print "Time PyBrain {}".format(time() - t1)
#PRINT RESULTS
for x in X:
print "{} ==> {}".format(x, net.activate(x))
# 将数据扁平化
X = datasets.reshape((datasets.shape[0], datasets.shape[1] * datasets.shape[2]))
X_train ,X_test, y_train, y_test = train_test_split(X, y, train_size=0.9)
# 添加数据到数据格式中
training =SupervisedDataSet(X.shape[1], y.shape[1])
for i in range(X_train.shape[0]):
training.addSample(X_train[i], y_train[i])
testing = SupervisedDataSet(X.shape[1], y.shape[1])
for i in range(X_test.shape[0]):
testing.addSample(X_test[i], y_test[i])
# 搭建三层网络
net = buildNetwork(X.shape[1], 150, y.shape[1] ,bias=True)
# 使用BP算法
trainer = BackpropTrainer(net, training ,weightdecay=0.01)
# 训练步数
trainer.trainEpochs(epochs=50)
# 保存模型
# model_filename = open('CAPTCHA_predictor.model','wb')
# pickle.dump(trainer,model_filename,0)
# model_filename.close()
predictions = trainer.testOnClassData(dataset=testing)
from sklearn.metrics import f1_score,classification_report
print(classification_report(y_test.argmax(axis=1), predictions))
fnn = buildNetwork(traindata.indim, 5, traindata.outdim, outclass = SoftmaxLayer)
trainer = BackpropTrainer(fnn, dataset=traindata, momentum=0.1, verbose=True, weightdecay=0.01)
ticks = arange(-3., 6., 0.2)
X, Y = meshgrid(ticks, ticks)
griddata = ClassificationDataSet(2, 1, nb_classes=3)
for i in range(X.size):
griddata.addSample([X.ravel()[i],Y.ravel()[i]], [0])
griddata._convertToOneOfMany()
for i in range(20):
trainer.trainEpochs(1) # usually 5
trainresult = percentError(trainer.testOnClassData(), traindata["class"])
testresult = percentError(trainer.testOnClassData(), testdata["class"])
print("epoch %4d" % trainer.totalepochs, "trainerror %5.2f%%" % trainresult, "testerror %5.2f%%" % testresult)
out = fnn.activateOnDataset(griddata)
out = out.argmax(axis=1)
out = out.reshape(X.shape)
figure(1)
# might be the wrong import for the following lines
ioff()
clf()
hold(True)
class AgentNTD(AgentNeural):
def __init__(self, state_class, load_knowledge=False):
super(AgentNTD, self).__init__(state_class,
NTD_NUM_OUTPUTS,
init_weights=NTD_NETWORK_INIT_WEIGHTS)
# Predicting separate state-action values for white and black only makes
# sense when training against self.
if NTD_NUM_OUTPUTS == 2:
assert TRAIN_BUDDY == TRAIN_BUDDY_SELF
self.trainer = BackpropTrainer(self.network,
learningrate=NTD_LEARNING_RATE,
momentum=0.0,
verbose=False)
self.epsilon = NTD_EPSILON
self.lamda = NTD_LAMBDA
self.alpha = NTD_ALPHA
self.gamma = NTD_GAMMA
# self.state_str = None
# self.state_in = None
self.last_state_str = None
# self.last_state_in = None
self.last_action = None
# Since we apply updates with one step delay, need to remember Whether
# the action in previous time step was exploratory.
self.was_last_action_random = False
self.processed_final_reward = False
self.episode_traj = ''
self.is_learning = True
self.e = {}
self.updates = {}
# astar_value[s'] = argmax_b Q(s', b) for undetermined roll.
self.astar_value = {}
# Used for alpha annealing. Note that the roll value that is recorded
# reflects the roll chosen by the agent, not the original random roll.
# So, including the roll makes sense for calculating the updates, which
# are based on the action chosen by the agent. But it doesn't make
# sense for epsilon annealing, which is calculated before the agent
# is asked to take an action.
self.visit_count = {} # Example key: (w-5-1, action)
# Used for epsilon annealing.
self.visit_count_no_roll = {} # Example key: w-5
self.visited_in_episode = {}
self.network_inputs = {}
self.network_outputs = {}
# Recording value of intersting states over time.
self.num_training_games = 0
self.value_tracker_file = None
# network_predictions are gathered at the end of each iteration to
# produce reports.
self.network_predictions = {}
# TODO: Merge this functionality with COLLECT_STATS logic.
self.traj_count = {}
if load_knowledge:
raise ValueError('AgentNTD does not support load_knowledge.')
# self.is_learning = False
def begin_episode(self):
self.e = {}
self.astar_value = {}
self.updates = {}
if self.is_learning:
self.network_outputs = {}
self.visited_in_episode = {}
# self.state_str = None
# self.state_in = None
self.last_state_str = None
# self.last_state_in = None
self.last_action = None
self.processed_final_reward = False
self.episode_traj = ''
def end_episode(self, reward):
if self.is_learning and not self.processed_final_reward:
if TRAIN_BUDDY == TRAIN_BUDDY_SELF:
# Ignore the reward parameter and construct own reward signal
# corresponding to the probability of white winning.
rewards = self.compute_values_for_final_state(self.state)
# winner = other_player(self.state.player_to_move)
# if winner == PLAYER_WHITE:
# rewards = np.array([REWARD_WIN, REWARD_LOSE])
# else:
# rewards = np.array([REWARD_LOSE, REWARD_WIN])
#
# if self.outputdim == 1:
# rewards = rewards[:1]
else:
rewards = np.array([reward])
self.ntd_step(action=None, is_action_random=False, rewards=rewards)
if PRINT_GAME_RESULTS:
print 'Episode traj: %s' % self.episode_traj
self.traj_count[self.episode_traj] = self.traj_count.get(
self.episode_traj, 0) + 1
self.apply_updates()
self.processed_final_reward = True
def update_values(self, delta):
# Number of elements in delta depends on NTD_NUM_OUTPUTS.
if all(v == 0 for v in delta): # If aLL elements in delta are zero.
return
alpha = self.alpha
for (si, ai) in self.e.iterkeys():
if NTD_USE_ALPHA_ANNEALING:
alpha = 1.0 / self.visit_count.get((si, ai), 1)
alpha = max(alpha, NTD_ALPHA)
if self.e[(si, ai)] != 0.0:
change = [alpha * x * self.e[(si, ai)] for x in delta]
# network_in = self.network_inputs[si]
current_update = self.updates.get((si, ai),
[0.0] * self.outputdim)
self.updates[(si, ai)] = [
a + b for a, b in zip(current_update, change)
]
def apply_updates(self):
dataset = SupervisedDataSet(self.inputdim, self.outputdim)
for (si, ai) in self.updates.iterkeys():
si_ai = '%s-%s' % (si, ai)
network_in = self.network_inputs[si_ai]
current_value = self.get_network_value(None, None, si_ai)
new_value = [
a + b for a, b in zip(current_value, self.updates[(si, ai)])
]
dataset.addSample(network_in, new_value)
if PRINT_GAME_RESULTS:
print 'updating (%s, %s) from %s to %s' % (
si, ai, map(PrettyFloat,
current_value), map(PrettyFloat, new_value))
# import pdb; pdb.set_trace()
if dataset: # len(dataset) > 0:
self.trainer.setData(dataset)
self.trainer.trainEpochs(NTD_TRAIN_EPOCHS)
# print '----'
def compute_values_for_final_state(self, state):
if state.has_player_won(PLAYER_WHITE):
values = np.array([REWARD_WIN, REWARD_LOSE])
else:
values = np.array([REWARD_LOSE, REWARD_WIN])
if self.outputdim == 1:
values = values[:1]
return values
def get_Q_value(self, state, action):
"""Returns state-action value.
Args:
state: State for which value is requested.
action: Action for which value is requested.
Returns:
List containing NTD_NUM_OUTPUTS elements.
When NTD_NUM_OUTPUTS == 1, one-dimensional return value can be
intepretted as [p_w] showing the probability for white winning.
When NTD_NUM_OUTPUTS == 2, the two-dimensional return value can be
intepretted as [p_w, p_b] showing probabilities for white or black
winning.
"""
if state.is_final():
# The algorithm never trains the network on final states, so it
# cannot know their values. Need to retrieve the value of final
# states directly.
values = self.compute_values_for_final_state(state)
else:
network_out = self.get_network_value(state, action)
values = network_out
# # If player to move is white, it means black is considering a move
# # outcome, so black is evaluating the position.
# if state.player_to_move == PLAYER_WHITE:
# multiplier = -1.0
# else:
# multiplier = 1.0
# return multiplier * state_value
return values
# if state.player_to_move == PLAYER_WHITE:
# return network_out[1]
# else:
# return network_out[0]
# def cache_network_values(self, state):
# state_str = str(state)[:-2]
# if state_str not in self.network_inputs:
# self.network_inputs[state_str] = state.encode_network_input()
# network_in = self.network_inputs[state_str]
# if state_str not in self.network_outputs:
# self.network_outputs[state_str] = self.network.activate(network_in)
# This function needs to receive the actual state object, because it needs
# to calculate the corresponding network inputs for it.
def get_network_value(self, state, action, state_action_str=None):
if state_action_str:
assert state is None
assert action is None
assert state_action_str in self.network_outputs
return self.network_outputs[state_action_str]
else:
state_action_str = '%s-%s' % (state, action)
if state_action_str in self.network_outputs:
return self.network_outputs[state_action_str]
if state_action_str not in self.network_inputs:
self.network_inputs[
state_action_str] = state.encode_network_input(action)
network_in = self.network_inputs[state_action_str]
self.network_outputs[state_action_str] = self.network.activate(
network_in)
return self.network_outputs[state_action_str]
def ntd_step(self, action, is_action_random, rewards=None):
"""Updates the underlying model after every transition.
This method is called in self.select_action() and self.end_episode().
Args:
action: Action taken by the agent.
is_action_random: Whether action was an exploratory action.
rewards: List of reward components received from the environment.
Returns:
None
"""
if rewards is None:
rewards = [0.0] * self.outputdim
assert len(rewards) == self.outputdim
s = self.last_state_str
a = self.last_action
sp = self.state
ap = action
# state_str_no_roll = str(self.state)[:-2]
if action is None:
self.episode_traj += ' -> %s.' % str(self.state)
else:
self.episode_traj += ' -> %s, %s' % (str(self.state), action)
if s is not None:
# update e
if ALGO == ALGO_Q_LEARNING and self.was_last_action_random:
# Q(lambda): Set all traces to zero.
self.e = {}
else:
for key in self.e.iterkeys():
self.e[key] *= (self.gamma * self.lamda)
# replacing traces
self.e[(s, a)] = 1.0
# set the trace for the other actions to 0
for other_action in self.state.action_object.get_all_actions():
if other_action != a:
if (s, other_action) in self.e:
self.e[(s, other_action)] = 0
s_a = '%s-%s' % (s, a)
if self.state.is_final():
# delta = reward - self.Q.get((s, a), self.default_q)
# print 'Shouldn\'t happen'
# if self.is_learning:
# import pdb; pdb.set_trace()
delta = rewards - self.get_network_value(None, None, s_a)
else:
# delta = (reward + self.gamma * self.Q.get((sp, ap), self.default_q) -
# self.Q.get((s, a), self.default_q))
# delta = (reward + self.gamma * self.get_network_value(sp_in) -
# self.get_network_value(s_in))
# In our domains, only the very last state transition receives
# a reward.
assert all(v == 0 for v in rewards)
if ALGO == ALGO_SARSA:
# Just consider the action we took in sp.
next_state_v = self.get_network_value(sp, ap)
elif ALGO == ALGO_Q_LEARNING:
# Consider the best we could do from sp.
next_state_v = self.astar_value[str(sp)
[:-2]] # state_str_no_roll
delta = (rewards + self.gamma * next_state_v -
self.get_network_value(None, None, s_a))
self.update_values(delta)
else:
# Just cache the value of current state-action, so we can access
# it on the next call to this method, when it's requested as s_a.
self.get_network_value(sp, ap)
# save visited state and chosen action
self.last_state_str = str(self.state)
# self.last_state_in = self.state_in
self.last_action = action
self.was_last_action_random = is_action_random
if action is not None: # end_episode calls this with action=None.
key = (self.last_state_str, self.last_action)
if key not in self.visited_in_episode:
self.visit_count[key] = self.visit_count.get(key, 0) + 1
self.visited_in_episode[key] = True
def select_action(self):
# self.last_played_as = self.state.player_to_move
# self.cache_network_values(self.state)
# self.state_str = str(self.state)[:-2]
# if self.state_str not in self.network_inputs:
# self.network_inputs[self.state_str] = self.encode_network_input(self.state)
# self.state_in = self.network_inputs[self.state_str]
if self.is_learning:
if NTD_USE_EPSILON_ANNEALING:
# Since under some conditions the current roll can be entirely
# ignored (--chooseroll=1.0), it makes sense to exclude the
# current roll from visit counts.
state_str_no_roll = str(self.state)[:-2]
self.visit_count_no_roll[state_str_no_roll] = (
self.visit_count_no_roll.get(state_str_no_roll, 0) + 1)
# Following logic with example: anneal_time = 100, visit_count = 5.
time_to_end = max(
0, NTD_EPSILON_ANNEAL_TIME -
self.visit_count_no_roll.get(state_str_no_roll, 0))
ratio = float(time_to_end) / NTD_EPSILON_ANNEAL_TIME # 0.95
epsilon = NTD_EPSILON_END + (NTD_EPSILON_START -
NTD_EPSILON_END) * ratio
# print "State: %s, visits: %d, time_to_end: %d, ratio: %.2f, epsilon: %.2f" % (
# state_str, self.visit_count.get(state_str, 0), time_to_end, ratio, epsilon)
else:
epsilon = self.epsilon
else:
epsilon = 0
choose_random_action = True if random.random() < epsilon else False
# Select the best action.
action, _ = self.select_action_with_search(
state=self.state,
choose_random_action=choose_random_action,
plies=NTD_SEARCH_PLIES)
# Update values.
if self.is_learning:
self.ntd_step(action, is_action_random=choose_random_action)
return action
# def save_knowledge(self):
#
# filename = './td-network.txt' % Domain.name
# f = open(filename, 'w')
# pickle.dump(self.network, f)
# f.close()
#
# def load_knowledge(self):
# filename = './td-network-%s.txt' % Domain.name
# f = open(filename, 'r')
# self.network = pickle.load(f)
# f.close()
def pause_learning(self):
self.is_learning = False
def resume_learning(self):
self.is_learning = True
def print_e(self):
e_keys = self.e.keys()
e_keys.sort()
print "e:"
for key in e_keys:
print "e%s -> %.10f" % (key, self.e[key])
def print_visit_count(self):
print "Visit Counts:"
# keys = self.visit_count.keys()
# keys.sort()
# for key in Q_keys:
# print "Q%s -> %.2f" % (key, self.Q[key])
for key, value in sorted(self.visit_count.iteritems(),
key=lambda (k, v): (v, k)):
print "%s: %s" % (key, value)
def probe_network(self):
exp_params = ExpParams.get_exp_params_from_command_line_args()
graph = exp_params.state_class.GAME_GRAPH
print "Network predictions:"
self.network_predictions = {} # Network predictions.
true_values = {
} # True values obtained from the graph using value iteration.
for state_roll_action_str in sorted(self.network_inputs.iterkeys()):
# state_value = self.network_outputs[state_str]
state_roll_action_value = self.network.activate(
self.network_inputs[state_roll_action_str])
self.network_predictions[
state_roll_action_str] = state_roll_action_value
node_id = graph.get_node_id(
state_roll_action_str[:-4]) # Removes roll and action.
true_value = graph.get_attr(node_id, VAL_ATTR)
true_values[state_roll_action_str] = true_value
# print "%s -> %s (%.2f)" % (state_str, state_value, abs_value)
for (si, ai), _ in sorted(self.visit_count.iteritems(),
key=lambda (k, v): (v, k)):
state_roll_action_str = '%s-%s' % (si, ai)
true_value = true_values[state_roll_action_str]
# Reward for white win is [1, 0],
# Reward for black win is [0, 1],
# state_value[0] - state_value[1] ranges from -1 to +1, although
# it can exceed those bounds when the network outputs are
# outside the range [0, 1].
# The following formula is meant to scale the difference to range [0, 1].
print "(%s, %s): opt. val. for white: %+.2f prediction: %s visited: %d" % (
si, ai, true_value,
map(PrettyFloat,
self.network_predictions[state_roll_action_str]),
self.visit_count.get((si, ai), 0))
print(
'Note: optimal values for white are based on the board '
'positions only and ignore the current roll.')
def track_interesting_states(self):
interesting_states = self.state.interesting_states()
if interesting_states:
if not self.value_tracker_file:
value_tracker_filename = (
self.state.exp_params.get_value_tracker_filename(
FILE_PREFIX_NTD))
self.value_tracker_file = open(value_tracker_filename, 'w')
self.num_training_games += NTD_NUM_TRAINING_GAMES
self.value_tracker_file.write('%d' % self.num_training_games)
for s in interesting_states:
s_val = self.network_predictions[s][
0] if s in self.network_predictions else 0.5
self.value_tracker_file.write(' %f' % s_val)
self.value_tracker_file.write('\n')
self.value_tracker_file.flush()
def print_traj_counts(self):
print "Trajectories in training:"
import operator
sorted_traj_count = sorted(self.traj_count.items(),
key=operator.itemgetter(1),
reverse=True)
for traj, cnt in sorted_traj_count:
print "%s: %d" % (traj, cnt)
# Reset after each query.
self.traj_count = {}
def print_learner_state(self):
self.print_visit_count()
self.print_e()
self.probe_network()
self.print_traj_counts()
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers.backprop import BackpropTrainer
from odyseus_model import OdyseusRecursiveTwoThrusters
import numpy as np
import optparse
from tools.common_run import add_common_options
if __name__ == "__main__":
usage = "python run_pretrain.py resulting_file.neu \n this script pretrain net of model described in|" \
" OdyseusRecursiveTwoThrusters, for 5 input nodes. Resulting network is saved to desired file"
parser = optparse.OptionParser(usage=usage)
opts, args = parser.parse_args()
ds = SupervisedDataSet(5, 2)
ds.addSample((50,50,50,0,0),(0,1))
ds.addSample((0,50,50,50,0),(1,1))
ds.addSample((0,0,50,0,0), (1,1))
ds.addSample((0,0,50,50,50),(1,0))
net = OdyseusRecursiveTwoThrusters.random_net()
trainer = BackpropTrainer(net, ds)
trainer.trainEpochs(3600)
np.savetxt(args[0], trainer.module.params, delimiter=',')
irisData = datasets.load_iris()
dataFeatures = irisData.data
dataTargets = irisData.target
#plt.matshow(irisData.images[11], cmap=cm.Greys_r)
#plt.show()
#print dataTargets[11]
#print dataFeatures.shape
dataSet = ClassificationDataSet(4, 1 , nb_classes=3)
for i in range(len(dataFeatures)):
dataSet.addSample(np.ravel(dataFeatures[i]), dataTargets[i])
trainingData, testData = splitWithProportion(dataSet,0.7)
trainingData._convertToOneOfMany()
testData._convertToOneOfMany()
neuralNetwork = buildNetwork(trainingData.indim, 7, trainingData.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(neuralNetwork, dataset=trainingData, momentum=0.01, learningrate=0.05, verbose=True)
trainer.trainEpochs(10000)
print('Error (test dataset): ' , percentError(trainer.testOnClassData(dataset=testData), testData['class']))
print('\n\n')
counter = 0
for input in dataFeatures:
print(counter," output is according to the NN: ", neuralNetwork.activate(input))
counter = counter + 1
def trainm_NN(x1, x2, parametresNN, actualNet):
start_time = time.time()
# prepare data
x1 = map(list, x1)
x2 = map(list, x2)
X = x1 + x2
print shape(X)
y1 = ones((shape(x1)[0], 1)) # els positius son la classe '1'
y2 = -1 * ones((shape(x2)[0], 1)) # els negatius son la classe '-1'
Y = list(y1) + list(y2)
Y = ravel(Y)
#-----RED NUMERO 1
n1 = FeedForwardNetwork()
inLayer = TanhLayer(199)
hiddenLayer1 = TanhLayer(40)
hiddenLayer2 = LinearLayer(3)
hiddenLayer3 = TanhLayer(5)
outLayer = TanhLayer(1)
n1.addInputModule(inLayer)
n1.addModule(hiddenLayer1)
n1.addModule(hiddenLayer2)
n1.addModule(hiddenLayer3)
n1.addOutputModule(outLayer)
in_to_hidden1 = FullConnection(inLayer, hiddenLayer1)
hidden1_to_hidden2 = FullConnection(hiddenLayer1, hiddenLayer2)
hidden2_to_hidden3 = FullConnection(hiddenLayer2, hiddenLayer3)
hidden3_to_out = FullConnection(hiddenLayer3, outLayer)
n1.addConnection(in_to_hidden1)
n1.addConnection(hidden1_to_hidden2)
n1.addConnection(hidden2_to_hidden3)
n1.addConnection(hidden3_to_out)
n1.sortModules() #Crida necesaria init de moduls interns
#-----RED NUMERO 2
n2 = FeedForwardNetwork()
inLayer = TanhLayer(199)
hiddenLayer1 = TanhLayer(12)
hiddenLayer2 = LinearLayer(3)
outLayer = LinearLayer(1)
n2.addInputModule(inLayer)
n2.addModule(hiddenLayer1)
n2.addModule(hiddenLayer2)
n2.addOutputModule(outLayer)
in_to_hidden1 = FullConnection(inLayer, hiddenLayer1)
hidden1_to_hidden2 = FullConnection(hiddenLayer1, hiddenLayer2)
hidden2_to_out = FullConnection(hiddenLayer2, outLayer)
n2.addConnection(in_to_hidden1)
n2.addConnection(hidden1_to_hidden2)
n2.addConnection(hidden2_to_out)
n2.sortModules() #Crida necesaria init de moduls interns
#-----RED NUMERO 3
n3 = FeedForwardNetwork()
inLayer = TanhLayer(199)
hiddenLayer1 = TanhLayer(27)
hiddenLayer2 = TanhLayer(5)
outLayer = LinearLayer(1)
n3.addInputModule(inLayer)
n3.addModule(hiddenLayer1)
n3.addModule(hiddenLayer2)
n3.addOutputModule(outLayer)
in_to_hidden1 = FullConnection(inLayer, hiddenLayer1)
hidden1_to_hidden2 = FullConnection(hiddenLayer1, hiddenLayer2)
hidden2_to_out = FullConnection(hiddenLayer2, outLayer)
n3.addConnection(in_to_hidden1)
n3.addConnection(hidden1_to_hidden2)
n3.addConnection(hidden2_to_out)
n3.sortModules() #Crida necesaria init de moduls interns
#-----RED NUMERO 4 (implementar RELU)
#Selection of the net that gonna be trained
if (actualNet == 1):
n = n1
elif (actualNet == 2):
n = n2
elif (actualNet == 3):
n = n3
else:
#TODO
n = n1
#Initialization weights
if (actualNet == 1):
r = math.sqrt(1 / ((199 + 70 + 3 + 5 + 1) * (1.0)))
sizeOfNet = 199 * 70 + 70 * 3 + 3 * 5 + 5
elif (actualNet == 2):
r = math.sqrt(1 / ((199 + 12 + 3 + 1) * (1.0)))
sizeOfNet = 199 * 12 + 12 * 3 + 3
elif (actualNet == 3):
r = math.sqrt(1 / ((199 + 27 + 5 + 1) * (1.0)))
sizeOfNet = 199 * 27 + 27 * 5 + 5
else:
#TODO
r = math.sqrt(1 / ((199 + 40 + 3 + 5 + 1) * (1.0)))
sizeOfNet = 199 * 40 + 40 * 3 + 3 * 5 + 5
weights_init = random.uniform(low=-r, high=r, size=(sizeOfNet, ))
n._setParameters(weights_init)
DS = ClassificationDataSet(199, nb_classes=1)
for i in range(shape(X)[0]):
DS.addSample(list(X[i]), Y[i])
#DS._convertToOneOfMany() # No -> volem nomes una sortida
#DS.setField('class', DS.getField('target'))
trainer = BackpropTrainer(n,
dataset=DS,
momentum=parametresNN['Momentum'],
learningrate=parametresNN['learningrate'],
verbose=parametresNN['verbose'],
weightdecay=parametresNN['weightdecay'],
batchlearning=parametresNN['batchlearning'])
trainningErrors, validationErrors = trainer.trainUntilConvergence(
maxEpochs=parametresNN['maxEpochs'])
f = trainer.trainEpochs(parametresNN['maxEpochs'])
print "Red Activa: ", actualNet, " Tiempo transcurrido: ", time.time(
) - start_time, " Error final training:", trainningErrors[
-1], " Error final validation:", validationErrors[-1]
return n
print
#PYBRAIN
from pybrain.tools.shortcuts import buildNetwork
from pybrain import LinearLayer, SigmoidLayer, FeedForwardNetwork, FullConnection, BiasUnit, SoftmaxLayer
from pybrain.supervised.trainers.backprop import BackpropTrainer
from pybrain.structure.modules.tanhlayer import TanhLayer
from pybrain.datasets import SupervisedDataSet
ds = SupervisedDataSet(2,1 )
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
net = buildNetwork(2, 2, 1, bias=True, outputbias= True, hiddenclass=SigmoidLayer)
trainer = BackpropTrainer(net, ds, learningrate= 0.1)
t1 = time()
trainer.trainEpochs(2000)
print "Time PyBrain {}".format(time()-t1)
#PRINT RESULTS
for x in X:
print "{} ==> {}".format( x, net.activate(x) )
training = SupervisedDataSet(X.shape[1], y.shape[1])
for i in range(X_train.shape[0]):
training.addSample(X_train[i], y_train[i])
testing = SupervisedDataSet(X.shape[1], y.shape[1])
for i in range(X_test.shape[0]):
testing.addSample(X_test[i], y_test[i])
# 指定维度，创建神经网络，第一个参数为输入层神经元数量，第二个参数隐含层神经元数量，第三个参数为输出层神经元数量
# bias在每一层使用一个一直处于激活状态的偏置神经元
net = buildNetwork(X.shape[1], 100, y.shape[1], bias=True)
trainer = BackpropTrainer(net,
training,
learningrate=0.01,
weightdecay=0.01)
# 设定代码的运行步数
trainer.trainEpochs(epochs=20)
# 预测值
predictions = trainer.testOnClassData(dataset=testing)
# f1_score的average默认值为'binary'，如果不指定average则会发生ValueError
print("F-score:{0:.2f}".format(
f1_score(y_test.argmax(axis=1), predictions, average="weighted")))
print("F-score:{0:.2f}".format(
f1_score(y_test.argmax(axis=1), predictions, average="micro")))
print("F-score:{0:.2f}".format(
f1_score(y_test.argmax(axis=1), predictions, average="macro")))
print("------------------------")
def predict_captcha(captcha_image, neural_network):
subimages = segment_image(captcha_image)
predicted_word = ""
for subimage in subimages: