def main(train_dir='train', test_dir='test'):
print '... loading data'
train_set, test_set, classes = load_data(train_dir, test_dir)
print '... building the model'
n = nn.Net(classes)
n.add_hidden_layer(601, 300)
n.add_hidden_layer(300, 150)
n.add_hidden_layer(150, 75)
n.add_hidden_layer(75, 25)
print '... compiling the model'
n.compile_model()
current_error = 1
error = 1
# We train the network 100 times
# Each time we evaluate the results and write out the error percentage
for epoch in range(1, 20):
if error < current_error:
current_error = error
n.save()
# print '... training'
for x in train_set:
n.train_model(x[0], x[1])
print '... calculating error'
# compute zero-one loss on validation set
error = numpy.mean([n.devtest_model(x[0], x[1]) for x in test_set])
print('epoch %i, validation error %f %%' % (epoch, error * 100))
def main(train_dir='../train', test_dir='../test'):
print '... loading data'
train_set, test_set, classes = load_data(train_dir, test_dir)
print '... building the model'
n = nn.Net(learning_rate=0.00001, classes=classes, L2_reg=0.0001)
n.add_hidden_layer(1024, 1800)
n.add_hidden_layer(1800, 1200)
n.add_hidden_layer(1200, 800)
n.add_hidden_layer(800, 600)
print '... compiling the model'
n.compile_model()
current_error = 1
error = 1
# We train the network 150 times
# Each time we evaluate the results and write out the error accuracy
for epoch in range(1, 151):
if error < current_error:
current_error = error
print 'Saving matrix ...'
n.save()
print 'Save completed ...'
z = time.time()
print '... training'
for x in train_set:
n.train_model(x[0], x[1])
print 'training took {}'.format(time.time() - z)
train_set = load_train_data(train_dir, classes)
# Calulating error
print '... calculating error'
error = numpy.mean(
[n.devtest_model(x[0], classes.index(x[1])) for x in test_set])
print('epoch %i, validation error %f %%' % (epoch, error * 100))
def speaker_recognition():
global clients
global client_frame
global data_for_deep_learning
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
nn = neuralnetwork.Net()
nn.load()
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 2
RATE = 16000
p = pyaudio.PyAudio()
while True:
for i, x in enumerate(data_for_deep_learning):
if len(x) >= 20:
y = x[:]
WAVE_OUTPUT_FILENAME = "output" + str(i) + ".wav"
wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(b''.join(y))
wf.close()
person = nn.evaluate(WAVE_OUTPUT_FILENAME)
print "Evaluate..."
for c in clients:
sock.sendto(str(person), (c[0], 8765))
data_for_deep_learning[i] = []
from os import path
from os.path import isfile, join
class bcolors:
HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKGREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
print 'Creating the network'
n = nn.Net()
n.load('matrix.txt')
train_input = [
join("test", f) for f in os.listdir("test") if isfile(join("test", f))
]
print 'Evaluation'
for elem in train_input:
name = n.evaluate(elem)
print "{}\t===>\t{}\t".format(elem.split('/')[-1], name),
if name in elem:
print bcolors.OKGREEN + "OK" + bcolors.ENDC
else:
print bcolors.FAIL + "FAIL" + bcolors.ENDC
def testEvaulateInCaseOfAPersonItWasTrainedFor(self):
n = neuralnetwork.Net()
n.load('matrix.txt')
test = n.evaluate('FMEV_Sr10.wav')
self.assertEqual(test, 'FMEV')
def testNeuralNetworkCanBeInstatiatedCorrectly(self):
n = neuralnetwork.Net()
self.assertIsInstance(n, neuralnetwork.Net)
batch_size=4,
shuffle=False,
num_workers=0)
numberOfClasses = 12
numberOfAttributes = 24
#0 is heartmonitor
#1-13 is imu1
#14-26 is imu2
#27-39 is imu3
imulist = [1, 13, 13, 13]
net = neuralnetwork.Net(imulist,
sliding_window_size,
12,
gpudevice,
uncertaintyForwardPasses=100)
#training_data = neuralnetwork.shapeinputs(imulist, training_data ,gpudevice)
#validation_data = neuralnetwork.shapeinputs(imulist, validation_data ,gpudevice)
#test_data = neuralnetwork.shapeinputs(imulist, test_data ,gpudevice)
#
neuralnetwork.train(net,
training_loader,
validation_loader,
attr_representation,
"cosine",
epochs=10)
neuralnetwork.test(net, test_loader, "test", attr_representation)
def test_performance():
config = {
"pamap2" : {
'batch_size' : 50,
'sliding_window_size' : 100,
'sliding_window_step' : 22,
#Training Parameters
'epochs' : 1,
'learning_rate' : [0.0001],
'weight_decay' : [0.0001],
'momentum' : [0.7],
'loss_critereon' : [torch.nn.BCELoss()],
'optimizer' : ["RMSprop"],
#Network parameters
'kernelsize' : [(5,1)],
#Attribute Representation
'n_attributes' : 24,
'distance_metric' : ["braycurtis"],
#Uncertainty
'uncertainty_forward_passes' : 100
},
"gestures" : {
'batch_size' : 100,
'sliding_window_size' : 24,
'sliding_window_step' : 12,
#Training Parameters
'epochs' : 10,
'learning_rate' : [0.0001],
'weight_decay' : [0.00001],
'momentum' : [0.9],
'loss_critereon' : [torch.nn.BCELoss()],
'optimizer' : ["RMSprop"],
#Network parameters
'kernelsize' : [(5,1)],
#Attribute Representation
'n_attributes' : 32,
'distance_metric' : ["cosine"],
#Uncertainty
'uncertainty_forward_passes' : 100
},
"locomotion" : {
'batch_size' : 100,
'sliding_window_size' : 24,
'sliding_window_step' : 12,
#Training Parameters
'epochs' : 10,
'learning_rate' : [0.0001],
'weight_decay' : [0.00001],
'momentum' : [0.9],
'loss_critereon' : [torch.nn.BCELoss()],
'optimizer' : ["RMSprop"],
#Network parameters
'kernelsize' : [(5,1)],
#Attribute Representation
'n_attributes' : 10,
'distance_metric' : ["cosine"],
#Uncertainty
'uncertainty_forward_passes' : 100
},
'gpu_device' : torch.device("cuda:0" if torch.cuda.is_available() else "cpu"),
}
run_number = 0
data_set = ["pamap2","locomotion","gestures"]
for ds in data_set:
batch_size = config[ds]['batch_size']
training_loader,validation_loader,test_loader, imu_list, attr_rep = load_data(
ds,config['gpu_device'],batch_size,config[ds]['sliding_window_size'],config[ds]['sliding_window_step'])
for lr in config[ds]['learning_rate']:
for wd in config[ds]['weight_decay']:
for m in config[ds]['momentum']:
for ks in config[ds]['kernelsize']:
for opt in config[ds]['optimizer']:
for criterion in config[ds]['loss_critereon']:
for dist_metric in config[ds]['distance_metric']:
for i in range(10):
network = neuralnetwork.Net(imu_list,config[ds]['sliding_window_size'], config[ds]['n_attributes'],
config['gpu_device'], ks, config[ds]['uncertainty_forward_passes']).cuda(config['gpu_device'])
optimizer = get_optimiser(network, opt, lr, wd, m)
data = neuralnetwork.train(network, training_loader, validation_loader, criterion, optimizer, config[ds]['epochs'], config['gpu_device'],attr_rep,dist_metric)
config_str = "Dataset; {}; batch_size; {}; window_size; {}; window_step; {}; epochs; {}; learning_rate; {}; weight_decay; {}; momentum; {}; optimizer; {}; distance_metric; {}; uncertainty; {}".format(
ds, batch_size, config[ds]['sliding_window_size'],config[ds]['sliding_window_step'],config[ds]['epochs'],lr,wd,m,opt,dist_metric,config[ds]['uncertainty_forward_passes'])
save_run_stats("train run {}, {}".format(run_number,ds),data,config_str)
run_number += 1
results = neuralnetwork.test(network, test_loader, criterion, config['gpu_device'], attr_rep, dist_metric, False)
print(results)
def main():
config = {
'data_set' : ["pamap2","locomotion","gestures"],
#'data_set' : ["locomotion","gestures","pamap2"],
#'data_set' : ["gestures","pamap2","locomotion"],
'batch_size' : {"pamap2" : 50, "locomotion" : 100, "gestures" : 100},
'sliding_window_size' : {"pamap2" : 100, "locomotion" : 24, "gestures" : 24},
'sliding_window_step' : {"pamap2" : 22, "locomotion" : 12, "gestures" : 12},
#Training Parameters
'epochs' : 10,
'learning_rate' : [0.01,0.001,0.0001],
'weight_decay' : [0.0001,0.00001,0.000001],
'momentum' : [0.9,0.8,0.7],
'loss_critereon' : [torch.nn.BCELoss()],
'optimizer' : ["SGD","Adam","RMSprop"],
#Network parameters
'kernelsize' : [(5,1)],
'gpu_device' : torch.device("cuda:0" if torch.cuda.is_available() else "cpu"),
#Attribute Representation
'n_attributes' : {"pamap2" : 24, "locomotion" : 10, "gestures" : 32},
'distance_metric' : ["cosine","braycurtis","euclidean"],
#Uncertainty
'uncertainty_forward_passes' : 100
}
run_number = 0
#for i in range(9):
# print(current_config_str(config, i))
for ds in config['data_set']:
#for b in config['batch_size']:
batch_size = config['batch_size'][ds]
training_loader,validation_loader,test_loader, imu_list, attr_rep = load_data(
ds,config['gpu_device'],batch_size,config['sliding_window_size'][ds],config['sliding_window_step'][ds])
for lr in config['learning_rate']:
for wd in config['weight_decay']:
for m in config['momentum']:
for ks in config['kernelsize']:
for opt in config['optimizer']:
for criterion in config['loss_critereon']:
for dist_metric in config['distance_metric']:
network = neuralnetwork.Net(imu_list,config['sliding_window_size'][ds], config['n_attributes'][ds],
config['gpu_device'], ks, config['uncertainty_forward_passes']).cuda(config['gpu_device'])
optimizer = get_optimiser(network, opt, lr, wd, m)
print("Run number: {}".format(run_number))
data = neuralnetwork.train(network, training_loader, validation_loader, criterion, optimizer, config['epochs'], config['gpu_device'],attr_rep,dist_metric)
#plot_run_stats("train run {}, {}".format(run_number,ds), data, config['epochs'])
save_run_stats("train run {}, {}".format(run_number,ds),data,current_config_str(config, run_number))
run_number += 1
