def ffnetwork(inputs=1, layers=1, outputs=1):
"""
Define a feedforward neural network
Parameters
----------
inputs : integer
default = 1
defines the length of input vector
layers : integer
default = 1
defines the number of layers
outputs : integer
default = 1
defines the length of output vector
Returns
-------
net : Feed-forward neural network
"""
conec = ffnet.mlgraph((inputs, layers, outputs), biases=False)
net = ffnet.ffnet(conec)
'''NX.draw_graphviz(net.graph, prog='dot')
plt.show()'''
return net
def run_network():
# Generate standard layered network architecture and create network
conec = mlgraph((14,28,1))
net = ffnet(conec)
df = pd.read_csv('data/copacabana.csv', sep=';')
variables = [
'Posicao', 'Quartos', 'Vagas', 'DistIpanema', 'DistPraia',
'DistFavela', 'RendaMedia', 'RendaMovel', 'RendaMovelRua',
'Vu2009', 'Mes', 'Idade', 'Tipologia', 'AreaConstruida'
]
input = df[variables]
target = df[['VAL_UNIT']]
# Train network
#first find good starting point with genetic algorithm (not necessary, but may be helpful)
print "FINDING STARTING WEIGHTS WITH GENETIC ALGORITHM..."
net.train_genetic(input, target, individuals=20, generations=500)
#then train with scipy tnc optimizer
print "TRAINING NETWORK..."
net.train_tnc(input, target, maxfun = 1000, messages=1)
print "TESTING NETWORK..."
output, regression = net.test(input, target, iprint=0)
# Save/load/export network
print "Network is saved..."
savenet(net, "data/capacabana.net")
return output, regression
def learn(inputD,outputData):
conec = mlgraph((2,22,12,1))
net = ffnet(conec)
print("READING DATA")
inputData = inputD
target = numpy.array(outputData)#data[:, -1] #last column
print ("TRAINING NETWORK...")
sys.stdout.flush()
net.train_tnc(inputData, target, maxfun = 5000, messages=1)
print ("TESTING NETWORK...")
output, regression = net.test(inputData, target, iprint = 0)
print(regression)
Rsquared = regression[0][2]
maxerr = abs( numpy.array(output).reshape( len(output) ) - numpy.array(target) ).max()
print ("R-squared: %s (should be >= 0.999999)" %str(Rsquared))
print ("max. absolute error: %s (should be <= 0.05)" %str(maxerr))
print ("Is ffnet ready for a stock?")
try:
plot( target, 'b--' )
plot( output, 'k-' )
legend(('target', 'output'))
xlabel('pattern'); ylabel('price')
title('Outputs vs. target of trained network.')
grid(True)
show()
return net
except ImportError:
print ("Cannot make plots. For plotting install matplotlib.\n%s" % e)
return net
def train(data):
#trains neural network based on passed training data.
#training data is a list of [input,output] lists
print "amount of training data:" + str(len(data))
inputsize = 30 * 30
outsize = 10
nodes = 350 #((inputsize + outsize) * 2) / 3
inp = [i for i,t in data]
trg = [t for i,t in data]
print "creating neural network, hidden nodes:" + str(nodes)
conec = mlgraph((inputsize,nodes,outsize))
print "initializing ffnet"
net = ffnet(conec)
#print "loading ffnet"
#net = loadnet("ffnet.net")
# print "assigning random weights"
# net.randomweights()
# Train process
print "training network"
net.train_tnc(inp, trg, messages=1,nproc=4)
print "saving trained network"
savenet(net, "ffnet.net")
print "testing network"
net.test(inp, trg, iprint = 1)
def build_ffnet(sorted_data,network_config):
#data_in_training2 = sorted_data[:training_set_size,10:-2].astype(float).tolist()
data_target_training2 = [[i] for i in sorted_data[:training_set_size,0].astype(float)]
new_data_in = sorted_data[:training_set_size,col_training_set[0]] # the first col
for i in col_training_set[1:]: # and the rest of the cols
new_data_in = numpy.column_stack((new_data_in, sorted_data[:training_set_size,i]))
data_in_training2 = new_data_in.astype(float).tolist()
print 'defining network'
# Define net (large one)
conec = mlgraph(network_config, biases=False)
net = ffnet(conec)
#print 'draw network'
#networkx.draw_graphviz(net.graph, prog='dot')
#pylab.show()
logging.info('network built as: ' + str(network_config) )
print "TRAINING NETWORK..."
# that are many different training algos
#net.train_rprop(data_in_training2, data_target_training2, a=1.9, b=0.1, mimin=1e-06, mimax=15.0, xmi=0.5, maxiter=max_functions, disp=1)
###net.train_momentum(data_in_training2, data_target_training2, eta=0.2, momentum=0.1, maxiter=max_functions, disp=1)
net.train_tnc(data_in_training2, data_target_training2, maxfun = max_functions, messages=1)
#net.train_cg(data_in_training2, data_target_training2, maxiter=max_functions, disp=1)
#net.train_genetic(data_in_training2, data_target_training2, individuals=max_population, generations=max_functions)
#net.train_bfgs(data_in_training2, data_target_training2, maxfun = max_functions, disp=1)
return net
def train(self, X, Y):
""" Trains the neural network based on the given set of inputs
and outputs. """
inp = array(X)
targ = array(Y)
n_inputs = len(inp[0])
# 1 Output node because Surrogate Model has only 1 output
self._nn_surr = ffnet(mlgraph((n_inputs, self.n_hidden_nodes, 1)))
# Start the training
if self.method == 'cg':
self._nn_surr.train_cg(inp, targ, disp=False)
elif self.method == 'genetic':
self._nn_surr.train_genetic(inp, targ, individuals=10*n_inputs,
generations=500)
elif self.method == 'tnc':
self._nn_surr.train_tnc(inp, targ, maxfun=5000)
elif self.method == 'momentum':
self._nn_surr.train_momentum(inp, targ, momentum=1)
elif self.method == 'rprop':
self._nn_surr.train_rprop(inp, targ)
elif self.method == 'bfgs':
self._nn_surr.train_bfgs(inp, targ)
else:
self.raise_exception('Unknown training method %r' % self.method)
def __init__(self, arch, verbose = False, biases = True):
"""
Initialises the neural network
"""
self.verbose = verbose
self.arch = arch
self.conec = mlgraph(self.arch, biases = biases)
self.net = ffnet(self.conec)
def deserialize(data, used_activation=None):
arguments = data['arguments']
if used_activation is None:
used_activation = getattr(ActivationFunctions, data['activation_function'])
nn = ffnet(*arguments)
for index, layer in enumerate(data['layers']):
for p_index, perceptron in enumerate(nn.layers[index]):
perceptron.weights = layer[p_index]
return nn
def create_bp(input, output):
it = len(input[0])
ot = len(output[0])
connection = mlgraph((it, 10, ot))
net = ffnet(connection)
print("Created new network...")
return net
def do(inp): conec = mlgraph((1,2,2,1)) net = ffnet(conec) input=inp[0] target=inp[1] #net.train_genetic(input, target, individuals=20, generations=500) print "TRAINING NETWORK..." net.train_tnc(input, target, maxfun = 5000) x=mgrid[0:1:n*1j] y=map(lambda x: net([x])[0],x) return vstack((x,y))
def create_net(inno, layer_definitions, outno, network_function):
from ffnet import ffnet
pts = [
inno,
] + layer_definitions + [
outno,
]
conec = network_function(pts, biases=True)
net = ffnet(conec)
print 'created new network with ', pts, 'layers and', len(
net.conec), 'connections'
return net
def train(self, X, Y):
""" Trains the neural network based on the given set of inputs
and outputs. """
inp = array(X)
targ = array(Y)
n_inputs = len(inp[0])
# 1 Output node because Surrogate Model has only 1 output
self._nn_surr = ffnet(mlgraph((n_inputs, self.n_hidden_nodes, 1)))
# Start the training
self._nn_surr.train_cg(inp, targ, disp=False)
def fit(self, descs, target_values, train_alg='tnc',**kwargs):
# setup neural network
if self.full_conn:
conec = tmlgraph(self.shape, self.biases)
else:
conec = mlgraph(self.shape, self.biases)
self.model = ffnet(conec)
if self.random_weights:
if not self.random_state is None:
random_seed(self.random_state)
self.model.randomweights()
# train
getattr(self.model, 'train_'+train_alg)(descs, target_values, nproc='ncpu' if self.n_jobs < 1 else self.n_jobs, **kwargs)
return self
def get_nn(init_and_save_weights):
# Create a new NN and save it to a json
if init_and_save_weights:
arguments = NN_ARGUMENTS
arguments.append(USED_ACTIVATION)
autoencoder = ffnet(*arguments)
with open(NN_FILE, 'w+') as file:
json.dump(ffnet_utils.serialize(autoencoder), file)
# Load the NN weights from the json
else:
with open(NN_FILE, 'r') as file:
data = json.load(file)
autoencoder = ffnet_utils.deserialize(data, USED_ACTIVATION)
return autoencoder
def train(input, target):
print input[0]
print len(input)
conec = mlgraph((16, 16, 10))
net = ffnet(conec)
input = input.tolist()
target = target.tolist()
print "FINDING STARTING WEIGHTS WITH GENETIC ALGORITHM..."
# net.train_genetic(input, target, individuals=20, generations=30)
#then train with scipy tnc optimizer
print "TRAINING NETWORK..."
net.train_tnc(input, target, maxfun=1000, messages=1)
return net
def __init__(self):
super(NeuralNetwork, self).__init__()
self.field = Field(20, 20)
self.outputs = []
self.input = []
self.target = []
b = QtGui.QPushButton("Learn!")
self.connect(b, QtCore.SIGNAL("clicked()"), self.learn)
self.outcomes_list = QtGui.QComboBox()
self._add_output("Square")
self._add_output("Triangle")
self._add_output("Line")
hpanel = QtGui.QHBoxLayout()
hpanel.addWidget(self.outcomes_list)
hpanel.addWidget(b)
btn_classify = QtGui.QPushButton("Classify")
self.connect(btn_classify, QtCore.SIGNAL("clicked()"), self.classify)
btn_clear = QtGui.QPushButton("Clear")
self.connect(btn_clear, QtCore.SIGNAL("clicked()"), self.clear)
self.label_output = QtGui.QLabel()
self.label_output.setMaximumHeight(20)
self.label_epoch = QtGui.QLabel()
self.label_epoch.setMaximumHeight(20)
vpanel = QtGui.QVBoxLayout()
vpanel.addWidget(self.field)
vpanel.addLayout(hpanel)
vpanel.addWidget(self.label_output)
vpanel.addWidget(self.label_epoch)
vpanel.addWidget(btn_classify)
vpanel.addWidget(btn_clear)
self.setLayout(vpanel)
try:
self.net, self.epoch = loadnet("netdata.dat")
except IOError:
conec = mlgraph((self.field.x * self.field.y, 10, 10, 3))
self.net = ffnet(conec)
self.epoch = 0
def __init__(self):
super(NeuralNetwork, self).__init__()
self.field = Field(20, 20)
self.outputs = []
self.input = []
self.target = []
b = QtGui.QPushButton("Learn!")
self.connect(b, QtCore.SIGNAL("clicked()"), self.learn)
self.outcomes_list = QtGui.QComboBox()
self._add_output("Square")
self._add_output("Triangle")
self._add_output("Line")
hpanel = QtGui.QHBoxLayout()
hpanel.addWidget(self.outcomes_list)
hpanel.addWidget(b)
btn_classify = QtGui.QPushButton("Classify")
self.connect(btn_classify, QtCore.SIGNAL("clicked()"), self.classify)
btn_clear = QtGui.QPushButton("Clear")
self.connect(btn_clear, QtCore.SIGNAL("clicked()"), self.clear)
self.label_output = QtGui.QLabel()
self.label_output.setMaximumHeight(20)
self.label_epoch = QtGui.QLabel()
self.label_epoch.setMaximumHeight(20)
vpanel = QtGui.QVBoxLayout()
vpanel.addWidget(self.field)
vpanel.addLayout(hpanel)
vpanel.addWidget(self.label_output)
vpanel.addWidget(self.label_epoch)
vpanel.addWidget(btn_classify)
vpanel.addWidget(btn_clear)
self.setLayout(vpanel)
try:
self.net, self.epoch = loadnet("netdata.dat")
except IOError:
conec = mlgraph((self.field.x*self.field.y, 10, 10, 3))
self.net = ffnet(conec)
self.epoch = 0
def fit(self, X, y):
dim = X.shape
nFeatures = int(dim[1])
#input = [ [0.,0.], [0.,1.], [1.,0.], [1.,1.] ]
#target = [ [1.], [0.], [0.], [1.] ]
input = list(X)
target = list(y)
conec = mlgraph((nFeatures, self.nNodes, 1))
self.net = ffnet(conec)
if self.maxfun == '':
self.net.train_tnc(input, target)
else:
self.net.train_tnc(input, target, maxfun=self.maxfun)
def add_mlp(self, n_hidden):
"""
Dodajem novu neuralnu mrežu s n_hidden neurona u skrivenom sloju.
n_hidden može biti broj ili tuple
"""
ind = len(self.nns)
nin = len(self._invars)
nout = len(self._outvars)
if isinstance(n_hidden, int): n_hidden = (n_hidden, )
arch = (nin, ) + n_hidden + (nout, )
net = ffnet(mlgraph(arch))
self.nns.append(net)
return ind
def main():
""" load training data"""
inputs = np.loadtxt("../handwriting/X2_100samples.dat")
targets = np.loadtxt("../handwriting/y2_100samples.dat")
""" define network topology """
conec = mlgraph((inputs.shape[1], 10, 1))
# reg = 0.1
reg = False
net = ffnet(conec)
system = NNSystem(net, inputs, targets, reg=reg)
database = system.create_database(
# db="/home/ab2111/machine_learning_landscapes/neural_net/db_ffnet_100samples_reg"+str(reg) +".sqlite"
db="../db/db_ffnet_100samples.sqlite")
run_gui(system, database)
def train(trainData):
print('Starting Training')
inLength = 64
inData = []
for i in range(len(trainData)):
row = []
for j in range(inLength):
row.append(trainData[i][j])
inData.append(row)
conec = mlgraph((inLength, 10, 10, inLength))
net = ffnet(conec)
input = numpy.array(inData)
target = numpy.array(inData)
net.train_tnc(input, target, maxfun=2000, messages=1)
print('Training completed')
def __init__(self,
inputDims,
actionSpace,
hiddenUnits=5,
bias=True,
independentOutputs=False,
**kwargs):
assert not actionSpace.hasContinuousDimensions() \
or actionSpace.getNumberOfDimensions() == 1, \
"MLP policy can currently not deal with continuous action "\
"spaces with more than one dimension!"
try:
import ffnet
except:
import warnings
warnings.warn("The MLP policy module requires the ffnet package.")
self.continuousActions = actionSpace.hasContinuousDimensions()
if self.continuousActions:
actionDimension = actionSpace.getDimensions()[
0] # there is per assert only 1
actionRanges = actionDimension.getValueRanges()
assert len(actionRanges) == 1, "MLP policy cannot deal with "\
"non-contiguous action ranges."
self.actionRange = actionRanges[0]
self.numActions = 1 # TODO
else:
self.actions = actionSpace.getActionList()
self.numActions = len(self.actions)
self.inputDims = inputDims
self.hiddenUnits = hiddenUnits
self.bias = bias
# Determine network topology
if independentOutputs:
conec = ffnet.imlgraph((inputDims, hiddenUnits, self.numActions),
biases=self.bias)
else:
conec = ffnet.mlgraph((inputDims, hiddenUnits, self.numActions),
biases=self.bias)
# Create net based on connectivity
self.net = ffnet.ffnet(conec)
def load_speaker_recognition_newtork(filename, create_new=False):
"""
Load or create (if you want) network for speker recognition form file
returns tuple: (network, people_names, people_number)
"""
people = voice_sample.get_names();
people_num = len(people)
network = None
try:
network = loadnet(filename)
except IOError, ex:
if create_new:
network = ffnet(mlgraph((LPC_COE_NUM, people_num + LPC_COE_NUM,
#network = ffnet(mlgraph((LPC_COE_NUM, 10,
people_num)) )
def main():
""" load training data"""
inputs = np.loadtxt("../handwriting/X2_100samples.dat")
targets = np.loadtxt("../handwriting/y2_100samples.dat")
""" define network topology """
conec = mlgraph((inputs.shape[1],10,1))
# reg = 0.1
reg=False
net = ffnet(conec)
system = NNSystem(net, inputs, targets, reg=reg)
database = system.create_database(
# db="/home/ab2111/machine_learning_landscapes/neural_net/db_ffnet_100samples_reg"+str(reg) +".sqlite"
db="../db/db_ffnet_100samples.sqlite"
)
run_gui(system, database)
def fit(self, descs, target_values, train_alg='tnc', **kwargs):
# setup neural network
if self.full_conn:
conec = tmlgraph(self.shape, self.biases)
else:
conec = mlgraph(self.shape, self.biases)
self.model = ffnet(conec)
if self.random_weights:
if not self.random_state is None:
random_seed(self.random_state)
self.model.randomweights()
# train
getattr(self.model, 'train_' + train_alg)(
descs,
target_values,
nproc='ncpu' if self.n_jobs < 1 else self.n_jobs,
**kwargs)
return self
def __init__(self, stateSpace, actions, **kwargs):
super(MLP, self).__init__(stateSpace)
try:
import ffnet
except ImportError:
raise Exception(
"Error: MLP function approximator cannot be used without the ffnet module!"
)
self.numberOfInputs = len(stateSpace.keys())
self.numberOfOutputs = len(actions)
self.actions = actions
self.stateSpace = stateSpace
conec = ffnet.mlgraph((self.numberOfInputs, 8, 1))
self.nets = dict([(action, ffnet.ffnet(conec)) for action in actions])
for action in self.actions:
for index in range(len(self.nets[action].weights)):
self.nets[action].weights[index] = 0.0
def run():
def formatPrediction(u):
if (u>0.5):
return 1
else:
return 0
dat = json.loads(dict(request.form).keys()[0])
dat["pgood"]["values"] = []
dat["pbad"]["values"] = []
good = set(dat["good"]["values"])
none = set(dat["none"]["values"])
bad = set(dat["bad"]["values"])
data = get_all_fruits()
train_input = []
train_target = []
test_input = []
for f in data:
if f[0] in good:
train_input.append(f[1:])
train_target.append(1)
elif f[0] in bad:
train_input.append(f[1:])
train_target.append(0)
elif f[0] in none:
pass
else:
test_input.append(f)
print len(test_input)
# Run algorithm
l = len(data[0])-1
conec = mlgraph( (l,2,1))
net = ffnet(conec)
net.train_tnc(train_input, train_target, maxfun = 1000)
## Print the name of the fruits used for test
o = net.test([u[1:] for u in test_input], [0]*len(test_input),iprint=0)
res = [formatPrediction(u[0]) for u in o[0]]
dat["pgood"]["values"] = [ k[0] for i,k in enumerate(test_input) if res[i] == 1 ]
dat["pbad"]["values"] = [ k[0] for i,k in enumerate(test_input) if res[i] == 0 ]
return json.dumps(dat)
def train(self, X, Y):
""" Trains the nerual network based on the given set of inputs
and outputs. """
inp = array(X)
targ = array(Y)
n_inputs = len(inp[0])
# 1 Output node because Surrogate Model has only 1 output
self._nn_surr = ffnet(mlgraph((n_inputs, self.n_hidden_nodes, 1)))
# Start the training
#self._nn_surr.train_genetic(inp, targ, individuals=10*n_inputs, generations=500)
#self._nn_surr.train_tnc(inp, targ,maxfun=5000)
#self._nn_surr.train_momentum(inp,targ,momentum=1)
#self._nn_surr.train_rprop(inp,targ)
self._nn_surr.train_cg(inp,targ,disp=False)
def main():
""" load training data"""
inputs = np.loadtxt("../handwriting/X2_100samples.dat")
targets = np.loadtxt("../handwriting/y2_100samples.dat")
ValInputs, ValTargets = get_validation_data()
""" define network topology """
conec = mlgraph((inputs.shape[1], 10, 1))
net = ffnet(conec)
system = NNSystem(net, inputs, targets)
pot = system.get_potential()
database = system.create_database(
db=
"/home/ab2111/machine_learning_landscapes/neural_net/db_ffnet_100samples.sqlite"
)
# database = system.create_database(db="/home/ab2111/machine_learning_landscapes/neural_net/db_ffnet_me3.sqlite")
# run_gui(system, database)
# check_its_a_minimum(system, database)
energies = np.array([])
for m in database.minima():
coords = m.coords
testenergy = pot.getValidationEnergy(coords, ValInputs,
ValTargets) / len(ValTargets)
energies = np.append(energies, testenergy)
# plt.plot(m.coords,'o')
# np.max(m.coords)
# plt.plot([m._id for m in database.minima()], np.array([m.energy for m in database.minima()])/100., 'o')
plt.plot(np.array([m.energy for m in database.minima()]) / 100)
plt.plot(energies)
plt.plot(
np.array([np.max(m.coords) for m in database.minima()]) / 1000, 'x')
plt.legend(["Etrain", "Evalidation", "max(params)"])
plt.show()
def creatingNeuralNetwork(num_hidden,data_s,data_l):
dataset_data = data_s
dataset_labels = data_l
#create the gab of 6-grams vocabulary
tfidf_vectorizer = TfidfVectorizer(ngram_range=(1, 6),token_pattern=ur'\b\w+\b',min_df=0.05)
tfidf_vectorizer.fit(dataset_data)
feature_names = tfidf_vectorizer.get_feature_names()
number_of_input_features = len(feature_names)
# Create the feature dataset
indata = np.zeros((len(dataset_data),number_of_input_features))
for j,sentence in enumerate(dataset_data):
indata[j,:] = tfidf_vectorizer.transform([sentence]).toarray()[0]
#create the neural network
number_of_hidden_nodes = num_hidden
conec = tmlgraph((number_of_input_features,number_of_hidden_nodes, 1))
net = ffnet(conec)
#please print nothing
net.train_tnc(indata, dataset_labels, maxfun = 5000, messages=0)
output, regression = net.test(indata, dataset_labels, iprint = 0)
return net, number_of_input_features, tfidf_vectorizer
def load_speaker_recognition_newtork(filename, create_new=False):
"""
Load or create (if you want) network for speker recognition form file
returns tuple: (network, people_names, people_number)
"""
people = voice_sample.get_names()
people_num = len(people)
network = None
try:
network = loadnet(filename)
except IOError, ex:
if create_new:
network = ffnet(
mlgraph((
LPC_COE_NUM,
people_num + LPC_COE_NUM,
#network = ffnet(mlgraph((LPC_COE_NUM, 10,
people_num)))
def main():
def formatPrediction(u):
if (u>0.5):
return 1
else:
return 0
res = []
for k in range(100):
header, tests, train = read_data()
inputLength = len(header) - 2
# 2 here is the middle layer, you can remove it and try, it does not
# seem to have much impact in that very case
conec = mlgraph( (inputLength,1) )
net = ffnet(conec)
train_input = [ u[1:-1] for u in train ]
target_input = [ u[-1] for u in train ]
test_input = [ u[1:-1] for u in tests ]
test_target = [ u[-1] for u in tests ]
net.train_tnc(train_input, target_input, maxfun = 1000)
# Print the name of the fruits used for test
o = net.test(test_input, test_target,iprint=0)#), iprint = 2)
res.append(float(sum([formatPrediction(u[0]) ^ int(test_target[i]) for i,u in enumerate(o[0])]))/len(test_target))
print sum(res)/len(res)
def __init__(
self, shape=None, full_conn=True, biases=True, random_weights=True, normalize=True, reduce_empty_dims=True
):
"""
shape: shape of a NN given as a tuple
"""
self.shape = shape
self.full_conn = full_conn
self.biases = biases
self.random_weights = random_weights
self.normalize = normalize
self.reduce_empty_dims = reduce_empty_dims
if self.normalize:
self.norm = StandardScaler()
self.shape = shape
if shape:
if self.full_conn:
conec = tmlgraph(self.shape, self.biases)
else:
conec = mlgraph(self.shape, self.biases)
self.model = ffnet(conec)
if random_weights:
self.model.randomweights()
def main():
conec = mlgraph((1, 4 ,1))
net = ffnet(conec)
patterns = 16
input = [[ k * 2 * pi / patterns] for k in xrange(patterns + 1)]
target = [[sin(x[0])] for x in input]
print "training"
net.train_genetic(input, target, individuals=20, generations=500)
print "simple trainig"
net.train_tnc(input, target, maxfun = 5000, messages = 1)
print "test"
output, regression = net.test(input, target, iprint = 2)
# draw it
points = 128
xaxis = [[ k * 2 * pi / patterns] for k in xrange(patterns + 1)]
sine = [sin(x) for x in xaxis]
cosine = [cos(x) for x in xaxis]
netsine = [net([x])[0] for x in xaxis]
netcosine = [net.derivative([x])[0][0] for x in xaxis]
subplot(211)
plot(xaxis, sine, 'b--', xaxis, netsine, 'k-')
legend(('sine', 'network output'))
grid(True)
title('Outputs of trained network.')
subplot(212)
plot(xaxis, cosine, 'b--', xaxis, netcosine, 'k-')
legend(('cosine', 'network derivative'))
grid(True)
show()
return 0
def main():
""" load training data"""
inputs = np.loadtxt("../handwriting/X2_100samples.dat")
targets = np.loadtxt("../handwriting/y2_100samples.dat")
ValInputs, ValTargets = get_validation_data()
""" define network topology """
conec = mlgraph((inputs.shape[1],10,1))
net = ffnet(conec)
system = NNSystem(net, inputs, targets)
pot = system.get_potential()
database = system.create_database(db="/home/ab2111/machine_learning_landscapes/neural_net/db_ffnet_100samples.sqlite")
# database = system.create_database(db="/home/ab2111/machine_learning_landscapes/neural_net/db_ffnet_me3.sqlite")
# run_gui(system, database)
# check_its_a_minimum(system, database)
energies = np.array([])
for m in database.minima():
coords = m.coords
testenergy = pot.getValidationEnergy(coords,ValInputs,ValTargets)/len(ValTargets)
energies = np.append(energies,testenergy)
# plt.plot(m.coords,'o')
# np.max(m.coords)
# plt.plot([m._id for m in database.minima()], np.array([m.energy for m in database.minima()])/100., 'o')
plt.plot(np.array([m.energy for m in database.minima()])/100)
plt.plot(energies)
plt.plot(np.array([np.max(m.coords) for m in database.minima()])/1000, 'x')
plt.legend(["Etrain","Evalidation","max(params)"])
plt.show()
def _train2(X, Y, filename, epochs=50):
global nn
conec = mlgraph((INPUT_SIZE, HIDDEN_LAYERS, OUTPUT_LAYER))
nn = ffnet(conec)
nn.train_momentum(X, Y, eta=0.001, momentum=0.8, maxiter=epochs, disp=True)
def ANN_gapfill_func(myBaseforResults,New_combined,Site_ID,list_in,list_out,iterations,index_str,is_this_all,ANN_label_all,ANN_label,frequency,Use_Fc_Storage):
###########################################################################################################
## START MAIN CODE
###########################################################################################################
if 'Fc' in list_out:
units="umol.m-2.s-1"
elif ('Fe' or 'Fh' or 'Fg') in list_out:
units="W.m-2"
else:
units=" "
###### User-set IO file locations ######
print "Starting ANN gap filling"
#Check for place to put results - does it exist? If not create
if not os.path.isdir(myBaseforResults):
os.mkdir(myBaseforResults)
#Then subdirectories
if not os.path.isdir(myBaseforResults+"/ANN"):
os.mkdir(myBaseforResults+"/ANN")
mypathforResults=myBaseforResults+"/ANN"
#We need to update VPD for input here so also need e and es
# Calculate vapour pressure from absolute humidity and temperature
# Ah - absolute humidity, g/m3
# Ta - air temperature, C
New_combined['VPD_Con']=(metfuncs.es(New_combined['Ta_Con']))-(metfuncs.vapourpressure(New_combined['Ah_Con'],New_combined['Ta_Con']))
number_of_inputs=len(list_in)
number_of_outputs=len(list_out)
#startdate=dt.date(2008,7,1)
#enddate=dt.date(2008,8,1)
alllist=list_in + list_out
xnow=New_combined[alllist] #[startdate:enddate]
xnow=xnow.dropna(how='any')
#Drop nans and missing values so that Good data only is used in the training
xarray=np.array(xnow.dropna().reset_index(drop=True))
#Define inputs and targets for NN from DF
inputs = xarray[:, :number_of_inputs] #first 2 columns
lastcolums=(-1*number_of_outputs)
targets = xarray[:, lastcolums:] #last column
# Generate standard layered network architecture and create network
#different network architectures avaiable
#conec = mlgraph((number_of_inputs,24,16,number_of_outputs)) # Creates standard multilayer network architecture
conec = tmlgraph((number_of_inputs,24,16,number_of_outputs)) # Creates multilayer network full connectivity list
#conec = imlgraph((number_of_inputs,24,16,number_of_outputs)) # Creates multilayer architecture with independent outputs
net = ffnet(conec)
print "TRAINING NETWORK..."
net.train_tnc(inputs, targets, maxfun = iterations, messages=1)
#net.train_rprop(inputs, targets, maxiter=iterations)
#net.train_momentum(inputs, targets, maxfun = iterations, messages=1)
#net.train_genetic(inputs, targets, maxfun = iterations, messages=1)
#net.train_cg(inputs, targets, maxfun = iterations, messages=1)
#net.train_bfgs(inputs, targets, maxfun = iterations, messages=1)
# Test network
print "TESTING NETWORK..."
output, regression = net.test(inputs, targets, iprint = 0)
print "R-squared: %s " %str(regression[0][2])
#print "max. absolute error: %s " %str(abs( array(output).reshape( len(output) ) - array(targets) ).max())
output, regress = net.test(inputs, targets)
#Create array for results. Then loop through elements on the original data to predict the ANN value
predicted=np.empty((len(xarray),number_of_outputs))
observed=np.empty((len(xarray),number_of_outputs))
for index,rowdata in enumerate(xarray):
predicted[index]=net([rowdata[0:number_of_inputs]])
observed[index]=np.array(rowdata[-1.0*number_of_outputs : ])
#observed[index]=np.array(rowdata[(-1.0*number_of_outputs)])
############################################
# Generate output and return new variables
############################################
#Create a new variable called '_NN'
for index, item in enumerate(list_out):
ANN_label=str(item+"_NN")
ANN_label_all=str(item+"_NN_all")
if is_this_all == True:
New_combined[ANN_label_all]=net.call(New_combined[list_in])[:,index]
else:
New_combined[ANN_label]=net.call(New_combined[list_in])[:,index]
for index, item in enumerate(list_out):
#####################################################
# Plots
#####################################################
#Plot time series of all 30 minute data
mintimeseries_plot(mypathforResults,predicted,observed,regress,item, Site_ID,units,targets,output,list_out,index_str)
#Plot regression of Tower versus ANN
regressionANN2(mypathforResults,predicted,observed,regress,item, Site_ID,units,list_out,index_str)
#Plot diurnals for every second month 6 graphs - only when enough months so all or annual
if frequency=="all" or frequency=="annual" or is_this_all==True:
Doplots_diurnal_monthly(mypathforResults,New_combined,item, Site_ID,units,list_out,index_str,is_this_all)
#Plot diurnals for every second month 6 graphs
Doplots_diurnal(mypathforResults,New_combined,item, Site_ID,units,list_out,index_str,frequency)
#Plot timeseries of monthly over all periods
Doplots_monthly(mypathforResults,New_combined,item, Site_ID,units,list_out,index_str,frequency)
return New_combined
from ffnet import ffnet
from math import pi, sin, cos
# Let's define network connectivity by hand:
conec = [(1, 2), (1, 3), (1, 4), (1, 5), (2, 6), (3, 6), (4, 6), (5, 6), \
(0, 2), (0, 3), (0, 4), (0, 5), (0, 6)]
# Note 1: Biases in ffnet are handled as the connections
# from special node numbered 0. Input nodes cannot be biased.
# Note 2: Node numbering and order of links in conec is meaningless,
# but the connections have to be from source to target.
# Note 3: The same connectivity can be obtained using mlgraph function
# provided with ffnet (layered architecture (1,4,1)).
# Network creation
net = ffnet(conec)
# Generation of training data (sine values for x from 0 to 2*pi)
patterns = 16
input = [[0.]] + [[k * 2 * pi / patterns] for k in xrange(1, patterns + 1)]
target = [[sin(x[0])] for x in input]
# Training network
#first find good starting point with genetic algorithm (not necessary, but may be helpful)
print "FINDING STARTING WEIGHTS WITH GENETIC ALGORITHM..."
net.train_genetic(input, target, individuals=20, generations=500)
#then train with scipy tnc optimizer
print "TRAINING NETWORK..."
net.train_tnc(input, target, maxfun=5000, messages=1)
# Testing network
# a = np.concatenate((np.ones(1).T, np.array(x)), axis=1)
a = np.concatenate((np.ones(1).T, x), axis=1)
for l in xrange(0, len(theta) - 1):
a = sigmoid(np.dot(a, theta[l]))
# print sum(a[a == 1])
# if sum(a[a == 1]) > 0: raise ValueError('predict warning 1')
a = np.dot(a, theta[l + 1])
# if a[0] == 1.0: raise ValueError('predict warning 2')
# print a[0]
# if a[0] > 10**11 or a[0] < -10**11:
# print('warning!')
return a[0]
conec = fn.mlgraph((64, 40, 20, 1))
net = fn.ffnet(conec)
def predict3(weights, x):
net.weights = weights
s = net.call(x)
# print(s)
# assert s != 1
return s
if __name__ == '__main__':
# a = list(np.matrix('[1,2;3,4]').T)
# b = list(np.matrix('[1,3;4,5]').T)
def __init__(self, con=(2,2,1)):
self.network = ffnet(mlgraph(con))
from ffnet import ffnet, mlgraph from math import pi, sin, cos # Let's define network connectivity by hand: # conec = [(1, 2), (1, 3), (1, 4), (1, 5), (2, 6), (3, 6), (4, 6), (5, 6), \ # (0, 2), (0, 3), (0, 4), (0, 5), (0, 6)] # Note 1: Biases in ffnet are handled as the connections # from special node numbered 0. Input nodes cannot be biased. # Note 2: Node numbering and order of links in conec is meaningless, # but the connections have to be from source to target. # Note 3: The same connectivity can be obtained using mlgraph function # provided with ffnet (layered architecture (1,4,1)). # Network creation net = ffnet(mlgraph((1, 4, 1))) # Generation of training data (sine values for x from 0 to 2*pi) patterns = 16 input = [ [ 0. ] ] + [ [ k * 2 * pi / patterns ] for k in xrange(1, patterns + 1) ] target = [ [ sin(x[0]) ] for x in input ] # Training network # first find good starting point with genetic algorithm (not necessary, but may be helpful) print "FINDING STARTING WEIGHTS WITH GENETIC ALGORITHM..." net.train_genetic(input, target, individuals=20, generations=500) # then train with scipy tnc optimizer print "TRAINING NETWORK..." net.train_tnc(input, target, maxfun=5000, messages=1) # Testing network
def createNNetwork(design):
conec = mlgraph(design)
return ffnet(conec)
def train_ANN(inputs_array, target_array, iterations, node_architecture,
**configs_dict):
# Same first dimension?
if not inputs_array.shape[0] == target_array.shape[0]:
raise Exception('Input and target arrays must have same first ' \
'dimension!')
# Specified number of input nodes matches second dim of input array?
n_input_nodes = node_architecture[0]
if len(inputs_array.shape) == 1:
sec_dim_inputs = 1
else:
sec_dim_inputs = inputs_array.shape[1]
if not n_input_nodes == sec_dim_inputs:
raise Exception('Specified input node architecture (n = %s) ' \
'incompatible with passed input arrays... Returning!'
%str(n_input_nodes))
# Specified number of target nodes matches second dim of target array?
n_target_nodes = node_architecture[-1]
if len(target_array.shape) == 1:
sec_dim_target = 1
else:
sec_dim_target = target_array.shape[1]
if not n_target_nodes == sec_dim_target:
raise Exception('Specified target node architecture (n = %s) ' \
'incompatible with passed input arrays... Returning!'
%str(n_target_nodes))
# Missing data in inputs array? (Warning only)
if np.isnan(inputs_array).any():
missing_inputs_flag = True
warnings.warn('Specified ANN training input variables contain missing ' \
'data. NaNs will be inserted into prediction series!')
else:
missing_inputs_flag = False
# Missing data in target array? (Warning only)
if np.isnan(target_array).any():
missing_target_flag = True
warnings.warn('Specified ANN training target variables contain missing ' \
'data. These will be removed for training!')
else:
missing_target_flag = False
# Check if saving trained network
save_flag = False
if 'save_network' in configs_dict.keys():
if configs_dict['save_network']:
save_flag = True
if not 'network_filepath' in configs_dict.keys():
raise Exception('You must specify a file path if you wish to ' \
'save a new network!')
else:
split_pathname_list = os.path.split(
configs_dict['network_filepath'])
if not os.path.isdir(split_pathname_list[0]):
raise Exception('The specified file path is not valid!')
if split_pathname_list[1] == '':
print 'Filename not supplied - using this_net.ann!'
configs_dict['network_filepath'] = os.path.join(
split_pathname_list[0], 'this_net.ann')
# Check if doing testing
test_flag = False
if 'test' in configs_dict:
if configs_dict['test']:
test_flag = True
# Create a second series with nans dropped
if missing_inputs_flag or missing_target_flag:
new_array = np.empty(
[inputs_array.shape[0], sec_dim_inputs + sec_dim_target])
new_array[:, :sec_dim_target] = target_array
new_array[:, sec_dim_target:] = inputs_array
new_array = new_array[~np.isnan(new_array).any(axis=1)]
clean_target_array = new_array[:, :sec_dim_target]
clean_inputs_array = new_array[:, sec_dim_target:]
# Generate network and train
conec = tmlgraph(node_architecture)
net = ffnet(conec)
net.train_tnc(clean_inputs_array,
clean_target_array,
maxfun=iterations,
messages=1)
# Save network if requested
if save_flag:
ffnet_class.savenet(net, configs_dict['network_filepath'])
# Generate full series from inputs
predict_array = net.call(inputs_array)
# Do testing if requested
if test_flag:
vars_list = [
'slope', 'intercept', 'r-value', 'p-value', 'slope stderr',
'estim. stderr'
]
valid_predict_array, stats_list = net.test(clean_inputs_array,
clean_target_array)
stats_dict = {var: stats_list[0][i] for i, var in enumerate(vars_list)}
return predict_array, stats_dict
else:
return predict_array
def __init__(self, nnStructure):
self.nnStructure = nnStructure
conec = mlgraph(nnStructure)
self.network = ffnet(conec)
def calculate_network(input_, target_, test_input, test_output, net1):
network, output, regression, error = single_network(input_, target_, test_input, test_output, net1)
for i in range(4):
network1, output1, regression1, error1 = single_network(input_, target_, test_input, test_output, net1)
if (error1 < error):
network = network
output = output1
regression = regression1
error = error1
return network, output, regression, error
CONEC = tmlgraph((54, 10, 24)) # model of connections
NET = ffnet(CONEC)
# NX.draw_graphviz(net.graph, prog='dot') show the network that's nice!
# pl.show()
#
# calculate special days
summ_error = 0.0
for i in range(4):
net = ffnet(CONEC) # year have 52 weeks so, we have 52 special days in year
network, output, regression, error = calculate_network(
LEARNING_SPECIALIST[i][:-52],
LEARNING_SPECIALIST_OUTPUT[i][:-52],
LEARNING_SPECIALIST[i][-52:],
LEARNING_SPECIALIST_OUTPUT[i][-52:], net)
summ_error += error
def fit(self, training_set, training_target):
self.feature_size = training_set.shape[1]
hidden_layer_size = self.hidden_node
connection_tuple = (self.feature_size, hidden_layer_size, 1)
self.nn = ffnet(mlgraph(connection_tuple))
self.nn.train_momentum(training_set, training_target)
result.append(float(l[i]))
train_x.append(result)
print "FINISH READING TRAIN FILE"
with open("para_test.txt") as f:
for l in f:
l = l.strip().split()
result = []
for i in range(len(l)):
result.append(float(l[i]))
test_x.append(result)
print "FINISH READING TEST FILE"
#train_x = train_x[:5]
#test_x = test_x[:5]
#train_y = train_y[:5]
#test_y = test_y[:5]
c = ffnet.ffnet(ffnet.mlgraph((len(train_x[0]), 50, 1)))
print "TRAINING....",
c.train_tnc(train_x, train_y, messages=1, nproc='ncpu', maxfun=1000)
print "OK"
print "TESTING....",
wrong = 0
for i in range(len(test_y)):
result = c.call(test_x[i]).tolist()[0]
if result >= 0.5:
result = 1.0
else:
result = 0.0
if result != test_y[i]:
wrong += 1
print "OK"
print float(wrong) / float(len(test_y))
if (headerskipped):
line = line.split(',')
last = len(line) - 1
instr = line[0:last]
inline = []
for j in range(len(instr)):
x = float(instr[j])
input[i, j] = x
target[i, 0] = float(line[last].strip())
i += 1
else:
headerskipped = True
f.close()
return input, target
input, target = readin(infile, inrownum)
testin, testtarget = readin(testfile, testrownum)
connections = mlgraph((inputnum, 100, 1))
net = ffnet(connections)
print('training net...')
#net.train_momentum(input, target, eta=0.5, momentum=.1)
net.train_tnc(input, target)
print('testing net...')
output, regression = net.test(testin, testtarget, iprint=2)
print(output)
print(regression)
nx.draw_networkx_nodes(G, pos, cmap=color_map, node_color=node_colorss, vmin=0, vmax=1.0)
def deserialize(data, used_activation=None):
arguments = data['arguments']
if used_activation is None:
used_activation = getattr(ActivationFunctions, data['activation_function'])
nn = ffnet(*arguments)
for index, layer in enumerate(data['layers']):
for p_index, perceptron in enumerate(nn.layers[index]):
perceptron.weights = layer[p_index]
return nn
def serialize(nn):
serialized_nn = {'arguments': nn.arguments}
weights = []
for layer in nn.layers:
layer_weights = []
for perceptron in layer:
layer_weights.append(perceptron.weights)
weights.append(layer_weights)
serialized_nn['layers'] = weights
serialized_nn['activation_function'] = nn.activation_function.__name__
return serialized_nn
if __name__ == '__main__':
args = [[10, 3, 10], ActivationFunctions.tanh]
nn = ffnet(*args)
draw_ffnet(nn)
plt.show()
from ffnet import ffnet, mlgraph, readdata
import numpy as np
import sys
def readfile( fname ):
lines = open( fname ).readlines()[1:]
vec = [ map( float, x.split(',')[0:-1] ) for x in lines ]
clas = [ x.split(',')[-1] for x in lines ]
output = [ [1,0,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0,0],
[0,0,1,0,0,0,0,0,0],
[0,0,0,1,0,0,0,0,0],
[0,0,0,0,1,0,0,0,0],
[0,0,0,0,0,1,0,0,0],
[0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1,0],
[0,0,0,0,0,0,0,0,1] ]
return vec, [ output[int(x.split('_')[-1])-1] for x in\
clas ]
if __name__ == '__main__':
conec = mlgraph((94,30,30,9))
net = ffnet(conec)
tra, out = readfile( sys.argv[1] )
tra = np.array(tra)
out = np.array(out)
net.train_tnc( tra, out, maxfun=2000, messages=1 )
def Fre_ANN_gapfill_func(myBaseforResults,New_combined,Site_ID,list_in,list_out,iterations,latitude,longitude,index_str,ANN_label,frequency,evening,min_threshold,max_threshold,Ustar_filter_type):
if 'Fc' in list_out:
units="umol.m-2.s-1"
elif ('Fe' or 'Fh' or 'Fg') in list_out:
units="W.m-2"
else:
units=" "
###### User-set IO file locations ######
print "Starting ANN gap filling"
#Check for place to put results - does it exist? If not create
if not os.path.isdir(myBaseforResults):
os.mkdir(myBaseforResults)
#Then subdirectories
if not os.path.isdir(myBaseforResults+"/ANN"):
os.mkdir(myBaseforResults+"/ANN")
mypathforResults=myBaseforResults+"/ANN"
if not os.path.isdir(myBaseforResults+"/ANN/Fre"):
os.mkdir(myBaseforResults+"/ANN/Fre")
mypathforResults=myBaseforResults+"/ANN/Fre"
#We need to update VPD for input here so also need e and es
# Calculate vapour pressure from absolute humidity and temperature
# Ah - absolute humidity, g/m3
# Ta - air temperature, C
number_of_inputs=len(list_in)
number_of_outputs=len(list_out)
#startdate=dt.date(2008,7,1)
#enddate=dt.date(2008,8,1)
alllist=list_in + list_out
#Here now for Re we can further restrict the traing data to be noctural and ustar filtered
#So first create a series with day_night based on solar geometry
#Get timezone info, call routines from external code
global timezone
currentdate="2013-06-01"
timezone,InDstNow=TimeZone.get_timezone_info(latitude,longitude,currentdate)
print "AskGEO TimZone offset (hrs): ", timezone
#Start with blank series
New_combined['day_night']=np.nan
def day_night(x):
#Get date from data group
currentdate= x.index[0]
currentyear= x.index[0].year
currentmonth= x.index[0].month
currentday= x.index[0].day
basedate=dt.datetime(1900, 1, 1,0,0,0,0)
delta=(currentdate-basedate).days
#Calculate Approximate Solar noon, call routines from external code
#Call Solar_Calcs.solar_calculations(Date_input_excel,latitude,longitude,timezone)
solar_sunrise,solar_noon_for_date,solar_sunset =Solar_Calcs.solar_calculations(delta,latitude,longitude,timezone)
#return a fraction. Convert to decimal hours
solar_sunrise=solar_sunrise*24
solar_sunset=solar_sunset*24
daystart_hour= int(solar_sunrise)
daystart_minute=int((solar_sunrise-daystart_hour)*60)
daystart_dt=dt.datetime(currentyear,currentmonth,currentday,daystart_hour,daystart_minute,0)
dayend_hour= int(solar_sunset)
dayend_minute=int((solar_sunset-dayend_hour)*60)
dayend_dt=dt.datetime(currentyear,currentmonth,currentday,dayend_hour,dayend_minute,0)
x['day_night'][daystart_dt:dayend_dt]=1
#Define evening as 3 hours after sunset. Needed for van Gorsel approach
d=dt.timedelta(hours=3)
eveningend_dt=dayend_dt+d
x['day_night'][dayend_dt:eveningend_dt]=2
#Else fill remainder with night
x['day_night'][x['day_night'].isnull()]=3
#print x
#print x[dayend_dt:eveningend_dt]
#print solar_sunset
#print daystart_dt
#print dayend_dt
#print eveningend_dt
return x
#For each day of each year run the function to calculate day or night
New_combined=New_combined.groupby([lambda x: x.year,lambda x: x.month,lambda x: x.day]).apply(day_night)
#New_combined.to_csv(myBaseforResults+'/'+'Final_combined_'+Site_ID+'.csv', sep=',')
###############################
#Define the data to select
###############################
#Can select period of 'night' (2) and or 'evening' (3)
if evening==True:
xnow=New_combined[(New_combined['day_night']==3)]
else:
xnow=New_combined[(New_combined['day_night']==2)]
# Use the actual ustar_used column which is defined from the type of ustar thershold approach chosen in the config
xnow=xnow[xnow['ustar']>xnow['ustar_used']]
#Remove -ve and +ve spikes which are uptake and inconsistent with Fre.
xnow=xnow[xnow['Fc']>min_threshold][xnow['Fc']<max_threshold]
xnow=xnow[alllist]
#Drop nans and missing values so that Good data only is used in the training
xnow=xnow.dropna(how='any')
xarray=np.array(xnow.dropna().reset_index(drop=True))
#Define inputs and targets for NN from DF
inputs = xarray[:, :number_of_inputs] #first 2 columns
lastcolums=(-1*number_of_outputs)
targets = xarray[:, lastcolums:] #last column
# Generate standard layered network architecture and create network
#different network architectures avaiable
#conec = mlgraph((number_of_inputs,24,16,number_of_outputs)) # Creates standard multilayer network architecture
conec = tmlgraph((number_of_inputs,6,4,number_of_outputs)) # Creates multilayer network full connectivity list
#conec = imlgraph((number_of_inputs,24,16,number_of_outputs)) # Creates multilayer architecture with independent outputs
net = ffnet(conec)
print "TRAINING NETWORK..."
#net.train_tnc(inputs, targets, maxfun = iterations, messages=1)
try:
net.train_rprop(inputs, targets, maxiter=iterations)
except:
net.train_tnc(inputs, targets, maxfun = iterations, messages=1)
#net.train_momentum(inputs, targets, maxfun = iterations, messages=1)
#net.train_genetic(inputs, targets, maxfun = iterations, messages=1)
#net.train_cg(inputs, targets, maxfun = iterations, messages=1)
#net.train_bfgs(inputs, targets, maxfun = iterations, messages=1)
# Test network
print "TESTING NETWORK..."
output, regression = net.test(inputs, targets, iprint = 0)
print "R-squared: %s " %str(regression[0][2])
#print "max. absolute error: %s " %str(abs( array(output).reshape( len(output) ) - array(targets) ).max())
output, regress = net.test(inputs, targets)
#Create array for results. Then loop through elements on the original data to predict the ANN value
predicted=np.empty((len(xarray),number_of_outputs))
observed=np.empty((len(xarray),number_of_outputs))
for index,rowdata in enumerate(xarray):
predicted[index]=net([rowdata[0:number_of_inputs]])
observed[index]=np.array(rowdata[(-1.0*number_of_outputs)])
############################################
# Generate output and return new variables
############################################
for index, item in enumerate(list_out):
New_combined[ANN_label]=net.call(New_combined[list_in])[:,index]
#TEST
#New_combined.to_csv("E:/My Dropbox/Dropbox/Data_flux_data/Site data processing/HowardSprings/Advanced/test_assertion.csv")
#####################################################
# Plots
#####################################################
#Plot time series of all 30 minute data
mintimeseries_plot(mypathforResults,predicted,observed,regress,item, Site_ID,units,targets,output,ANN_label,index_str)
#Plot regression of Tower versus ANN
regressionANN2(mypathforResults,predicted,observed,regress,item, Site_ID,units,ANN_label,index_str)
#Plot diurnals for every second month 6 graphs
Doplots_diurnal(mypathforResults,New_combined,item, Site_ID,units,ANN_label,index_str)
#Plot diurnals for every second month 6 graphs
if frequency=="all" or frequency=="annual":
Doplots_diurnal_monthly(mypathforResults,New_combined,item, Site_ID,units,ANN_label,index_str)
#Plot timeseries of monthly over all periods
Doplots_monthly(mypathforResults,New_combined,item, Site_ID,units,ANN_label,index_str)
###################################################
# File stuff
###################################################
return (New_combined)
