def signal_handler(msg): """ Speech and button controls share the same handler here""" print "signal received", msg global progress, task, demo, n_repeats if msg.data in (10, 20, 30): task_type = msg.data / 10 if progress and not progress.finished: progress.end_game() if task != msg.data: n_repeats = 0 nrepeats_pub.publish(n_repeats) demo = myo_state2.MyoPrompt2(task_type=task_type) time.sleep(.5) demo.callback(0, 1) #mdp = pickle.load(open('../data'+str(task_type)+'/mdp.pkl')) mdp = 'dummy' args = { "give_prompt": True, "mdp": mdp, "id": "new patient", "task_type": task_type } progress = myo_state2.Progress(classifier_pkl='../data' + str(task_type) + '/state_classifier.pkl', **args) else: n_repeats += 1 nrepeats_pub.publish(n_repeats) #time.sleep(0.5) progress.reset() progress.finished = False # start tracking proress task = msg.data elif msg.data == -1: progress.pub.publish(1.0) progress.end_game() elif msg.data == 100: # "Home" command if demo is not None: demo.skip = True if progress is not None: progress.end_game() n_repeats = 0 progress = None task = None demo = None elif msg.data == -2: # skip demonstration if demo is not None: print "skipping demo..." demo.skip = True
def signal_handler(msg): logger.info('signal received...') print "signal received", msg global progress global is_running if msg.data != 1 and progress is not None: if is_running: is_running = False progress.end_game() progress = None if msg.data == 0: # There is intentional repetition of this line in both conidition statements rather than # at the top of the routine because msg.data is not always 0 or 1 is_running = False gather_samples_and_build() demo = myo_state2.MyoPrompt2() time.sleep(.5) demo.callback(0, 1) elif msg.data == 1: # practice #gather_samples_and_build() mdp = pickle.load(open('../data/mdp.pkl')) args = {"give_prompt": True, "mdp": mdp, "id": "new patient"} if progress is None: progress = myo_state2.Progress( classifier_pkl='../data/state_classifier.pkl', **args) is_running = True else: if is_running: progress.reset() progress = myo_state2.Progress( classifier_pkl='../data/state_classifier.pkl', **args) is_running = True
def signal_handler(msg): print "signal received", msg if msg.data == 0: bagFiles = glob.glob(os.path.join('../../data/work', '*.bag')) samples = len(bagFiles) print "number of training samples:", samples if samples == 0: "No data to process!" return build_classifier(samples=samples) demo = myo_state2.MyoPrompt2() demo.callback(0) elif msg.data == 1: mdp = pickle.load(open('../data/mdp.pkl')) args = {"give_prompt": True, "mdp": mdp, "id": "new patient"} progress = myo_state2.Progress( classifier_pkl='../data/state_classifier.pkl', **args)
def signal_handler(msg): print "signal received", msg global progress if msg.data != 1 and progress != 0: progress.task = progress.full_task[:] progress.start = False progress.progress = 0 if msg.data == 0: # There is intentional repetition of this line in both conidition statements rather than # at the top of the routine because msg.data is not always 0 or 1 gather_samples_and_build() demo = myo_state2.MyoPrompt2() time.sleep(.5) demo.callback(0) elif msg.data == 1: #gather_samples_and_build() mdp = pickle.load(open('../data/mdp.pkl')) args = {"give_prompt": True, "mdp": mdp, "id": "new patient"} progress = myo_state2.Progress( classifier_pkl='../data/state_classifier.pkl', **args)
def build_classifier(samples=1, nClusters=None, ID='user', used=False): if used: mdp = pickle.load(open('../data/mdp.pkl')) args = {"give_prompt": True, "mdp": mdp, "id": ID} progress = myo_state2.Progress( classifier_pkl='../data/state_classifier.pkl', **args) return for identifier in ('l', 'u'): for i in range(samples): data_i, EMG_max_i, EMG_min_i, GYRO_max_i = preprocess( os.path.join('../../data/work/', str(i)), update_extremes=True, identifier=identifier) emg_i = data_i[:, 1:9] imu_i = data_i[:, 9:] if i == 0: emg_demos = emg_i imu_demos = imu_i EMG_MAX = EMG_max_i EMG_MIN = EMG_min_i GYRO_MAX = GYRO_max_i else: imu_i_a = align_signal(imu_demos, imu_i, w=5, has_time=False) imu_demos += imu_i_a EMG_MAX += EMG_max_i EMG_MIN += EMG_min_i GYRO_MAX += GYRO_max_i n = len(imu_demos) # get average if identifier == 'l': print "\nProcessing myo on lower arm..." emg_demos_l = emg_demos imu_demos_l = imu_demos / samples EMG_MAX_l = EMG_MAX / samples EMG_MIN_l = EMG_MIN / samples GYRO_MAX_l = GYRO_MAX / samples print "EMG_MAX_l", EMG_MAX_l print "EMG_MIN_l", EMG_MIN_l print "GYRO_MAX_l", GYRO_MAX_l print "# data points", len(imu_demos_l) else: print "\nProcessing myo on upper arm..." emg_demos_u = emg_demos imu_demos_u = imu_demos / samples EMG_MAX_u = EMG_MAX / samples EMG_MIN_u = EMG_MIN / samples GYRO_MAX_u = GYRO_MAX / samples print "EMG_MAX_u", EMG_MAX_u print "EMG_MIN_u", EMG_MIN_u print "GYRO_MAX_u", GYRO_MAX_u print "# data points", len(imu_demos_u) N_l = imu_demos_l.shape[0] N_u = imu_demos_u.shape[0] print N_u if N_l < N_u: emg_demos_u = emg_demos_u[0:N_l, :] imu_demos_u = imu_demos_u[0:N_l, :] Time = np.arange(N_l).reshape((N_l, 1)) elif N_l > N_u: emg_demos_l = emg_demos_l[0:N_u, :] imu_demos_l = imu_demos_l[0:N_u, :] Time = np.arange(N_u).reshape((N_u, 1)) else: Time = np.arange(N_u).reshape((N_u, 1)) if os.path.exists('/usr/local/MATLAB'): print "MATLAB FOUND" ## use the following if there is Malab under /usr/local ## GMM and GMR will be performed os.chdir('../matlab') subprocess.call([ 'matlab', '-nodisplay', '-nojvm', '-nosplash', '-r', 'demo(' + str(samples) + ');exit' ]) os.chdir('../myo_python') else: print "MATLAB NOT FOUND" ## use the following if there is no Matlab ## simply use the aligned average as expected trajectory np.savetxt('../data/demo_l.dat', imu_demos_l[:, -4:], delimiter=',') np.savetxt('../data/demo_u.dat', imu_demos_u[:, -4:], delimiter=',') emg_demos = np.hstack((emg_demos_l, emg_demos_u)) emg_cluster = classifier.SignalCluster(emg_demos, n_clusters=8) observations = np.hstack((EMG_WEIGHT * emg_demos_l, imu_demos_l, EMG_WEIGHT * emg_demos_u, imu_demos_u)) timed_observations = np.hstack( (TIME_WEIGHT * Time, EMG_WEIGHT * emg_demos_l, imu_demos_l, EMG_WEIGHT * emg_demos_u, imu_demos_u)) if nClusters is None: N = observations.shape[0] low_limit = N / 20 # 0.5 states per second high_limit = int(1.5 * N / 20) # 0.75 states per second scores = {} for n in range(low_limit, high_limit): state_cluster = classifier.SignalCluster(timed_observations, n) score = state_cluster.evaluate(timed_observations, state_cluster.labels) scores[score] = n print '# clusters, score', n, score max_score = max(scores.keys()) n_clusters = scores[max_score] state_cluster = classifier.SignalCluster(timed_observations, n_clusters) else: state_cluster = classifier.SignalCluster(timed_observations, nClusters) plt.figure() plt.plot(imu_demos) plt.plot(state_cluster.labels, '*') plt.show(block=False) builder = BuildMDP(actionsData=emg_cluster.labels, statesData=state_cluster.labels) pickle.dump(builder, open('../data/mdp.pkl', 'wb')) print "path", builder.path print "policy", builder.Pi with open('../data/state_sequence.dat', 'w') as f: for item in builder.path: f.write('s' + str(item) + '\n') print "expected actions: ", emg_cluster.labels print "expected states: ", state_cluster.labels baseline = evaluate(emg_cluster.labels, state_cluster.labels, builder) print "baseline performance: ", baseline state_classifier = classifier.SignalClassifier(n_neighbors=5) state_classifier.train(observations, state_cluster.labels, trainingFile=None) pickle.dump((state_classifier, EMG_MAX, EMG_MIN, GYRO_MAX, baseline), open('../data/state_classifier.pkl', 'wb')) action_classifier = classifier.SignalClassifier(n_neighbors=5) action_classifier.train(emg_demos, emg_cluster.labels, trainingFile=None) pickle.dump(action_classifier, open('../data/action_classifier.pkl', 'wb'))
def build_classifier(samples=1, nClusters=None, ID='user', used=False): if used: mdp = pickle.load(open('../data/mdp.pkl')) args = {"give_prompt": True, "mdp": mdp, "id": ID} progress = myo_state2.Progress( classifier_pkl='../data/state_classifier.pkl', **args) return has_matlab = os.path.exists('/usr/local/MATLAB') for identifier in ('l', 'u'): for i in range(samples): data_i, EMG_max_i, EMG_min_i, GYRO_max_i, states_i = preprocess( os.path.join('../../data/work/', str(i)), update_extremes=True, identifier=identifier) emg_i = data_i[:, 1:9] imu_i = data_i[:, 9:] if i == 0: emg_demos = emg_i imu_demos = imu_i emg_data = emg_i imu_data = imu_i state_labels = states_i EMG_MAX = EMG_max_i EMG_MIN = EMG_min_i GYRO_MAX = GYRO_max_i Time_a = np.arange(imu_i.shape[0]).reshape((imu_i.shape[0], 1)) ort_data_a = np.hstack((Time_a, imu_i[:, -4:])) else: imu_i_a = align_signal(imu_demos / i, imu_i, w=5, has_time=False) imu_demos += imu_i_a emg_data = np.vstack((emg_data, emg_i)) imu_data = np.vstack((imu_data, imu_i)) EMG_MAX += EMG_max_i EMG_MIN += EMG_min_i GYRO_MAX += GYRO_max_i state_labels = np.concatenate((state_labels, states_i)) # Used by Matlab function to compute the expected trojectory ort_data_a = np.vstack( (ort_data_a, np.hstack((Time_a, imu_i_a[:, -4:])))) # # Use original data to train state classifier # # aligned data is only used for expected trajectory # Time = np.arange(emg_i.shape[0]).reshape((emg_i.shape[0],1)) # emg_data.append(np.hstack((Time, emg_i))) # # Time = np.arange(imu_i.shape[0]).reshape((imu_i.shape[0],1)) # imu_data.append(np.hstack((Time, imu_i))) n = len(imu_demos) # get average if identifier == 'l': print "\nProcessing myo on lower arm..." emg_demos_l = emg_demos imu_demos_l = imu_demos / samples EMG_MAX_l = EMG_MAX / samples EMG_MIN_l = EMG_MIN / samples GYRO_MAX_l = GYRO_MAX / samples emg_data_l = emg_data imu_data_l = imu_data ort_data_l = ort_data_a print "EMG_MAX_l", EMG_MAX_l print "EMG_MIN_l", EMG_MIN_l print "GYRO_MAX_l", GYRO_MAX_l print "# data points", len(imu_demos_l) else: print "\nProcessing myo on upper arm..." emg_demos_u = emg_demos imu_demos_u = imu_demos / samples EMG_MAX_u = EMG_MAX / samples EMG_MIN_u = EMG_MIN / samples GYRO_MAX_u = GYRO_MAX / samples emg_data_u = emg_data imu_data_u = imu_data ort_data_u = ort_data_a print "EMG_MAX_u", EMG_MAX_u print "EMG_MIN_u", EMG_MIN_u print "GYRO_MAX_u", GYRO_MAX_u print "# data points", len(imu_demos_u) N_l = imu_demos_l.shape[0] N_u = imu_demos_u.shape[0] print N_u if N_l < N_u: emg_demos_u = emg_demos_u[0:N_l, :] imu_demos_u = imu_demos_u[0:N_l, :] Time = np.arange(N_l).reshape((N_l, 1)) elif N_l > N_u: emg_demos_l = emg_demos_l[0:N_u, :] imu_demos_l = imu_demos_l[0:N_u, :] Time = np.arange(N_u).reshape((N_u, 1)) else: Time = np.arange(N_u).reshape((N_u, 1)) if has_matlab: print "MATLAB FOUND" ## use the following if there is Malab under /usr/local ## GMM and GMR will be performed os.chdir('../matlab') #subprocess.call(['matlab', '-nodisplay', '-nojvm', '-nosplash', '-r', 'demo('+str(samples)+');exit']) np.savetxt('ort_data_u', ort_data_u, delimiter=',') np.savetxt('ort_data_l', ort_data_l, delimiter=',') subprocess.call([ 'matlab', '-nodisplay', '-nojvm', '-nosplash', '-r', 'demo_gmm();exit' ]) os.chdir('../myo_python') else: print "MATLAB NOT FOUND" ## use the following if there is no Matlab ## simply use the aligned average as expected trajectory np.savetxt('../data/demo_l.dat', imu_demos_l[:, -4:], delimiter=',') np.savetxt('../data/demo_u.dat', imu_demos_u[:, -4:], delimiter=',') emg_demos = np.hstack((emg_demos_l, emg_demos_u)) emg_cluster = classifier.SignalCluster(emg_demos, n_clusters=8) # observations = np.hstack((EMG_WEIGHT*emg_demos_l, imu_demos_l, EMG_WEIGHT*emg_demos_u, imu_demos_u)) # timed_observations = np.hstack((TIME_WEIGHT*Time, EMG_WEIGHT*emg_demos_l, imu_demos_l, EMG_WEIGHT*emg_demos_u, imu_demos_u)) print emg_data_l.shape, imu_data_l.shape, emg_data_u.shape, imu_data_u.shape n_points = min(emg_data_l.shape[0], emg_data_u.shape[0]) state_labels = state_labels[0:n_points] observations = np.hstack( (EMG_WEIGHT * emg_data_l[0:n_points, :], imu_data_l[0:n_points, :], EMG_WEIGHT * emg_data_u[0:n_points, :], imu_data_u[0:n_points, :])) # if nClusters is None: # N = observations.shape[0] # low_limit = N/20 # 0.5 states per second # high_limit = int(1.5*N/20) # 0.75 states per second # scores = {} # for n in range(low_limit, high_limit): # state_cluster = classifier.SignalCluster(timed_observations, n) # score = state_cluster.evaluate(timed_observations, state_cluster.labels) # scores[score] = n # print '# clusters, score', n, score # # max_score = max(scores.keys()) # n_clusters = scores[max_score] # state_cluster = classifier.SignalCluster(timed_observations, n_clusters) # else: # state_cluster = classifier.SignalCluster(timed_observations, nClusters) plt.figure() plt.plot(imu_demos) plt.plot(state_labels, '*') plt.show(block=True) statesData = state_labels[0:len(emg_demos)] valid_states = statesData >= 0 actionsData = emg_cluster.labels[valid_states] statesData = statesData[valid_states] builder = BuildMDP(actionsData=actionsData, statesData=statesData) pickle.dump(builder, open('../data/mdp.pkl', 'wb')) print "path", builder.path print "policy", builder.Pi with open('../data/state_sequence.dat', 'w') as f: for item in builder.path: f.write('s' + str(item) + '\n') print "expected actions: ", actionsData print "expected states: ", statesData baseline = evaluate(actionsData, statesData, builder) print "baseline performance: ", baseline state_classifier = classifier.SignalClassifier(n_neighbors=5) state_classifier.train(observations, state_labels, trainingFile=None) pickle.dump((state_classifier, EMG_MAX, EMG_MIN, GYRO_MAX, baseline), open('../data/state_classifier.pkl', 'wb')) action_classifier = classifier.SignalClassifier(n_neighbors=5) action_classifier.train(emg_demos, emg_cluster.labels, trainingFile=None) pickle.dump(action_classifier, open('../data/action_classifier.pkl', 'wb'))
def build_classifier(samples=1, nClusters=None, ID='user', used=False, has_matlab=False): if used: mdp = pickle.load(open('../data/mdp.pkl')) args = {"give_prompt": True, "mdp": mdp, "id": ID} progress = myo_state2.Progress( classifier_pkl='../data/state_classifier.pkl', **args) return if has_matlab is None: has_matlab = os.path.exists('/usr/local/MATLAB') for identifier in ('l', 'u'): for i in range(samples): data_i, EMG_max_i, EMG_min_i, GYRO_max_i, states_i = preprocess( os.path.join('../../data/work/', str(i)), update_extremes=True, identifier=identifier) emg_i = data_i[:, 1:9] imu_i = data_i[:, 9:] if i == 0: emg_demos = emg_i # use the first emg sample as demo imu_demos = imu_i emg_data = emg_i imu_data = imu_i state_labels = states_i EMG_MAX = EMG_max_i EMG_MIN = EMG_min_i GYRO_MAX = GYRO_max_i Time_a = np.arange(imu_i.shape[0]).reshape((imu_i.shape[0], 1)) ort_data_a = np.hstack((Time_a, imu_i[:, -4:])) emg_data_a = np.hstack((Time_a, emg_i)) else: imu_i_a = align_signal(imu_demos / i, imu_i, w=5, has_time=False) imu_demos += imu_i_a emg_data = np.vstack( (emg_data, emg_i)) # concatenate emg signals imu_data = np.vstack((imu_data, imu_i)) EMG_MAX += EMG_max_i EMG_MIN += EMG_min_i GYRO_MAX += GYRO_max_i state_labels = np.concatenate( (state_labels, states_i)) # all labels emg_i_a = align_signal(emg_demos, emg_i, w=5, has_time=False) # Used by Matlab function to compute the expected trojectory # The signals are aligned to the first one # Potentional improvement: align the to the one with medium length. ort_data_a = np.vstack( (ort_data_a, np.hstack((Time_a, imu_i_a[:, -4:])))) emg_data_a = np.vstack((emg_data_a, np.hstack( (Time_a, emg_i_a)))) n = len(imu_demos) # get average if identifier == 'l': print "\nProcessing myo on lower arm..." emg_demos_l = emg_demos imu_demos_l = imu_demos / samples EMG_MAX_l = EMG_MAX / samples EMG_MIN_l = EMG_MIN / samples GYRO_MAX_l = GYRO_MAX / samples emg_data_l = emg_data emg_data_l_timed = emg_data_a # timed, for GMM imu_data_l = imu_data ort_data_l = ort_data_a print "EMG_MAX_l", EMG_MAX_l print "EMG_MIN_l", EMG_MIN_l print "GYRO_MAX_l", GYRO_MAX_l print "# data points", len(imu_demos_l) else: print "\nProcessing myo on upper arm..." emg_demos_u = emg_demos imu_demos_u = imu_demos / samples EMG_MAX_u = EMG_MAX / samples EMG_MIN_u = EMG_MIN / samples GYRO_MAX_u = GYRO_MAX / samples emg_data_u = emg_data emg_data_u_timed = emg_data_a imu_data_u = imu_data ort_data_u = ort_data_a print "EMG_MAX_u", EMG_MAX_u print "EMG_MIN_u", EMG_MIN_u print "GYRO_MAX_u", GYRO_MAX_u print "# data points", len(imu_demos_u) N_l = imu_demos_l.shape[0] N_u = imu_demos_u.shape[0] N_min = min(N_l, N_u) print N_min emg_demos_u = emg_demos_u[0:N_min, :] imu_demos_u = imu_demos_u[0:N_min, :] emg_demos_l = emg_demos_l[0:N_min, :] imu_demos_l = imu_demos_l[0:N_min, :] Time = np.arange(N_min).reshape((N_min, 1)) show_ort_l = np.genfromtxt('../../data/work/0/ort_l.mat', delimiter=',') show_ort_l = show_ort_l[16:-6:2, :] np.savetxt('../data/prompt_l.dat', show_ort_l, delimiter=',') show_ort_u = np.genfromtxt('../../data/work/0/ort_u.mat', delimiter=',') show_ort_u = show_ort_u[16:-6:2, :] np.savetxt('../data/prompt_u.dat', show_ort_u, delimiter=',') if has_matlab: print "MATLAB FOUND" ## use the following if there is Malab under /usr/local ## GMM and GMR will be performed os.chdir('../matlab') np.savetxt('ort_data_u', ort_data_u, delimiter=',') np.savetxt('ort_data_l', ort_data_l, delimiter=',') np.savetxt('emg_data_u', emg_data_u_timed, delimiter=',') np.savetxt('emg_data_l', emg_data_l_timed, delimiter=',') subprocess.call([ 'matlab', '-nodisplay', '-nojvm', '-nosplash', '-r', 'demo_gmm();exit' ]) os.chdir('../myo_python') else: print "MATLAB NOT FOUND" ## use the following if there is no Matlab ## simply use the aligned average as expected trajectory np.savetxt('../data/demo_l.dat', imu_demos_l[:, -4:], delimiter=',') np.savetxt('../data/demo_u.dat', imu_demos_u[:, -4:], delimiter=',') np.savetxt('../data/emg_l.dat', emg_demos_l, delimiter=',') np.savetxt('../data/emg_u.dat', emg_demos_u, delimiter=',') emg_demos = np.hstack((emg_demos_l, emg_demos_u)) emg_cluster = classifier.SignalCluster(emg_demos, n_clusters=8) observations = np.hstack((EMG_WEIGHT * emg_demos_l, imu_demos_l, EMG_WEIGHT * emg_demos_u, imu_demos_u)) if nClusters is None: N = max(state_labels) # number of tagged points print "state labels:", N low_limit = max(2, N / 2) # at least 2 clusters high_limit = N scores = {} for n in range(low_limit, high_limit + 2): state_cluster = classifier.SignalCluster(observations, n) score = state_cluster.evaluate(observations, state_cluster.labels) scores[score] = n print '# clusters, score', n, score max_score = max(scores.keys()) n_clusters = scores[max_score] state_cluster = classifier.SignalCluster(observations, n_clusters) else: state_cluster = classifier.SignalCluster(observations, nClusters) plt.figure() plt.plot(show_ort_l) #plt.plot(emg_demos_u) plt.plot(state_cluster.labels, '*') plt.show(block=True) ## Currently we implement the n-gram model without explicitly training the MDP ## So the following code is not used ## ============================================================================ ## build mdp # # indexes = [x for x,item in enumerate(valid_states) if item] # critical points # segments = [] # left = indexes[0] # for i,ind in enumerate(indexes): # if ind-left > 5: # segments.append((left, ind)) # left = ind # print segments # pickle.dump(segments, open('../data/segments.dat', 'w')) #actionsData = emg_cluster.labels[valid_states] #statesData = statesData[valid_states] # builder = BuildMDP(actionsData=statesData, statesData=statesData) # use the same labels # pickle.dump(builder, open('../data/mdp.pkl', 'wb')) # # print "path", builder.path # print "policy", builder.Pi #print "expected actions: ", actionsData ## ============================================================================== print "expected states: ", state_cluster.labels #baseline = evaluate(actionsData, statesData, builder) #print "baseline performance: ", baseline state_classifier = classifier.SignalClassifier(n_neighbors=5) state_classifier.train(observations, state_cluster.labels, trainingFile=None) baseline = None pickle.dump((state_classifier, EMG_MAX, EMG_MIN, GYRO_MAX, baseline), open('../data/state_classifier.pkl', 'wb')) state_labels = state_labels[0:N_min] critical_points = observations[state_labels >= 0] task = state_classifier.predict(critical_points) state_sequence = [] with open('../data/state_sequence.dat', 'w') as f: for item in task: if item not in state_sequence or item != state_sequence[-1]: state_sequence.append(item) f.write(str(item) + '\n')