def __init__(self, fps, timeout):
self.fps = fps
self.controller = Leap.Controller()
self.timeout = timeout
self.data = m.Sequence()
self.raw_data = m.Sequence()
self.frames = []
self.timeout_start = None
self.previous_palm_position = None
self.done_reading = False
def read_data_from_leap(self):
self.done_reading = False
self.data = m.Sequence()
self.raw_data = m.Sequence()
self.frames = []
while len(self.frames) < self.fps * self.timeout:
self.read()
time.sleep(1.0 / self.fps)
for frame in self.frames:
self.compute_frame(frame)
self.done_reading = True
return self.data, self.raw_data
def SEQUENCE(self, ast):
if not ast.terms:
return model.Empty()
elif len(ast.terms) < 2:
return ast.terms[0]
else:
return model.Sequence(ast.terms)
def makeNewSeq(self):
seq, ok = QtGui.QInputDialog.getText(self, "QInputDialog.getText()",
"Sequence name:", QtGui.QLineEdit.Normal,"")
if ok and len(str(seq)) == 2:
#self.textLabel.setText(text)
print
newseq = model.Sequence(Name= unicode(string.upper(str(seq))))
self.ui.SequComboBox.addItem(string.upper(str(seq)))
self.curProject.Seqs.append(newseq)
model.saveData()
def load_file(self, file_name):
classified_sequence_list = []
with open('../data/' + file_name + '.json') as f:
data = json.load(f)
for classified_sequence in data:
gesture_code = classified_sequence['gesture']
seq = classified_sequence['sequence']
sequence = m.Sequence()
gesture = m.Gesture.gesture_from_code(gesture_code)
for vector in seq:
sequence.add_data(m.DiscretizedHandModel(m.HandModel(None, None, vector)))
classified_sequence_list.append(m.ClassifiedSequence(sequence, gesture))
return classified_sequence_list
def load_raw_data(self, file_name):
classified_sequence_list = []
with open("../data/raw/" + file_name + ".data", "rb") as data_file:
for j in range(0, 16):
frame_list = []
for i in range(0, 60):
next_block_size = data_file.read(4)
size = struct.unpack('i', next_block_size)[0]
data = data_file.read(size)
leap_byte_array = Leap.byte_array(size)
address = leap_byte_array.cast().__long__()
ctypes.memmove(address, data, size)
frame = Leap.Frame()
frame.deserialize((leap_byte_array, size))
frame_list.append(frame)
code = struct.unpack('i', data_file.read(4))[0]
classified_sequence_list.append(
m.ClassifiedSequence(m.Sequence().load_data(frame_list), m.Gesture.gesture_from_code(code)))
return classified_sequence_list
conn = sqlite3.connect(args.file_db)
# Création de la fabrique
factory = FactoryRDF.FactoryRDF()
factory.open(True)
#region Sequence
query = open('./SQL/sequence.sql', 'r').read()
cursor = conn.cursor()
cursor.execute(query)
records = cursor.fetchall()
for row in records:
factory.addSequence(model.Sequence(row[0], row[2], row[3], row[1], row[4]))
cursor.close()
#endregion
#region Drug Delivery
query = open('./SQL/drug_delivery.sql', 'r').read()
cursor = conn.cursor()
cursor.execute(query)
records = cursor.fetchall()
for row in records:
factory.addEventDrugDelivery(
model.Event(str(row[0]), model.Pharmacy(str(row[5])),
model.DrugDelevery(str(row[3]), row[4]), row[1], row[2]))
def main():
matplotlib.use('Agg')
parser = argparse.ArgumentParser(description='SMFS Event Detect')
parser.add_argument('--datafolder',
default="./input",
type=str,
help='folder for data (.np) files')
parser.add_argument('--modelfile',
default="./report/model-latest.pt",
type=str,
help='folder for model (.pt) files')
parser.add_argument('--cuda',
metavar='1 or 0',
default=0 if torch.cuda.is_available() else 0,
type=int,
help='use cuda')
parser.add_argument(
'--train',
default=1,
type=int,
help='set 1 to train the model, set 0 to test the trained model')
parser.add_argument('--predict_size',
default=300,
type=int,
help='predict_size for predicting')
parser.add_argument('--minibatches_per_step',
default=10,
type=int,
help='minibatches_per_step for training')
parser.add_argument('--minibatch_size',
default=300,
type=int,
help='minibatch_size for training')
parser.add_argument('--epoch',
default=30,
type=int,
help='epochs for training')
parser.add_argument('--learning_rate',
default=0.001,
type=float,
help='learning_rate for training')
parser.add_argument('--data_split',
default="0,1.0",
type=str,
help='data_split for truncating dataset')
parser.add_argument('--data_kept',
default="0,0",
type=str,
help='data_kept for truncating dataset')
parser.add_argument(
'--source_scale',
default="400, 50",
type=str,
help=
'source_scale in nm and pN for transforming input signals in the dataset'
)
parser.add_argument(
'--source_bias',
default="-1.6, -1.5",
type=str,
help=
'source_bias after applying source_scale for transforming input signals in the dataset'
)
parser.add_argument(
'--downsampling',
default=1,
type=int,
help='perform downsampling using averaging filter on input data')
parser.add_argument(
'--noiselevel',
default="0,0",
type=str,
help='add extra Gaussian noise (level in nm and pN) into input dataset'
)
parser.add_argument('--report',
default="./report/",
type=str,
help='folder for saving repots')
parser.add_argument('--report_note',
default="train",
type=str,
help='add prefix to each report file')
args = parser.parse_args()
device = torch.device('cuda' if args.cuda else 'cpu')
print(device)
data_split = [float(item) for item in args.data_split.split(',')]
source_scale = [float(item) for item in args.source_scale.split(',')]
source_bias = [float(item) for item in args.source_bias.split(',')]
data_kept = [int(item) for item in args.data_kept.split(',')]
if args.cuda == 0:
print("WARNING: run in debugging mode")
args.epoch = 0
if not args.train:
args.report_note = "test"
args.epoch = 1
args.report = args.report
noiselevel = [float(item) for item in args.noiselevel.split(',')]
print("using noise level " + str(noiselevel))
spLoader = SpectrumLoader(datafolder=args.datafolder,
recpetive_field=model.receptive_field,
filename_suffix="",
AWGN=noiselevel,
downsampling=args.downsampling,
source_scale=source_scale,
source_bias=source_bias,
data_split=data_split,
data_kept=data_kept)
print("DataSet Size: %d" % spLoader.size)
total_steps_per_epoch = (
spLoader.size + args.minibatches_per_step) // args.minibatches_per_step
print("total_steps_per_epoch: %d" % total_steps_per_epoch)
seq_predictor = model.Sequence(2).to(device)
if not args.train:
seq_predictor.load_state_dict(
torch.load(args.modelfile, map_location=device))
seq_predictor.eval()
print("loading trained model")
if args.cuda == 0:
from torchsummary import summary
summary(seq_predictor, (2, 224))
seq_predictor.double()
bcecriterion = nn.BCELoss()
msecriterion = nn.L1Loss()
if args.train:
optimizer = optim.Adam(seq_predictor.parameters(),
lr=args.learning_rate) # , momentum=0.9
best_metric_epoch = Metric()
best_epoch_id = 0
for epoch in range(args.epoch):
metric_epoch = Metric()
spLoader.reset(randomize=True)
for step in range(total_steps_per_epoch):
if args.train:
optimizer.zero_grad()
total_loss = 0
total_mse_loss = 0
for _ in range(args.minibatches_per_step):
source_minibatch, target_regress, target_invreg, _ = spLoader.get_samples(
device=device, sample_per_file=args.minibatch_size)
predict_invreg, predict_regressor = seq_predictor(
source_minibatch)
lossmse = msecriterion(predict_regressor, target_regress) * 0.5
lossmse_inv = msecriterion(predict_invreg, target_invreg) * 0.5
enable = (abs(predict_regressor - 0.5) +
abs(predict_invreg - 0.5))
with torch.no_grad():
metric_epoch.update(enable, target_regress,
predict_regressor)
loss = lossmse + lossmse_inv
total_loss += float(loss.item())
total_mse_loss += float(lossmse.item())
if args.train:
loss /= args.minibatches_per_step
loss.backward(retain_graph=True)
if args.train:
optimizer.step()
report_man.progress_bar(
step, total_steps_per_epoch,
args.report_note + " Epoch: %d | Loss: %.6f/%.6f | " %
(epoch, total_loss, total_mse_loss) + str(metric_epoch))
print("FINAL: " + args.report_note + " | Epoch: %d | total metric " %
(epoch) + str(metric_epoch))
if metric_epoch.get_score(F1_only=True) >= best_metric_epoch.get_score(
F1_only=True):
best_metric_epoch = metric_epoch
best_epoch_id = epoch
with torch.no_grad():
if not args.train:
print("No checkpointing to prevent trouble.")
else:
if epoch % 10 == 0:
print("Checkpoint ... | Epoch: %d" % (epoch))
torch.save(
seq_predictor.state_dict(),
report_man.get_report_folder(args.report) +
'model%d.pt' % epoch)
with open(
report_man.get_report_folder(args.report) + args.report_note +
".log", "a") as logfile:
import sys
logfile.write(' '.join(sys.argv) + "\n")
logfile.write('at {}: {}\n'.format(best_epoch_id,
str(best_metric_epoch)))
if args.train:
torch.save(seq_predictor.state_dict(), args.modelfile)
else:
predict_on_single(args, spLoader, device, seq_predictor, noiselevel)
with open(
report_man.get_report_folder(args.report) + args.report_note +
".log", "r") as logfile:
print(logfile.read())
import model
import layer
import optimizers
import pickle
import util
import numpy
import matplotlib.pyplot as plt
train_set, val_set, test_set = pickle.load(open("mnist.pkl", "rb"),
encoding='latin1')
model = model.Sequence()
model.add(layer.Dense(300, input_dim=28 * 28, activation="Relu"))
#model.add(layer.Dense(300, activation="Relu"))
model.add(layer.Dense(10))
train_y = util.to_categorical(train_set[1])
idx = numpy.random.choice(train_set[0].shape[0], 50000)
train_set = train_set[0][idx]
train_y = train_y[idx]
model.init()
model.fit(input_data=train_set, output_data=train_y, epoch=500, batch_num=10)
model.compile(optimizer=optimizers.SGD(model, 0.1), loss="Mean_squared_error")
model.train()
id = 0
rightnum = 0
for now in val_set[0]:
# plt.imshow(numpy.reshape(now,(28,28)))
# plt.show()
for filename in file_names:
file = open("../train/" + filename + ".txt", "r")
raw_data[filename] = []
for line in file:
raw_data[filename].append(map(float, line.split()))
file_y = open("../train/y_train.txt", "r")
gestures = []
for line in file_y:
gestures.append(int(line))
classified_sequence_list = []
for i in range(0, 810):
sequence = m.Sequence()
for j in range(0, 200):
model = []
for filename in file_names:
model.append(round(raw_data[filename][i][j], 3))
sequence.add_data(model)
classified_sequence_list.append(
m.ClassifiedSequence(sequence,
m.Gesture.gesture_from_code(gestures[i])))
saver = fl.Saver()
saver.add_data_to_file(classified_sequence_list, "avola_dataset_all")
for i in range(10):
saver.add_data_to_file(classified_sequence_list[i * 50:i * 50 + 50],
"2_avola_dataset" + str(i))
def p_NonAnyType_sequence(p):
"""NonAnyType : sequence "<" Type ">" Null"""
p[0] = model.Sequence(t=p[3], nullable=p[5])
