def rate_switching(src_dir, cycles_set=slice(0,8)):
paths = sorted(glob(os.path.join(src_dir,'0*')))
data = []
for path in paths:
all_gaze_data = load_data(os.path.join(path,"gaze_coordenates_on_screen.txt"))
left_gaze_mask, right_gaze_mask = gaze_mask_left_right(all_gaze_data)
switchings = switching_timestamps(all_gaze_data, left_gaze_mask, right_gaze_mask)
beha_data = load_data(os.path.join(path,"behavioral_events.txt"))
target_intervals = stimuli_onset(beha_data)
red_intervals = zip(target_intervals[0], target_intervals[1])
blue_intervals = zip(target_intervals[1], target_intervals[0][1:])
red_data = rate_in(red_intervals, switchings)[cycles_set]
blue_data = rate_in(blue_intervals, switchings)[cycles_set]
data.append((red_data,blue_data,switchings.shape[0]))
return data
def relative_rate_left_right(src_dir, target_intervals='all_onsets'):
timestamps = 'time'
paths = sorted(glob(os.path.join(src_dir,'0*')))
data = []
for path in paths:
all_gaze_data = load_data(os.path.join(path,"gaze_coordenates_on_screen.txt"))
all_gaze_data, left_gaze_mask, right_gaze_mask = gaze_mask_left_right(all_gaze_data)
left_timestamps = all_gaze_data[left_gaze_mask][timestamps]
right_timestamps = all_gaze_data[right_gaze_mask][timestamps]
beha_data = load_data(os.path.join(path,"behavioral_events.txt"))
if 'all_onsets' in target_intervals:
l_target_intervals = all_stimuli(beha_data)
l_target_intervals = zip(l_target_intervals, l_target_intervals[1:])
left_data = rate_in(l_target_intervals, left_timestamps)
right_data = rate_in(l_target_intervals, right_timestamps)
relative_rate_all = relative_rate(left_data, right_data)
data.append(relative_rate_all)
elif 'left_right_onsets' in target_intervals:
l_target_intervals = all_stimuli(beha_data)
l_target_intervals = zip(l_target_intervals, l_target_intervals[1:])
left_data = rate_in(l_target_intervals, left_timestamps)
right_data = rate_in(l_target_intervals, right_timestamps)
relative_rate_all = relative_rate(left_data, right_data)
data.append([relative_rate_all[::2],relative_rate_all[1::2]])
elif 'red_blue_onsets' in target_intervals:
l_target_intervals = stimuli_onset(beha_data)
red_intervals = zip(l_target_intervals[0], l_target_intervals[1])
left_red_data = rate_in(red_intervals, left_timestamps)
red_intervals = zip(l_target_intervals[0], l_target_intervals[1])
right_red_data = rate_in(red_intervals, right_timestamps)
blue_intervals = zip(l_target_intervals[1], l_target_intervals[0][1:])
left_blue_data = rate_in(blue_intervals, left_timestamps)
blue_intervals = zip(l_target_intervals[1], l_target_intervals[0][1:])
right_blue_data = rate_in(blue_intervals, right_timestamps)
relative_rate_positive = relative_rate(left_red_data, right_red_data)
relative_rate_negative = relative_rate(left_blue_data, right_blue_data)
data.append((relative_rate_positive, relative_rate_negative))
return data
def baseline_tracking_extinction_switching_correlation():
from constants import INNER_PATHS_DISCRIMINATION
from methods import get_data_path
X = []
Y = []
filenames = [os.path.join(get_data_path(), filename) for filename in INNER_PATHS_DISCRIMINATION]
for filename in filenames:
# ID = os.path.basename(os.path.dirname(filename))
timestamps = 'time'
paths = sorted(glob(os.path.join(filename,'0*')))
baseline_tracking_path = paths[0]
all_gaze_data = load_data(os.path.join(baseline_tracking_path,"gaze_coordenates_on_screen.txt"))
left_gaze_mask, right_gaze_mask = gaze_mask_left_right(all_gaze_data)
left_timestamps = all_gaze_data[left_gaze_mask][timestamps]
right_timestamps = all_gaze_data[right_gaze_mask][timestamps]
beha_data = load_data(os.path.join(baseline_tracking_path,"behavioral_events.txt"))
# left_right_onsets
l_target_intervals = all_stimuli(beha_data)
l_target_intervals = zip(l_target_intervals, l_target_intervals[1:])
left_data = rate_in(l_target_intervals, left_timestamps)
right_data = rate_in(l_target_intervals, right_timestamps)
relative_rate_all = relative_rate(left_data, right_data)
X.append(np.nanmean(relative_rate_all[::2])-np.nanmean(relative_rate_all[1::2]))
extintion_switching_path = paths[1]
all_gaze_data = load_data(os.path.join(extintion_switching_path,"gaze_coordenates_on_screen.txt"))
left_gaze_mask, right_gaze_mask = gaze_mask_left_right(all_gaze_data)
switchings = switching_timestamps(all_gaze_data, left_gaze_mask, right_gaze_mask)
beha_data = load_data(os.path.join(extintion_switching_path,"behavioral_events.txt"))
target_intervals = stimuli_onset(beha_data)
red_intervals = zip(target_intervals[0], target_intervals[1])
blue_intervals = zip(target_intervals[1], target_intervals[0][1:])
red_data = rate_in(red_intervals, switchings)
blue_data = rate_in(blue_intervals, switchings)
Y.append(np.nanmean(blue_data)-np.nanmean(red_data))
return np.array(X), np.array(Y)
def draw_single_proportion(src_dir, show=True):
print(os.path.dirname(src_dir))
ID = os.path.basename(os.path.dirname(src_dir))
paths = sorted(glob(os.path.join(src_dir, '0*')))
data = []
x_label = 'Successive cycles'
y_label = 'Button-pressing proportion'
title = ID
figure, axarr = plt.subplots(1,
3,
sharey=True,
sharex=True,
figsize=(9, 3))
# figure.suptitle(title);
# figure.text(0.5, 0.02, x_label)
for path, axis in zip(paths, axarr):
beha_data = load_data(os.path.join(path, "behavioral_events.txt"))
target_intervals = stimuli_onset(beha_data)
red_intervals = zip(target_intervals[0], target_intervals[1])
blue_intervals = zip(target_intervals[1], target_intervals[0][1:])
responses = all_responses(beha_data)
red_data = rate_in(red_intervals, responses)
blue_data = rate_in(blue_intervals, responses)
relative_rate = [
r / (r + b) if r + b > 0 else np.nan
for r, b in zip(red_data, blue_data)
]
axis.plot(relative_rate, color="k", label="Right")
# remove outer frame
axis.spines['top'].set_visible(False)
axis.spines['bottom'].set_visible(False)
axis.spines['left'].set_visible(False)
axis.spines['right'].set_visible(False)
axis.set_ylim(0., 1.)
axis.set_xlim(-0.5, len(relative_rate) + 0.5)
axis.set_xticklabels([x for x in range(-1, len(relative_rate) + 1, 2)])
#remove ticks
axis.xaxis.set_ticks_position('none')
axis.yaxis.set_ticks_position('none')
axarr[0].set_ylabel(y_label)
axarr[0].spines['left'].set_visible(True)
axarr[1].set_xlabel(x_label)
figure.tight_layout()
# save/plot figure
if show:
plt.show()
def relative_rate_blue_red(src_dir, cycles_set=slice(0,8)):
paths = sorted(glob(os.path.join(src_dir,'0*')))
data = []
for path in paths:
beha_data = load_data(os.path.join(path,"behavioral_events.txt"))
target_intervals = stimuli_onset(beha_data)
red_intervals = zip(target_intervals[0], target_intervals[1])
blue_intervals = zip(target_intervals[1], target_intervals[0][1:])
responses = all_responses(beha_data)
red_data = rate_in(red_intervals, responses)
blue_data = rate_in(blue_intervals, responses)
relative_rate_all = relative_rate(red_data, blue_data)
data.append(relative_rate_all[cycles_set])
return data
def draw_single(src_dir, show=True):
print(os.path.dirname(src_dir))
ID = os.path.basename(os.path.dirname(src_dir))
paths = sorted(glob(os.path.join(src_dir, '0*')))
data = []
ymax = []
for path in paths:
be = load_data(os.path.join(path, "behavioral_events.txt"))
responses = all_responses(be)
data.append((stimuli_onset(be), responses))
ymax.append(len(responses))
ymax = np.amax(ymax)
x_label = 'Ciclos'
y_label = 'Taxa (respostas por segundo)'
title = 'Particip. ' + ID + ': taxa de resp. durante as cores Verm. e Azul.'
n_plots = len(paths)
if n_plots == 1:
figsize = (4, 4)
elif n_plots == 2:
figsize = (8, 4)
elif n_plots == 3:
figsize = (12, 4)
else:
figsize = (14, 4)
figure, axarr = plt.subplots(1,
n_plots,
sharey=True,
sharex=False,
figsize=figsize)
figure.suptitle(title)
figure.text(0.5, 0.02, x_label)
for i, d in enumerate(data):
(onsets, responses) = d
temporal_perfil(axarr[i], onsets, responses)
axarr[0].set_ylabel(y_label)
figure.tight_layout()
# save/plot figure
if show:
plt.show()
def VFM_train(model_name,
data_csv,
threads,
data_dir=None,
loading_data=False,
dims=24):
if threads == None:
threads = 1
print('Start time for training: ' + str(datetime.datetime.now()))
train_X = None
train_Y = None
if loading_data:
(train_X, train_Y) = ms.load_data(data_csv, True, dims)
else:
for index, folder in enumerate(data_dir):
(ids, temp_X, temp_Y) = ms.train_preprocess(folder, index, threads)
if train_X is None:
train_X = temp_X
train_Y = temp_Y
else:
train_X = np.concatenate((train_X, temp_X), axis=0)
train_Y = np.concatenate((train_Y, temp_Y), axis=0)
# save data
data = np.concatenate((train_X, train_Y), axis=1)
np.savetxt(os.path.join("user_models", data_csv), data, delimiter=",")
# Param:
seed = 7
num_tree = 50
print("Start training...")
model = RandomForestClassifier(n_estimators=num_tree, random_state=seed)
# Deal with nan values
if np.isnan(train_X).sum() > 0:
train_X = ms.fill_nan(train_X)
if train_Y.ndim == 2:
train_Y = train_Y.flatten()
model.fit(train_X, train_Y)
print("Training finished.")
print("Saving model...")
joblib.dump(model, "user_models/" + model_name)
print('End time for training: ' + str(datetime.datetime.now()) + "\n")
def draw_single(src_dir, show=True):
ID = os.path.basename(os.path.dirname(src_dir))
paths = sorted(glob(os.path.join(src_dir, '0*')))
x_label = 'Ciclo'
y_label = 'dir. < Taxa (gaze/s) > esq.'
title = 'Particip. ' + ID + ': Taxa de movim. oculares durante cada cor'
n_plots = len(paths)
if n_plots == 1:
figsize = (4, 4)
elif n_plots == 2:
figsize = (8, 4)
elif n_plots == 3:
figsize = (12, 4)
else:
figsize = (14, 4)
figure, axarr = plt.subplots(1,
n_plots,
sharey=True,
sharex=False,
figsize=figsize)
figure.suptitle(title)
figure.text(0.5, 0.02, x_label)
keyword_arguments = {'screen_center': np.array([0.5, 0.5])}
left_shape = mp(Circle('left').Points(2))
# left_shape = mp(SQUARE.Points())
right_shape = mp(Circle('right').Points(2))
for i, path in enumerate(paths):
data_folder = os.path.join(src_dir, path)
print(data_folder)
beha_events_path = os.path.join(data_folder, "behavioral_events.txt")
gaze_events_path = os.path.join(data_folder,
'gaze_coordenates_on_screen.txt')
beha_data = load_data(beha_events_path)
all_data = load_data(gaze_events_path)
left_gaze_mask, right_gaze_mask = gaze_mask_left_right(all_data)
left_timestamps = all_data[left_gaze_mask]['time']
right_timestamps = all_data[right_gaze_mask]['time']
temporal_perfil(axarr[i],
color_pair(beha_data, 0),
left_timestamps,
'pair',
c1=RED_LEFT,
nsize=0)
temporal_perfil(axarr[i],
color_pair(beha_data, 0),
right_timestamps,
'pair',
c1=GREEN_RIGHT,
nsize=0,
doreversed=True)
temporal_perfil(axarr[i],
color_pair(beha_data, 1),
left_timestamps,
'pair',
c1=RED_LEFT,
nsize=1)
temporal_perfil(axarr[i],
color_pair(beha_data, 1),
right_timestamps,
'pair',
c1=CYAN_RIGHT,
nsize=1,
doreversed=True)
temporal_perfil(axarr[i],
color_pair(beha_data, 2),
left_timestamps,
'pair',
c1=BLUE_LEFT,
nsize=2)
temporal_perfil(axarr[i],
color_pair(beha_data, 2),
right_timestamps,
'pair',
c1=CYAN_RIGHT,
nsize=2,
doreversed=True)
temporal_perfil(axarr[i],
color_pair(beha_data, 3),
left_timestamps,
'pair',
c1=BLUE_LEFT,
nsize=3)
temporal_perfil(axarr[i],
color_pair(beha_data, 3),
right_timestamps,
'pair',
c1=GREEN_RIGHT,
nsize=3,
doreversed=True)
ticks = [30, 20, 10, 0, 10, 20, 30]
axarr[0].set_yticklabels(labels=ticks)
plt.ylim(ymin=-30)
plt.ylim(ymax=30)
axarr[0].set_ylabel(y_label)
figure.tight_layout()
if show:
plt.show()
if len(weight.size()) > 1:
weigth_init.orthogonal(weight.data)
def forward(self, x, x_lens):
x = self.embedd(x)
output, hidden = self.lstm(x)
x = output[:, -1, :]
x = x.view(-1, 128)
x = self.fc(x)
return x
''' load data '''
print('...load data...')
train_x = me.load_data(str(sys.argv[1]))
train_y = me.load_data(str(sys.argv[2]))
test_x = me.load_data(str(sys.argv[3]))
''' take out words'''
print('...take out words...')
train_x = [i[1] for i in train_x]
train_y = [i[1] for i in train_y]
test_x = [i[1] for i in test_x]
''' word segmentation '''
print('...word segmentation...')
nlp = spacy.load("en_core_web_sm")
tokenizer = nlp.Defaults.create_tokenizer(nlp)
seg_train = me.word_segmentation(train_x, tokenizer)
seg_test = me.word_segmentation(test_x, tokenizer)
if whichdataset == 'ACDC':
data_dir = 'ACDC_dataset/training'
raw_image_path01 = '_frame01.nii.gz'
raw_image_path12 = '_frame12.nii.gz'
label_path01 = '_frame01_gt.nii.gz'
label_path12 = '_frame12_gt.nii.gz'
path = 'ACDC_results'
images_paths, labels_paths = methods.load_images(data_dir, raw_image_path01, raw_image_path12, label_path01, label_path12)
images_paths.sort() # each label should be on the same index than its corresponding image
labels_paths.sort()
img_data = methods.load_data(images_paths)
input = np.load('unet_input.npy')
labels = np.load('unet_labels.npy')
unet_input = []
unet_labels = []
#TODO variable amount of slices per person? (in percentages)
total_number_of_patients = len(input)
arr_number_of_patients = [total_number_of_patients-1, int(total_number_of_patients*0.25), int(total_number_of_patients*0.5), int(total_number_of_patients*0.75)]
def guess_dbscan_parameters(
K,
gaze_coordenates_on_screen,
stimuli_size=(130, 130), # in pixels
screen_size=(1280, 768), # in pixels
max_trials=50,
data=[{}],
do_plot=True):
"""
k: min clusters
gaze_coordenates_on_screen: string
"""
def get_min_samples(all_places):
N = len(gaze_data)
if all_places >= N:
return N
else:
return N / all_places
dictionary = len(data) - 1
gaze_data = load_data(gaze_coordenates_on_screen)
print('Target: ', gaze_coordenates_on_screen)
# stimulus size in pixels
width, height = stimuli_size[0], stimuli_size[1]
# normalize stimulus size
width /= float(screen_size[0])
height /= float(screen_size[1])
# assume stimuli with uniform diameter, assume eps as stimulus radius
stimulus_radius = np.mean([width, height]) / 2
data[dictionary]['eps'] = stimulus_radius
print('Using EPS: ', data[dictionary]['eps'])
# assume min_samples as the quotient between the number of gaze points
# and the number of places used to present stimuli
# let the number of places be all possible paths in a graph
data[dictionary]['all_places'] = (K * K) * (K - 1)
data[dictionary]['min_samples'] = get_min_samples(
data[dictionary]['all_places'])
print('Using Min.Samples: ', data[dictionary]['min_samples'])
# the researcher knowns how many clusters, so we use this information as a termination clause
data[dictionary]['min_clusters'] = K
print('Using Min.Clusters: ', data[dictionary]['min_clusters'])
# DBSCAN expects data with shape (-1,2), we need to transpose ours first
data[dictionary]['src_xy'] = np.array(
[gaze_data['x_norm'], gaze_data['y_norm']]).T
data[dictionary]['src_timestamps'] = gaze_data['time']
trials = 0
while True:
data[dictionary]['dbscan'] = DBSCAN(
eps=data[dictionary]['eps'],
min_samples=data[dictionary]['min_samples']).fit(
data[dictionary]['src_xy'])
data[dictionary]['categorized_xy'] = plot_dbscan(
data[dictionary]['src_xy'], data[dictionary]['dbscan'], do_plot)
n_clusters = len_clusters(data[dictionary]['dbscan'])
if n_clusters >= data[dictionary]['min_clusters']:
print('Finished with: ', n_clusters, ' clusters.')
break
else:
plt.gcf().clear()
data[dictionary]['all_places'] /= 2
data[dictionary]['min_samples'] = get_min_samples(
data[dictionary]['all_places'])
print('Min.Clusters were not found, trying again using:',
data[dictionary]['min_samples'], ' min. samples.')
trials += 1
if trials == max_trials:
print(max_trials, " trials. Finished without clusters.")
break
if data[dictionary]['all_places'] < 2:
print("Too few places. Finished without clusters.")
break
def draw_single(src_dir, show=True):
ID = os.path.basename(os.path.dirname(src_dir))
basepath = os.path.dirname(os.path.dirname(src_dir))
print(src_dir)
print(ID)
print(basepath)
if src_dir == os.path.join(basepath, 'P001/2015-05-19'):
data = [{
'eps': 0.07,
'min_samples': 370
}, {
'eps': 0.06,
'min_samples': 1000
}]
elif src_dir == os.path.join(basepath, 'P001/2015-05-27'):
data = [{
'eps': 0.02,
'min_samples': 1000
}, {
'eps': 0.02,
'min_samples': 1000
}, {
'eps': 0.02,
'min_samples': 1000
}]
elif src_dir == os.path.join(basepath, 'P002/2015-05-19'):
data = [{
'eps': 0.06,
'min_samples': 1000
}, {
'eps': 0.06,
'min_samples': 1000
}, {
'eps': 0.06,
'min_samples': 1000
}]
elif src_dir == os.path.join(basepath, 'P002/2015-05-20'):
data = [{
'eps': 0.06,
'min_samples': 1000
}, {
'eps': 0.06,
'min_samples': 1000
}, {
'eps': 0.06,
'min_samples': 500
}]
elif src_dir == os.path.join(basepath, 'P003/2015-05-20'):
data = [{
'eps': 0.06,
'min_samples': 1000
}, {
'eps': 0.06,
'min_samples': 1000
}, {
'eps': 0.06,
'min_samples': 800
}]
elif src_dir == os.path.join(basepath, 'P004/2015-05-20'):
data = [{
'eps': 0.06,
'min_samples': 1500
}, {
'eps': 0.06,
'min_samples': 1500
}, {
'eps': 0.06,
'min_samples': 1500
}]
elif src_dir == os.path.join(basepath, 'P005/2015-05-19'):
data = [{
'eps': 0.08,
'min_samples': 500
}, {
'eps': 0.07,
'min_samples': 500
}, {
'eps': 0.06,
'min_samples': 1000
}, {
'eps': 0.06,
'min_samples': 1000
}]
elif src_dir == os.path.join(basepath, 'P006/2015-05-25'):
data = [{
'eps': 0.065,
'min_samples': 1700
}, {
'eps': 0.065,
'min_samples': 1300
}, {
'eps': 0.065,
'min_samples': 1200
}]
elif src_dir == os.path.join(basepath, 'P007/2015-05-25'):
data = [{
'eps': 0.06,
'min_samples': 1200
}, {
'eps': 0.06,
'min_samples': 1200
}, {
'eps': 0.06,
'min_samples': 1200
}]
elif src_dir == os.path.join(basepath, 'P008/2015-05-26'):
data = [{
'eps': 0.06,
'min_samples': 1200
}, {
'eps': 0.06,
'min_samples': 1200
}, {
'eps': 0.06,
'min_samples': 1200
}]
elif src_dir == os.path.join(basepath, 'P009/2015-05-26'):
data = [{
'eps': 0.06,
'min_samples': 1700
}, {
'eps': 0.06,
'min_samples': 1000
}, {
'eps': 0.06,
'min_samples': 1000
}, {
'eps': 0.06,
'min_samples': 1000
}]
elif src_dir == os.path.join(basepath, 'P010/2015-05-26'):
data = [{
'eps': 0.06,
'min_samples': 600
}, {
'eps': 0.06,
'min_samples': 600
}, {
'eps': 0.06,
'min_samples': 600
}, {
'eps': 0.06,
'min_samples': 600
}]
paths = sorted(glob(os.path.join(src_dir, '0*')))
for i, path in enumerate(paths):
data_folder = os.path.join(src_dir, path)
beha_events_path = os.path.join(data_folder, "behavioral_events.txt")
gaze_events_path = os.path.join(data_folder, 'gaze_positions.csv')
gaze_data = load_data(gaze_events_path, ',')
data[i]['beha_data'] = load_data(beha_events_path)
# DBSCAN expects data with shape (-1,2), we need to transpose ours first
data[i]['src_xy'] = np.array(
[gaze_data['x_norm'], gaze_data['y_norm']]).T
data[i]['dbsc'] = DBSCAN(eps=data[i]['eps'],
min_samples=data[i]['min_samples']).fit(
data[i]['src_xy'])
data[i]['points_categorized'] = plot_dbscan(data[i]['src_xy'],
data[i]['dbsc'])
data[i]['masks'] = categorize_masks(data[i]['src_xy'], data[i]['dbsc'])
data[i]['src_timestamps'] = gaze_data['time']
data[i]['time_categorized'] = categorize_timestamps(
data[i]['src_timestamps'], data[i]['dbsc'])
x_label = 'Ciclo'
y_label = 'dir. < Taxa (gaze/s) > esq.'
title = 'Particip. ' + ID + ': Taxa de movim. oculares durante cada cor'
n_plots = len(data)
if n_plots == 1:
figsize = (4, 4)
elif n_plots == 2:
figsize = (8, 4)
elif n_plots == 3:
figsize = (12, 4)
else:
figsize = (14, 4)
figure, axarr = plt.subplots(1,
n_plots,
sharey=True,
sharex=False,
figsize=figsize)
figure.suptitle(title)
figure.text(0.5, 0.02, x_label)
# look rate (left)
# look rate (right)
for i, d in enumerate(data):
turnover_count = 0
turnover = [
a for a, b in zip(d['masks']['cluster_0'], d['masks']['cluster_1'])
if a or b
]
for c, n in zip(turnover, turnover[1:]):
if c != n:
turnover_count += 1
print('\n', 'turnover_count:', turnover_count)
left_right_xy = []
left_right_timestamps = []
for ttime, points in zip(d['time_categorized'].iteritems(),
d['points_categorized'].iteritems()):
_, xy = points
time_key, timestamps = ttime
print(time_key, len(timestamps), len(xy))
if len(timestamps) > 0 and 'cluster' in time_key:
left_right_timestamps.append(timestamps)
left_right_xy.append(xy)
if np.mean(left_right_xy[0][0]) > np.mean(left_right_xy[1][0]):
left_right_xy = [left_right_xy[1], left_right_xy[0]]
left_right_timestamps = [
left_right_timestamps[1], left_right_timestamps[0]
]
else:
left_right_xy = [left_right_xy[0], left_right_xy[1]]
left_right_timestamps = [
left_right_timestamps[0], left_right_timestamps[1]
]
temporal_perfil(axarr[i],
color_pair(data[i]['beha_data'], 0),
left_right_timestamps[0],
'pair',
c1=RED_LEFT,
nsize=0)
temporal_perfil(axarr[i],
color_pair(data[i]['beha_data'], 0),
left_right_timestamps[1],
'pair',
c1=GREEN_RIGHT,
nsize=0,
doreversed=True)
temporal_perfil(axarr[i],
color_pair(data[i]['beha_data'], 1),
left_right_timestamps[0],
'pair',
c1=RED_LEFT,
nsize=1)
temporal_perfil(axarr[i],
color_pair(data[i]['beha_data'], 1),
left_right_timestamps[1],
'pair',
c1=CYAN_RIGHT,
nsize=1,
doreversed=True)
temporal_perfil(axarr[i],
color_pair(data[i]['beha_data'], 2),
left_right_timestamps[0],
'pair',
c1=BLUE_LEFT,
nsize=2)
temporal_perfil(axarr[i],
color_pair(data[i]['beha_data'], 2),
left_right_timestamps[1],
'pair',
c1=CYAN_RIGHT,
nsize=2,
doreversed=True)
temporal_perfil(axarr[i],
color_pair(data[i]['beha_data'], 3),
left_right_timestamps[0],
'pair',
c1=BLUE_LEFT,
nsize=3)
temporal_perfil(axarr[i],
color_pair(data[i]['beha_data'], 3),
left_right_timestamps[1],
'pair',
c1=GREEN_RIGHT,
nsize=3,
doreversed=True)
ticks = [30, 20, 10, 0, 10, 20, 30]
axarr[0].set_yticklabels(labels=ticks)
plt.ylim(ymin=-30)
plt.ylim(ymax=30)
axarr[0].set_ylabel(y_label)
figure.tight_layout()
if show:
plt.show()
# if len(weight.size()) > 1:
# weigth_init.orthogonal(weight.data)
def forward(self, x, x_lens):
x = self.embedd(x)
output, hidden = self.lstm(x)
x = output[:, -1, :]
x = x.view(-1, 128)
x = self.fc(x)
return x
''' load data '''
print('...load data...')
test_x = me.load_data(str(sys.argv[1]))
''' take out words'''
print('...take out words...')
test_x = [i[1] for i in test_x]
''' word segmentation '''
print('...word segmentation...')
nlp = spacy.load("en_core_web_sm")
tokenizer = nlp.Defaults.create_tokenizer(nlp)
seg_test = me.word_segmentation(test_x, tokenizer)
''' load stop words and remove stop words '''
print('...load stop words and remove stop words...')
rmseg_test = me.remove_stopwords('./stop_words.txt', seg_test)
data_dir = 'ACDC_dataset/training'
raw_image_path01 = '_frame01.nii.gz'
raw_image_path12 = '_frame12.nii.gz'
label_path01 = '_frame01_gt.nii.gz'
label_path12 = '_frame12_gt.nii.gz'
images_paths, labels_paths = methods.load_images(data_dir, raw_image_path01,
raw_image_path12,
label_path01, label_path12)
images_paths.sort(
) # each label should be on the same index than its corresponding image
labels_paths.sort()
myocar_labels = methods.remove_other_segmentations(
labels_paths) # array with all the myocar labels
img_data = methods.load_data(
images_paths) # array with all the heart images in slices
# all_labels = methods.load_data(labels_paths)
# methods.save_datavisualisation(img_data, all_labels, 'untouched_data/untouched_data', False)
# methods.save_datavisualisation2(img_data, all_labels, 'test/', False)
center_of_masses, empty_labels = methods.find_center_of_mass(myocar_labels)
empty_labels.sort(reverse=True) # need to do this for remove_empty_labels
myocar_labels = methods.remove_empty_label_data(
myocar_labels,
empty_labels) # need to remove empty labels from labels and image_data
img_data = methods.remove_empty_label_data(img_data, empty_labels)
image_counter = 0
# methods.save_datavisualisation2(img_data, myocar_labels, 'test/', False)
async def startup_event():
load_data()
# methods file
import methods
#parameters
NUMTOPICS = 10 # you can experiment with this parameter
NUMTERMS = 10 # you can experiment with this parameter
rank_method = "rank_idf" # choose one of the following ranking methods (rank_norm, rank_tfidf, rank_idf) refer to paper for details.
coh_metric = "c_npmi"
#input
data_file = "data.txt"
###### Main ########
## prep data
raw_texts = methods.load_data(data_file)
processed_texts = methods.clean_data(raw_texts)
dictionary, corpus = methods.get_dict(processed_texts)
## create LDA model
ldamodel = LdaModel(corpus,
id2word=dictionary,
num_topics=NUMTOPICS,
passes=10)
# examine learned topics
topics_list = []
for topic_ind in range(NUMTOPICS):
topic = ldamodel.get_topic_terms(topic_ind, NUMTERMS)
