def start_controller(args):
logger.info('Loading user interface')
views.start_view()
logger.info('User interface loaded')
logger.info('Loading alarms')
alarms = model.Alarms(args.alarmsFile)
alarms.load_alarms()
logger.info('Alarms loaded')
if args.preload:
logger.info('Loading physio data -- data will be preloaded')
data = model.Data(args.rawJsonFile)
data.load_physio_data()
data.create_single_data_streams(load_then_display=True)
logger.info('Physio data loaded')
else:
logger.info('Loading physio data -- data will be computed on the fly')
data = model.Data(args.rawJsonFile)
data.load_physio_data()
data.create_single_data_streams(load_then_display=False)
logger.info('Physio data loaded')
return alarms, data
def save_steam_obj(steam_id, obj):
data = model.Data.query(model.Data.steam_id == steam_id).get()
if not data:
data = model.Data()
data.steam_id = obj["steam_id"]
data.title = obj["title"]
data.released = obj["released"]
if len(obj["released"]) > 0:
try:
try:
data.released_datetime = datetime.datetime.strptime(
obj["released"], '%b %d, %Y')
# print("invalid date:%s - %s" % ( obj["title"], obj["released"]) )
except:
data.released_datetime = datetime.datetime.strptime(
obj["released"], '%b %Y')
# print("invalid date:%s - %s" % ( obj["title"], obj["released"]) )
except:
print("invalid date:%s - %s" % (obj["steam_id"], obj["released"]))
data.reviews = obj["reviews"]
data.sentiment = obj["sentiment"]
data.perc = obj["perc"]
data.followers = obj["followers"]
data.top_seller = obj["top_seller"]
data.new_release = obj["new_release"]
data.thumb_url = obj["thumb_url"]
data.put()
# create a time series
followersOverTime = model.FollowersOverTime()
followersOverTime.steam_id = obj["steam_id"]
followersOverTime.followers = obj["followers"]
followersOverTime.reviews = obj["reviews"]
followersOverTime.sentiment = obj["sentiment"]
followersOverTime.perc = obj["perc"]
followersOverTime.put()
def prepare_data(is_char, seq_length):
prepared_data = model.Data()
if is_char:
raw_text = get_seq_of_char()
else:
raw_text = get_seq_of_word()
prepared_data.raw_text = raw_text
chars = sorted(list(set(raw_text)))
prepared_data.char_to_int = dict((c, i) for i, c in enumerate(chars))
prepared_data.int_to_char = dict((i, c) for i, c in enumerate(chars))
n_chars = len(raw_text)
n_vocab = len(chars)
prepared_data.n_vocab = n_vocab
print("Total Thai Vocab: %s" % (n_chars))
print("Total Unique Vocab: %s" % (n_vocab))
# print(chars)
# seq_length = 10
dataX = []
dataY = []
for i in range(0, n_chars - seq_length, 1):
seq_in = raw_text[i:i + seq_length]
seq_out = raw_text[i + seq_length]
dataX.append([prepared_data.char_to_int[char] for char in seq_in])
dataY.append(prepared_data.char_to_int[seq_out])
n_patterns = len(dataX)
prepared_data.dataX = dataX
prepared_data.dataY = dataY
print("Total Patterns: %s" % (n_patterns))
# print(dataX[0])
X = numpy.reshape(dataX, (n_patterns, seq_length, 1))
# print (X)
prepared_data.X = X / float(n_vocab)
prepared_data.Y = np_utils.to_categorical(dataY)
# print (X)
# print(Y)
return prepared_data
def __init__(self):
self.model = model.Data("todo_list.txt")
self.view = view.Display()
self.is_running = True
from sorting_algorithms import *
import model
import view
from pygame.locals import *
running = True
data_model = model.Data()
graphics = view.View(data_model)
graphics.initialize()
choice = ''
while running:
for event in pygame.event.get():
if event.type == QUIT:
running = False
choice = graphics.intro()
graphics.screen.fill(graphics.WHITE)
print(choice)
graphics.show_array()
pygame.time.wait(1000)
if choice == "BUBBLE":
bubble_sort(graphics, data_model)
elif choice == "SELECTION":
selection_sort(graphics, data_model)
elif choice == "INSERTION":
insertion_sort(graphics, data_model)
def main():
#################### BEGIN PARAMETER BLOCK ###############################
#********** Manuscript parameter: N **************************
n_channels = ([16]) # Manuscript variable: N
#n_channels = ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20])
#********** Manuscript parameter: C **************************
n_cell_type = 4 # Manuscript variable: M
#********** Manuscript parameter: M **************************
n_marker = 5
#********** Manuscript parameter: Delta m **************************
marker_mean_diff = ([50]) # Manuscript variable Delta M
#marker_mean_diff = ([0, 1, 2, 3, 5, 7, 10, 15, 20, 25, 30, 35, 40, 45, 50])
#********** Manuscript parameter: s **************************
marker_stdv = ([30]) # Manuscript variable s
#marker_stdv = ([1, 2, 3, 4, 5, 7, 10, 15, 20, 25, 30, 35, 40, 45, 50, 60, 70, 80, 90, 100, 120, 150, 200, 300, 400, 500, 600, 700, 800, 900, 1000])
#********** Manuscript parameter: H **************************
cutoffs = [0] # Manuscript variable H
#cutoffs = [0.9999, 0.9995, 0.999, 0.995, 0.99, 0.95, 0.98, 0.97, 0.96, 0.95, 0.94, 0.93, 0.92, 0.91, 0.9, 0.89, 0.88, 0.87, 0.86, 0.85, 0.84, 0.83, 0.82, 0.81, 0.8]
#################### END PARAMETER BLOCK ###############################
n_cell = 22000
marker_base = 400
m_training_instance = 20000
m_test_instance = n_cell - m_training_instance
#marker_mean_diff = np.random.uniform(1, 50, 1000)
#marker_stdv = (np.random.uniform(0.1, 3,1000))**3
n_iter = 1 # Set this value to take the average accuracy calculations from multiple runs
write_header = 1
file_accuracy = "accuracy.csv"
for i in range(len(n_channels)): # loop over the channels
n_ch = n_channels[i]
for mm in range(len(marker_mean_diff)): # loop over the markers
for k in range(len(marker_stdv)):
marker_info = []
marker_info.append(marker_base)
marker_info.append(marker_mean_diff[mm])
marker_info.append(marker_stdv[k])
marker_info.append(n_marker)
data = model.Data(n_iter)
for j in range(
n_iter
): # iterations for the same set of channels and markers (however creates a new set of cells everytime)
X, fw = model.get_cell_and_flowcytometer_data(
n_ch, n_cell_type, n_cell, marker_info)
n_cell, n_channel_used = X[0].shape #
#model.plot_cell_marker_expression.plot_(fw.sample, fw.markers) # Uncomment if you would like to see he marker expression plot
#model.plot_fingerprint.plot_(X) # Uncomment if you would like to see the fingerprints
#model.plot_detector_signal_distributions.plot_(X) # Uncomment if you would like to see signal distribution in every detector
X_train, y_train, X_test, y_test, train_sample, test_sample = \
model.get_training_and_test_sets(fw.sample, m_training_instance, m_test_instance)
n_hidden_layer_node = 100
n_output_layer_node = n_cell_type
input_shape_X = 1 # 1D image (only 1 pixel in the vertical direction)
input_shape_Y = n_channel_used # Number of pixes in the horizontal direction
dnn = model.create_dnn(input_shape_X, input_shape_Y, \
n_hidden_layer_node, n_output_layer_node)
dnn = model.compile_dnn(dnn)
epochs = 10
dnn = model.fit_dnn(dnn, X_train, y_train, epochs)
type_of_interest = 0
#file_name = "roc_0_" + str(n_ch) + ".csv"
#model.evaluate_roc(dnn, X_test, y_test, test_sample, type_of_interest, file_name)
file_name = "purity_0_" + str(n_ch) + ".csv"
#model.evaluate_purity(dnn, X_test, y_test, test_sample, file_name, cutoffs)
data.accuracy[j] = model.evaluate_accuracy(
dnn, X_test, y_test, test_sample)
model.print_accuracy(data, n_ch, marker_mean_diff[mm],
marker_stdv[k], file_accuracy,
write_header)
write_header = 0
def build_secondary_view(self, note, win):
notaInicial = model.Data().notaIni
distancia = model.Requests.interval_request(note)
ascendente = _(str(model.lNotes[notaInicial])) + "-" + _(
str(model.lNotes[(notaInicial + distancia) % 12]))
descendente = _(str(model.lNotes[notaInicial])) + "-" + _(
str(model.lNotes[(notaInicial - distancia) % 12]))
win.set_default_size(300, 200)
win.set_border_width(30)
grid = Gtk.Grid()
win.add(grid)
label_Asc = Gtk.Label(label=_("Ascendente:"), xalign=0)
label_Des = Gtk.Label(label=_("Descentente:"), xalign=0)
notes_Asc = Gtk.Label(label=_("Exemplo:") + ascendente, xalign=0)
notes_Des = Gtk.Label(label=_("Exemplo:") + descendente, xalign=0)
lb_Asc = Gtk.ListBox()
lb_Des = Gtk.ListBox()
songsAsc = model.Requests.getSongs(note, "asc")
for i in range(0, len(songsAsc)):
if songsAsc[i][2] == "YES":
text = "<a href=\"" + escape(
songsAsc[i]
[1]) + "\" > <b> " + songsAsc[i][0] + " </b></a>"
else:
text = "<a href=\"" + escape(
songsAsc[i][1]) + "\" > " + songsAsc[i][0] + " </a>"
escape(text, quote=True)
song = Gtk.Label()
song.set_markup(text)
lb_Asc.add(song)
songsDes = model.Requests.getSongs(note, "des")
for i in range(0, len(songsDes)):
if songsDes[i][2] == "YES":
text = "<a href=\"" + escape(
songsDes[i]
[1]) + "\" > <b> " + songsDes[i][0] + " </b></a>"
else:
text = "<a href=\"" + escape(
songsDes[i][1]) + "\" > " + songsDes[i][0] + " </a>"
escape(text, quote=True)
song = Gtk.Label()
song.set_markup(text)
lb_Des.add(song)
#Grid properties
grid.set_column_spacing(30)
grid.set_row_spacing(10)
#Grid elements
label_Asc.set_hexpand(True)
label_Des.set_hexpand(True)
grid.add(label_Asc)
grid.attach(label_Des, 1, 0, 2, 1)
grid.attach_next_to(notes_Asc, label_Asc, Gtk.PositionType.BOTTOM, 1,
2)
grid.attach_next_to(notes_Des, label_Des, Gtk.PositionType.BOTTOM, 1,
2)
grid.attach_next_to(lb_Asc, notes_Asc, Gtk.PositionType.BOTTOM, 1, 1)
grid.attach_next_to(lb_Des, lb_Asc, Gtk.PositionType.RIGHT, 1, 1)
GLib.idle_add(self.show_secondary_all, win)