def keep_latest_dict(self, load_event_dicts): ''' Given a list of dicts with table-name, load-date, and row num keys, return a new list with only the dicts that describe the most recent table refresh. @param load_event_dicts: array of dict describing table refresh events. @type load_event_dicts: [{}] ''' # Dict {tbl_name : load_event_dict} to hold # the most recent dict for the respective table. # Use an ordered dict to not mess up order of # passed-in dicts: latest_dicts = OrderedDict() for load_event_dict in load_event_dicts: tbl_nm = load_event_dict['tbl_name'] try: if load_event_dict['time_refreshed'] > latest_dicts[tbl_nm]['time_refreshed']: latest_dicts[tbl_nm] = load_event_dict except KeyError: # First time we see an entry for this table: latest_dicts[tbl_nm] = load_event_dict res = [newest_refresh_dict for newest_refresh_dict in latest_dicts.values()] return res
def __init__(self, port, controller, script): ''' Builds the GUI, connects it to the server (thread). The GUI is just another client of the service. ''' global cmdClient cmdClient = self self.logger = logging.getLogger(__name__) self.port = port self.controller = controller self.script = script self.prompt = '$ ' (self.stdin, self.echo) = (sys.stdin, False) if self.script == '-' else (open(script, 'r'), True) self.stdout = sys.stdout self.conn = rpyc.connect(self.controller.hostAddress, port) # Local connection to the service GLib.io_add_watch( self.conn, 1, GLib.IO_IN, self.bg_server) # Register the callback with the service GLib.io_add_watch(self.stdin, 1, GLib.IO_IN, self.cmd_server) self.conn.root.login("*gui*", self.on_serverMessage) # Log in to the service self.appDownLoaded = False self.appFolder = None self.appName = None self.deplName = None self.nodeIDDict = OrderedDict() self.appStatusDict = OrderedDict() self.loop = GLib.MainLoop()
def test_update_settings(self): # open page and check the panel self.open_page("#settings") self.wait_js("{settings_list}.length>0".format(**self.EXT_QUERIES), 'There is no settings panel!') self.wait_js("!{is_masked}".format(**self.BASE_EXT_QUERIES), 'Masked!', silent=True) # get old values and update new old_values = self.driver.execute_script( "return {settings_form}.getValues();".format(**self.EXT_QUERIES)) self.driver.execute_script( "{settings_form}.setValues({test_data});".format( test_data=json_dump(self.TEST_DATA), **self.EXT_QUERIES)) self.click_component("{settings_save_btn}".format(**self.EXT_QUERIES)) # refresh page and check values are saved self.open_page("#settings") self.wait_js("!{is_masked}".format(**self.BASE_EXT_QUERIES), 'Masked!', silent=True) new_value = self.driver.execute_script( "return {settings_form}.getValues();".format(**self.EXT_QUERIES)) self.assertEqual(OrderedDict(sorted(self.TEST_DATA.items())), OrderedDict(sorted(new_value.items())), 'Values are not equal.') # reset values to original self.driver.execute_script( "{settings_form}.setValues({test_data});".format( test_data=json_dump(old_values), **self.EXT_QUERIES)) self.click_component("{settings_save_btn}".format(**self.EXT_QUERIES))
def create_tables(): """Creating Std tables""" db_obj.execute_query(db_connection, 'Show Tables') tables_to_execute = list( OrderedSet(['User', 'Admin', 'ProductCategory', 'Product', 'Cart']) - set([i[0] for i in db_connection])) mapper_ = OrderedDict({ 'User': """Create Table User ( customer_id int NOT NULL, name varchar(255) NOT NULL, email varchar(255), address varchar(255), PRIMARY KEY (customer_id))""", 'Admin': """Create Table Admin ( admin_id int NOT NULL, name varchar(255) NOT NULL, email varchar(255), address varchar(255), PRIMARY KEY (admin_id))""", 'ProductCategory': """Create Table ProductCategory( category_id int NOT NULL, name varchar(255) NOT NULL,description varchar(255),PRIMARY KEY (category_id))""", 'Product': """Create Table Product ( product_id int NOT NULL, name varchar(255) NOT NULL, category_id int not null,description varchar(255),PRIMARY KEY (product_id), foreign key(category_id) references ProductCategory(category_id))""", 'Cart': """ Create Table Cart ( cart_id int not null, customer_id int,address varchar(255), email varchar(255), product_id int not null, discount_amount int not null, total_amount int not null, PRIMARY KEY (cart_id), foreign key(customer_id) references User(customer_id), foreign key(product_id) references Product(product_id))""" }) for query in tables_to_execute: try: db_obj.execute_query(db_connection, mapper_.get(query)) except Error as e: db_obj.db_close() raise e
def _sort_locs(self): """ Sort the locs by distance. :return: """ self._locs = OrderedDict(sorted(self._locs.items(), key=lambda t: t[0]))
def createFasta(input_file,append_file,order): fastaInDict=dict() seq=OrderedDict() with open(input_file) as FASTAIN, open(append_file, "a") as APP, open(order) as ORD: fastaParse = SeqIO.parse(FASTAIN,"fasta") for fastaSeq in fastaParse: s = str(fastaSeq.seq) idFasta = fastaSeq.id fastaInDict[idFasta]=s for line in ORD: line=line.rstrip("\n") v=line.split("\t") val=v[0].split("__") start=int(val[1])-1 end=int(val[2]) k=val[0] chrom=v[1] if chrom in seq: seq[chrom].append(fastaInDict[k][start:end]) else: seq[chrom]=[] seq[chrom].append(fastaInDict[k][start:end]) for k,v in seq.items(): print("Writing Chromosome"+str(k)) APP.write(">"+k+"\n") APP.write("".join(v)) APP.write("\n")
def setCompletionPrefix(self, text: str): temp_file_name = util.get_temp_file("cpp") with codecs.open(temp_file_name, "w", "utf-8") as f: f.write(self.parent.toPlainText()) src_line_num = str(self.parent.textCursor().blockNumber() + 1) src_char_num = str(self.parent.textCursor().columnNumber()) try: out = subprocess.check_output( # read all header is too slow # "clang -fsyntax-only -Xclang -code-completion-at=%s:%s:%s %s" "clang -cc1 -fsyntax-only -code-completion-at=%s:%s:%s %s" % (temp_file_name, src_line_num, src_char_num, temp_file_name), shell=True, ).decode() except subprocess.CalledProcessError as e: out = e.output.decode() self.candidates_dict = OrderedDict() for line in out.split("\n"): if line.startswith("COMPLETION:"): cand = line.split(" ")[1] if text not in cand: continue if cand not in self.ng_words: self.candidates_dict[cand] = -1 for live_template in self.live_templates: if live_template.name.startswith(text): self.candidates_dict[live_template.template] = live_template.rpos if len(self.candidates_dict) >= 10 or text in self.candidates_dict.keys(): self.candidates_dict = {} self.setModel(QtCore.QStringListModel(self.candidates_dict.keys())) super().setCompletionPrefix(text)
def sube(nombrearchivo): doc = fitz.open(nombrearchivo) salida = open(nombrearchivo + ".txt", "wb") for pagina in doc: texto = pagina.getText().encode("utf8") salida.write(texto.lower()) salida.write(b"\n-----\n") salida.close() with open(nombrearchivo + '.txt', 'r', encoding='UTF8') as archivo: texto = archivo.read() stop_words = set(stopwords.words(fileids=('english', 'spanish'))) word_tokens = word_tokenize(texto) word_tokens = list( filter(lambda token: token not in string.punctuation, word_tokens)) #areglo=[] #word_tokens.append("--") filtro = [] for palabra in word_tokens: if palabra not in stop_words: filtro.append(palabra) c = Counter(filtro) y = OrderedDict(c.most_common()) with open(nombrearchivo + 'KEYWORDS.txt', 'w', encoding='UTF8') as far: for k, v in y.items(): far.write(f"{k} {v}\n")
def create_vocabulary(): """ Using RNN_CONFIG['vocab_using_n_tweets'] tweets from the train.csv dataset, \n creates a vocabulary with RNN_CONFIG['AE_vocab_size']] words.\n The vocabulary is an ordered dictionary: the keys are the word radicals and the keys each word's index.\n :return: None, dumps the vocabulary as a .json file at data/vocab.json """ with open(cfg['csv_relative_path'], newline='') as csvfile: data = list(csv.reader(csvfile))[1:] vocab = {} ps = PorterStemmer() for idx, line in enumerate(data[:RNN_CONFIG['vocab_using_n_tweets']]): printProgressBar(idx, RNN_CONFIG['vocab_using_n_tweets'], 'creating dictionary') for word in line[COLUMN_NAME_TO_IDX['text']].lower().split(' '): w = ps.stem(word) if w in vocab: vocab[w] += 1 else: vocab[w] = 1 # sort the vocabulary by descending occurrences vocab = OrderedDict([(k, idx) for idx, (k, _) in enumerate( sorted(vocab.items(), key=lambda item: item[1], reverse=True) [:RNN_CONFIG['AE_vocab_size']])]) with open('data/vocab.json', 'w') as f: json.dump(vocab, f, indent=4)
def test_largescale(): s = Stopwatch() integration_factor = 5 device_map = device_parser.build_device_map(device_parser.parse_data('test.xml')) test_size = 10000 histogram = OrderedDict() for i in range(5): time = 0.0 for j in range(5): s.start() generate_test_input(device_map, test_size, file_name='test_input1.csv') s.stop() print('Generating test input of size {}: '.format(test_size), s.read()) s.reset() s.start() analyze_data_nograph('csvs/test_input1.csv', integration_factor, device_map) s.stop() print('Processing input of size {}: '.format(test_size), s.read()) time += s.read() s.reset() print('Average time for input of size {}: '.format(test_size), time/5) histogram[test_size] = time/5 test_size *= 2 print(histogram) for i,j in histogram.items(): print(' size | time ') print('{0:5d}|{1:5f}'.format(i,j))
async def do_menu(self, ctx, c): emoji_to_embed = OrderedDict() for idx, image_info in enumerate(c['images']): emoji = char_to_emoji(str(idx)) emoji_to_embed[emoji] = make_card_embed(c, idx) starting_menu_emoji = list(emoji_to_embed.keys())[0] return await self._do_menu(ctx, starting_menu_emoji, emoji_to_embed)
def __init__(self, DirectoryName, BayesFolder): colors = sns.color_palette('muted') self.colors = [colors[0], colors[1], colors[3], colors[2]] self.Foldername = DirectoryName self.BayesFolder = BayesFolder self.SaveFolder = os.path.join(self.Foldername, 'SaveAnalysed') self.animalname = [ f for f in os.listdir(self.Foldername) if f not in ['LickData', 'BayesResults_All', 'SaveAnalysed'] ] print(self.animalname) self.taskdict = ['Task1', 'Task2', 'Task3', 'Task4'] self.framespersec = 30.98 self.tracklength = 200 self.velocity_in_space, self.bayescompiled = OrderedDict( ), OrderedDict() self.slope, self.speed_ratio = OrderedDict(), OrderedDict() for a in self.animalname: animalinfo = DataDetails.ExpAnimalDetails(a) animaltasks = animalinfo['task_dict'] bayesfile = [f for f in os.listdir(self.BayesFolder) if a in f][0] self.accuracy_dict = self.get_bayes_error(animaltasks, bayesfile) self.goodrunningdata, self.running_data, self.good_running_index, self.lickdata, self.lapspeed, self.numlaps, = self.load_runningdata( a) self.good_lapframes = self.get_lapframes(a, animaltasks) plt.plot(self.goodrunningdata['Task2']) plt.plot(self.good_lapframes['Task2']) plt.title(np.max(self.good_lapframes['Task2'])) plt.show() self.velocity_in_space[a], self.bayescompiled[ a] = self.get_velocity_in_space_bylap(a, animaltasks) self.slope[a], self.speed_ratio[a] = self.get_slopeatend( a, animaltasks) # self.save_data()
def get_output_parameters(observable_df: pd.DataFrame, sbml_model: libsbml.Model) -> List[str]: """Get output parameters Returns IDs of parameters used in observable and noise formulas that are not defined in the SBML model. Arguments: observable_df: PEtab observable table sbml_model: SBML model Returns: List of output parameter IDs """ formulas = list(observable_df[OBSERVABLE_FORMULA]) if NOISE_FORMULA in observable_df: formulas.extend(observable_df[NOISE_FORMULA]) output_parameters = OrderedDict() for formula in formulas: free_syms = sorted(sp.sympify(formula).free_symbols, key=lambda symbol: symbol.name) for free_sym in free_syms: sym = str(free_sym) if sbml_model.getElementBySId(sym) is None and sym != 'time': output_parameters[sym] = None return list(output_parameters.keys())
def parse_argv(args: list, namemap: dict = None) -> dict: """ A simple helper for get arguments of __main__ function """ d = OrderedDict() if not args: return d i = 1 while True: if i >= len(args): break s = args[i] if s.startswith('-'): if namemap and s in namemap: s = namemap[s] if s not in d: d[s] = [] while i + 1 < len(args) and args[i + 1][0] != '-': d[s].append(args[i + 1]) i += 1 i += 1 for k, v in tuple(d.items()): if not v: d[k] = None elif len(v) == 1: d[k] = v[0] return d
def importSeqFiles(request, pk): template_name = 'importFiles.html' excel_file = request.FILES['excel_file'] excel_file_content = excel_file.read().decode("utf-8") lines = excel_file_content.split("\n") runDict = OrderedDict() count = 1 for line in lines: line = line.rstrip("\r") v = line.split(",") if (v[1] != ""): runName = v[1] if (v[0] != ""): expName = v[0] runDict[v[2]] = [expName, runName] count += 1 if "File Path" in runDict: del runDict["File Path"] if " " in runDict: del runDict[" "] context = {} runDictSorted = sorted(runDict.items()) context['runDict'] = runDictSorted project = Project.objects.get(pk=pk) context['project'] = project return (request, template_name, context)
def test_sort_by_inner_dict(self): # Example dict from https://www.geeksforgeeks.org/python-sort-nested-dictionary-by-key/ d1 = { 'Nikhil': { 'roll': 24, 'marks': 17 }, 'Akshat': { 'roll': 54, 'marks': 12 }, 'Akash': { 'roll': 12, 'marks': 15 } } # Test 1, sort by 'marks' field1 = 'marks' exp1 = OrderedDict( sorted(d1.items(), key=lambda x: getitem(x[1], field1))) self.assertEqual(exp1, self._cu.sort_by_inner_dict(d=d1, field=field1)) # Test 2, sort by 'marks' in reverse. exp2 = OrderedDict( sorted(d1.items(), key=lambda x: getitem(x[1], field1), reverse=True)) act2 = self._cu.sort_by_inner_dict(d=d1, field=field1, is_descending=True) self.assertEqual(exp2, act2)
def parse(self, input_features): if 'bounding_boxes_{}'.format(self.disease_annotation) not in input_features: Add_Bounding_Box = Add_Bounding_Box_Indexes([self.disease_annotation], add_to_dictionary=False) input_features = Add_Bounding_Box.parse(input_features) if 'bounding_boxes_{}'.format(self.disease_annotation) in input_features: bounding_boxes = input_features['bounding_boxes_{}'.format(self.disease_annotation)] voxel_volumes = input_features['voxel_volumes_{}'.format(self.disease_annotation)] del input_features['voxel_volumes_{}'.format(self.disease_annotation)] del input_features['bounding_boxes_{}'.format(self.disease_annotation)] image_base = input_features['image'] annotation_base = input_features['annotation'] out_features = OrderedDict() for cube_index, [box, voxels] in enumerate(zip(bounding_boxes, voxel_volumes)): if voxels < self.min_voxel_volume or voxels > self.max_voxels: continue z_start, z_stop, r_start, r_stop, c_start, c_stop = add_bounding_box_to_dict(box, return_indexes=True) box_size = [z_stop - z_start, r_stop - r_start, c_stop - c_start] remainders = np.asarray([self.cube_size[i] - box_size[i] % self.cube_size[i] if box_size[i] % self.cube_size[i] != 0 else 0 for i in range(3)]) z_start, z_stop, r_start, r_stop, c_start, c_stop = expand_box_indexes(z_start, z_stop, r_start, r_stop, c_start, c_stop, annotation_shape= annotation_base.shape, bounding_box_expansion= remainders//2+1) image = image_base[z_start:z_stop, r_start:r_stop, c_start:c_stop] annotation = annotation_base[z_start:z_stop, r_start:r_stop, c_start:c_stop] stack_image, stack_annotation = [image[None,...]], [annotation[None,...]] for axis in range(3): output_images = [] output_annotations = [] for i in stack_image: split = i.shape[axis+1] // self.cube_size[axis] if split > 1: output_images += np.array_split(i, split, axis=axis+1) else: output_images += [i] for i in stack_annotation: split = i.shape[axis+1] // self.cube_size[axis] if split > 1: output_annotations += np.array_split(i, split, axis=axis+1) else: output_annotations += [i] stack_image = output_images stack_annotation = output_annotations for box_index, [image_cube, annotation_cube] in enumerate(zip(stack_image, stack_annotation)): temp_feature = OrderedDict() image_cube, annotation_cube = image_cube[0], annotation_cube[0] temp_feature['image'] = image_cube[:self.cube_size[0]] temp_feature['annotation'] = annotation_cube[:self.cube_size[0]] for key in input_features: # Bring along anything else we care about if key not in temp_feature.keys(): temp_feature[key] = input_features[key] out_features['Disease_Box_{}_{}'.format(cube_index, box_index)] = temp_feature input_features = out_features return input_features return input_features
def make_tick(self): updates = OrderedDict() updates.update(self.update()) self.theano_tick = theano.function([], [], updates=updates) # introduce 1-time-tick delay for o in self.origin.values(): if o.func is not None and self.mode == 'direct': continue o.tick()
def firstUniqChar(self, s: str) -> int: from _collections import OrderedDict order_dict = OrderedDict() for char in s: order_dict[char] = order_dict.get(char,0)+1 for key,val in order_dict.items(): if val == 1: return s.index(key) return -1
def unpack(self, action: OrderedDict) -> OrderedDict: newactions = {} for actid, value in action.items(): if actid in self._subdicts: origactions = self._subdicts[actid].getById(value) for origid, origact in origactions.items(): newactions[origid] = origact else: newactions[actid] = value return OrderedDict(newactions)
def f_rec(n): dict = OrderedDict({0: 0, 1: 1, 2: 2}) if n in dict.keys(): return dict[n] else: for i in range(3, n + 1): current_value = dict[i - 1] + dict[i - 3] dict.popitem(last=False) dict[i] = current_value return dict[n]
def __init__(self, model, recording_mode=['inputs'], exclude_matcher_fn=lambda n, m: False, include_matcher_fn=lambda n, m: True, input_fn=None, output_fn=None, grad_in_fn=None, grad_out_fn=None, activation_reducer_fn=None, grad_reducer_fn=None, include_gradients=False, device_modifier='cpu', recursive=False): Recorder._assert_supported_static(recording_mode, '_ALL_RECORDING_MODES') Recorder._assert_callable_or_none([ input_fn, output_fn, grad_in_fn, grad_out_fn, activation_reducer_fn, grad_reducer_fn ]) self._forward_hooks = [] self._backward_hooks = [] self.record = OrderedDict() self.tracked_modules = OrderedDict() self.recording_mode = recording_mode if callable(device_modifier): self.device_modifier = device_modifier else: Recorder._assert_supported_static(device_modifier, '_SUPPORTED_DEVICE_MODES') self.device_modifier = lambda v: v if device_modifier == 'same' else v.cpu( ) self.tag = None self.master_record_enable = True if recursive: generator = model.named_modules else: generator = model.named_children for trace_name, m in generator(): if include_matcher_fn(trace_name, m) and not exclude_matcher_fn(trace_name, m): self.tracked_modules[trace_name] = m self._forward_hooks.append( m.register_forward_hook( self.recording_hook_generator(trace_name + '_forward', input_fn, output_fn, activation_reducer_fn))) if include_gradients: self._backward_hooks.append( m.register_backward_hook( self.recording_hook_generator( trace_name + '_grad', grad_in_fn, grad_out_fn, grad_reducer_fn)))
def update(self, dt): """ :param float dt: the timestep of the update """ if self.pstc >= dt: decay = TT.cast(np.exp(-dt / self.pstc), self.value.dtype) value_new = decay * self.value + (1 - decay) * self.source return OrderedDict([(self.value, value_new.astype(FLOAT_TYPE))]) else: ### no filtering, so just make the value the source return OrderedDict([(self.value, self.source.astype(FLOAT_TYPE))])
def analis(self, column): alphabet = " абвгдежзийклмнопрстуфхцчшщъыьэюя" self.dicts = {letter: 0 for letter in alphabet} dict_step = {letter: i for (i, letter) in enumerate(alphabet)} for i in column: self.dicts[i] += 1 self.dicts = OrderedDict( sorted(self.dicts.items(), key=lambda t: -t[1])) self.super_dicts.append(self.dicts) azaza = list(self.dicts.keys()) return dict_step.get(azaza[0])
def get_features(image_path, annotation_path, image_processors=None, record_writer=None): features = OrderedDict() features['image_path'] = image_path features['annotation_path'] = annotation_path if image_processors is not None: for image_processor in image_processors: features, _ = down_dictionary(features, OrderedDict(), 0) for key in features.keys(): features[key] = image_processor.parse(features[key]) features, _ = down_dictionary(features, OrderedDict(), 0) record_writer.parse(features)
def commentCountDistribution(streamComments): commentCount = OrderedDict() for user in streamComments: count = len(streamComments[user]) if count not in commentCount: commentCount[count] = [] commentCount[count].append(user) commentDistribution = {} for count in sorted(commentCount.keys()): commentDistribution[count] = len(commentCount[count]) return commentDistribution
def test_multiroot_one_root(self): # Single root, degenerate case equivalent # to SingleRootImageDataset: mrds = MultiRootImageDataset(self.TEST_FILE_PATH_CARS) self.assertDictEqual(mrds.class_to_id, {'audi': 0, 'bmw': 1}) self.assertDictEqual( mrds.sample_id_to_class, OrderedDict({ 0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 1, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1, })) self.assertListEqual(mrds.class_id_list(), [0, 1]) self.assertDictEqual( mrds.sample_id_to_path, OrderedDict({ 0: os.path.join(self.TEST_FILE_PATH_CARS, 'audi', 'audi1.jpg'), 1: os.path.join(self.TEST_FILE_PATH_CARS, 'audi', 'audi2.jpg'), 2: os.path.join(self.TEST_FILE_PATH_CARS, 'audi', 'audi3.jpg'), 3: os.path.join(self.TEST_FILE_PATH_CARS, 'audi', 'audi4.jpg'), 4: os.path.join(self.TEST_FILE_PATH_CARS, 'audi', 'audi5.jpg'), 5: os.path.join(self.TEST_FILE_PATH_CARS, 'audi', 'audi6.jpg'), 6: os.path.join(self.TEST_FILE_PATH_CARS, 'bmw', 'bmw1.jpg'), 7: os.path.join(self.TEST_FILE_PATH_CARS, 'bmw', 'bmw2.jpg'), 8: os.path.join(self.TEST_FILE_PATH_CARS, 'bmw', 'bmw3.jpg'), 9: os.path.join(self.TEST_FILE_PATH_CARS, 'bmw', 'bmw4.jpg'), 10: os.path.join(self.TEST_FILE_PATH_CARS, 'bmw', 'bmw5.jpg'), 11: os.path.join(self.TEST_FILE_PATH_CARS, 'bmw', 'bmw6.jpg') }))
def _loadPlugins(self): """ Loads available plugins. Adds default. :raise RuntimeError: When there is problem with plugins. """ # available features extractors if len(FEATURE_EXTRACTORS) == 0: raise RuntimeError("There are no features extractors plugins.") feTmp = {} for fe in FEATURE_EXTRACTORS.values(): if fe.getName() in feTmp: # wow, name collision raise RuntimeError( "Collision of features extractors names. For name: " + fe.getName()) feTmp[fe.getName()] = fe # lets put the default feature extractor as the first if exists if self.DEFAULT_FEATURE_EXTRACTOR_NAME in feTmp: cont = [(self.DEFAULT_FEATURE_EXTRACTOR_NAME, feTmp[self.DEFAULT_FEATURE_EXTRACTOR_NAME])] # add the rest cont += [(n, p) for n, p in feTmp.items() if n != self.DEFAULT_FEATURE_EXTRACTOR_NAME] self._featuresExt = OrderedDict(cont) else: self._featuresExt = OrderedDict(feTmp) # available classifiers if len(CLASSIFIERS) == 0: raise RuntimeError("There are no classifiers plugins.") clsTmp = set() for cls in CLASSIFIERS.values(): if cls.getName() in clsTmp: # wow, name collision raise RuntimeError( "Collision of classifiers names. For name: " + cls.getName()) clsTmp.add(cls.getName()) # available Validators self.availableEvaluationMethods = getAllSubclasses(Validator) self._evaluationMethod = self.availableEvaluationMethods[0]( ) # add default # available Features selectors self.availableFeatureSelectors = getAllSubclasses(FeaturesSelector)
def __init__(self, course_stats_obj_list): self.course_name = course_stats_obj_list[0]['crse_code'] num_offerings = len(course_stats_obj_list) # Compute average percentage in each difficulty level # of each offering: diff_level1_sum = 0 diff_level2_sum = 0 diff_level3_sum = 0 diff_level4_sum = 0 diff_level5_sum = 0 diff_level6_sum = 0 diff_level7_sum = 0 diff_level8_sum = 0 # Sum the percentage difficulties for each # difficulty for all offerings of the current course: for course_stat_obj in course_stats_obj_list: diff_level1_sum += course_stat_obj.percent_by_difficulty(1) diff_level2_sum += course_stat_obj.percent_by_difficulty(2) diff_level3_sum += course_stat_obj.percent_by_difficulty(3) diff_level4_sum += course_stat_obj.percent_by_difficulty(4) diff_level5_sum += course_stat_obj.percent_by_difficulty(5) diff_level6_sum += course_stat_obj.percent_by_difficulty(6) diff_level7_sum += course_stat_obj.percent_by_difficulty(7) diff_level8_sum += course_stat_obj.percent_by_difficulty(8) self.summary_dict = OrderedDict({ CourseStats.DIFF_LEVEL1: diff_level1_sum / num_offerings, CourseStats.DIFF_LEVEL2: diff_level2_sum / num_offerings, CourseStats.DIFF_LEVEL3: diff_level3_sum / num_offerings, CourseStats.DIFF_LEVEL4: diff_level4_sum / num_offerings, CourseStats.DIFF_LEVEL5: diff_level5_sum / num_offerings, CourseStats.DIFF_LEVEL6: diff_level6_sum / num_offerings, CourseStats.DIFF_LEVEL7: diff_level7_sum / num_offerings, CourseStats.DIFF_LEVEL8: diff_level8_sum / num_offerings }) self.num_offerings = num_offerings # List of termcores when course was offered self.termcores = [ stats_obj['termcore'] for stats_obj in course_stats_obj_list ]
def __init__(self, *args, **kwargs): """ """ self.results = OrderedDict() self.y = None self.x = None self.layers = OrderedDict() for layer in args: layer_name = layer.name self.layers[layer_name] = layer self.name = kwargs.get('name', str(random.randint(0, 2**5)))
def stringPermutation(orgString): char_count_map = {}; for temp_char in orgString: if temp_char not in char_count_map: char_count_map[temp_char] = 1; continue; char_count_map[temp_char] += 1; char_count_map = OrderedDict(sorted(char_count_map.items(), key=lambda t: t[0])); temp_arr = []; string_permutaion_list = []; Util.string_permutation_helper(len(orgString), char_count_map, temp_arr, string_permutaion_list) # print(len(string_permutaion_list)) print(string_permutaion_list)
def update(self, dt): """Update the input and output of all the theano variables. """ updates = OrderedDict() for input in self.input.values(): updates.update(input.update(dt)) for origin in self.origin.values(): if origin.func is None: updates.update( {origin.decoded_output: origin.method()}) return updates
def make_theano_tick(self): """Generate the theano function for running the network simulation. :returns: theano function """ # dictionary for all variables # and the theano description of how to compute them updates = OrderedDict() # for every node in the network for node in self.nodes.values(): # if there is some variable to update if hasattr(node, 'update'): # add it to the list of variables to update every time step updates.update(node.update(self.dt)) # create graph and return optimized update function return theano.function([], [], updates=updates.items())#, mode='ProfileMode')
def update(self, dt): """Compute the set of theano updates needed for this ensemble. Returns a dictionary with new neuron state, termination, and origin values. :param float dt: the timestep of the update """ ### find the total input current to this population of neurons # set up matrix to store accumulated decoded input X = None # updates is an ordered dictionary of theano variables to update updates = OrderedDict() for ii, di in enumerate(self.decoded_input.values()): # add its values to the total decoded input if ii == 0: X = di.value else: X += di.value updates.update(di.update(dt)) # if we're in spiking mode, then look at the input current and # calculate new neuron activities for output if self.mode == 'spiking': # apply respective biases to neurons in the population J = TT.as_tensor_variable(np.array(self.bias)) for ei in self.encoded_input.values(): # add its values directly to the input current J += (ei.value.T * self.alpha.T).T updates.update(ei.update(dt)) # only do this if there is decoded_input if X is not None: # add to input current for each neuron as # represented input signal x preferred direction for i in range(self.array_size): #len(self.bias)): J = TT.basic.inc_subtensor(J[i], TT.dot(X[i], self.shared_encoders[i].T)) # if noise has been specified for this neuron, if self.noise: # generate random noise values, one for each input_current element, # with standard deviation = sqrt(self.noise=std**2) # When simulating white noise, the noise process must be scaled by # sqrt(dt) instead of dt. Hence, we divide the std by sqrt(dt). if self.noise_type.lower() == 'gaussian': J += self.srng.normal( size=self.bias.shape, std=np.sqrt(self.noise/dt)) elif self.noise_type.lower() == 'uniform': J += self.srng.uniform( size=self.bias.shape, low=-self.noise/np.sqrt(dt), high=self.noise/np.sqrt(dt)) # pass that total into the neuron model to produce # the main theano computation updates.update(self.neurons.update(J, dt)) for l in self.learned_terminations: # also update the weight matrices on learned terminations updates.update(l.update(dt)) # and compute the decoded origin decoded_input from the neuron output for o in self.origin.values(): updates.update(o.update(dt, updates[self.neurons.output])) if self.mode == 'direct': # if we're in direct mode then just directly pass the decoded_input # to the origins for decoded_output for o in self.origin.values(): if o.func is None: if len(self.decoded_input) > 0: updates.update(OrderedDict({o.decoded_output: TT.flatten(X).astype('float32')})) return updates