[str, str]:\\n directory = \\\"{}/{}/{}/{}\\\".format(self.save_path, EXPERIMENTS_DIRECTORY, self.name, self.run_id)\\n sourcecode_directory = \\\"{}/sourcecode\\\".format(directory)\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n else:\\n raise Exception(\\\"Experiment run [{}] already exists for experiment [{}]\\\".format(self.run_id, self.name))\\n return directory, sourcecode_directory\",\n \"def mkdir(path):\",\n \"def initializeFolder(savePath,name,bOverWrite):\\n if savePath==None:\\n savePath=os.path.join('.','results')\\n path=os.path.join(savePath,name)\\n path_copy=deepcopy(path)\\n if not bOverWrite:\\n if os.path.exists(path_copy):\\n fi=2\\n poss_path=os.path.join(path_copy,'Run (%i)'%fi)\\n while os.path.exists(poss_path):\\n fi+=1\\n poss_path=os.path.join(path_copy,'Run (%i)'%fi)\\n path=poss_path\\n \\n os.makedirs(path)\\n \\n bexisted=True\\n if not os.path.exists(path):\\n os.makedirs(path)\\n bexisted=False\\n \\n if path[-1]!=os.path.sep:\\n path+=os.path.sep\\n \\n print \\\"Results will be saved in %s folder '%s'\\\"%('existing' if bexisted else 'new',path) \\n return path\",\n \"def create_download_folder(path=None):\\n local_path = path or DEFAULT_PATH\\n folder_name = time.strftime(\\\"%Y%m%dT%H%M%S\\\")\\n folder_path = os.path.join(local_path, folder_name)\\n\\n if not os.path.exists(local_path):\\n os.mkdir(local_path)\\n if not os.path.exists(folder_path):\\n os.mkdir(folder_path)\\n\\n return folder_path\",\n \"def createFolder(self):\\n\\n self.directory = \\\"D:\\\\\\\\CompositionHelper\\\"\\n if not os.path.exists(self.directory):\\n os.makedirs(self.directory)\\n print ('Created new folder')\",\n \"def create_folder(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def create_experiment_folder(path_out, dir_name, name='', stamp_unique=True):\\n assert os.path.exists(path_out), 'missing base folder \\\"%s\\\"' % path_out\\n date = time.gmtime()\\n if isinstance(name, str) and name:\\n dir_name = '{}_{}'.format(dir_name, name)\\n path_exp = os.path.join(path_out, dir_name)\\n if stamp_unique:\\n path_exp += '_' + time.strftime(FORMAT_DATE_TIME, date)\\n path_created = None\\n while not path_created:\\n logging.warning('particular out folder already exists')\\n if path_created is not None:\\n path_exp += '-' + str(np.random.randint(0, 100))\\n path_created = create_folder(path_exp, ok_existing=False)\\n else:\\n path_created = create_folder(path_exp, ok_existing=False)\\n logging.info('created experiment folder \\\"%r\\\"', path_created)\\n return path_exp\",\n \"def createFolder(self):\\n raise NotImplementedError\",\n \"def create_folder(path: str):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def create_folder(folder_path: List[str]) -> str:\\n drive = _drive_gen()\\n return _create_or_find_folder(folder_path, drive)\",\n \"def create_experiment_folder(path_out, dir_name, name='', stamp_unique=True):\\n if not os.path.isdir(path_out):\\n raise FileNotFoundError('missing base folder \\\"%s\\\"' % path_out)\\n date = time.gmtime()\\n if isinstance(name, str) and name:\\n dir_name = '%s_%s' % (dir_name, name)\\n # if you require time stamp\\n if stamp_unique:\\n path_stamp = time.strftime(FORMAT_DATE_TIME, date)\\n # prepare experiment path with initial timestamp - now\\n path_exp = os.path.join(path_out, '%s_%s' % (dir_name, path_stamp))\\n if os.path.isdir(path_exp):\\n logging.warning('particular out folder already exists')\\n path_exp += '-' + str(uuid.uuid4().hex)\\n else:\\n path_exp = os.path.join(path_out, dir_name)\\n path_created = create_folder(path_exp, ok_existing=False)\\n logging.info('created experiment folder \\\"%r\\\"', path_created)\\n return path_exp\",\n \"def create_folder(self):\\n Path(self.root_name).mkdir(parents=True, exist_ok=True)\\n Path(self.root_name + \\\"/VOC2021/\\\").mkdir(parents=True, exist_ok=True)\\n Path(self.image_folder_path).mkdir(parents=True, exist_ok=True)\\n Path(self.annot_path).mkdir(parents=True, exist_ok=True)\\n Path(self.root_name + \\\"/VOC2021/ImageSets/\\\").mkdir(parents=True, exist_ok=True)\\n Path(self.txt_path).mkdir(parents=True, exist_ok=True)\",\n \"def createFolder(folder):\\n folder_ = os.path.join(os.getcwd(),folder)\\n if not(os.path.isdir(folder_)):\\n os.mkdir(folder_)\",\n \"def create_folder(path):\\n if not exists(path):\\n os.makedirs(path)\",\n \"def makefilename(self):\\n fp= (pathlib.Path(self.vr_folder).expanduser()/(time.strftime(self.vr_filename))).with_suffix('')\\n fp.parent.mkdir(parents=True, exist_ok=True)\\n print('files setup', str(fp))\\n return fp\",\n \"def create_folder(folder):\\n if not os.path.exists(folder):\\n os.makedirs(folder)\",\n \"def createPath(self, outPath):\\n # Create new directory for output path\\n try:\\n os.mkdir(outPath)\\n except OSError:\\n print (\\\"Creation of the directory %s failed\\\" % outPath)\\n else:\\n print (\\\"Successfully created the directory %s \\\" % outPath)\",\n \"def prepare_folder(self) -> str:\\n base_folder = self.config['info']['folder']\\n today_folder = f'{datetime.today():%Y-%m-%d}'\\n folder = os.path.join(base_folder, today_folder)\\n if not os.path.isdir(folder):\\n os.makedirs(folder)\\n return folder\",\n \"def createdatafolder(name):\\n folder = os.path.join(pathtofolder(),name)\\n os.makedirs(folder)\\n pass\",\n \"def set_save_path(self, path):\\n self.save_path = path\\n if not os.path.exists(path):\\n os.makedirs(path)\\n return path\",\n \"def create_folder(path):\\n try:\\n os.listdir(path)\\n except:\\n os.makedirs(path)\\n else:\\n shutil.rmtree(path)\\n os.makedirs(path)\\n return path\",\n \"def create_folder(self, unformatted_path):\\n os.makedirs(self.format_path(unformatted_path), exist_ok=True)\",\n \"def download_folder(self) -> Path:\\n path = (\\n config.storage_vol\\n / f\\\"{self.device_type}/{self.patient_id}/{self.device_id}\\\"\\n )\\n path.mkdir(parents=True, exist_ok=True)\\n return path\",\n \"def new_dir(folder):\\n os.makedirs(folder, exist_ok=True)\\n return folder\",\n \"def create_directories(self, path):\\n os.makedirs(path)\\n print('Directory created at:', path)\\n return path\",\n \"def dirCreate(newFoldername):\\r\\n current_directory = os.getcwd()\\r\\n new_directory = os.path.join(current_directory,newFoldername)\\r\\n \\r\\n if not os.path.exists(new_directory):\\r\\n os.makedirs(new_directory)\\r\\n return new_directory\",\n \"def create_folder(self):\\n self.config.csv_path.mkdir(parents=True, exist_ok=True)\\n self.config.images_path.mkdir(parents=True, exist_ok=True)\",\n \"def _create_dirs(model_name: str) -> str:\\n model_dir = os.path.join(os.path.expanduser(\\\"~\\\"), \\\"bnlp\\\", \\\"models\\\")\\n os.makedirs(model_dir, exist_ok=True)\\n model_path = os.path.join(model_dir, model_name)\\n return model_path\",\n \"def createFolder(folderFullPath):\\n os.makedirs(folderFullPath, exist_ok=True)\",\n \"def _create_folders(self):\\n if not os.path.exists(os.path.join(BASE_DIR, DIR)):\\n os.mkdir(os.path.join(BASE_DIR, DIR))\\n directory = os.path.join(BASE_DIR, DIR, self.title)\\n if not os.path.exists(directory):\\n os.mkdir(directory)\\n return directory\",\n \"def create_dir_structure():\\n LOG.info('In create_dir_structure')\\n OutputWrite.change_to_script_directory(__file__)\\n path = os.path.abspath(os.path.join('..', 'results',\\n global_constants.TEXT_BOARD,\\n global_constants.TEXT_INTERFACE,\\n global_constants.TEXT_DEVICE,\\n global_constants.TEST_EXECUTION_NAME\\n ))\\n LOG.debug('Path to be Created = {0}'.format(path))\\n os.makedirs(path, exist_ok=True, mode=0o755)\\n for item in global_constants.TEST_CASE_LIST_NAMES:\\n in_path = os.path.exists(os.path.join(path, item))\\n if not os.path.exists(in_path):\\n LOG.debug('Path with Test Case name = {0}'.format(in_path))\\n os.mkdir(in_path)\\n LOG.debug('Path = {0}'.format(path))\\n return path\",\n \"def create_folder(path):\\n command = ['mkdir', TEST_DIR]\\n file_operation(path, command)\",\n \"def Create_my_dir(new_path): #Create paths (windows os)\\r\\n if not os.path.exists(new_path):\\r\\n os.makedirs(new_path);\",\n \"def create_folder(folder_path: str) -> None:\\n if not os.path.exists(folder_path):\\n os.makedirs(folder_path)\",\n \"def create_folder():\\n directory = \\\"data/\\\"\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n logging.info(\\\"Data folder created.\\\")\\n else:\\n logging.info(\\\"Data folder already existed.\\\")\",\n \"def save(path='data', name='', savetime=True):\\n\\n os.chdir(project_path + path)\\n # Create folder for results\\n if savetime:\\n directory = name + '_' + time.strftime(\\\"%d_%m_%Y-%H_%M_%S\\\")\\n else:\\n directory = name\\n\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n # das steht hier einfach so, ist bestimmt nicht sinnvoll\\n # folder = False\\n # if folder:\\n # if not os.path.exists(directory + \\\"/H\\\"):\\n # os.makedirs(directory + \\\"/H\\\")\\n # if not os.path.exists(directory + \\\"/Uin\\\"):\\n # os.makedirs(directory + \\\"/Uin\\\")\\n # if not os.path.exists(directory + \\\"/Uout\\\"):\\n # os.makedirs(directory + \\\"/Uout\\\")\\n # if not os.path.exists(directory + \\\"/K\\\"):\\n # os.makedirs(directory + \\\"/K\\\")\\n # if not os.path.exists(directory + \\\"/a\\\"):\\n # os.makedirs(directory + \\\"/a\\\")\\n\\n path = path + '/' + directory\\n return path\",\n \"def create_folder(output_directory: str, fldrname: str):\\n\\n os.makedirs(output_directory, exist_ok=True)\\n tstmp = datetime.now().strftime('%Y%m%d_%H%M%S')\\n try:\\n fldr_path = os.path.join(output_directory, fldrname)\\n os.mkdir(fldr_path)\\n except FileExistsError:\\n fldr_path = os.path.join(output_directory, fldrname + '_{}'.format(tstmp))\\n os.mkdir(fldr_path)\\n return fldr_path\",\n \"def create_output_folder(self):\\n if not os.path.exists(self.current_path):\\n os.mkdir(self.current_path)\\n data_dir_by_date = datetime.datetime.now().strftime(\\n \\\"data-%d-%b_%H-%M-%S\\\")\\n self.date_path = os.path.join(self.current_path, data_dir_by_date)\\n if not os.path.exists(self.date_path):\\n os.mkdir(self.date_path)\",\n \"def create_folder(self, foldername, parents=''):\\r\\n formatted_parents = (parents + '/').replace('/', '%2F')\\r\\n\\r\\n return self.yandex_requests.create_folder(\\r\\n foldername, formatted_parents)\",\n \"def create_app_folders(self):\\n\\t\\tif not os.path.exists(self.TEMP_FOLDER):\\n\\t\\t\\tos.makedirs(self.TEMP_FOLDER)\\n\\t\\tif not os.path.exists(self.SAVE_FOLDER):\\n\\t\\t\\tos.makedirs(self.SAVE_FOLDER)\",\n \"def create_output_dir(self):\\n if self.output_dir is None:\\n new_path = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\\n self.output_dir = os.path.expanduser(os.path.join(self.input_dir, new_path))\\n try:\\n os.makedirs(self.output_dir)\\n except OSError:\\n pass\",\n \"def create_directory():\\n global dirName\\n dirName = 'Downloaded Files'\\n global folder_path\\n if os.path.isdir(dirName) == True:\\n print(\\\"This folder already exists, path:\\\", os.path.abspath(dirName))\\n else:\\n os.mkdir(dirName)\\n global folder_path\\n folder_path = os.path.abspath(dirName)\\n print(\\\"Directory \\\" , dirName , \\\" Created \\\")\",\n \"def create_download_path(params: DownloadCommandParameters) -> None:\\n if not os.path.exists(params.output):\\n os.makedirs(params.output)\",\n \"def make_folder(l: str) -> None:\\n\\n Path(l).mkdir(parents=True, exist_ok=True)\\n\\n return\",\n \"def _create_dir(self):\\n images_train_dir = os.path.join('images', self.name, 'train')\\n images_test_dir = os.path.join('images', self.name, 'test')\\n log_dir = os.path.join('log', self.name)\\n model_dir = os.path.join('checkpoint', self.name)\\n if not os.path.exists(images_train_dir):\\n os.makedirs(images_train_dir)\\n\\n if not os.path.exists(images_test_dir):\\n os.makedirs(images_test_dir)\\n\\n if not os.path.exists(log_dir):\\n os.makedirs(log_dir)\\n\\n if not os.path.exists(model_dir):\\n os.makedirs(model_dir)\\n\\n return images_train_dir, images_test_dir, log_dir, model_dir\",\n \"def create_project_folder(self):\\n\\t\\tif not os.path.exists(self.segment_path):\\n\\t\\t\\tfileutil.makedirs(self.segment_path)\",\n \"def generate_temp_folder(self):\\n folder_name = str(time.time()).replace(\\\".\\\", \\\"\\\")\\n folder_path = os.path.join(self.temp_folder, folder_name)\\n os.makedirs(folder_path)\\n self.logger.debug(f\\\"Created nested temp folder at {folder_path}\\\")\\n return folder_path\",\n \"def create_temp_folder():\\n path_join = os.path.join(tempfile.gettempdir(), id_generator(5))\\n os.makedirs(path_join)\\n return path_join\",\n \"def prepare_folder(path):\\n if not os.path.isdir(path):\\n os.makedirs(path)\",\n \"def create_folder_path(folder_path):\\n try:\\n if os.path.exists(folder_path):\\n shutil.rmtree(folder_path)\\n os.makedirs(folder_path)\\n except Exception:\\n raise Error('Create {folder_path} exception'.format(folder_path))\",\n \"def create_new_dir(path):\\n logger.debug('Function Successful: % s',\\n 'create_new_dir: create_new_dir successfully called from save_single_file_locally', extra=d)\\n\\n if not os.path.exists(path):\\n logger.debug('Calling Function: % s',\\n 'create_new_dir: create_new_dir calling makedirs', extra=d)\\n os.makedirs(path)\\n logger.debug('Function Successful: % s',\\n 'create_new_dir: create_new_dir successfully called makedirs', extra=d)\",\n \"def _make_save_path(self, save_path, save_name):\\n if save_name.endswith('.txt'):\\n path = os.path.join(save_path, save_name)\\n else:\\n self.save_name = save_name+'.txt'\\n path = os.path.join(save_path, save_name)\\n return path\",\n \"def create_folder(folder_name):\\n if not os.path.exists(folder_name):\\n os.makedirs(folder_name)\",\n \"def create_folder(folder_name):\\n if not os.path.exists(folder_name):\\n os.makedirs(folder_name)\",\n \"def get_save_root(self, sub_directories_list=None,\\r\\n create_folder_if_no_exist=True):\\r\\n if sub_directories_list is None:\\r\\n sub_directories_list = []\\r\\n elif not isinstance(sub_directories_list, list):\\r\\n # Assume string, normally I would check for a string but apparently this\\r\\n # is a bit quirky with Python 2 vs 3\\r\\n sub_directories_list = [sub_directories_list]\\r\\n\\r\\n if getattr(self, 'default_save_path', None) is not None:\\r\\n root_path = self.default_save_path\\r\\n if not os.path.isdir(root_path):\\r\\n raise Exception('Specified default save path does not exist')\\r\\n else:\\r\\n # http://stackoverflow.com/questions/50499/in-python-how-do-i-get-the-path-and-name-of-the-file-that-is-currently-executin/50905#50905\\r\\n package_path = os.path.dirname(\\r\\n os.path.abspath(inspect.getfile(inspect.currentframe())))\\r\\n\\r\\n # Go up to root, then down to specific save path\\r\\n root_path = os.path.split(package_path)[0]\\r\\n root_path = os.path.join(root_path, 'data')\\r\\n\\r\\n save_folder_path = os.path.join(root_path, *sub_directories_list)\\r\\n\\r\\n if create_folder_if_no_exist and not os.path.exists(save_folder_path):\\r\\n os.makedirs(save_folder_path)\\r\\n\\r\\n return save_folder_path\",\n \"def create_save_directories(self):\\n # Set the name for the saved model and training summary directory\\n self.model_dir = op.join('../logs', self.name, 'models')\\n self.train_summary_dir = op.join('../logs', self.name, 'training_summary')\\n\\n if not op.exists(self.model_dir):\\n if not op.exists(op.join('../logs', self.name)):\\n if not op.exists('../logs'):\\n os.mkdir('../logs')\\n os.mkdir(op.join('../logs', self.name))\\n os.mkdir(self.model_dir)\\n\\n if not op.exists(self.train_summary_dir):\\n if not op.exists(op.join('../logs', self.name)):\\n if not op.exists('../logs'):\\n os.mkdir('../logs')\\n os.mkdir(op.join('../logs', self.name))\\n os.mkdir(self.train_summary_dir)\\n return self\",\n \"def create_path(self, path):\\n path_list = path.split(\\\"/\\\")\\n done_path = self.parent_folder + \\\"/\\\"\\n\\n for directory in path_list:\\n try:\\n os.mkdir(done_path + directory + \\\"/\\\")\\n except FileExistsError:\\n done_path += directory + \\\"/\\\"\",\n \"def create_experiment_folder(args, project_folder):\\n\\n # Generating the folder absolute path\\n dict_args = vars(args).copy()\\n\\n # Don't include unnecessary identifiers\\n dict_args.pop('input_size')\\n dict_args.pop('job_dir')\\n dict_args.pop('gcloud')\\n\\n expe_folder_abs_path = os.path.join(\\n project_folder,\\n \\\"results\\\",\\n dict_args.pop('model'),\\n dict_args.pop('prior'),\\n dict_args.pop('dataset'),\\n str(dict_args).replace('\\\\'', '').replace('{', '').replace('}', '').replace(': ', '-'),\\n \\\"\\\"\\n )\\n\\n # Creating the folder\\n if not os.path.exists(expe_folder_abs_path):\\n try:\\n os.makedirs(expe_folder_abs_path)\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise\\n\\n # Save the json file containing the parameters in the folder\\n param_path = os.path.join(expe_folder_abs_path, 'parameters.json')\\n with open(param_path, 'w') as f:\\n json.dump(vars(args), f, indent=4)\\n f.close()\\n\\n return expe_folder_abs_path\",\n \"async def new_folder(name):\\n res = await joplin.create_folder(folder=name)\\n return res.json()['id']\",\n \"def _check_save_directory_path(self):\\n if self.save_directory_path is not None:\\n if os.path.exists(self.save_directory_path):\\n raise ValueError(\\n 'You must provide non-existing save output directory, '\\n '{} given.'.format(self.save_directory_path))\\n else:\\n os.makedirs(self.save_directory_path)\",\n \"def create_folder(self):\\n path = os.path.expanduser('~') + \\\"/.ip_enrich/\\\"\\n # Does it exist already?\\n if os.path.isdir(path):\\n return True\\n try:\\n os.mkdir(path)\\n return True\\n except Exception as e:\\n print (f\\\"Creation of the directory {path} failed\\\")\\n print (f\\\"Error {e}\\\")\\n return False\",\n \"def create_folder(self, c_path):\\n raise NotImplementedError\",\n \"def make_save_dirs(save_dir, debug_dir=True):\\n save_dir = make_fancy_output_dir(save_dir,\\n save_environ=False, save_command=False,\\n save_git=False, save_gitignore=False,\\n save_pip=False)\\n os.makedirs(osp.join(save_dir, 'color'), exist_ok=True)\\n os.makedirs(osp.join(save_dir, 'depth'), exist_ok=True)\\n os.makedirs(osp.join(save_dir, 'camera_info'), exist_ok=True)\\n os.makedirs(osp.join(save_dir, 'annotation'), exist_ok=True)\\n\\n if debug_dir:\\n os.makedirs(osp.join(save_dir, 'debug_axis'), exist_ok=True)\\n os.makedirs(osp.join(save_dir, 'debug_roi'), exist_ok=True)\\n os.makedirs(osp.join(save_dir, 'debug_mask'), exist_ok=True)\\n return save_dir\",\n \"def gen_dir(layer, teste, root_folder):\\r\\n lyr = project.mapLayersByName(layer)[0]\\r\\n selection = get_lst_reprovado(lyr, teste)\\r\\n features = lyr.getFeatures()\\r\\n root_path = 'C:/' + root_folder + '_shp_result'\\r\\n\\r\\n os.mkdir(root_path)\\r\\n \\r\\n for feat in features:\\r\\n lote = feat['lote']\\r\\n municipio = feat['municipio']\\r\\n cod_emp = feat['cod_emp']\\r\\n lote_path = root_path + '/' + lote\\r\\n mun_path = lote_path + '/' + municipio\\r\\n imovel_path = mun_path + '/' + cod_emp\\r\\n \\r\\n if cod_emp in selection:\\r\\n if not os.path.exists(lote_path):\\r\\n os.makedirs(lote_path)\\r\\n \\r\\n if not os.path.exists(mun_path):\\r\\n os.makedirs(mun_path)\\r\\n \\r\\n os.mkdir(imovel_path)\\r\\n os.mkdir(imovel_path + '/shapefiles')\",\n \"def create_files(save_dir, vid_name):\\n file_name = vid_name.split('/')[-1].split('.')[0]\\n if not os.path.isdir(os.path.join(save_dir, file_name)):\\n os.makedirs(os.path.join(save_dir, file_name))\\n return file_name\",\n \"def create_folder(path_folder, name_subfolder=None):\\n if not name_subfolder:\\n if not os.path.exists(path_folder):\\n os.makedirs(path_folder)\\n else:\\n path_result_subolder = os.path.join(path_folder, name_subfolder)\\n if not os.path.exists(path_result_subolder):\\n os.makedirs(path_result_subolder)\",\n \"def make_save_dir(self, dir_string='', date='auto', date_first=True):\\n # Make a new unique identifier when making a new directory for data to be stored\\n if self.update_ID:\\n self.set_exp_id()\\n\\n # add the ID to the subdirectory, if prepend_ID is true\\n if dir_string is not '' and self.prepend_ID:\\n dir_string = rf'{self.exp_ID}_{dir_string}'\\n\\n # add the date automatically\\n if date is 'auto':\\n date = datetime.datetime.now().strftime('%Y_%m_%d')\\n\\n # decide ordering which to put the date\\n if date_first:\\n save_dir = rf'{self.base_directory}/{date}/{dir_string}'\\n else:\\n save_dir = rf'{self.base_directory}/{dir_string}/{date}'\\n\\n # or don't add the date\\n if date is None: # if you want to make a directory that doesn't specify date, for saving more general stuff\\n save_dir = rf'{self.base_directory}/{dir_string}'\\n\\n if not os.path.exists(save_dir):\\n print(\\\"Data storage dir does not exist,\\\"\\n \\\" creating it at {}\\\".format(save_dir))\\n os.makedirs(save_dir)\\n\\n return save_dir\",\n \"def _gen_folder_(self):\\n os.makedirs(self.fld_name)\\n dic_json = {\\\"PARAM_EXCOND\\\": self.cond_ex,\\n \\\"PARAM_CALCOND\\\": self.cond_cal,\\n \\\"PARAM_MODELCONST\\\": self.const_model\\n }\\n with open(os.path.join(self.fld_name, \\\"cond.json\\\"), \\\"w\\\") as f:\\n json.dump(dic_json, f, ensure_ascii=False, indent=4)\",\n \"def create_folder(folders_to_create=[]):\\n for f in folders_to_create:\\n if not os.path.exists(f):\\n os.makedirs(f)\",\n \"def path(self, *args, **kwds):\\n def makepath(args, mkdir=True):\\n path = os.path.join(self.dir, *args)\\n dirname = os.path.dirname(path)\\n if mkdir and not os.path.isdir(dirname):\\n os.makedirs(dirname)\\n return path\\n return makepath(args, **kwds)\",\n \"def create_folders(folder_name):\\n\\n if os.path.exists(downloads_path + '\\\\\\\\' + folder_name):\\n pass\\n else:\\n os.makedirs(folder_name)\\n print(f'Folder: {folder_name} has been created in {downloads_path}')\",\n \"def get_outfolder():\\n \\n valid = False\\n while not valid:\\n fname = raw_input(\\\"Please enter directory to save images. \\\")\\n if not os.path.exists(fname):\\n os.makedirs(fname)\\n #Check to see if the file is there.\\n if os.path.exists(fname): \\n valid = True\\n #File is not there, check to see if write privileges can be given\\n #to created file.\\n elif os.access(os.path.dirname(fname), os.W_OK):\\n valid = True\\n else:\\n print \\\"Invalid local path, please try again.\\\"\\n return fname\",\n \"def create_folders(self):\\n for f in self.params['folder_names']:\\n if not os.path.exists(f):\\n print 'Creating folder:\\\\t%s' % f\\n os.system(\\\"mkdir %s\\\" % (f))\",\n \"def create_folders(self):\\n for f in self.params['folder_names']:\\n if not os.path.exists(f):\\n print 'Creating folder:\\\\t%s' % f\\n os.system(\\\"mkdir %s\\\" % (f))\",\n \"def getCreate(newFoldername):\\r\\n current_directory = os.getcwd()\\r\\n new_directory = os.path.join(current_directory,newFoldername)\\r\\n \\r\\n if os.path.exists(new_directory):\\r\\n return new_directory\",\n \"def create_new(self, root, name_length):\\n self.name = create_random_string(name_length)\\n self.ctime = datetime.datetime.now()\\n date_time = datetime.datetime.strftime(self.ctime, \\\"%Y%m%d_%H%M%S\\\")\\n self.folder = f\\\"{date_time}_{self.name}\\\"\\n self.path = os.path.join(root, self.folder)\\n try:\\n os.makedirs(self.path)\\n print(f\\\"Created folder {self.folder}\\\")\\n except OSError:\\n print(f\\\"Directory {self.folder} already exists\\\")\\n except:\\n print(f\\\"Cannot create folder: {self.folder}\\\")\\n raise\",\n \"def make_save_path(self):\\n if self.paddle_length_factor is not None:\\n for gym_env in self.env.envs:\\n gym_env.scale_paddle_height(self.paddle_length_factor)\\n self.save_path = f\\\"{self.save_folder}/{self.save_name}_paddle_length_{self.paddle_length_factor}\\\"\\n else:\\n self.save_path = f\\\"{self.save_folder}/{self.save_name}\\\"\",\n \"def make_new_dir(path):\\n\\n if(not(os.path.isdir(path))):\\n os.makedirs(path)\\n\\n return path\",\n \"def create(path, overwrite=False):\\n path = os.path.abspath(path)\\n if os.path.isfile(path):\\n if overwrite:\\n pdbox._args.get(\\\"dryrun\\\") or os.remove(path)\\n else:\\n raise ValueError(\\\"%s is a file\\\" % path)\\n if os.path.isdir(path):\\n if overwrite:\\n pdbox._args.get(\\\"dryrun\\\") or shutil.rmtree(path)\\n else:\\n raise ValueError(\\\"%s already exists\\\" % path)\\n\\n pdbox._args.get(\\\"dryrun\\\") or os.makedirs(path)\\n\\n pdbox.info(\\\"Created new folder %s\\\" % path)\\n return None if pdbox._args.get(\\\"dryrun\\\") else LocalFolder(path)\",\n \"def create_folders(self):\\n\\n for f in self.params['folder_names']:\\n if not os.path.exists(f):\\n print 'Creating folder:\\\\t%s' % f\\n os.system(\\\"mkdir %s\\\" % (f))\",\n \"def create_folder(path: str):\\n try:\\n Path(path).mkdir(parents=True, exist_ok=True)\\n return True\\n except:\\n print(\\\"An error occured.\\\")\",\n \"def mkdir(self, *args):\\n p = self.join(*args)\\n error.checked_call(os.mkdir, os.fspath(p))\\n return p\",\n \"def create_folders():\\n if not os.path.exists(\\\"data/train-npy/\\\"):\\n os.makedirs(\\\"data/train-npy/\\\")\\n if not os.path.exists(\\\"data/test-npy/\\\"):\\n os.makedirs(\\\"data/test-npy/\\\")\\n if not os.path.exists(\\\"data/valid-npy/\\\"):\\n os.makedirs(\\\"data/valid-npy/\\\")\",\n \"def make_test_dir(path, test_name):\\n LOG.info('In make_test_dir')\\n OutputWrite.change_to_script_directory(__file__)\\n path_with_test_name = os.path.join(path, test_name)\\n LOG.debug('Path with Test name = {0}'.format(path_with_test_name))\\n os.makedirs(path_with_test_name, exist_ok=True)\\n print('path with test name {0}'.format(path_with_test_name))\\n return path_with_test_name\",\n \"def create_folder(self):\\n cur_dir=os.getcwd()\\n unique=False\\n dirlist= [item for item in os.listdir(cur_dir) if os.path.isdir(os.path.join(cur_dir,item))]\\n folder_name='taxonomy_{}_{}'.format(self.place,self.year)\\n j=1\\n while not unique:\\n if folder_name in dirlist:\\n folder_name='taxonomy_{}_{}({})'.format(self.place,self.year,str(j))\\n j+=1\\n else:\\n unique=True\\n new_folder=os.path.join(cur_dir,folder_name)\\n os.mkdir(new_folder)\\n os.chdir(new_folder)\\n return folder_name\",\n \"def create_directory(folder_name):\\n if not os.path.exists(folder_name):\\n os.makedirs(folder_name)\",\n \"def _directory_path(self):\\n if not os.path.isdir(self.new_img_dir) : os.mkdir(self.new_img_dir)\\n if not os.path.isdir(os.path.join(self.new_img_dir, \\\"train\\\")) : os.mkdir(os.path.join(self.new_img_dir, \\\"train\\\"))\\n if not os.path.isdir(os.path.join(self.new_img_dir, \\\"test\\\")) : os.mkdir(os.path.join(self.new_img_dir, \\\"test\\\"))\",\n \"def create_dir(dir_path,plot_type):\\n\\n alphabet = \\\"ABCDEFGHIJKLMNOPQRSTUZWXYZ\\\"\\n alphabet += alphabet.lower()\\n alphabet += \\\"01234567890\\\"\\n\\n\\n if dir_path==None or dir_path=='':\\n dir_path=''\\n random_dir_name=''.join([choice(alphabet) for i in range(10)])\\n dir_path ='./'+plot_type+strftime(\\\"%Y_%m_%d_%H_%M_%S\\\")+random_dir_name+'/'\\n\\n if not os.path.exists(dir_path):\\n os.mkdir(dir_path)\\n\\n return dir_path\",\n \"def create_folder(self, req, folder_path, new_folder_name):\\n\\t\\tdirectory_path = os.path.join(self.get_selected_root(req), folder_path)\\n\\t\\t\\n\\t\\t#prevent shenanigans\\n\\t\\tnew_folder_name = new_folder_name.split('/').pop()\\n\\t\\t\\n\\t\\tnew_path = os.path.join(directory_path, new_folder_name)\\n\\t\\tif(os.access(new_path, os.F_OK)):\\n\\t\\t\\tcontent = tags.Tag('Error')(number=FLD_EXISTS)\\n\\t\\telse:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tos.mkdir(new_path)\\n\\t\\t\\t\\tcontent = tags.Tag('Error')(number=SUCCESS)\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tcontent = tags.Tag('Error')(number=FLD_UNKNOWN_ERROR)\\n\\t\\t\\n\\t\\treturn content\",\n \"def set_save_dir(dirname):\\n global SAVE_DIR\\n SAVE_DIR = Path(dirname)\\n\\n if not SAVE_DIR.exists():\\n print(\\\"Creating\\\", SAVE_DIR)\\n SAVE_DIR.mkdir()\\n\\n raw_dir = SAVE_DIR/RAW_SAVE_DIR \\n if not raw_dir.exists():\\n print(\\\"Creating\\\", raw_dir)\\n raw_dir.mkdir()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7928659","0.7695204","0.76085055","0.7281233","0.71740186","0.7165479","0.70561624","0.6956532","0.6895045","0.68900746","0.683801","0.68368167","0.6809364","0.6801099","0.6799192","0.67921394","0.6790769","0.6772145","0.67521167","0.67416507","0.6723689","0.6703453","0.66502863","0.6649287","0.66436595","0.66365427","0.663295","0.6628687","0.66132134","0.6600879","0.6593925","0.65816784","0.6572477","0.65527445","0.6548005","0.6543067","0.65322906","0.65269727","0.65217966","0.65216166","0.6520812","0.6499014","0.6479713","0.64784515","0.6471105","0.64687437","0.64612323","0.6459062","0.6443512","0.6434496","0.6434142","0.6430231","0.64200777","0.6400429","0.6373861","0.63640964","0.6357957","0.6352017","0.6349683","0.6348489","0.63421744","0.6337436","0.6334014","0.6334014","0.63317627","0.63296545","0.63286763","0.6313831","0.6313077","0.63116246","0.6311467","0.63085234","0.6308484","0.6305193","0.62997216","0.6287178","0.62854874","0.6279452","0.62788737","0.6277521","0.6277336","0.62659705","0.626112","0.626112","0.62602603","0.6259711","0.62463725","0.62331176","0.6224739","0.62166256","0.6213755","0.62115866","0.6208871","0.6206063","0.61979514","0.61811095","0.61686814","0.6166849","0.61643404","0.6164224"],"string":"[\n \"0.7928659\",\n \"0.7695204\",\n \"0.76085055\",\n \"0.7281233\",\n \"0.71740186\",\n \"0.7165479\",\n \"0.70561624\",\n \"0.6956532\",\n \"0.6895045\",\n \"0.68900746\",\n \"0.683801\",\n \"0.68368167\",\n \"0.6809364\",\n \"0.6801099\",\n \"0.6799192\",\n \"0.67921394\",\n \"0.6790769\",\n \"0.6772145\",\n \"0.67521167\",\n \"0.67416507\",\n \"0.6723689\",\n \"0.6703453\",\n \"0.66502863\",\n \"0.6649287\",\n \"0.66436595\",\n \"0.66365427\",\n \"0.663295\",\n \"0.6628687\",\n \"0.66132134\",\n \"0.6600879\",\n \"0.6593925\",\n \"0.65816784\",\n \"0.6572477\",\n \"0.65527445\",\n \"0.6548005\",\n \"0.6543067\",\n \"0.65322906\",\n \"0.65269727\",\n \"0.65217966\",\n \"0.65216166\",\n \"0.6520812\",\n \"0.6499014\",\n \"0.6479713\",\n \"0.64784515\",\n \"0.6471105\",\n \"0.64687437\",\n \"0.64612323\",\n \"0.6459062\",\n \"0.6443512\",\n \"0.6434496\",\n \"0.6434142\",\n \"0.6430231\",\n \"0.64200777\",\n \"0.6400429\",\n \"0.6373861\",\n \"0.63640964\",\n \"0.6357957\",\n \"0.6352017\",\n \"0.6349683\",\n \"0.6348489\",\n \"0.63421744\",\n \"0.6337436\",\n \"0.6334014\",\n \"0.6334014\",\n \"0.63317627\",\n \"0.63296545\",\n \"0.63286763\",\n \"0.6313831\",\n \"0.6313077\",\n \"0.63116246\",\n \"0.6311467\",\n \"0.63085234\",\n \"0.6308484\",\n \"0.6305193\",\n \"0.62997216\",\n \"0.6287178\",\n \"0.62854874\",\n \"0.6279452\",\n \"0.62788737\",\n \"0.6277521\",\n \"0.6277336\",\n \"0.62659705\",\n \"0.626112\",\n \"0.626112\",\n \"0.62602603\",\n \"0.6259711\",\n \"0.62463725\",\n \"0.62331176\",\n \"0.6224739\",\n \"0.62166256\",\n \"0.6213755\",\n \"0.62115866\",\n \"0.6208871\",\n \"0.6206063\",\n \"0.61979514\",\n \"0.61811095\",\n \"0.61686814\",\n \"0.6166849\",\n \"0.61643404\",\n \"0.6164224\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75882685"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":21486,"cells":{"query":{"kind":"string","value":"Saves model and history file. Arguments"},"document":{"kind":"string","value":"def save_model(save_folder): \n model.save(save_folder + '/savedmodel' + '.h5')\n with open(save_folder +'/history.pickle', 'wb') as f_save:\n pickle.dump(model_fit.history, f_save)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def save_model(self, filename):\r\n pass","def save_model(model, model_filepath):","def save(path_to_model):\n pass","def save_model(self, model_path: str):","def do_save(self, arg):\n try:\n args = self.saveparser.parseString(arg)\n except pyparsing.ParseException:\n self.perror('Could not understand save target %s' % arg)\n raise SyntaxError(self.do_save.__doc__)\n fname = args.fname or self.default_file_name\n if args.idx == '*':\n saveme = '\\n\\n'.join(self.history[:])\n elif args.idx:\n saveme = self.history[int(args.idx) - 1]\n else:\n # Since this save command has already been added to history, need to go one more back for previous\n saveme = self.history[-2]\n try:\n f = open(os.path.expanduser(fname), 'w')\n f.write(saveme)\n f.close()\n self.pfeedback('Saved to {}'.format(fname))\n except Exception:\n self.perror('Error saving {}'.format(fname))\n raise","def save_model(self, path):\n pass","def do_save(self, arg):\n try:\n args = self.saveparser.parseString(arg)\n except pyparsing.ParseException:\n self.perror('Could not understand save target %s' % arg, traceback_war=False)\n raise SyntaxError(self.do_save.__doc__)\n\n # If a filename was supplied then use that, otherwise use a temp file\n if args.fname:\n fname = args.fname\n else:\n fd, fname = tempfile.mkstemp(suffix='.txt', text=True)\n os.close(fd)\n\n if args.idx == '*':\n saveme = '\\n\\n'.join(self.history[:])\n elif args.idx:\n saveme = self.history[int(args.idx) - 1]\n else:\n # Wrap in try to deal with case of empty history\n try:\n # Since this save command has already been added to history, need to go one more back for previous\n saveme = self.history[-2]\n except IndexError:\n self.perror('History is empty, nothing to save.', traceback_war=False)\n return\n try:\n f = open(os.path.expanduser(fname), 'w')\n f.write(saveme)\n f.close()\n self.pfeedback('Saved to {}'.format(fname))\n except Exception as e:\n self.perror('Saving {!r} - {}'.format(fname, e), traceback_war=False)","def writeAfter(self, model=None, histories=None, results={}, saveModel=False):\n# Write out everything new we know after running the experiment\n# Will append to the existing file\n with open(self.filename,'a') as f:\n finish = datetime.datetime.now()\n f.write( \"Finish: {}\\n\".format( finish ) )\n f.write( \"Elapsed: {}\\n\".format( finish-self.start ) )\n if model is not None:\n summ_list = []\n model.summary(print_fn=lambda x: summ_list.append(x))\n f.write( \"Model:\\n\" )\n for summ in summ_list:\n f.write( ' {}\\n'.format(summ) )\n f.write( \"Results:\\n\" )\n for key,value in results.items():\n f.write( \" {}: {}\\n\".format( key, value ) )\n if model is not None and saveModel:\n fname = os.path.join( self.dir_name, self.name+\"_model.json\" )\n with open(fname,'w') as f:\n f.write(model.to_json())\n fname = os.path.join( self.dir_name, self.name+\"_weights.h5\" )\n model.save_weights(fname)\n if histories is not None:\n try:\n his_fname = os.path.join(self.dir_name, \"histories.pickle\")\n with open(his_fname, 'wb') as f:\n pickle.dump( histories, f, pickle.HIGHEST_PROTOCOL)\n except Exception as ex:\n print( \"Failed to write history ({}) to {}\\n {}\".format( type(histories), his_fname, ex ) )","def saveModel(self, savePath=\"DataStore/SavedModels/Forecasters/\"):\n projectRoot = self.getProjectRoot()\n ds = projectRoot + \"DataStore/\"\n savePath = projectRoot + savePath\n if \"SavedModels\" not in os.listdir(ds):\n os.mkdir(ds + \"SavedModels\")\n os.mkdir(ds + \"SavedModels/Agents\")\n os.mkdir(ds + \"SavedModels/Forecasters\")\n modelName = self.__class__.__name__\n if modelName not in os.listdir(savePath):\n os.mkdir(savePath + modelName)\n savePath = savePath + modelName\n\n saveDateTime = str(datetime.datetime.now())[:-10].replace(\" \", \"@\")\n if saveDateTime in os.listdir(savePath):\n message = \"model already exists for this datetime\"\n raise Exception(message)\n savePath = \"{}/{}/\".format(savePath, saveDateTime)\n os.mkdir(savePath)\n with open(savePath + \"modelSummary.txt\", \"w+\") as f:\n self.model.summary(print_fn=lambda x: f.write(x + '\\n'))\n with open(savePath + \"modelConfig.json\", \"w+\") as f:\n f.write(self.model.to_json())\n with open(savePath + \"history.pickle\", \"wb+\") as f:\n pickle.dump(self.history, f)\n self.model.save(savePath + \"model\", save_format=\"tf\")","def save(\n self,\n modelSavePath\n ):\n pass","def save(model: nn.Module, path):\n save_model(model, path)","def save():","def save_model(self, *args, **kwargs):\n raise NotImplementedError","def save_model(self, file=None):\n return None","def save_model(self, fname):\n self.get_booster().save_model(fname)","def _save_model(self, epoch, batch, logs):\n self.save(self._get_file_path(epoch, batch, logs))","def save_model(model):\n # ***\n # Please remove the comment to enable model save.\n # However, it will overwrite the baseline model we provided.\n # ***\n model.save(\"model/model.h5\")\n print(\"Model Saved Successfully.\")","def export_model(self, save_path: str, save_format: Optional[str] = None) -> None:","def save_model(self, filename):\n self.model.save('models/' + str(filename))","def save(self,model_path):\n pass\n # filename = \"Models/\"+model_path+\"1.sav\"\n # pickle.dump(self.crf_model, open(filename, 'wb'))","def save_model(self):\n pass","def save_model(self, filename):\n\t\tpickle.dump(self, open(filename, 'wb'))\n\t\tprint('Model saved in',filename)","def save(self, *args):\n # need to do!!\n pass","def save(model, filename):\n print(\"... saving model in {}\".format(filename))\n f = open(filename, \"wb\")\n pickle.dump(model, f)\n f.close()","def save(self):\n print(\"==> Saving model to\", self.model_dir)\n self.model.save(self.model_dir)","def save_model(model, model_filepath):\n dump(model, model_filepath)","def save_model(cls, vocab, path, filename):\n return super().save_model(vocab, path, filename)","def save(self, filename):\n # serialize model to JSON\n model_json = self._model.to_json()\n with open('models/' + filename + \".json\", \"w\") as json_file:\n json_file.write(model_json)\n\n # serialize weights to HDF5\n self._model.save_weights('models/' + filename + \".h5\")\n print(\"Saved model to disk\")","def save_model(self, step):\n\n # file_name = params['name']\n # pickle.dump(self, gzip.open(file_name, 'wb'))","def save():\n pass","def save_model(self):\n joblib.dump(self.pipeline, 'model.joblib')\n print(colored('model.joblib saved locally', 'green'))","def save_model(self):\n joblib.dump(self.pipeline, \"model.joblib\")","def save_model(model, name, savedir='./study/', \n history=None, history_model_state=None, cfg=None, verbose=True):\n str_filename = name + '.pt'\n if not os.path.exists(savedir):\n os.makedirs(savedir)\n str_savepath = savedir + str_filename\n data = {\"model_state\": model.state_dict(),\n \"history\": history,\n \"history_model_state\": history_model_state,\n \"cfg\": cfg}\n if verbose:\n print(\"Saving model to %s\" % str_savepath)\n torch.save(data, str_savepath)","def save_model(model, filename=None):\n if not filename:\n p = re.compile(r\"(.*)\\(.*\")\n model_name = re.match(p, str(model)).group(1)\n current_time = datetime.now().strftime(format='%m-%d-%y-%H-%M')\n name = \"/home/ubuntu/ca_bills_project/data/extra/\"+model_name+current_time+\".pkl\"\n else:\n name = \"/home/ubuntu/ca_bills_project/data/extra/\"+filename\n with open(name, 'w') as p:\n pickle.dump(model, p)","def save(self, model_file):\n pickle.dump(self, open(model_file, 'wb'))","def save_model(self):\n filename=self.name + '_words'\n file_write(filename, self.words)\n\n filename2=self.name+'_word_lengths'\n file_write(filename2, self.word_lengths)\n\n filename3=self.name+'_stems'\n file_write(filename3, self.stems)\n\n filename4=self.sentence_lengths+'_sentence_lengths'\n file_write(filename4, self.sentence_lengths)\n\n filename5= self.endings+'_endings'\n file_write(filename5, self.endings)","def save_model(model, filename):\n with open(filename, 'wb') as f:\n joblib.dump(model, f)","def save_model(model, model_index, args):\n logger.info(\"saving local model-{}\".format(model_index))\n with open(args.modeldir+\"trained_local_model\"+str(model_index), \"wb\") as f_:\n torch.save(model.state_dict(), f_)\n return","def save_model(self):\n\n # =============================================================\n # Default : pickle the trained model. Change this (and the load\n # function, below) only if the library you used does not support\n # pickling.\n # self.Model_made.save(\"Model_made.h5\")\n # self.Model_claim.save(\"Model_claim.h5\")\n # Model_made = self.Model_made\n # Model_claim = self.Model_claim\n # self.Model_made = None\n # self.Model_claim = None\n with open('pricing_model.p', 'wb') as target:\n pickle.dump(self, target)\n\n # self.Model_made = Model_made\n # self.Model_claim = Model_claim\n\n # zipObj = ZipFile(\"model.zip\",\"w\")\n # zipObj.write(\"Model_made.h5\")\n # zipObj.write(\"Model_claim.h5\")\n # zipObj.write(\"pricing_model.p\")\n # zipObj.close()","def save(self):\n #test output\n pywikibot.output('PICKLING %s records at %s' % (len(self.historyDict),datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")))\n with open(self.datfilename, 'wb') as f:\n pickle.dump(self.historyDict, f, protocol=config.pickle_protocol)","def save_model(args,model,epoch):\n path='./model_'+args.name\n if not os.path.exists(path):\n os.mkdir(path)\n model_name='checkpoint_epoch={}'.format(epoch)\n filepath=os.path.join(path,model_name)\n torch.save(model.state_dict(), filepath)","def save_model(self, filename) -> None:\n #t.save(self, filename)\n traced=t.jit.script(self)\n t.jit.save(traced,filename)","def save_model(model, filename):\n model_dir = \"models\"\n os.makedirs(model_dir,exist_ok=True) #create only if model directory dosent exists\n filePath = os.path.join(model_dir, filename)\n logging.info(filePath)\n joblib.dump(model, filePath)","def _save_model(self):\n save_generic(self.model, self.model_pkl_fname)","def save_training_history(hist):\n if os.path.exists(\"history/history\") != True:\n os.mknod(\"history/history\")\n with open(\"history/history\", \"wb\") as file_pi:\n pickle.dump(hist.history, file_pi)\n print(\"Training History saved\")","def save_model(model, file_name):\n with open(file_name, 'wb') as file:\n pickle.dump(model, file)","def save_model(self, model_file):\n m = {'b':self.b,\n 'w':self.w.tolist()}\n\n with open(model_file, 'w') as f:\n json.dump(m, f)","def save_model(self):\n pickle.dump(self, open(\"Logistic_Regression_Model.pkl\", \"wb\"))","def save_checkpoint(model: nn.Module, args: Namespace, path: str):\r\n state = {\r\n 'args': args,\r\n 'state_dict': model.state_dict()\r\n }\r\n torch.save(state, path)","def save_model(exe, program, save_dir, model_name, postfix=''):\n if not os.path.isdir(save_dir):\n os.makedirs(save_dir)\n saved_model_name = model_name + postfix\n\n fluid.save(program, os.path.join(save_dir, saved_model_name))\n\n return","def save_model(self, filename, overwrite=None):\n return\n pickle.dump(\n obj=self._model,\n file=open(filename, \"wb\")\n )","def save(self,sess):\n self.saver.save(sess,\"./Models/\" + self.mod_name + \".ckpt\")","def saveModel(model, file_name):\n with open(SAVE_PATH + file_name, \"wb\") as out_file:\n # wo do not want to save redundant data, so keys and vals are excluded\n pickle.dump(model, out_file)\n print(\"model save to\", SAVE_PATH + file_name)","def save_model(model, model_filepath): \n pickle.dump(model, open(model_filepath, 'wb'))","def save(self, to_file: Path)->None:\n self.model.save(to_file)","def save(self, filename):\n pass","def save_checkpoint(state, model_name=None):\n \n if not model_name: model_name = f\"model_date_{date_time_str}.pth\"\n torch.save(state, osj(out_path, model_name))","def save_model(model, model_filepath):\n joblib.dump(model, model_filepath)","def save_model(model, model_filepath):\n joblib.dump(model, model_filepath)","def save_model(model, model_filepath):\n joblib.dump(model, model_filepath)","def save_model(file_name, ep, model, optimizer):\n\n torch.save({\n 'epoch': ep,\n 'model_state_dict': model.state_dict(),\n 'optimizer_state_dict': optimizer.state_dict(),\n }, file_name) \n \n return","def save(self):\n\n self.saver.save(self.sess, self.path + '/tensorflow-model', global_step=self.counter.count)","def save(self, *args, **kwargs) -> None:\n pass","def save(self, *args, **kwargs) -> None:\n pass","def save(self, *args, **kwargs) -> None:\n pass","def save_model(model, loss, inner_val_loss, mean_outer_val_loss, mean_test_loss, fpath):\n\n\t# Dump data\n\twith open(fpath + '.json', 'w') as structure_fpath:\n\t\tjson.dump(model.to_json(), structure_fpath)\n\tlogging.info('...saved structural information')\n\n\t# Dump weights\n\tmodel.save_weights(fpath + '.h5', overwrite = True)\n\tlogging.info('...saved weights')\n\n\t# Dump image\n\ttry:\n\t\tplot(model, to_file = fpath + '.png')\n\t\tlogging.info('...saved image')\n\texcept:\n\t\tpass\n\n\t# Dump history\n\tsave_model_history_manual(loss, inner_val_loss, fpath + '.hist')\n\n\tmean_loss = loss[-1]\n\tmean_inner_val_loss = inner_val_loss[-1]\n\twrite_loss_report(mean_loss, mean_inner_val_loss, mean_outer_val_loss, mean_test_loss, fpath + '_loss_report.txt')\n\tlogging.info ('...saved history')\n\n\tlogging.info('...saved model to {}.[json, h5, png]'.format(fpath))","def save(self, filename):\n pass","def save_model(self, file_name=None):\n try:\n if file_name:\n self.agent.save_model(file_name)\n else:\n self.agent.save_model()\n print('Model saved successfully')\n return 1\n except:\n print('Failed to save model')\n return 0","def save_model(model, model_filepath):\n\n outfile = open('model_filepath','wb')\n pickle.dump(model, outfile)\n outfile.close()","def save(nntagger, args):\n outdir = args.save\n modelname = outdir + \".model\"\n nntagger.model.save(modelname)\n import pickle\n myparams = {\"num_words\": len(nntagger.w2i),\n \"num_chars\": len(nntagger.c2i),\n \"w2i\": nntagger.w2i,\n \"c2i\": nntagger.c2i,\n \"tag2idx\": nntagger.tag2idx,\n \"activation\": nntagger.activation,\n \"in_dim\": nntagger.in_dim,\n \"h_dim\": nntagger.h_dim,\n \"c_in_dim\": nntagger.c_in_dim,\n \"h_layers\": nntagger.h_layers\n }\n pickle.dump(myparams, open( modelname+\".pickle\", \"wb\" ) )\n print(\"model stored: {}\".format(modelname), file=sys.stderr)","def save_model(model, model_name):\r\n if os.path.isfile(model_name):\r\n print('Error: File already exists - please change name or remove conflicting file')\r\n else:\r\n joblib.dump(model, model_name)","def _save_model(self):\n with open(self.filepath, 'wb') as file:\n pickle.dump(self.cmodel, file)","def save_model(model, model_filepath):\n\n with open(model_filepath , 'wb') as file:\n pickle.dump(model, file)","def save_model(model, model_filepath):\n pickle.dump( model, open( model_filepath, \"wb\" ) )","def save_model(self):\n\n self.check_model()\n\n with open(self.filename, 'wb') as file:\n pickle.dump({'model': self.model, 'vec': self.vectorizer, 'vec_data': self.vectorized_data,\n 'df': self.df_topic_keywords}, file)","def save(self, path):\n for i, m in enumerate(self.model_save):\n m.save(os.path.join(path, str(i) + \"-\" + m.name))","def save(self, fname):\n pass","def save_model(model, model_filepath): \n \n model_file = open(model_filepath,\"wb\")\n pickle.dump(model, model_file)\n model_file.close()","def save(self, *args, **kwargs):\n pass","def saveModel(self):\n with open(self.modelSaveFile, 'wb') as f:\n pickle.dump(self.values, f, pickle.HIGHEST_PROTOCOL)\n pickle.dump(self.policy, f, pickle.HIGHEST_PROTOCOL)","def saveHistory(self, token, history):\n filename = \"%s.json\" % token\n helpers.saveFile(self.dataDir, filename, json.dumps(history))","def save_model(self, model, model_filepath):\n joblib.dump(model, model_filepath)","def save_model(model):\n model.to_disk(\"../model/custom_ner_model\")","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, \"wb\"))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, \"wb\"))","def saveModel(self, fileName):\n\n if self.saver is None:\n self.saver = tf.train.Saver()\n self.saver.save(self.sess, fileName)\n else:\n self.saver.save(self.sess, fileName)","def save_model(self):\n # words dictionary\n filename = self.name + \"_words\"\n f = open(filename, 'w')\n f.write(str(self.words))\n f.close()\n\n # word_lengths dictionary\n filename = self.name + \"_word_lengths\"\n f = open(filename, 'w')\n f.write(str(self.word_lengths))\n f.close()\n\n # stems dictionary\n filename = self.name + \"_stems\"\n f = open(filename, 'w')\n f.write(str(self.stems))\n f.close()\n\n # sentence_lengths dictionary\n filename = self.name + \"_sentence_lengths\"\n f = open(filename, 'w')\n f.write(str(self.sentence_lengths))\n f.close()\n\n # ten most common words\n filename = self.name + \"_common_word\"\n f = open(filename, 'w')\n f.write(str(self.common_word))\n f.close()","def save(self, model_name = 'mr-senti'):\n\n\t\tjoblib.dump(self.classifier, os.path.join('model', model_name + '.pkl'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(model, model_filepath):\n pickle.dump(model, open(model_filepath, 'wb'))","def save_model(learn, name):\n# callback_fns = learn.callback_fns # preserve wandb callback and others\n# callbacks = learn.callbacks\n \n# learn.callback_fns = [] # clean callbacks\n# learn.callbacks = []\n \n learn.save(PATH_TO_MODELS / name) # save only weights, adds .pth automatically\n learn.export(PATH_TO_MODELS / f\"{name}.pkl\") # serialize entire model, need to add .pkl","def save_history(history):\n cat_acc = history.history['categorical_accuracy']\n val_cat_acc = history.history['val_categorical_accuracy']\n loss = history.history['loss']\n val_loss = history.history['val_loss']\n\n np.savetxt(\n os.path.join(dbc.MODEL_PATH, \"cat_acc.txt\"), cat_acc, delimiter=\",\")\n np.savetxt(\n os.path.join(dbc.MODEL_PATH, \"val_cat_acc.txt\"), val_cat_acc,\n delimiter=\",\")\n np.savetxt(os.path.join(dbc.MODEL_PATH, \"loss.txt\"), loss, delimiter=\",\")\n np.savetxt(\n os.path.join(dbc.MODEL_PATH, \"val_loss.txt\"), val_loss, delimiter=\",\")"],"string":"[\n \"def save_model(self, filename):\\r\\n pass\",\n \"def save_model(model, model_filepath):\",\n \"def save(path_to_model):\\n pass\",\n \"def save_model(self, model_path: str):\",\n \"def do_save(self, arg):\\n try:\\n args = self.saveparser.parseString(arg)\\n except pyparsing.ParseException:\\n self.perror('Could not understand save target %s' % arg)\\n raise SyntaxError(self.do_save.__doc__)\\n fname = args.fname or self.default_file_name\\n if args.idx == '*':\\n saveme = '\\\\n\\\\n'.join(self.history[:])\\n elif args.idx:\\n saveme = self.history[int(args.idx) - 1]\\n else:\\n # Since this save command has already been added to history, need to go one more back for previous\\n saveme = self.history[-2]\\n try:\\n f = open(os.path.expanduser(fname), 'w')\\n f.write(saveme)\\n f.close()\\n self.pfeedback('Saved to {}'.format(fname))\\n except Exception:\\n self.perror('Error saving {}'.format(fname))\\n raise\",\n \"def save_model(self, path):\\n pass\",\n \"def do_save(self, arg):\\n try:\\n args = self.saveparser.parseString(arg)\\n except pyparsing.ParseException:\\n self.perror('Could not understand save target %s' % arg, traceback_war=False)\\n raise SyntaxError(self.do_save.__doc__)\\n\\n # If a filename was supplied then use that, otherwise use a temp file\\n if args.fname:\\n fname = args.fname\\n else:\\n fd, fname = tempfile.mkstemp(suffix='.txt', text=True)\\n os.close(fd)\\n\\n if args.idx == '*':\\n saveme = '\\\\n\\\\n'.join(self.history[:])\\n elif args.idx:\\n saveme = self.history[int(args.idx) - 1]\\n else:\\n # Wrap in try to deal with case of empty history\\n try:\\n # Since this save command has already been added to history, need to go one more back for previous\\n saveme = self.history[-2]\\n except IndexError:\\n self.perror('History is empty, nothing to save.', traceback_war=False)\\n return\\n try:\\n f = open(os.path.expanduser(fname), 'w')\\n f.write(saveme)\\n f.close()\\n self.pfeedback('Saved to {}'.format(fname))\\n except Exception as e:\\n self.perror('Saving {!r} - {}'.format(fname, e), traceback_war=False)\",\n \"def writeAfter(self, model=None, histories=None, results={}, saveModel=False):\\n# Write out everything new we know after running the experiment\\n# Will append to the existing file\\n with open(self.filename,'a') as f:\\n finish = datetime.datetime.now()\\n f.write( \\\"Finish: {}\\\\n\\\".format( finish ) )\\n f.write( \\\"Elapsed: {}\\\\n\\\".format( finish-self.start ) )\\n if model is not None:\\n summ_list = []\\n model.summary(print_fn=lambda x: summ_list.append(x))\\n f.write( \\\"Model:\\\\n\\\" )\\n for summ in summ_list:\\n f.write( ' {}\\\\n'.format(summ) )\\n f.write( \\\"Results:\\\\n\\\" )\\n for key,value in results.items():\\n f.write( \\\" {}: {}\\\\n\\\".format( key, value ) )\\n if model is not None and saveModel:\\n fname = os.path.join( self.dir_name, self.name+\\\"_model.json\\\" )\\n with open(fname,'w') as f:\\n f.write(model.to_json())\\n fname = os.path.join( self.dir_name, self.name+\\\"_weights.h5\\\" )\\n model.save_weights(fname)\\n if histories is not None:\\n try:\\n his_fname = os.path.join(self.dir_name, \\\"histories.pickle\\\")\\n with open(his_fname, 'wb') as f:\\n pickle.dump( histories, f, pickle.HIGHEST_PROTOCOL)\\n except Exception as ex:\\n print( \\\"Failed to write history ({}) to {}\\\\n {}\\\".format( type(histories), his_fname, ex ) )\",\n \"def saveModel(self, savePath=\\\"DataStore/SavedModels/Forecasters/\\\"):\\n projectRoot = self.getProjectRoot()\\n ds = projectRoot + \\\"DataStore/\\\"\\n savePath = projectRoot + savePath\\n if \\\"SavedModels\\\" not in os.listdir(ds):\\n os.mkdir(ds + \\\"SavedModels\\\")\\n os.mkdir(ds + \\\"SavedModels/Agents\\\")\\n os.mkdir(ds + \\\"SavedModels/Forecasters\\\")\\n modelName = self.__class__.__name__\\n if modelName not in os.listdir(savePath):\\n os.mkdir(savePath + modelName)\\n savePath = savePath + modelName\\n\\n saveDateTime = str(datetime.datetime.now())[:-10].replace(\\\" \\\", \\\"@\\\")\\n if saveDateTime in os.listdir(savePath):\\n message = \\\"model already exists for this datetime\\\"\\n raise Exception(message)\\n savePath = \\\"{}/{}/\\\".format(savePath, saveDateTime)\\n os.mkdir(savePath)\\n with open(savePath + \\\"modelSummary.txt\\\", \\\"w+\\\") as f:\\n self.model.summary(print_fn=lambda x: f.write(x + '\\\\n'))\\n with open(savePath + \\\"modelConfig.json\\\", \\\"w+\\\") as f:\\n f.write(self.model.to_json())\\n with open(savePath + \\\"history.pickle\\\", \\\"wb+\\\") as f:\\n pickle.dump(self.history, f)\\n self.model.save(savePath + \\\"model\\\", save_format=\\\"tf\\\")\",\n \"def save(\\n self,\\n modelSavePath\\n ):\\n pass\",\n \"def save(model: nn.Module, path):\\n save_model(model, path)\",\n \"def save():\",\n \"def save_model(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def save_model(self, file=None):\\n return None\",\n \"def save_model(self, fname):\\n self.get_booster().save_model(fname)\",\n \"def _save_model(self, epoch, batch, logs):\\n self.save(self._get_file_path(epoch, batch, logs))\",\n \"def save_model(model):\\n # ***\\n # Please remove the comment to enable model save.\\n # However, it will overwrite the baseline model we provided.\\n # ***\\n model.save(\\\"model/model.h5\\\")\\n print(\\\"Model Saved Successfully.\\\")\",\n \"def export_model(self, save_path: str, save_format: Optional[str] = None) -> None:\",\n \"def save_model(self, filename):\\n self.model.save('models/' + str(filename))\",\n \"def save(self,model_path):\\n pass\\n # filename = \\\"Models/\\\"+model_path+\\\"1.sav\\\"\\n # pickle.dump(self.crf_model, open(filename, 'wb'))\",\n \"def save_model(self):\\n pass\",\n \"def save_model(self, filename):\\n\\t\\tpickle.dump(self, open(filename, 'wb'))\\n\\t\\tprint('Model saved in',filename)\",\n \"def save(self, *args):\\n # need to do!!\\n pass\",\n \"def save(model, filename):\\n print(\\\"... saving model in {}\\\".format(filename))\\n f = open(filename, \\\"wb\\\")\\n pickle.dump(model, f)\\n f.close()\",\n \"def save(self):\\n print(\\\"==> Saving model to\\\", self.model_dir)\\n self.model.save(self.model_dir)\",\n \"def save_model(model, model_filepath):\\n dump(model, model_filepath)\",\n \"def save_model(cls, vocab, path, filename):\\n return super().save_model(vocab, path, filename)\",\n \"def save(self, filename):\\n # serialize model to JSON\\n model_json = self._model.to_json()\\n with open('models/' + filename + \\\".json\\\", \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n\\n # serialize weights to HDF5\\n self._model.save_weights('models/' + filename + \\\".h5\\\")\\n print(\\\"Saved model to disk\\\")\",\n \"def save_model(self, step):\\n\\n # file_name = params['name']\\n # pickle.dump(self, gzip.open(file_name, 'wb'))\",\n \"def save():\\n pass\",\n \"def save_model(self):\\n joblib.dump(self.pipeline, 'model.joblib')\\n print(colored('model.joblib saved locally', 'green'))\",\n \"def save_model(self):\\n joblib.dump(self.pipeline, \\\"model.joblib\\\")\",\n \"def save_model(model, name, savedir='./study/', \\n history=None, history_model_state=None, cfg=None, verbose=True):\\n str_filename = name + '.pt'\\n if not os.path.exists(savedir):\\n os.makedirs(savedir)\\n str_savepath = savedir + str_filename\\n data = {\\\"model_state\\\": model.state_dict(),\\n \\\"history\\\": history,\\n \\\"history_model_state\\\": history_model_state,\\n \\\"cfg\\\": cfg}\\n if verbose:\\n print(\\\"Saving model to %s\\\" % str_savepath)\\n torch.save(data, str_savepath)\",\n \"def save_model(model, filename=None):\\n if not filename:\\n p = re.compile(r\\\"(.*)\\\\(.*\\\")\\n model_name = re.match(p, str(model)).group(1)\\n current_time = datetime.now().strftime(format='%m-%d-%y-%H-%M')\\n name = \\\"/home/ubuntu/ca_bills_project/data/extra/\\\"+model_name+current_time+\\\".pkl\\\"\\n else:\\n name = \\\"/home/ubuntu/ca_bills_project/data/extra/\\\"+filename\\n with open(name, 'w') as p:\\n pickle.dump(model, p)\",\n \"def save(self, model_file):\\n pickle.dump(self, open(model_file, 'wb'))\",\n \"def save_model(self):\\n filename=self.name + '_words'\\n file_write(filename, self.words)\\n\\n filename2=self.name+'_word_lengths'\\n file_write(filename2, self.word_lengths)\\n\\n filename3=self.name+'_stems'\\n file_write(filename3, self.stems)\\n\\n filename4=self.sentence_lengths+'_sentence_lengths'\\n file_write(filename4, self.sentence_lengths)\\n\\n filename5= self.endings+'_endings'\\n file_write(filename5, self.endings)\",\n \"def save_model(model, filename):\\n with open(filename, 'wb') as f:\\n joblib.dump(model, f)\",\n \"def save_model(model, model_index, args):\\n logger.info(\\\"saving local model-{}\\\".format(model_index))\\n with open(args.modeldir+\\\"trained_local_model\\\"+str(model_index), \\\"wb\\\") as f_:\\n torch.save(model.state_dict(), f_)\\n return\",\n \"def save_model(self):\\n\\n # =============================================================\\n # Default : pickle the trained model. Change this (and the load\\n # function, below) only if the library you used does not support\\n # pickling.\\n # self.Model_made.save(\\\"Model_made.h5\\\")\\n # self.Model_claim.save(\\\"Model_claim.h5\\\")\\n # Model_made = self.Model_made\\n # Model_claim = self.Model_claim\\n # self.Model_made = None\\n # self.Model_claim = None\\n with open('pricing_model.p', 'wb') as target:\\n pickle.dump(self, target)\\n\\n # self.Model_made = Model_made\\n # self.Model_claim = Model_claim\\n\\n # zipObj = ZipFile(\\\"model.zip\\\",\\\"w\\\")\\n # zipObj.write(\\\"Model_made.h5\\\")\\n # zipObj.write(\\\"Model_claim.h5\\\")\\n # zipObj.write(\\\"pricing_model.p\\\")\\n # zipObj.close()\",\n \"def save(self):\\n #test output\\n pywikibot.output('PICKLING %s records at %s' % (len(self.historyDict),datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")))\\n with open(self.datfilename, 'wb') as f:\\n pickle.dump(self.historyDict, f, protocol=config.pickle_protocol)\",\n \"def save_model(args,model,epoch):\\n path='./model_'+args.name\\n if not os.path.exists(path):\\n os.mkdir(path)\\n model_name='checkpoint_epoch={}'.format(epoch)\\n filepath=os.path.join(path,model_name)\\n torch.save(model.state_dict(), filepath)\",\n \"def save_model(self, filename) -> None:\\n #t.save(self, filename)\\n traced=t.jit.script(self)\\n t.jit.save(traced,filename)\",\n \"def save_model(model, filename):\\n model_dir = \\\"models\\\"\\n os.makedirs(model_dir,exist_ok=True) #create only if model directory dosent exists\\n filePath = os.path.join(model_dir, filename)\\n logging.info(filePath)\\n joblib.dump(model, filePath)\",\n \"def _save_model(self):\\n save_generic(self.model, self.model_pkl_fname)\",\n \"def save_training_history(hist):\\n if os.path.exists(\\\"history/history\\\") != True:\\n os.mknod(\\\"history/history\\\")\\n with open(\\\"history/history\\\", \\\"wb\\\") as file_pi:\\n pickle.dump(hist.history, file_pi)\\n print(\\\"Training History saved\\\")\",\n \"def save_model(model, file_name):\\n with open(file_name, 'wb') as file:\\n pickle.dump(model, file)\",\n \"def save_model(self, model_file):\\n m = {'b':self.b,\\n 'w':self.w.tolist()}\\n\\n with open(model_file, 'w') as f:\\n json.dump(m, f)\",\n \"def save_model(self):\\n pickle.dump(self, open(\\\"Logistic_Regression_Model.pkl\\\", \\\"wb\\\"))\",\n \"def save_checkpoint(model: nn.Module, args: Namespace, path: str):\\r\\n state = {\\r\\n 'args': args,\\r\\n 'state_dict': model.state_dict()\\r\\n }\\r\\n torch.save(state, path)\",\n \"def save_model(exe, program, save_dir, model_name, postfix=''):\\n if not os.path.isdir(save_dir):\\n os.makedirs(save_dir)\\n saved_model_name = model_name + postfix\\n\\n fluid.save(program, os.path.join(save_dir, saved_model_name))\\n\\n return\",\n \"def save_model(self, filename, overwrite=None):\\n return\\n pickle.dump(\\n obj=self._model,\\n file=open(filename, \\\"wb\\\")\\n )\",\n \"def save(self,sess):\\n self.saver.save(sess,\\\"./Models/\\\" + self.mod_name + \\\".ckpt\\\")\",\n \"def saveModel(model, file_name):\\n with open(SAVE_PATH + file_name, \\\"wb\\\") as out_file:\\n # wo do not want to save redundant data, so keys and vals are excluded\\n pickle.dump(model, out_file)\\n print(\\\"model save to\\\", SAVE_PATH + file_name)\",\n \"def save_model(model, model_filepath): \\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save(self, to_file: Path)->None:\\n self.model.save(to_file)\",\n \"def save(self, filename):\\n pass\",\n \"def save_checkpoint(state, model_name=None):\\n \\n if not model_name: model_name = f\\\"model_date_{date_time_str}.pth\\\"\\n torch.save(state, osj(out_path, model_name))\",\n \"def save_model(model, model_filepath):\\n joblib.dump(model, model_filepath)\",\n \"def save_model(model, model_filepath):\\n joblib.dump(model, model_filepath)\",\n \"def save_model(model, model_filepath):\\n joblib.dump(model, model_filepath)\",\n \"def save_model(file_name, ep, model, optimizer):\\n\\n torch.save({\\n 'epoch': ep,\\n 'model_state_dict': model.state_dict(),\\n 'optimizer_state_dict': optimizer.state_dict(),\\n }, file_name) \\n \\n return\",\n \"def save(self):\\n\\n self.saver.save(self.sess, self.path + '/tensorflow-model', global_step=self.counter.count)\",\n \"def save(self, *args, **kwargs) -> None:\\n pass\",\n \"def save(self, *args, **kwargs) -> None:\\n pass\",\n \"def save(self, *args, **kwargs) -> None:\\n pass\",\n \"def save_model(model, loss, inner_val_loss, mean_outer_val_loss, mean_test_loss, fpath):\\n\\n\\t# Dump data\\n\\twith open(fpath + '.json', 'w') as structure_fpath:\\n\\t\\tjson.dump(model.to_json(), structure_fpath)\\n\\tlogging.info('...saved structural information')\\n\\n\\t# Dump weights\\n\\tmodel.save_weights(fpath + '.h5', overwrite = True)\\n\\tlogging.info('...saved weights')\\n\\n\\t# Dump image\\n\\ttry:\\n\\t\\tplot(model, to_file = fpath + '.png')\\n\\t\\tlogging.info('...saved image')\\n\\texcept:\\n\\t\\tpass\\n\\n\\t# Dump history\\n\\tsave_model_history_manual(loss, inner_val_loss, fpath + '.hist')\\n\\n\\tmean_loss = loss[-1]\\n\\tmean_inner_val_loss = inner_val_loss[-1]\\n\\twrite_loss_report(mean_loss, mean_inner_val_loss, mean_outer_val_loss, mean_test_loss, fpath + '_loss_report.txt')\\n\\tlogging.info ('...saved history')\\n\\n\\tlogging.info('...saved model to {}.[json, h5, png]'.format(fpath))\",\n \"def save(self, filename):\\n pass\",\n \"def save_model(self, file_name=None):\\n try:\\n if file_name:\\n self.agent.save_model(file_name)\\n else:\\n self.agent.save_model()\\n print('Model saved successfully')\\n return 1\\n except:\\n print('Failed to save model')\\n return 0\",\n \"def save_model(model, model_filepath):\\n\\n outfile = open('model_filepath','wb')\\n pickle.dump(model, outfile)\\n outfile.close()\",\n \"def save(nntagger, args):\\n outdir = args.save\\n modelname = outdir + \\\".model\\\"\\n nntagger.model.save(modelname)\\n import pickle\\n myparams = {\\\"num_words\\\": len(nntagger.w2i),\\n \\\"num_chars\\\": len(nntagger.c2i),\\n \\\"w2i\\\": nntagger.w2i,\\n \\\"c2i\\\": nntagger.c2i,\\n \\\"tag2idx\\\": nntagger.tag2idx,\\n \\\"activation\\\": nntagger.activation,\\n \\\"in_dim\\\": nntagger.in_dim,\\n \\\"h_dim\\\": nntagger.h_dim,\\n \\\"c_in_dim\\\": nntagger.c_in_dim,\\n \\\"h_layers\\\": nntagger.h_layers\\n }\\n pickle.dump(myparams, open( modelname+\\\".pickle\\\", \\\"wb\\\" ) )\\n print(\\\"model stored: {}\\\".format(modelname), file=sys.stderr)\",\n \"def save_model(model, model_name):\\r\\n if os.path.isfile(model_name):\\r\\n print('Error: File already exists - please change name or remove conflicting file')\\r\\n else:\\r\\n joblib.dump(model, model_name)\",\n \"def _save_model(self):\\n with open(self.filepath, 'wb') as file:\\n pickle.dump(self.cmodel, file)\",\n \"def save_model(model, model_filepath):\\n\\n with open(model_filepath , 'wb') as file:\\n pickle.dump(model, file)\",\n \"def save_model(model, model_filepath):\\n pickle.dump( model, open( model_filepath, \\\"wb\\\" ) )\",\n \"def save_model(self):\\n\\n self.check_model()\\n\\n with open(self.filename, 'wb') as file:\\n pickle.dump({'model': self.model, 'vec': self.vectorizer, 'vec_data': self.vectorized_data,\\n 'df': self.df_topic_keywords}, file)\",\n \"def save(self, path):\\n for i, m in enumerate(self.model_save):\\n m.save(os.path.join(path, str(i) + \\\"-\\\" + m.name))\",\n \"def save(self, fname):\\n pass\",\n \"def save_model(model, model_filepath): \\n \\n model_file = open(model_filepath,\\\"wb\\\")\\n pickle.dump(model, model_file)\\n model_file.close()\",\n \"def save(self, *args, **kwargs):\\n pass\",\n \"def saveModel(self):\\n with open(self.modelSaveFile, 'wb') as f:\\n pickle.dump(self.values, f, pickle.HIGHEST_PROTOCOL)\\n pickle.dump(self.policy, f, pickle.HIGHEST_PROTOCOL)\",\n \"def saveHistory(self, token, history):\\n filename = \\\"%s.json\\\" % token\\n helpers.saveFile(self.dataDir, filename, json.dumps(history))\",\n \"def save_model(self, model, model_filepath):\\n joblib.dump(model, model_filepath)\",\n \"def save_model(model):\\n model.to_disk(\\\"../model/custom_ner_model\\\")\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, \\\"wb\\\"))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, \\\"wb\\\"))\",\n \"def saveModel(self, fileName):\\n\\n if self.saver is None:\\n self.saver = tf.train.Saver()\\n self.saver.save(self.sess, fileName)\\n else:\\n self.saver.save(self.sess, fileName)\",\n \"def save_model(self):\\n # words dictionary\\n filename = self.name + \\\"_words\\\"\\n f = open(filename, 'w')\\n f.write(str(self.words))\\n f.close()\\n\\n # word_lengths dictionary\\n filename = self.name + \\\"_word_lengths\\\"\\n f = open(filename, 'w')\\n f.write(str(self.word_lengths))\\n f.close()\\n\\n # stems dictionary\\n filename = self.name + \\\"_stems\\\"\\n f = open(filename, 'w')\\n f.write(str(self.stems))\\n f.close()\\n\\n # sentence_lengths dictionary\\n filename = self.name + \\\"_sentence_lengths\\\"\\n f = open(filename, 'w')\\n f.write(str(self.sentence_lengths))\\n f.close()\\n\\n # ten most common words\\n filename = self.name + \\\"_common_word\\\"\\n f = open(filename, 'w')\\n f.write(str(self.common_word))\\n f.close()\",\n \"def save(self, model_name = 'mr-senti'):\\n\\n\\t\\tjoblib.dump(self.classifier, os.path.join('model', model_name + '.pkl'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(model, model_filepath):\\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save_model(learn, name):\\n# callback_fns = learn.callback_fns # preserve wandb callback and others\\n# callbacks = learn.callbacks\\n \\n# learn.callback_fns = [] # clean callbacks\\n# learn.callbacks = []\\n \\n learn.save(PATH_TO_MODELS / name) # save only weights, adds .pth automatically\\n learn.export(PATH_TO_MODELS / f\\\"{name}.pkl\\\") # serialize entire model, need to add .pkl\",\n \"def save_history(history):\\n cat_acc = history.history['categorical_accuracy']\\n val_cat_acc = history.history['val_categorical_accuracy']\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n\\n np.savetxt(\\n os.path.join(dbc.MODEL_PATH, \\\"cat_acc.txt\\\"), cat_acc, delimiter=\\\",\\\")\\n np.savetxt(\\n os.path.join(dbc.MODEL_PATH, \\\"val_cat_acc.txt\\\"), val_cat_acc,\\n delimiter=\\\",\\\")\\n np.savetxt(os.path.join(dbc.MODEL_PATH, \\\"loss.txt\\\"), loss, delimiter=\\\",\\\")\\n np.savetxt(\\n os.path.join(dbc.MODEL_PATH, \\\"val_loss.txt\\\"), val_loss, delimiter=\\\",\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78629273","0.7653769","0.73715615","0.7215964","0.7110899","0.70959747","0.7047263","0.7046574","0.7008128","0.70005685","0.6987576","0.6981723","0.6968098","0.6932804","0.69116753","0.6904762","0.68979573","0.68828714","0.68811744","0.68712103","0.68363184","0.68319255","0.6827592","0.68033534","0.68011487","0.6778706","0.6776051","0.6768296","0.6764092","0.6758727","0.67317957","0.6720644","0.6718771","0.67103314","0.6699251","0.6698576","0.6678565","0.66724473","0.66714793","0.6666044","0.6662331","0.66524595","0.665114","0.6649502","0.6646141","0.66371065","0.6632519","0.6625848","0.6624661","0.6621544","0.6607201","0.6606343","0.6605376","0.66052157","0.6585829","0.6579474","0.6575389","0.65667087","0.65667087","0.65667087","0.65629977","0.6562617","0.65475553","0.65475553","0.65475553","0.65457606","0.65445864","0.65402114","0.6531053","0.65261614","0.65259194","0.6516205","0.65071577","0.65070623","0.6505816","0.65019643","0.6489735","0.6488297","0.6482963","0.6475046","0.6463402","0.64563096","0.6453313","0.64393055","0.64393055","0.6429081","0.64237374","0.6422588","0.6420212","0.6420212","0.6420212","0.6420212","0.6420212","0.6420212","0.6420212","0.6420212","0.6420212","0.6420212","0.6418145","0.6417602"],"string":"[\n \"0.78629273\",\n \"0.7653769\",\n \"0.73715615\",\n \"0.7215964\",\n \"0.7110899\",\n \"0.70959747\",\n \"0.7047263\",\n \"0.7046574\",\n \"0.7008128\",\n \"0.70005685\",\n \"0.6987576\",\n \"0.6981723\",\n \"0.6968098\",\n \"0.6932804\",\n \"0.69116753\",\n \"0.6904762\",\n \"0.68979573\",\n \"0.68828714\",\n \"0.68811744\",\n \"0.68712103\",\n \"0.68363184\",\n \"0.68319255\",\n \"0.6827592\",\n \"0.68033534\",\n \"0.68011487\",\n \"0.6778706\",\n \"0.6776051\",\n \"0.6768296\",\n \"0.6764092\",\n \"0.6758727\",\n \"0.67317957\",\n \"0.6720644\",\n \"0.6718771\",\n \"0.67103314\",\n \"0.6699251\",\n \"0.6698576\",\n \"0.6678565\",\n \"0.66724473\",\n \"0.66714793\",\n \"0.6666044\",\n \"0.6662331\",\n \"0.66524595\",\n \"0.665114\",\n \"0.6649502\",\n \"0.6646141\",\n \"0.66371065\",\n \"0.6632519\",\n \"0.6625848\",\n \"0.6624661\",\n \"0.6621544\",\n \"0.6607201\",\n \"0.6606343\",\n \"0.6605376\",\n \"0.66052157\",\n \"0.6585829\",\n \"0.6579474\",\n \"0.6575389\",\n \"0.65667087\",\n \"0.65667087\",\n \"0.65667087\",\n \"0.65629977\",\n \"0.6562617\",\n \"0.65475553\",\n \"0.65475553\",\n \"0.65475553\",\n \"0.65457606\",\n \"0.65445864\",\n \"0.65402114\",\n \"0.6531053\",\n \"0.65261614\",\n \"0.65259194\",\n \"0.6516205\",\n \"0.65071577\",\n \"0.65070623\",\n \"0.6505816\",\n \"0.65019643\",\n \"0.6489735\",\n \"0.6488297\",\n \"0.6482963\",\n \"0.6475046\",\n \"0.6463402\",\n \"0.64563096\",\n \"0.6453313\",\n \"0.64393055\",\n \"0.64393055\",\n \"0.6429081\",\n \"0.64237374\",\n \"0.6422588\",\n \"0.6420212\",\n \"0.6420212\",\n \"0.6420212\",\n \"0.6420212\",\n \"0.6420212\",\n \"0.6420212\",\n \"0.6420212\",\n \"0.6420212\",\n \"0.6420212\",\n \"0.6420212\",\n \"0.6418145\",\n \"0.6417602\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6840933"},"document_rank":{"kind":"string","value":"20"}}},{"rowIdx":21487,"cells":{"query":{"kind":"string","value":"Plot the accuracy during training for the train and val datasets. Arguments"},"document":{"kind":"string","value":"def plot_accuracy(model_fit, save_folder): \n train_acc = model_fit.history['binary_accuracy']\n val_acc = model_fit.history['val_binary_accuracy']\n epoch_axis = np.arange(1, len(train_acc) + 1)\n plt.title('Train vs Validation Accuracy')\n plt.plot(epoch_axis, train_acc, 'b', label='Train Acc')\n plt.plot(epoch_axis, val_acc,'r', label='Val Acc')\n plt.xlim([1, len(train_acc)])\n plt.xticks(np.arange(min(epoch_axis), max(epoch_axis) + 1, round((len(train_acc) / 10) + 0.5)))\n plt.legend(loc='lower right')\n plt.ylabel('Accuracy')\n plt.xlabel('Epochs')\n plt.savefig(save_folder + '/accuracy.png')\n plt.show()\n plt.close()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_accuracy(self):\n plot_title, img_title = self.prep_titles(\"\")\n test_legend = ['training data', 'test data']\n\n # Data for plotting x- and y-axis\n x = np.arange(1, CFG.EPOCHS + 1)\n y = [self.tr_accuracy, self.test_accuracy]\n\n # prints x and y-axis values\n print(f'x: {x}')\n print(f'training: {self.tr_accuracy}')\n print(f'test: {self.test_accuracy}')\n\n plt.figure(figsize=(CFG.FIG_WIDTH, CFG.FIG_HEIGHT))\n\n # Create the lineplot\n for line in range(2):\n ax = sns.lineplot(x=x, y=y[line], color=CFG.COLOR_ACCURACY[line], label=test_legend[line])\n\n if CFG.ANNOTATE:\n ax.set(xlabel='Epochs',\n ylabel='Accuracy (%)',\n title=plot_title,\n xlim=(1, CFG.EPOCHS + 2),\n ylim=(0, 119))\n\n for line in range(2):\n for e in range(0, CFG.EPOCHS):\n if y[line][e] > CFG.ANNOTATE_LEVEL:\n value = \"{:.2f}\".format(y[line][e])\n label = \"epoch \" + str(e + 1) + \"\\n\" + value + \"%\"\n plt.annotate(label,\n xy=(x[e], y[line][e]),\n alpha=1,\n size=9,\n rotation=45,\n textcoords='offset pixels', xytext=(0, 7),\n ha='left', va='bottom')\n else:\n ax.set(xlabel='Epochs',\n ylabel='Accuracy (%)',\n title=plot_title,\n xlim=(1, CFG.EPOCHS),\n ylim=(0, 102))\n\n ax.legend(loc='best')\n\n self.save_plot(img_title)\n plt.show()","def cross_validation_visualization_accuracy(epochs, accs, save=False, filename=\"cross_validation_acc\"):\n plt.plot(epochs, accs, marker=\".\", color='r', label='accuracy')\n plt.xlabel(\"epoch\")\n plt.ylabel(\"accuracy\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n if (save):\n plt.savefig(filename)","def plot_acc(acc_v, acc_t, save_plots_path):\n\n plt.figure()\n plt.plot(acc_v, label='Validation acc')\n plt.plot(acc_t, label='Training acc')\n plt.legend()\n title = 'Accuracy per epoch'\n plt.title(title)\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Accuracy\")\n plt.savefig(save_plots_path + \"swag_accuracy_plot.png\")","def main():\n args = parse_args()\n\n with open(args.train_details_json, mode='r', encoding='utf-8') as json_f:\n results_dict = json.load(json_f)[-1]\n\n losses_plot = plt.figure()\n plt.plot(range(1, len(results_dict['train_loss']) + 1),\n results_dict['train_loss'])\n plt.plot(range(1, len(results_dict['val_loss']) + 1),\n results_dict['val_loss'])\n plt.plot(range(1, len(results_dict['test_loss']) + 1),\n results_dict['test_loss'])\n plt.legend(['train', 'val', 'test'])\n plt.title(f'loss vs epoch for {args.model} model on {args.dataset} dataset')\n plt.xlabel('epoch')\n plt.ylabel('loss')\n plt.grid(True)\n losses_plot.set_size_inches((8, 8))\n losses_plot.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_losses_plot.png'))\n\n accuracies_plot = plt.figure()\n plt.plot(range(1, len(results_dict['train_acc']) + 1),\n results_dict['train_acc'])\n plt.plot(range(1, len(results_dict['val_acc']) + 1),\n results_dict['val_acc'])\n plt.plot(range(1, len(results_dict['test_acc']) + 1),\n results_dict['test_acc'])\n plt.legend(['train', 'val', 'test'])\n plt.title(f'accuracy vs epoch for {args.model} '\n f'model on {args.dataset} dataset')\n plt.xlabel('epoch')\n plt.ylabel('accuracy')\n plt.grid(True)\n accuracies_plot.set_size_inches((8, 8))\n accuracies_plot.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_accuracies_plot.png'))","def make_accuracy_plot(num_trials=10):\n data = load_digits()\n # print data.DESCR\n train_percentages = range(5, 95, 5)\n test_accuracies = numpy.zeros(len(train_percentages))\n\n for i in range(len(train_percentages)):\n individual_trial_accuracies = []\n for j in range(num_trials):\n X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, train_size=train_percentages[i]*.01)\n model = LogisticRegression(C=10**-10)\n model.fit(X_train, y_train)\n individual_trial_accuracies.append(model.score(X_test, y_test))\n test_accuracies[i] = numpy.mean(individual_trial_accuracies)\n\n fig = plt.figure()\n plt.plot(train_percentages, test_accuracies, 'b')\n plt.xlabel('Percentage of Data Used for Training')\n plt.ylabel('Accuracy on Test Set')\n plt.show()","def train_visualization(output_path): \n log_path = output_path + 'output.log'\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\n n_epoch = len(Train_Cost)\n\n x1 = range(n_epoch)\n x2 = range(n_epoch)\n y1 = Train_Cost\n y2 = Valid_Cost\n y3 = Test_Cost\n y4 = Train_Acc\n y5 = Valid_Acc\n y6 = Test_Acc\n plt.subplot(2, 1, 1)\n plt.plot(x1, y1, label=\"Train_Cost\", linewidth=2)\n plt.plot(x1, y2, label=\"Valid_Cost\", linewidth=2)\n plt.plot(x1, y3, label=\"Test_Cost\", linewidth=2)\n\n plt.title('binary cross entropy vs. epoches')\n plt.ylabel('binary cross entropy')\n plt.legend(loc='best')\n plt.subplot(2, 1, 2)\n plt.plot(x2, y4, label=\"Train_Acc\", linewidth=2)\n plt.plot(x2, y5, label=\"Valid_Acc\", linewidth=2)\n plt.plot(x2, y6, label=\"Test_Acc\", linewidth=2)\n plt.xlabel('Accuracy@20 vs. epoches')\n plt.ylabel('Accuracy@20')\n plt.legend(loc='best')\n plt.savefig(output_path + 'loss_fig.png')\n # plt.show()","def plot_on_ax(ax, trn_ls, val_ls, ylabel=\"Accuracy\"):\n ax.plot(trn_ls, 'o-', label='Training')\n ax.plot(val_ls, 'x-', label='Validation')\n ax.set_xlabel('Epochs')\n ax.set_ylabel(ylabel)\n ax.legend()","def model_testing(X_train,y_train):\n\n # for testing amount of layers, each layer has 32 neurons\n # layers = [[32, 32], [32, 32, 32], [32, 32, 32, 32], [32, 32, 32, 32],\\\n # [32, 32, 32, 32, 32], [32, 32, 32, 32, 32, 32]]\n layers = [[8], [16], [32], [64], [128], [256]]\n\n # activation = [\"linear\", \"sigmoid\", \"relu\", \"softmax\"]\n activation = [\"relu\"]\n runs = 1\n for i, act in enumerate(activation):\n val_accs = []\n for layer in layers:\n acc_avg = []\n for run in range(runs):\n model = create_model_testing(layer, act)\n\n # train model on full train set, with 80/20 CV split\n training = model.fit(X_train, y_train, epochs=100, validation_split=0.2, verbose=0)\n val_acc = np.mean(training.history['val_accuracy'])\n print(\"Run \", run, \" - \", act + \" activation - layer \" + str(layer))\n acc_avg.append(val_acc)\n\n # save average accuracy of runs\n val_accs.append(round(np.mean(acc_avg)*100, 2))\n print(\"accuracy: \" + str(np.mean(acc_avg)))\n\n # plot line for each activation method\n plt.plot([1,2,4,8,16,32,64,128,256], val_accs, label=act)\n # plt.plot(val_accs, label=act)\n\n # plotting\n plt.title(\"Accuracy of neural network model with different layers (N=\" +\\\n str(len(layers)) + \")\", fontsize=22)\n plt.xlabel(\"Layers\", fontsize=20)\n # plt.xticks(np.arange(1, len(val_accs) + 1, 1), fontsize=18)\n plt.ylabel(\"Accuracy (%)\", fontsize=20)\n plt.legend()\n plt.subplots_adjust(bottom=.15, left=.15)\n plt.savefig(\"results/linear-relu-\" + str(runs) + \"runs.png\")\n plt.show()","def plot_acc(model_dir):\n ## extract loss from csv\n file_dir = os.path.join(model_dir, 'acc.csv')\n data = pd.read_csv(file_dir)\n epochs = data['epoch'].ravel()\n acc_train = data['acc_train'].ravel()\n acc_test = data['acc_test'].ravel()\n # epoch,acc_train,acc_test\n\n ## Theoretical Loss\n fig, ax = plt.subplots(1, 1, figsize=(7, 5), sharey=True, sharex=True, dpi=400)\n ax.plot(epochs, acc_train, label='train', color='green', alpha=0.8)\n ax.plot(epochs, acc_test, label='test', color='red', alpha=0.8)\n ax.set_ylabel('Accuracy', fontsize=10)\n ax.set_xlabel('Epoch', fontsize=10)\n ax.legend(loc='lower right', prop={\"size\": 15}, ncol=3, framealpha=0.5)\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n plt.tight_layout()\n\n ## create saving directory\n acc_dir = os.path.join(model_dir, 'figures', 'acc')\n os.makedirs(acc_dir, exist_ok=True)\n file_name = os.path.join(acc_dir, 'accuracy.png')\n plt.savefig(file_name, dpi=400)\n print(\"Plot saved to: {}\".format(file_name))\n file_name = os.path.join(acc_dir, 'accuracy.pdf')\n plt.savefig(file_name, dpi=400)\n plt.close()\n print(\"Plot saved to: {}\".format(file_name))","def plot_acc (history, acc='acc', val_acc='val_acc'):\n \n history_dict = history.history\n acc = history_dict[acc]\n val_acc = history_dict[val_acc]\n loss_values = history_dict['loss']\n epochs = range(1, len(loss_values) + 1)\n\n plt.plot (epochs, acc, 'bo', label='Training accuracy')\n plt.plot (epochs, val_acc, 'b', label=\"validation accuracy\")\n plt.title('Training and validation accuracy')\n plt.xlabel('Epochs')\n plt.ylabel('Accuracy')\n plt.legend()\n plt.show()","def accuracy_plot(training, test, layers, data_size, n_neighbours, learning_rate, dropout_rate):\n\n plt.figure()\n plt.plot(training, label=\"Training\")\n plt.plot(test, label=\"Test\")\n plt.xlabel(\"Iterations\", size='medium')\n plt.ylabel(\"Accuracy function (%)\", size='medium')\n plt.suptitle(\"Accuracy function while training the neural network\", size='medium', ha='center')\n plt.title(\"layers: {} with dropout rate of {}, learning rate: {}\".format(layers, dropout_rate, learning_rate),\n size='small', ha='center')\n if n_neighbours == 0:\n plt.figtext(0.83, 0.80, \"Neighbours\\nexcluded\", size='medium')\n else:\n plt.figtext(0.83, 0.80, \"{} neighbours\\nincluded\".format(n_neighbours), size='medium')\n plt.figtext(0.83, 0.70, \"{}\\nsamples\".format(data_size), size='medium')\n plt.legend(loc='right', bbox_to_anchor=(1.3, 0.5))\n plt.subplots_adjust(right=0.8)\n\n working_dir = os.path.dirname(os.path.abspath(__file__))\n saving(working_dir + \"/output_ANN/accuracy_plots/{}_accuracy_{}\".format(n_neighbours, data_size))","def plot_eval_3(trained_model, X_val, y_val, image_name):\n # FOR EACH CLASS\n # val_pred = trained_model.predict_proba(X_val, num_iteration=iteration)\n \n iterations = trained_model.booster_.current_iteration()\n# results = np.zeros((2, iterations))\n results = np.zeros((iterations,))\n for pos in range(iterations):\n \n # Calculate the current iteration (from 1 to iterations)\n iteration = pos + 1\n \n # Predict validation set for the current iteration\n# start_time = timeit.default_timer()\n val_pred = trained_model.predict(X_val, num_iteration=iteration)\n# end_time = timeit.default_timer()\n# time = end_time - start_time\n# speed = int(X_val.shape[0] / time)\n \n # Number of hits\n val_ok = (val_pred == y_val)\n \n # Percentage of hits\n val_acc = val_ok.sum() / val_ok.size\n \n # Actualize data for plotting results\n# results[0][pos] = time\n# results[1][pos] = val_acc\n results[pos] = val_acc\n \n # Generate accuracy plot\n plt.figure()\n# plt.plot(results[0], results[1], 'b')\n plt.plot(results, 'b')\n plt.title('Validation accuracy')\n plt.xlabel('iterations')\n plt.ylabel('accuracy')\n plt.legend()\n \n # Save validation plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_val_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def plot_observations():\n plt.plot(history.history['loss'], label='training_loss')\n plt.plot(history.history['val_loss'], label='val_loss ')\n plt.xlabel('Epoch')\n plt.ylabel('Loss')\n plt.show()\n\n plt.plot(history.history['acc'], label='accuracy')\n plt.plot(history.history['val_acc'], label='val_accuracy')\n plt.xlabel('Epoch')\n plt.ylabel('Accuracy')\n plt.legend(loc='lower right')\n plt.show()\n\n test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)\n print(\"Test Accuracy:\", test_acc)","def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc):\n \n green = '#72C29B'\n orange = '#FFA577'\n \n with plt.xkcd():\n # plot model loss\n fig, ax1 = plt.subplots()\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\n label='training')\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\n linewidth=5, label='validation')\n ax1.set_xlabel('# epoch')\n ax1.set_ylabel('loss')\n ax1.tick_params('y')\n ax1.legend(loc='upper right', shadow=False)\n # plot model accuracy\n fig, ax2 = plt.subplots()\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\n label='training')\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\n linewidth=5, label='validation')\n ax2.set_xlabel('# epoch')\n ax2.set_ylabel('accuracy')\n ax2.tick_params('y')\n ax2.legend(loc='lower right', shadow=False)\n plt.show()","def cross_validation_visualization_accuracy_multiple(epochs, accs, save=False, filename=\"cross_validation_acc_multiple\"):\n \n for i in range(accs.shape[0]):\n plt.plot(epochs, accs[i], marker=\".\", color='r', label=str(i+1)+'th accuracy')\n \n plt.xlabel(\"epoch\")\n plt.ylabel(\"accuracy\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n if (save):\n plt.savefig(filename)","def display_convergence_acc(train_accs, valid_accs):\n if len(valid_accs) > 0:\n plt.plot(len(train_accs), train_accs, color=\"red\")\n plt.plot(len(valid_accs), valid_accs, color=\"blue\")\n plt.legend([\"Train\", \"Valid\"])\n else:\n plt.plot(len(train_accs), train_accs, color=\"red\")\n plt.legend([\"Train\"])\n plt.xlabel('Epoch')\n plt.ylabel('Accuracy')\n plt.show()","def plot_results(\n train_data: tuple[Tensor, Tensor],\n test_data: tuple[Tensor, Tensor],\n correct_class: Tensor\n):\n #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(21,7), subplot_kw=dict(box_aspect=1))\n fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(14,7), subplot_kw=dict(box_aspect=1))\n fig2, ax3 = plt.subplots(figsize=(7,7), subplot_kw=dict(box_aspect=1))\n ax1.set_title('Training data')\n plot_dataset(train_data, ax1)\n\n ax2.set_title('Test data')\n plot_dataset(test_data, ax2)\n\n ax3.set_title('Test prediction correctness')\n plot_dataset((test_data[0], correct_class.int()), ax3, cmap={0: '#ff0000', 1: '#00ff00'})\n \n fig1.savefig('plots/datasets')\n fig2.savefig('plots/predictions')\n plt.show()","def plot(self, ylog=False, category=\"Accuracy\", figsize=(12, 5)):\n if self.CV == False: # no Cross Validation set case\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\n plt.suptitle(\"Training Curve for \" + self.loss, fontsize=12)\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\n ax[0].set_xlabel('Iteration')\n ax[0].set_ylabel(\"Error\")\n if ylog == True:\n ax[0].set_yscale('log')\n ax[0].legend()\n ax[0].grid('on')\n\n if category == \"Accuracy\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'r-', label='Training Accuracy')\n ax[1].set_ylabel(\"Accuracy\")\n elif category == \"Error Rate\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'r-', label='Training Error Rate')\n ax[1].set_ylabel(\"Error Rate\")\n # ax[1].set_ylim((0, 1))\n ax[1].set_xlabel('Iteration')\n ax[1].legend(loc='best')\n ax[1].grid('on')\n plt.show()\n if self.CV == True: # has Cross Validation set case\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\n plt.suptitle(\"Training Curve for \" + self.loss, fontsize=12)\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\n ax[0].plot(range(1, len(self.cvError) + 1), self.cvError, 'r-', label='CV Error')\n ax[0].set_xlabel('Iteration')\n ax[0].set_ylabel(\"Error\")\n if ylog == True:\n ax[0].set_yscale('log')\n ax[0].legend()\n ax[0].grid('on')\n\n if category == \"Accuracy\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'g-', label='Training Accuracy')\n ax[1].plot(range(1, len(self.cvAcc) + 1), self.cvAcc, 'r-', label='CV Accuracy')\n ax[1].set_ylabel(\"Accuracy\")\n elif category == \"Error Rate\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'g-', label='Training Error Rate')\n ax[1].plot(range(1, len(self.cvAcc) + 1), 1 - np.array(self.cvAcc), 'r-', label='CV Error Rate')\n ax[1].set_ylabel(\"Error Rate\")\n # ax[1].set_ylim((0, 1))\n ax[1].set_xlabel('Iteration')\n ax[1].legend(loc='best')\n ax[1].grid('on')\n plt.show()\n\n return fig, ax","def create_val_plots(x_vals, vals_zeros,vals_ones):\n plt.plot(x_vals, vals_zeros,label=\"non-fraud\")\n plt.plot(x_vals, vals_ones,label=\"fraud\")\n plt.title('Accuracy per number of iterations')\n plt.xlabel('Number of Iterations')\n plt.ylabel('Accuracy')\n plt.xticks(np.arange(100, 210, 10))\n plt.legend() \n plt.show()\n # plt.savefig('./analysis_deliverable/visualizations/accuracy_plot.png')","def plot_train_results(metrics2record, loss_metric,\n train_metrics, test_metrics):\n pyplot.figure(figsize=(10, 5))\n min_, max_ = np.min(loss_metric), np.max(loss_metric)\n lg, = pyplot.plot(loss_metric)\n pyplot.yticks(min_ + np.arange(5) * (max_ - min_))\n # if learning_rate is not None:\n # lg, = pyplot.plot(learning_rate)\n pyplot.title('Loss')\n pyplot.xlabel('Epoch')\n pyplot.yscale('log')\n pyplot.show()\n\n for prm in basic_metrics:\n if prm in metrics2record:\n leg = []\n met_idx = metrics2record.index(prm)\n pyplot.figure(figsize=(10, 5))\n lg, = pyplot.plot(train_metrics[:, met_idx], label=('train'))\n leg.append(lg)\n lg, = pyplot.plot(test_metrics[:, met_idx], label=('test'))\n leg.append(lg)\n\n pyplot.legend(handles=leg)\n pyplot.title(prm)\n pyplot.xlabel('Epoch')\n pyplot.show()\n\n has_prf = any([(prm in PRF_metrics) for prm in metrics2record])\n if has_prf:\n pyplot.figure(figsize=(10, 5))\n leg = []\n for prm in PRF_metrics:\n if prm in metrics2record:\n met_idx = metrics2record.index(prm)\n lg, = pyplot.plot(train_metrics[:, met_idx],\n label=(prm + ':train'))\n leg.append(lg)\n\n for prm in PRF_metrics:\n if prm in metrics2record:\n met_idx = metrics2record.index(prm)\n lg, = pyplot.plot(test_metrics[:, met_idx],\n label=(prm + ':test'))\n leg.append(lg)\n\n pyplot.legend(handles=leg)\n pyplot.title('Precision / Recall')\n pyplot.xlabel('Epoch')\n pyplot.show()","def cross_validation_experiment(train_data, train_labels):\n accuracies = []\n for i in range(1, 200):\n avg = cross_validation(train_data, train_labels, i, 10)\n accuracies.append(avg)\n fig = plt.figure()\n dim = np.arange(1,len(accuracies)+1)\n plt.plot(dim,accuracies, label='Accuracy')\n plt.xlabel('k')\n plt.ylabel('accuracy')\n plt.grid()\n plt.legend()\n plt.tight_layout()\n fig.savefig('knn_cross_validation.png')\n best_k = np.argmax(accuracies)+1\n return best_k","def train_accuracy(self):\n # Train accuarcy\n add = np.ones(len(self.X_train))\n X_add1 = np.c_[add, self.X_train]\n pred_train = np.dot(X_add1, self.w_result.T)\n pred_train[pred_train > 0] = 1\n pred_train[pred_train < 0] = 0\n print(pred_train)\n train_check_lable = np.isclose(pred_train, self.y_train)\n num_true_lable = np.sum(train_check_lable)\n num_all_lable = np.size(train_check_lable)\n train_accuracy = num_true_lable / num_all_lable\n print(\"train_accuracy is: %f\" %train_accuracy)\n return train_accuracy","def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc, save_figure_path):\n\n green = '#72C29B'\n orange = '#FFA577'\n\n with plt.xkcd():\n fig, (ax1, ax2) = plt.subplots(2, figsize=(10, 8))\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\n label='training')\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\n linewidth=5, label='validation')\n ax1.set_xlabel('# epoch')\n ax1.set_ylabel('loss')\n ax1.tick_params('y')\n ax1.legend(loc='upper right', shadow=False)\n ax1.set_title('Model loss through #epochs', fontweight='bold')\n\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\n label='training')\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\n linewidth=5, label='validation')\n ax2.set_xlabel('# epoch')\n ax2.set_ylabel('accuracy')\n ax2.tick_params('y')\n ax2.legend(loc='lower right', shadow=False)\n ax2.set_title('Model accuracy through #epochs', fontweight='bold')\n\n plt.tight_layout()\n plt.show()\n fig.savefig(save_figure_path)\n plt.close(fig)","def plot_training_info(case, metrics, save, history):\n val = False\n if 'val_accuracy' in history and 'val_loss' in history:\n val = True\n plt.ioff()\n if 'accuracy' in metrics:\n fig = plt.figure()\n plt.plot(history['accuracy'])\n if val:\n plt.plot(history['val_accuracy'])\n plt.title('model accuracy')\n plt.ylabel('accuracy')\n plt.xlabel('epoch')\n if val:\n plt.legend(['train', 'val'], loc='upper left')\n else:\n plt.legend(['train'], loc='upper left')\n if save:\n plt.savefig(case + 'accuracy.png')\n plt.gcf().clear()\n else:\n plt.show()\n plt.close(fig)\n\n # summarize history for loss\n if 'loss' in metrics:\n fig = plt.figure()\n plt.plot(history['loss'])\n if val:\n plt.plot(history['val_loss'])\n plt.title('model loss')\n plt.ylabel('loss')\n plt.xlabel('epoch')\n # plt.ylim(1e-3, 1e-2)\n plt.yscale(\"log\")\n if val:\n plt.legend(['train', 'val'], loc='upper left')\n else:\n plt.legend(['train'], loc='upper left')\n if save:\n plt.savefig(case + 'loss.png')\n plt.gcf().clear()\n else:\n plt.show()\n plt.close(fig)","def acc_loss_graph(self):\n acc = self.history['accuracy']\n val_acc = self.history['val_accuracy']\n loss = self.history['loss']\n val_loss = self.history['val_loss']\n plt.figure(figsize=(15, 5))\n plt.subplot(1, 2, 1)\n plt.plot(acc, label='Train')\n plt.plot(val_acc, label='Val')\n plt.legend(loc='lower right')\n plt.ylabel('Accuracy')\n plt.xlabel('Epoch')\n plt.ylim([min(plt.ylim()), 1])\n plt.title('Accuracy')\n\n plt.subplot(1, 2, 2)\n plt.plot(loss, label='Train')\n plt.plot(val_loss, label='Val')\n plt.legend(loc='lower right')\n plt.ylabel('Loss')\n plt.xlabel('Epoch')\n plt.ylim([0, max(plt.ylim())])\n plt.title('Loss')\n plt.show();","def train_nn(train_nn_results, label, title, yaxis):\n plt.figure(figsize=(12,5))\n for i in range(len(label)):\n plt.plot(train_nn_results[i], label=label[i], alpha=0.75)\n plt.title(title)\n plt.xlabel('epoch')\n plt.ylabel(yaxis)\n plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')\n plt.tight_layout()\n plt.show()","def create(self, train: List[float], validation: List[float]) -> None:\n self.ax.plot(train)\n self.ax.plot(validation)\n self.ax.set_xlabel('epochs')\n if self.loss:\n self.ax.set_ylabel('loss')\n else:\n self.ax.set_ylabel('accuracy')\n self.ax.legend(['train', 'validation'])","def test(self, plot=False):\n accuracy_list = []\n fobj_avg = self.load_stats()\n\n for ii in range(settings.PARS['maxIters']):\n model = self.load_model(ii)\n D1 = model['D']\n W1 = model['W']\n\n # classification\n tic = time.time()\n accuracy_list.append(self.classification(D1, W1)[1])\n toc = time.time()\n print(\n 'Final recognition rate for OnlineDL is : {} , objective function value: {}, time: {}'\n .format(accuracy_list[ii], fobj_avg[ii], toc-tic)\n )\n\n accuracy_list = np.asarray(accuracy_list)\n\n print('Best recognition rate for OnlineDL is {} at iteration {}'.format(\n accuracy_list.max(), accuracy_list.argmax()))\n\n if plot:\n # plot the objective function values for all iterations\n plt.clf()\n plt.plot(list(fobj_avg.keys()), list(fobj_avg.values()), 'mo--', linewidth=2)\n plt.xlabel('Iterations')\n plt.ylabel('Average objective function value')\n plt.xticks(list(range(0, 20)), list(range(1, 21)))\n plt.show()\n\n plt.clf()\n plt.plot(accuracy_list, 'rs--', linewidth=2)\n plt.xticks(list(range(0, 20)), list(range(1, 21)))\n plt.xlabel('Iterations')\n plt.ylabel('Accuracy')\n plt.show()","def plot_metric_values(self, threshold=0):\n epochs_range = np.arange(threshold, len(self.accuracies), 1)\n plt.plot(epochs_range, self.accuracies[threshold:], color='red', marker='o')\n plt.title('Accuracy on test data. Eta={:.2f} Lambda={:2.2f}'.format(self.eta, self.lambda_r))\n plt.xlabel('Epochs')\n plt.ylabel('Accuracy')\n plt.grid(True)\n plt.show()","def predict(x_train, y_train, x_test, y_test, fn, params):\n y_train_predicted = fn(x_train, None, *params)\n y_train_predicted = (y_train_predicted >= 0.5) * 1\n y_test_predicted = fn(x_test, None, *params)\n y_test_predicted = (y_test_predicted >= 0.5) * 1\n\n train_acc = np.sum(y_train_predicted == y_train) / x_train.shape[0]\n test_acc = np.sum(y_test_predicted == y_test) / x_test.shape[0]\n print('train accuracy =', train_acc)\n print('test accuracy =', test_acc)\n scatter_plot(x_train, y_train_predicted, x_test, y_test_predicted, 'predicted 0', 'predicted 1')","def plotgraph(readfile='archivo.csv', outfiles='',cost_function='Categorical Cross Entropy'):\r\n plt.rcParams['figure.figsize']=(12,9)\r\n \r\n df=pd.read_csv(str(readfile), header=None)\r\n df=df.rename(columns={0:'cost_train', 1:'acc_train', 2:'cost_test', 3:'acc_test'})\r\n\r\n plt.figure(1)\r\n plt.title('Accuracy', fontsize=20, fontweight='bold')\r\n train=plt.scatter(np.arange(1,len(df)+1,1), df['acc_train'].values*100, color='red',\r\n marker='x',s=100)\r\n test=plt.scatter(np.arange(1,len(df)+1,1), df['acc_test'].values*100, color='blue',\r\n marker='o',s=100)\r\n plt.legend([train,test],['Training set', 'Test set'], fontsize=18)\r\n plt.xlabel('Epochs',fontsize=20, fontweight='bold')\r\n plt.xticks(fontsize=16)\r\n plt.yticks(fontsize=16)\r\n plt.ylabel('Accuracy %', fontsize=20, fontweight='bold')\r\n plt.annotate(str(round(df['acc_train'].values[-1]*100,2))+' %', xy=(len(df),int(df['acc_train'].values[-1]*100)), \r\n xytext=(len(df),int(df['acc_train'].values[-1]*100-1)), fontsize=14, fontweight='bold')\r\n plt.annotate(str(round(df['acc_test'].values[-1]*100,2))+' %', xy=(len(df),int(df['acc_test'].values[-1]*100)),\r\n xytext=(len(df),int(df['acc_test'].values[-1]*100+2)), fontsize=14, fontweight='bold')\r\n plt.savefig('Accuracy'+'_'+str(outfiles)+'.png')\r\n \r\n plt.figure(2)\r\n plt.title(str(cost_function), fontsize=20, fontweight='bold')\r\n train=plt.scatter(np.arange(1,len(df)+1,1), df['cost_train'].values, color='red',\r\n marker='x',s=100)\r\n test=plt.scatter(np.arange(1,len(df)+1,1), df['cost_test'].values, color='blue',\r\n marker='o',s=100)\r\n plt.legend([train,test],['Training set', 'Test set'], fontsize=18)\r\n plt.xlabel('Epochs',fontsize=20, fontweight='bold')\r\n plt.xticks(fontsize=16)\r\n plt.yticks(fontsize=16)\r\n plt.ylabel('Cost function', fontsize=20, fontweight='bold')\r\n plt.annotate(str(round(df['cost_train'].values[-1],4)), xy=(len(df),df['cost_train'].values[-1]), \r\n xytext=(len(df),1.1*df['cost_train'].values[-1]), fontsize=14, fontweight='bold')\r\n plt.annotate(str(round(df['cost_test'].values[-1],4)), xy=(len(df),df['cost_test'].values[-1]),\r\n xytext=(len(df),1.1*df['cost_test'].values[-1]+0.05), fontsize=14, fontweight='bold')\r\n plt.savefig('Cost function'+'_'+str(outfiles)+'.png')\r\n plt.close('all')\r\n\r\n return","def plot_acc_and_loss(trn_hist, val_hist):\n assert isinstance(trn_hist, np.ndarray) and isinstance(val_hist, np.ndarray)\n fig, (ax_acc, ax_loss) = plt.subplots(1, 2, figsize=(10, 4))\n plot_on_ax(ax_acc, trn_hist[:,0], val_hist[:,0], \"Accuracy\")\n plot_on_ax(ax_loss, trn_hist[:,1], val_hist[:,1], \"Loss\")\n plt.show()","def plot_results(self):\n\n\n f1, ax1 = plt.subplots()\n h1, = ax1.plot(self.history[\"step\"], self.history[\"trainLoss\"],\\\n \"b-\", label=\"Loss - Train\")\n h2, = ax1.plot(self.history[\"step\"], self.history[\"validLoss\"],\\\n \"b.\", label=\"Loss - Validation\")\n\n ax1.set_ylabel(\"Loss\", color = \"blue\")\n ax1.tick_params(\"y\", color = \"blue\")\n ax1.yaxis.label.set_color(\"blue\")\n ax1.set_xlabel(\"Training Steps [{}]\".format(self.FLAGS.eval_every))\n\n ax2 = ax1.twinx()\n h3, = ax2.plot(self.history[\"step\"], self.history[\"trainAccr\"], \"r-\",\\\n label = \"Accuracy - Train\")\n h4, = ax2.plot(self.history[\"step\"], self.history[\"validAccr\"], \"r.\",\\\n label = \"Accuracy - Validation\")\n\n ax2.set_ylabel(\"Accuracy\", color = \"red\")\n ax2.tick_params(\"y\", color = \"red\")\n ax2.yaxis.label.set_color(\"red\")\n\n hds = [h1,h2,h3,h4]\n lbs = [l.get_label() for l in hds]\n ax1.legend(hds, lbs)\n f1.tight_layout()\n plt.savefig(\"trainingHistory.png\")\n\n plt.close(f1)\n #plt.show()","def see_evaluation(epoch, training_acc, test_acc):\n print (\"Epoch \", epoch, \"Training acc: \", training_acc*100, \"Test acc: \", test_acc*100)","def show_learning_curve(self):\n\n # Loop output classes\n for c in range(1,self.n_output_classes):\n # Get data\n x_values = np.array(self.n_class_samples_list[c])\n accuracy = np.array(self.accuracy_list[c])\n precision = np.array(self.precision_list[c])\n recall = np.array(self.recall_list[c])\n F1 = np.array(self.F1_list[c])\n\n # Make plot\n with sns.axes_style(\"ticks\"):\n fig,ax = plt.subplots()\n plt.plot([np.min(x_values),np.max(x_values)],[0.5,0.5],\n color='#777777',linestyle='--')\n plt.plot([np.min(x_values),np.max(x_values)],[0.66,0.66],\n color='#777777',linestyle=':')\n plt.plot([np.min(x_values),np.max(x_values)],[0.8,0.8],\n color='#777777',linestyle=':')\n plt.plot([np.min(x_values),np.max(x_values)],[0.9,0.9],\n color='#777777',linestyle=':')\n\n plt.plot( x_values, accuracy, color='#000000',\n linewidth=1, label='Accuracy' )\n plt.plot( x_values, precision, color='#0000aa',\n linewidth=1, label='Precision' )\n plt.plot( x_values, recall, color='#00aa00',\n linewidth=1, label='Recall' )\n plt.plot( x_values, F1, color='#aa0000',\n linewidth=2, label='F1' )\n\n plt.yticks( [0, 0.5, 0.66, 0.8, 0.9, 1.0],\n ['0','0.5','0.66','0.8','0.9','1.0'], ha='right' )\n plt.xlim(np.max(x_values)*-0.02,np.max(x_values)*1.02)\n plt.ylim(-0.02,1.02)\n plt.xlabel('Number of training samples')\n plt.ylabel('Performance')\n plt.title('Learning curve, class {}'.format(c))\n sns.despine(ax=ax, offset=0, trim=True)\n lgnd = plt.legend(loc=4, ncol=1, frameon=True, fontsize=9)\n lgnd.get_frame().set_facecolor('#ffffff')\n ax.spines['left'].set_bounds(0,1)\n ax.spines['bottom'].set_bounds(np.min(x_values),np.max(x_values))","def plot_predictions(net, x_train, y_train, idx_train, x_val, y_val, idx_val):\n fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(20, 30))\n pred1 = net.predict(x_val, batch_size=batch_size)\n # print(\"pred1.shape:\", pred1.shape)\n ax1.plot(idx_val, y_val, label=\"Actual Data\", marker=\"+\")\n ax1.plot(idx_val, pred1, label=\"Prediction\", marker=\"o\")\n # ax1.set_ylim(-0.1, 1.1)\n ax1.set_xlabel(\"Year\")\n ax1.set_ylabel(\"Sunspot Numbers\")\n ax1.legend()\n ax1.set_title(\"Predicted vs Actual Validation Data\")\n\n pred2 = net.predict(x_train, batch_size=batch_size)\n # print(\"pred2.shape:\", pred2.shape)\n ax2.plot(idx_train, y_train, label=\"Actual Data\", marker=\"+\")\n ax2.plot(idx_train, pred2, label=\"Prediction\", marker=\"o\")\n # ax2.set_ylim(-0.1, 1.1)\n ax2.set_xlabel(\"Year\")\n ax2.set_ylabel(\"Sunspot Numbers\")\n ax2.legend()\n ax2.set_title(\"Predicted vs Actual Training Data\")\n\n plt.tight_layout()\n\n filename = \"img/\"\n filename += datetime.now().strftime(\"%y%m%d_%H%M\")\n filename += \"_predicted_vs_actual_data.png\"\n fig.savefig(filename, format=\"png\")","def plot_eval_1(trained_model, image_name):\n # Get training evaluation data\n train_accuracy = trained_model.history['acc']\n train_val_accuracy = trained_model.history['val_acc']\n train_loss = trained_model.history['loss']\n train_val_loss = trained_model.history['val_loss']\n \n # Generate accuracy plot\n epochs = range(len(train_accuracy))\n plt.figure()\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\n plt.title('Training and validation accuracy')\n plt.legend()\n \n # Save accuracy plot\n plot_file = os.path.join(OUTPUT_DIR,\n \"{}_training_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')\n \n # Generate loss plot\n plt.figure()\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n \n # Save loss plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_training_loss\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def make_accuracy_plot(ax,\n groundtruth_boxes,\n hpu_boxes,\n cpu_boxes,\n hpu_strategy,\n label,\n N=10,\n num_graph_points=20,\n match_mode=\"ellipse\",\n):\n print \"Making plot for\", repr(label)\n print \"TODO: this should graph seconds per image\"\n mix_fractions = np.linspace(0, 1.0, num_graph_points)\n # Plot confidence intervals\n min_ci = []\n max_ci = []\n mean_accs = []\n stderr_accs = []\n for mix_fraction in mix_fractions:\n accuracies = [\n maximum_F_score(\n groundtruth_boxes,\n hpu_strategy(hpu_boxes, cpu_boxes, mix_fraction),\n match_mode=match_mode,\n )\n for _ in xrange(N)\n ]\n mean_accs.append(np.mean(accuracies))\n stderr_accs.append(np.std(accuracies, ddof=1) / np.sqrt(N))\n #print mix_fraction, np.mean(accuracies)\n ax.errorbar(mix_fractions, mean_accs, stderr_accs, label=label)\n ax.set_xlabel(\"Fraction of HPU-labeled images\")\n ax.set_ylabel(\"Maximum F-score\")","def _plot_train_test_experiment(mtrain, mval, metric_name, isState):\n # axes\n f, axes = plt.subplots(2,2,figsize=(12,10))\n ltrain = _plot_experiment(mtrain, axes[:,0], metric_name, isTrain=True)\n lval = _plot_experiment(mval, axes[:,1], metric_name, isTrain=False)\n # title\n target = \"State\" if isState else \"Output\"\n f.suptitle(f\"{target} Errors\")\n f.tight_layout()\n return f, axes","def train_model_and_plot_results(**kwargs):\n epochs = kwargs[\"epochs\"]\n\n history, model = train_model(**kwargs)\n\n dice = history.history['dice_loss']\n val_dice = history.history['val_dice_loss']\n\n loss = history.history['loss']\n val_loss = history.history['val_loss']\n\n epochs_range = range(epochs)\n\n plt.figure(figsize=(16, 8))\n plt.subplot(1, 2, 1)\n plt.plot(epochs_range, dice, label='Training Dice Loss')\n plt.plot(epochs_range, val_dice, label='Validation Dice Loss')\n plt.legend(loc='upper right')\n plt.title('Training and Validation Dice Loss')\n\n plt.subplot(1, 2, 2)\n plt.plot(epochs_range, loss, label='Training Loss')\n plt.plot(epochs_range, val_loss, label='Validation Loss')\n plt.legend(loc='upper right')\n plt.title('Training and Validation Loss')\n\n plt.show()","def visualize_train_history(history):\n cat_acc = history.history['categorical_accuracy']\n val_cat_acc = history.history['val_categorical_accuracy']\n loss = history.history['loss']\n val_loss = history.history['val_loss']\n\n epochs = range(1, len(cat_acc) + 1)\n\n plt.plot(epochs, cat_acc, 'bo', label='Training cat_acc')\n plt.plot(epochs, val_cat_acc, 'b', label='Validation cat_acc')\n plt.title('Training and validation accuracy')\n plt.legend()\n\n plt.figure()\n\n plt.plot(epochs, loss, 'bo', label='Training loss')\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n\n plt.show()","def graph_ACC(history,title):\n _, ax = plt.subplots()\n ax.set_title(title)\n try:\n ax.plot(history.history['acc'], label='Train')\n ax.plot(history.history['val_acc'], label='Test')\n except:\n ax.plot(history['acc'], label='Train')\n ax.plot(history['val_acc'], label='Test')\n ax.set_xlabel(\"Epochs\")\n ax.set_ylabel(\"Accuracy\")\n ax.legend()","def accuracy_plot(LS_sizes, data_fun):\r\n\r\n opt_neigh = []\r\n\r\n #plot of optimal n_neighbors as a function of the LS size\r\n\r\n for size in LS_sizes:\r\n\r\n acc = []\r\n neighbors_values = np.arange(1,size+1,1)\r\n\r\n # For a given LS size, plots of accuracy(n_neighbors)\r\n\r\n for value in neighbors_values:\r\n\r\n X_train, y_train, X_test, y_test = data_fun(n_ts=500, n_ls=size)\r\n\r\n clf = KNeighborsClassifier(n_neighbors = value)\r\n clf = clf.fit(X_train, y_train)\r\n acc.append(clf.score(X_test,y_test))\r\n\r\n plt.figure()\r\n plt.plot(neighbors_values,acc, '.')\r\n plt.title(\"Evolution of accuracy as a function \\nof n_neighbors for LS_size = {} samples, for {}.\".format(size, data_fun.__name__))\r\n plt.savefig(\"acc(n_neigh)_{}_{}.pdf\".format(size, data_fun.__name__))\r\n\r\n opt_neigh.append(np.argmax(acc)+1)\r\n\r\n plt.figure()\r\n plt.plot(LS_sizes, opt_neigh, '.')\r\n plt.title(\"Optimal n_neighbors as a function \\nof the size of the learning sample, for {}.\".format(data_fun.__name__))\r\n plt.savefig(\"opt_n_neigh(LS_size)_{}.pdf\".format(data_fun.__name__))","def plt_accuracy(self, lamda_choice, weights_initial):\n weights_random = []\n train_accuracy = []\n test_accuracy = []\n for i in range(len(lamda_choice)):\n self.lamda = lamda_choice[i]\n self.fit(weights_initial)\n pred_result = self.predict()\n test_ac = self.evaluate(pred_result)\n test_accuracy.append(test_ac)\n train_ac = self.train_accuracy() \n train_accuracy.append(train_ac)\n weights_random.append(self.w_result[-1])\n # print best lamda with highest accuracy\n print(\"choose lambda: %f\" % lamda_choice[np.argmax(train_accuracy)])\n labels = [\"Train_accuracy\", \"Test_accuracy\"]\n fig, ax = plt.subplots()\n ax.plot(lamda_choice, train_accuracy, 'o-', label='Train_accuracy')\n ax.plot(lamda_choice, test_accuracy, 'o-', label='Test_accuracy')\n # Draw absolute weight value corresponding the random feature\n fig, ax = plt.subplots()\n ax.plot(lamda_choice, weights_random, label='Weight for random')\n plt.show()\n # find the best lamda\n self.lamda = lamda_choice[np.argmax(train_accuracy)]","def test(self, training_set, original_test_set, imitation_test_set ):\n\n plt.figure()\n\n training_axis = np.arange(len(training_set))\n original_test_axis = np.arange(len(original_test_set))+len(training_axis)\n imitation_test_axis = np.arange(len(imitation_test_set))+len(training_axis)+len(original_test_set)\n\n training_scores = []\n original_test_scores = []\n imitation_test_scores = []\n\n for signature in training_set:\n vectorized_signature = signature.tolist()\n score = -1*self.model.score(vectorized_signature)\n training_scores.append(score)\n\n for signature in original_test_set:\n vectorized_signature = signature.tolist()\n score = -1*self.model.score(vectorized_signature)\n original_test_scores.append(score)\n\n for signature in imitation_test_set:\n vectorized_signature = signature.tolist()\n score = -1*self.model.score(vectorized_signature)\n imitation_test_scores.append(score)\n\n accuracy, threshold = self.evaluate(training_scores, original_test_scores, imitation_test_scores)\n\n xaxis = np.arange(len(imitation_test_set)+len(training_axis)+len(original_test_set))\n plt.plot( xaxis, threshold*np.ones(len(xaxis)), \"--\", label=\"Threshold\" )\n plt.scatter(training_axis,training_scores, label=\"Training data\")\n plt.scatter(original_test_axis, original_test_scores, c=\"g\", label=\"Original Test data\")\n plt.scatter(imitation_test_axis, imitation_test_scores, c=\"r\", label=\"Imitated Test data\")\n plt.legend(loc=\"best\")\n plt.title(f\"{self.user} data. Accuracy={accuracy} \")\n plt.ylabel(\"Score\")\n plt.xlabel(\"File\")\n plt.savefig(f\"{self.n_components}_{self.user}.png\")\n\n Model.accuracies.append(accuracy)","def acc_plotter(model_history, ax = None):\n \n import matplotlib.pyplot as plt\n import seaborn as sns\n \n training_loss = model_history['loss']\n\n acc = model_history['accuracy']\n \n val_acc = model_history['val_accuracy']\n\n epoch_count = range(1,len(training_loss)+1)\n \n sns.set(font_scale=1.15)\n \n sns.lineplot(\n x=epoch_count,\n y=acc,\n ax=ax\n )\n \n sns.lineplot(\n x=epoch_count,\n y=val_acc,\n ax=ax\n )\n\n ax.set_title('Accuracy Curves: Pre-Trained VGG-16 with 2 Trained Layers',fontsize=19)\n \n ax.set_ylabel('Accuracy',fontsize=18)\n \n ax.set_xlabel('Epochs',fontsize=18)\n\n plt.legend(['Training Accuracy', 'Validation Accuracy'])\n\n plt.show()","def visualize_training(features, labels, pl):\n print(\"Visualizing training\")\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n # Take out each feature type, one at a time\n label_map = get_label_map(labels)\n\n for key in label_map.keys():\n like_ind = label_map[key]\n like_data = np.array([features[i] for i in like_ind])\n\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\n\n # get limits\n xmin = features.column_min(0) - .5\n xmax = features.column_max(0) + .5\n ymin = features.column_min(1) - .5\n ymax = features.column_max(1) + .5\n\n plt.xlim(xmin,xmax)\n plt.ylim(ymin,ymax)\n\n # Track the current dividing line, as well as the number of epochs passed\n divider, = plt.plot([],[])\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\n\n def update(i):\n \"\"\"\n 1.) Get the next set of weights from the tracker\n 2.) Calculate and draw the new divider line\n 3.) Update the epoch counter\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\n \"\"\"\n epoch = i//features.instance_count\n w = pl.weights_tracker[i]\n a = pl.accuracy_tracker[epoch]\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\n epoch_tracker.set_text(\"{} {}\".format(epoch + 1, a))\n\n # Keep a shadow of the hyperplane at the end of each epoch\n if i % features.instance_count == 0:\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\n\n return divider\n\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\n plt.legend()\n\n # optional save file\n if len(sys.argv) >= 3 :\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\n\n plt.show()","def evaluate(self):\n predictions = self.model.predict(self.test[0])\n accuracy = accuracy_score(self.test[1], predictions)\n print(\"Accuracy:\", str(accuracy * 100) + \"%\")\n self.plot_results(predictions)","def plot_train_val_loss(path_to_file, train_filename, val_filename):\n path = '../'\n labels = ['gen_total_loss', 'gen_loss', 'l1_loss', 'disc_total_loss', 'disc_gen_loss', 'disc_real_loss']\n with open(path_to_file + train_filename + '.csv', newline='') as f:\n reader = csv.reader(f)\n train_data = np.array(list(reader))\n with open(path_to_file + val_filename + '.csv', newline='') as f:\n reader = csv.reader(f)\n val_data = np.array(list(reader))\n\n if train_data.shape == val_data.shape:\n # change label number for the type of loss that should be plotted\n label = 0\n print(train_data.shape, val_data.shape)\n epoch_count = range(1, train_data.shape[0] + 1)\n plt.figure()\n plt.plot(epoch_count, val_data[:len(epoch_count), label].astype('float32'))\n plt.plot(epoch_count, train_data[:len(epoch_count), label].astype('float32'))\n plt.legend(['validation', 'train'])\n plt.xlabel('Epoch')\n plt.ylabel(labels[label])\n plt.show()","def plot_loss_and_acc(history):\n hist = history.history\n x_arr = np.arange(len(hist['loss'])) + 1\n fig = plt.figure(figsize=(12,4))\n ax = fig.add_subplot(1,2,1)\n ax.plot(x_arr, hist['loss'], '-o', label='Train loss')\n ax.plot(x_arr, hist['val_loss'], '--<', label='Validation loss')\n ax.legend(fontsize=15)\n ax.set_xlabel('Epoch', size=15)\n ax.set_ylabel('Loss', size=15)\n\n ax = fig.add_subplot(1,2,2)\n ax.plot(x_arr, hist['accuracy'], '-o', label='Train acc.')\n ax.plot(x_arr, hist['val_accuracy'], '--<', label='Validation acc.')\n ax.legend(fontsize=15)\n ax.set_xlabel('Epoch', size=15),\n ax.set_ylabel('Accuracy', size=15)\n plt.show()","def plot_training_history(history, metric):\n \n val_metric = 'val_'+metric\n acc = history.history[metric]\n val_acc = history.history[val_metric]\n \n loss = history.history['loss']\n val_loss = history.history['val_loss']\n \n epochs_range = history.epoch\n \n plt.figure(figsize=(8, 8))\n plt.subplot(2, 1, 1)\n plt.plot(epochs_range, acc, label='Training Acc.')\n plt.plot(epochs_range, val_acc, label='Validation Acc.')\n plt.legend(loc='best',)\n plt.title('Training and Validation Accuracy')\n \n plt.subplot(2, 1, 2)\n plt.plot(epochs_range, loss, label='Training Loss')\n plt.plot(epochs_range, val_loss, label='Validation Loss')\n plt.legend(loc='best')\n plt.title('Training and Validation Loss')\n plt.show()","def save_accuracy_chart(self):\n history = self.model.history.history\n fig = plt.figure()\n plt.plot(history['accuracy'], label='Training Accuracy')\n plt.plot(history['val_accuracy'],label='Validation Set Accuracy')\n plt.legend()\n fig.savefig('model_accuracy.png')","def plot_eval_2(trained_model, image_name):\n # Get training evaluation data\n train_accuracy = trained_model.history['acc']\n train_val_accuracy = trained_model.history['val_acc']\n train_loss = trained_model.history['loss']\n train_val_loss = trained_model.history['val_loss']\n \n # Generate accuracy plot\n epochs = range(len(train_accuracy))\n plt.figure()\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\n plt.title('Training and validation accuracy')\n plt.legend()\n \n # Save accuracy plot\n plot_file = os.path.join(OUTPUT_DIR,\n \"{}_training_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')\n \n # Generate loss plot\n plt.figure()\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n \n # Save loss plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_training_loss\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def calc_params_train_val(history):\r\n # Metric of each feature\r\n acc_params = ['covid_severity_output_categorical_accuracy',\r\n 'pleural_regular_output_binary_accuracy',\r\n 'consolidation_output_binary_accuracy']\r\n precision_params = ['covid_severity_output_precision',\r\n 'pleural_regular_output_precision_1',\r\n 'consolidation_output_precision_2']\r\n recall_params = ['covid_severity_output_recall',\r\n 'pleural_regular_output_recall_1',\r\n 'consolidation_output_recall_2']\r\n AUC_params = ['covid_severity_output_auc',\r\n 'pleural_regular_output_auc_1',\r\n 'consolidation_output_auc_2']\r\n mae_params = ['covid_severity_output_mae',\r\n 'pleural_regular_output_mae',\r\n 'consolidation_output_mae']\r\n\r\n # Accuracy\r\n for acc_param in acc_params:\r\n plt.clf()\r\n fig = go.Figure()\r\n fig.add_trace(go.Scatter(\r\n y=history.history[acc_param],\r\n name='Train'))\r\n val_acc_param = 'val_' + acc_param\r\n fig.add_trace(go.Scatter(\r\n y=history.history[val_acc_param],\r\n name='Validation'))\r\n title_acc_param = 'Accuracy for ' + acc_param + ' feature'\r\n fig.update_layout(height=500,\r\n width=700,\r\n title=title_acc_param,\r\n xaxis_title='Epoch',\r\n yaxis_title='Accuracy')\r\n fig.show()\r\n\r\n # Precision\r\n for precision_param in precision_params:\r\n plt.clf()\r\n fig = go.Figure()\r\n fig.add_trace(go.Scatter(\r\n y=history.history[precision_param],\r\n name='Train'))\r\n val_precision_param = 'val_' + precision_param\r\n fig.add_trace(go.Scatter(\r\n y=history.history[val_precision_param],\r\n name='Validation'))\r\n title_precision_param = 'Precision for ' + precision_param + ' feature'\r\n fig.update_layout(height=500,\r\n width=700,\r\n title=title_precision_param,\r\n xaxis_title='Epoch',\r\n yaxis_title='Precision')\r\n fig.show()\r\n\r\n # Recall\r\n for recall_param in recall_params:\r\n plt.clf()\r\n fig = go.Figure()\r\n fig.add_trace(go.Scatter(\r\n y=history.history[recall_param],\r\n name='Train'))\r\n val_recall_param = 'val_' + recall_param\r\n fig.add_trace(go.Scatter(\r\n y=history.history[val_recall_param],\r\n name='Validation'))\r\n title_recall_param = 'Recall for ' + recall_param + ' feature'\r\n fig.update_layout(height=500,\r\n width=700,\r\n title=title_recall_param,\r\n xaxis_title='Epoch',\r\n yaxis_title='Recall')\r\n fig.show()\r\n\r\n # AUC\r\n for AUC_param in AUC_params:\r\n plt.clf()\r\n fig = go.Figure()\r\n fig.add_trace(go.Scatter(\r\n y=history.history[AUC_param],\r\n name='Train'))\r\n val_AUC_param = 'val_' + AUC_param\r\n fig.add_trace(go.Scatter(\r\n y=history.history[val_AUC_param],\r\n name='Validation'))\r\n title_AUC_param = 'AUC for ' + AUC_param + ' feature'\r\n fig.update_layout(height=500,\r\n width=700,\r\n title=title_AUC_param,\r\n xaxis_title='Epoch',\r\n yaxis_title='AUC')\r\n fig.show()\r\n\r\n # MAE\r\n for mae_param in mae_params:\r\n plt.clf()\r\n fig = go.Figure()\r\n fig.add_trace(go.Scatter(\r\n y=history.history[mae_param],\r\n name='Train'))\r\n val_mae_param = 'val_' + mae_param\r\n fig.add_trace(go.Scatter(\r\n y=history.history[val_mae_param],\r\n name='Validation'))\r\n title_mae_param = 'mae for ' + mae_param + ' feature'\r\n fig.update_layout(height=500,\r\n width=700,\r\n title=title_mae_param,\r\n xaxis_title='Epoch',\r\n yaxis_title='mae')\r\n fig.show()","def finetune_n_estimators(savefigure=False):\n res = np.array(np.load('npy-data/result_n_estimators_tuning_acc_auc_crossval_train.npy'))\n acc, auc = res[:int(len(res)/2)], res[int(len(res)/2):]\n plt.plot([j*10 for j in range(1,31)],acc,[j*10 for j in range(1,31)],auc)\n plt.xlabel('Number of trees')\n plt.ylabel('Accuracy/AUC score')\n plt.legend([\"Accuracy\",\"ROC AUC\"])\n if savefigure:\n plt.savefig('img/accuracy_n_estimators_tuning_acc_auc_crossval.pdf', bbox_inches='tight')\n plt.show()","def plot_testacc_numlabels(dataset, models, results, path, suffix):\n res = results[results['dataset'] == dataset]\n plt.close()\n for mod in models:\n res_model = res[res['model'] == mod]\n res_model.sort_values(by=['num_labels'], inplace=True)\n plt.scatter(res_model['num_labels'], res_model['test_acc'],\n label=mod, marker='o')\n plt.ylabel('test accuracy')\n plt.xlabel('num labels')\n plt.title('Dataset: {}'.format(dataset))\n plt.legend()\n plt.tight_layout()\n if suffix is None:\n plt.savefig('{}{}_performance.png'.format(path, dataset))\n else:\n plt.savefig('{}{}_performance_{}.png'.format(path, dataset,\n suffix))","def plots(self, history):\n print(history.history.keys())\n plt.plot(history.history['acc'])\n plt.plot(history.history['val_acc'])\n plt.title('model accuracy')\n plt.ylabel('accuracy')\n plt.xlabel('epoch')\n plt.legend(['train','test'], loc='upper left')\n plt.show()\n\n plt.plot(history.history['loss'])\n plt.plot(history.history['val_loss'])\n plt.title('model loss')\n plt.ylabel('loss')\n plt.xlabel('epoch')\n plt.legend(['train','test'], loc='upper left')\n plt.show()","def acc_loss_graph(accuracies, losses):\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))\n\n for experiment_id in accuracies.keys():\n ax1.plot(accuracies[experiment_id], label=experiment_id)\n ax1.legend()\n ax1.set_title('Validation Accuracy')\n fig.tight_layout()\n\n for experiment_id in accuracies.keys():\n ax2.plot(losses[experiment_id], label=experiment_id)\n ax2.legend()\n ax2.set_title('Validation Loss');\n\n fig.tight_layout()","def plot_accuracy_and_loss(histories=None):\n fig = subplots.make_subplots(rows=2, cols=2, subplot_titles=('Training accuracy', 'Validation accuracy',\n 'Training loss ', 'Validation loss'))\n\n def append_trace(model_name, acc, val_acc, loss, val_loss, epochs):\n e = list(range(epochs))\n color = random.choice(hex_colors_only)\n trace_ta = create_trace(e, acc, model_name, color)\n trace_va = create_trace(e, val_acc, model_name, color)\n trace_tl = create_trace(e, loss, model_name, color)\n trace_vl = create_trace(e, val_loss, model_name, color)\n\n fig.append_trace(trace_ta, 1, 1)\n fig.append_trace(trace_va, 1, 2)\n fig.append_trace(trace_tl, 2, 1)\n fig.append_trace(trace_vl, 2, 2)\n\n if histories is None:\n df_accuracies, df_losses = get_tensorboard_scalars()\n for model_name in df_accuracies.model_name.unique():\n df_acc = df_accuracies.loc[df_accuracies.model_name == model_name]\n df_l = df_losses.loc[df_losses.model_name == model_name]\n\n acc = df_acc.loc[df_acc.result_of == 'train'].accuracy.values.tolist()\n val_acc = df_acc.loc[df_acc.result_of == 'validation'].accuracy.values.tolist()\n loss = df_l.loc[df_l.result_of == 'train'].loss.values.tolist()\n val_loss = df_l.loc[df_l.result_of == 'validation'].loss.values.tolist()\n epochs = len(df_acc)\n\n append_trace(model_name, acc, val_acc, loss, val_loss, epochs)\n\n else:\n for model_name, history in histories.items():\n acc = history['accuracy']\n val_acc = history['val_accuracy']\n loss = history['loss']\n val_loss = history['val_loss']\n epochs = list(range(1, len(acc) + 1))\n\n append_trace(model_name, acc, val_acc, loss, val_loss, epochs)\n fig['layout']['xaxis'].update(title='Epoch')\n fig['layout']['xaxis2'].update(title='Epoch')\n fig['layout']['yaxis'].update(title='Accuracy', range=[0, 1])\n fig['layout']['yaxis2'].update(title='Loss', range=[0, 1])\n\n iplot(fig, filename='accuracies-losses')","def plot_learning_curve(X_train_all, X_val_all, y_train_all, y_val_all, train_sizes, title):\n\n errors_df = pd.DataFrame(columns = ['train_size', 'train_acc', 'val_acc'])\n\n # Loop through example sizes and get the training and validation error\n for train_size in train_sizes:\n # Select Subset of Data\n X_train = X_train_all[:train_size]\n X_val = X_val_all[:train_size]\n y_train = y_train_all[:train_size]\n y_val = y_val_all[:train_size]\n\n # Initialize Model\n model = svm.SVC(kernel='linear')\n\n # Fit model\n print(f\"Training {title} using {train_size} examples\")\n model.fit(X_train, y_train)\n\n # Get Predictions \n train_pred = model.predict(X_train)\n val_pred = model.predict(X_val)\n\n # Get Accuracy Score for X_Train and X_Val\n errors = pd.DataFrame({\n 'train_size': [train_size],\n 'train_acc': [accuracy_score(y_train, train_pred)],\n 'val_acc': [accuracy_score(y_val, val_pred)]\n })\n \n # Concatenate Dataframes\n errors_df = pd.concat([errors_df, errors])\n\n # Plot Learning Curve\n fig, ax = plt.subplots()\n\n errors_df.plot(x='train_size', y='train_acc',kind='line', ax=ax)\n errors_df.plot(x='train_size', y='val_acc',kind='line', color='red', ax=ax)\n\n ax.set_xlabel(\"Training Size\")\n ax.set_ylabel(\"Accuracy\")\n ax.set_title(title)\n\n # Save Figure\n plt.savefig('figs/' + title + '_learning_curve.png')","def train(self):\n y_list = []\n y_hat_list = []\n for ex_dict in ut.EXAMPLES_LIST:\n y_list.append(ex_dict[1])\n y_hat_list.append(self.predict(ex_dict[0]))\n\n acc = ut.compute_accuracy(y_hat_list, y_list)\n return acc","def check_test_accuracy(self):\n print('\\n# Evaluate on test data')\n results = self.model.evaluate(self.data.test_dataset)\n print('\\ntest loss, test acc:', results)","def evaluate_test(model, history, class_labels, train_X, test_X, train_y, test_y):\n train_loss, train_acc = model.evaluate(train_X, train_y, verbose=0)\n test_loss, test_acc = model.evaluate(test_X, test_y, verbose=0)\n print('Accuracy \\n Train: %.3f, Test: %.3f' % (train_acc, test_acc))\n print('Loss \\n Train: %.3f, Test: %.3f \\n' % (train_loss, test_loss))\n # plot loss during training\n plt.subplots_adjust(hspace = .5, wspace = 0.5)\n plt.subplot(211)\n plt.title('Loss', weight='bold')\n plt.plot(history.history['loss'], label='train')\n plt.plot(history.history['val_loss'], label='val')\n plt.legend()\n # plot accuracy during training\n plt.subplot(212)\n plt.title('Accuracy', weight='bold')\n plt.plot(history.history['acc'], label='train')\n plt.plot(history.history['val_acc'], label='val')\n plt.legend()\n plt.show()\n print('\\n')\n # predict probabilities for test set\n yhat_probs = model.predict(test_X, verbose=0)\n # predict classes for test set\n yhat_classes = model.predict_classes(test_X, verbose=0)\n # reduce to 1d array\n yhat_probs = yhat_probs[:, 0]\n yhat_classes = yhat_classes[:, 0]\n # calculate metrics\n report = metrics.classification_report(test_y, yhat_classes, target_names=class_labels)\n confusion_matrix = metrics.confusion_matrix(test_y, yhat_classes)\n plot_confusion_matrix(confusion_matrix, class_labels)\n print('\\n')\n return report","def plot_data(losses, accuracies, name):\n # convert accuracies to percentages\n accuracies['Train'] = [acc * 100 for acc in accuracies['Train']]\n accuracies['Valid'] = [acc * 100 for acc in accuracies['Valid']]\n # set fontsize\n plt.rcParams.update({'font.size': 13})\n fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(8,5))\n ax1.set_xlabel('Number of Epochs')\n ax1.set_ylabel('Cross Entropy Loss')\n ax1.set_ylim(0,2)\n ax1.plot(losses['Train'], label='Training')\n ax1.plot(losses['Valid'], label='Validation')\n ax1.legend(loc='upper right')\n\n ax2.set_xlabel('Number of Epochs')\n ax2.set_ylabel('Accuracy (%)')\n ax2.set_ylim(0,100)\n ax2.plot(accuracies['Train'], label='Training')\n ax2.plot(accuracies['Valid'], label='Validation')\n ax2.legend(loc='upper left')\n\n fig.tight_layout()\n fig.savefig('../outputs/' + name)","def plot_data():\n \n [X_train, X_dev, X_test, Y_train, Y_dev, Y_test, numOutputNodes] = load_data('regression') \n \n traindev = np.concatenate((Y_train, Y_dev), 1)\n traindevtest = np.concatenate((traindev, Y_test), 1)\n tdt = traindevtest.reshape(traindevtest.shape[1],)\n\n Y_train = Y_train.reshape(Y_train.shape[1],)\n Y_dev = Y_dev.reshape(Y_dev.shape[1],)\n Y_test = Y_test.reshape(Y_test.shape[1],)\n\n sigma = np.round(np.std(tdt), 3)\n mu = np.round(np.mean(tdt), 3)\n\n # plots histogram of all data together, indicating values of mean and standard deviation\n plt.figure(1)\n plt.hist(tdt)\n plt.title(\"{} data points, mu = {}, sigma = {}\".format(tdt.size, mu, sigma))\n plt.xlabel(\"average Fe coordination number\")\n plt.ylabel(\"frequency\")\n plt.show()\n\n # plots histogram where the training, cross-validation, and test sets have separate bars\n plt.figure(2)\n plt.hist([Y_train, Y_dev, Y_test], label = ['training', 'cross-validation', 'test'], density = True)\n plt.xlabel(\"average Fe coordination number\")\n plt.ylabel(\"frequency\")\n plt.legend()\n plt.show()\n\n # below is graphing for the charge data, as opposed to the averaged spectrum data\n [X_train1, X_dev1, X_test1, _, _, _, Y_train1, Y_dev1, Y_test1, numOutputNodes1] = load_data('multi_task')\n traindev1 = np.concatenate((Y_train1, Y_dev1), 1)\n traindevtest1 = np.concatenate((traindev1, Y_test1), 1)\n tdt1 = traindevtest1.reshape(traindevtest1.shape[1],)\n\n Y_train1 = Y_train1.reshape(Y_train1.shape[1],)\n Y_dev1 = Y_dev1.reshape(Y_dev1.shape[1],)\n Y_test1 = Y_test1.reshape(Y_test1.shape[1],)\n\n sigma = np.round(np.std(tdt1), 3)\n mu = np.round(np.mean(tdt1), 3)\n\n # plots histogram of all data together, indicating values of mean and standard deviation\n plt.figure(3)\n plt.hist(tdt1)\n plt.title(\"{} data points, mu = {}, sigma = {}\".format(tdt1.size, mu, sigma))\n plt.xlabel(\"charge\")\n plt.ylabel(\"frequency\")\n plt.show()\n\n # plots histogram where the training, cross-validation, and test sets have separate bars\n plt.figure(4)\n plt.hist([Y_train1, Y_dev1, Y_test1], label = ['training', 'cross-validation', 'test'], density = True)\n plt.xlabel(\"charge\")\n plt.ylabel(\"frequency\")\n plt.legend()\n plt.show()\n\n return None","def plot_loss_curves(results):\n loss = results[\"train_loss\"]\n test_loss = results[\"test_loss\"]\n\n accuracy = results[\"train_acc\"]\n test_accuracy = results[\"test_acc\"]\n\n epochs = range(len(results[\"train_loss\"]))\n\n plt.figure(figsize=(15, 7))\n\n # Plot loss\n plt.subplot(1, 2, 1)\n plt.plot(epochs, loss, label=\"train_loss\")\n plt.plot(epochs, test_loss, label=\"test_loss\")\n plt.title(\"Loss\")\n plt.xlabel(\"Epochs\")\n plt.legend()\n\n # Plot accuracy\n plt.subplot(1, 2, 2)\n plt.plot(epochs, accuracy, label=\"train_accuracy\")\n plt.plot(epochs, test_accuracy, label=\"test_accuracy\")\n plt.title(\"Accuracy\")\n plt.xlabel(\"Epochs\")\n plt.legend()","def example():\n accShape, accTexture, accFinal = train_and_eval_all_models()\n print(f'Accuracy -- only shape: {accShape}; only texture: {accTexture}; combined: {accFinal}.')","def cross_validation_visualization(lambds, score_tr, score_te):\n plt.semilogx(lambds, score_tr, marker=\".\", color='b', label='train score');\n plt.semilogx(lambds, score_te, marker=\".\", color='r', label='test score');\n plt.xlabel(\"lambda\")\n plt.ylabel(\"score\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation_test\")","def plot_run_basic():\n # Define files prefix, model variables to plot and title\n str_learning_rate = ['lr_', 'learning_rate', 'Learning rate', 'LR']\n str_f_number = ['f_', 'F', 'Filter number', 'F']\n str_regular = ['reg_param_', 'reg_par', 'Regularization', 'RP']\n\n fig = plt.figure(figsize=(16,12))\n # Plot learning rate\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_learning_rate[0], str_learning_rate[1])\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_learning_rate[2], str_learning_rate[3], [2,2,1])\n # Plot F number\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_f_number[0], str_f_number[1])\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_f_number[2], str_f_number[3], [2,2,2])\n # Plot Regularization\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_regular[0], str_regular[1])\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_regular[2], str_regular[3], [2,2,3])\n plt.suptitle('Validation accuracy - Sweep parameters', fontsize=20)\n plt.show();\n \n # Save as PDF file if wanted\n if DataLoader.SAVE_FIGURE:\n DataLoader.save_plot(fig, 'sweep_parameters_CNN.pdf')","def plot_results(sgd_train_acc, sgd_train_std, sgd_heldout_acc, sgd_heldout_std, sgd_test_acc,\n dt_train_acc, dt_train_std, dt_heldout_acc, dt_heldout_std, dt_test_acc,\n dt4_train_acc, dt4_train_std, dt4_heldout_acc, dt4_heldout_std, dt4_test_acc,\n stumps_train_acc, stumps_train_std, stumps_heldout_acc, stumps_heldout_std, stumps_test_acc):\n train_x_pos = [0, 4, 8, 12]\n cv_x_pos = [1, 5, 9, 13]\n test_x_pos = [2, 6, 10, 14]\n ticks = cv_x_pos\n\n labels = ['sgd', 'dt', 'dt4', 'stumps (4 x 50)']\n\n train_accs = [sgd_train_acc, dt_train_acc, dt4_train_acc, stumps_train_acc]\n train_errors = [sgd_train_std, dt_train_std, dt4_train_std, stumps_train_std]\n\n cv_accs = [sgd_heldout_acc, dt_heldout_acc, dt4_heldout_acc, stumps_heldout_acc]\n cv_errors = [sgd_heldout_std, dt_heldout_std, dt4_heldout_std, stumps_heldout_std]\n\n test_accs = [sgd_test_acc, dt_test_acc, dt4_test_acc, stumps_test_acc]\n\n fig, ax = plt.subplots()\n ax.bar(train_x_pos, train_accs, yerr=train_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='train')\n ax.bar(cv_x_pos, cv_accs, yerr=cv_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='held-out')\n ax.bar(test_x_pos, test_accs, align='center', alpha=0.5, capsize=10, label='test')\n ax.set_ylabel('Accuracy')\n ax.set_xticks(ticks)\n ax.set_xticklabels(labels)\n ax.set_title('Models')\n ax.yaxis.grid(True)\n ax.legend()\n plt.tight_layout()","def plot_training_history(history):\n fig, (ax_loss, ax_acc) = plt.subplots(1, 2, figsize=(15, 5))\n ax_loss.plot(history.epoch, history.history[\"loss\"], label=\"Train loss\")\n ax_loss.plot(history.epoch, history.history[\"val_loss\"], label=\"Validation loss\")\n ax_loss.legend()\n ax_acc.plot(history.epoch, history.history[\"iou_score\"], label=\"Train iou\")\n ax_acc.plot(history.epoch, history.history[\"val_iou_score\"], label=\"Validation iou\")\n ax_acc.legend()","def plot_errors(loss_train, loss_val, jet):\n plt.plot(list(range(len(loss_train))), loss_train, 'g', label='Training loss')\n plt.plot(list(range(len(loss_val))), loss_val, 'b', label='Validation loss')\n plt.title('Training and Validation loss for jet: {jet}'.format(jet=jet))\n plt.xlabel('Epochs')\n plt.ylabel('Loss')\n plt.legend()\n plt.show()","def plot_train_test_data(train, test):\n fig = plt.figure()\n ax1 = fig.add_subplot(1, 2, 1)\n ax1.spy(train, precision=0.01, markersize=0.5)\n ax1.set_xlabel(\"Users\")\n ax1.set_ylabel(\"Items\")\n ax1.set_title(\"Training data\")\n ax2 = fig.add_subplot(1, 2, 2)\n ax2.spy(test, precision=0.01, markersize=0.5)\n ax2.set_xlabel(\"Users\")\n ax2.set_ylabel(\"Items\")\n ax2.set_title(\"Test data\")\n plt.tight_layout()\n plt.savefig(\"../results/train_test\")\n plt.show()","def show_accuracy(self):\r\n return round(accuracy_score(self.actual, self.predicted),2)","def plot_train(func):\n def plotting_func(model, train_config, arch, data_loader, epoch, handle_dict, optimizers):\n output_dict = func(model, train_config, arch, data_loader, epoch, optimizers)\n metrics = [output_dict['avg_elbo'], output_dict['avg_cond_log_like'], output_dict['avg_kl']]\n plot_average_metrics(metrics, epoch, handle_dict, 'Train')\n plot_param_grad_mags(output_dict['avg_param_grad_mags'], epoch, handle_dict)\n plot_state_grad_mags(output_dict['avg_state_grad_mags'], epoch, handle_dict)\n plot_opt_lr(optimizers, epoch, handle_dict)\n return output_dict, handle_dict\n return plotting_func","def accuracy(self, X_train, X_test):\n loss, accuracy = self.estimator.evaluate(X_test, X_train)\n return accuracy","def __init__(self, experiment_count: int, total_tr_data: int, tr_accuracy: [int], total_test_data: int,\n test_accuracy: [int], function_name: str, batch_size: int, title: str=\"CNN Accuracy Plot\"):\n self.title = title\n self.total_tr_data = total_tr_data\n self.total_test_data = total_test_data\n\n # accuracy and last epoch\n self.tr_accuracy = tr_accuracy.ravel()\n self.last_epoch = str(int(self.tr_accuracy[CFG.EPOCHS - 1]))\n self.last_epoch_per = self.tr_accuracy[CFG.EPOCHS - 1]\n self.tr_mean = np.mean(self.tr_accuracy[-(CFG.EPOCHS - 10):])\n self.tr_mean_str = \"{:.2f}\".format(self.tr_mean)\n\n self.test_accuracy = test_accuracy.ravel()\n self.last_epoch = str(int(self.test_accuracy[CFG.EPOCHS - 1]))\n self.last_epoch_per = self.test_accuracy[CFG.EPOCHS - 1]\n self.test_mean = np.mean(self.test_accuracy[-(CFG.EPOCHS - 10):])\n self.test_mean_str = \"{:.2f}\".format(self.test_mean)\n\n # hyperparameters and string equivalents (for formatting easily in overleaf)\n self.function_name = function_name\n self.batch_size = batch_size\n\n # data table specifications\n self.cell_length = len(str(\" \" + str(self.total_tr_data) + \"/\" + str(self.total_tr_data) + \" \"))\n self.total_cells = 3\n self.max_length = (self.cell_length + 1) * (self.total_cells)\n self.tablefile = \"table.txt\"\n self.experiment_count = experiment_count","def plot_train_and_valid_curves(ax, train_points, valid_points, learning_rate_updates_epoch, best_per_lr, mode=\"loss\"):\n if mode==\"loss\":\n name = \"Loss\"\n names = \"losses\"\n factor = [1.2, 1.22]\n loc_legend = 1\n elif mode ==\"acc\":\n name = \"Accuracy\"\n names = \"acc\"\n factor = [0.9, 0.88]\n loc_legend = 4\n else:\n print \"Mode not understood. Available modes : 'loss' and 'acc'\"\n return\n\n #ax = plt.subplot(1,1,1)#\n # Plot training and valid loss curves\n ax.plot(np.arange(len(train_points)),train_points, c=\"k\", zorder=1)\n ax.plot(np.arange(len(valid_points)),valid_points, c=\"k\", zorder=1)\n ax.scatter(np.arange(len(train_points)),train_points, c=\"b\", label=\"Train %s\"%names, zorder=2)\n ax.scatter(np.arange(len(valid_points)),valid_points, c=\"r\", label=\"Valid %s\"%names, zorder=2)\n # Plot vertical line when the learning rate was updated\n first = True\n for elem in learning_rate_updates_epoch:\n if first:\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\"k\", label=\"LR updates\", linestyle=\"--\")\n first = False\n else:\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\"k\", linestyle=\"--\")\n # Plot best model in each region\n first = True\n for i,elem in enumerate(best_per_lr):\n if first:\n x = elem[0]\n y = elem[1]\n plt.scatter(x,y, c=\"g\", label=\"Best models\", marker=\"*\", zorder=3, s=100)\n plt.plot([x,x],[y,factor[0]*y], c=\"g\")\n plt.text(x,factor[1]*y, \"Epoch %d\"%(x), fontsize=8)\n first = False\n else:\n x = elem[0]+learning_rate_updates_epoch[i-1]\n y = elem[1]\n plt.scatter(x,y, c=\"g\", marker=\"*\", zorder=3, s=100)\n plt.plot()\n plt.plot([x,x],[y,factor[0]*y], c=\"g\")\n plt.text(x,factor[1]*y, \"Epoch %d\"%(x), fontsize=8)\n # Xlim, Ylim, labels, legend...\n ax.set_ylim([0,1])\n ax.set_xlim([0,len(train_points)+5])\n ax.set_xlabel(\"Epochs\")\n ax.set_ylabel(name)\n handles,labels = ax.get_legend_handles_labels()\n sorted_zip = sorted(zip([2,0,1,3],handles, labels))\n index, handles, labels = zip(*sorted_zip)\n ax.legend(handles,labels, loc=loc_legend, prop={'size':10})","def _accuracy(net, data_loader):\n net.train(False)\n\n num_correct = 0\n num_total = 0\n for X, y in data_loader:\n # Data.\n X = torch.autograd.Variable(X.cuda())\n y = torch.autograd.Variable(y.cuda())\n X.requires_grad = True\n # Prediction.\n score = net(X)\n _, prediction = torch.max(score.data, 1)\n num_total += y.size(0)\n num_correct += torch.sum(prediction == y.data).item()\n net.train(True) # Set the model to training phase\n return 100 * num_correct / num_total","def graph_results(loss, acc):\n N = len(loss)\n x = np.linspace(0, N, N)\n plt.subplot(1,2,1)\n plt.plot(x, loss)\n plt.subplot(1,2,2)\n plt.plot(x,acc)\n plt.show()","def validate_and_plot_one_class(normal,outliers):\n print \"running a validation\"\n \n #classifier\n \n train_data = genfromtxt(normal, delimiter='\\t',skip_header=0)\n test_data = genfromtxt(outliers, delimiter='\\t',skip_header=0)\n\n outliers_proportion = float(test_data.shape[0])/(float(train_data.shape[0])+float(test_data.shape[0]))\n outliers_proportion=0.01\n\n clf = OneClassSVMClassifier(normal,outliers_proportion,0.95,0.05)\n #processing data without targets\n X_train = clf.scale(train_data)\n X_test = clf.scale(test_data)\n\n y_pred_train = clf.predict(X_train)\n y_pred_test = clf.predict(X_test)\n n_error_train = y_pred_train[y_pred_train == 1].size\n n_error_test = y_pred_test[y_pred_test == -1].size\n \n X=np.vstack((X_train,X_test))\n y_score = clf.predict(X)\n\n Y1=np.ones((X_train.shape[0],))\n Y2=(np.ones((X_test.shape[0],))*-1)\n y_true=np.concatenate((Y1,Y2))\n \n # Compute ROC curve and area the curve\n fpr, tpr, thresholds = metrics.roc_curve(y_true,y_score)\n roc_auc = metrics.auc(fpr, tpr)\n print \"Area under the ROC curve : %f\" % roc_auc\n \n # Plot ROC curve\n\n fig = matplotlib.pyplot.gcf()\n fig.set_size_inches(6.5,6.5)\n #font = {'family' : 'sans-serif',\n # 'weight' : 'normal',\n # 'size' : 18}\n\n #matplotlib.rc('font', **font)\n pl.clf()\n #modify plot area\n #modify tick label font size\n ax = pl.gca() # get the current axes\n for l in ax.get_xticklabels() + ax.get_yticklabels():\n l.set_fontsize('x-large')\n\n #color from html code table, linewidth x2.0\n pl.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc,color=\"#00CC66\",linewidth=3.0)\n# pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\"#009900\",linewidth=3.0)\n# pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\n# pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\n# pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\n #for more lines with different kernels\n #default_kernel=\"sigmoid\";clf = hermes.OneClassSVMClassifier(train,0.00,0.0,0.0595,default_kernel);y_score_sigmoid = clf.predict(X);fpr_sigmoid, tpr_sigmoid, thresholds_sigmoid = metrics.roc_curve(y_true,y_score_sigmoid);roc_auc_sigmoid = metrics.auc(fpr_sigmoid, tpr_sigmoid);fpr_sigmoid;tpr_sigmoid;roc_auc_sigmoid\n #pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\"#00CC66\",linewidth=2.0)\n #pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\n #pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\n #pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\n pl.plot([0, 1], [0, 1], 'k--')\n #modify base font size\n pl.xlim([0.0, 1.0])\n pl.ylim([0.0, 1.0])\n pl.xlabel('False positive rate',fontsize='xx-large')\n pl.ylabel('True positive rate',fontsize='xx-large')\n #pl.title('Receiver operating characteristic example')\n pl.legend(loc=\"lower right\",prop={'size':18})\n pl.show()\n sys.exit(0)\n ##the code here below was used to create the ROC curve for europar 13","def plot_train_history(modell=config.model):\n history = pd.read_csv(f'model/this/{modell}_history.csv')\n epochs = len(history.epoch)\n\n plt.style.use(\"ggplot\")\n plt.rcParams['figure.figsize'] = (5, 9)\n plt.plot(np.arange(0, epochs), history[\"accuracy\"], label=\"model accuracy\", color=\"red\", zorder=10, linewidth=2)\n plt.plot(np.arange(0, epochs), history[\"loss\"], label=\"training loss\", color=\"blue\", zorder=9, linewidth=2)\n plt.plot(np.arange(0, epochs), history[\"val_accuracy\"], label=\"validation accuracy\", color=\"red\", zorder=1, linewidth=1, alpha= 0.4)\n plt.plot(np.arange(0, epochs), history[\"val_loss\"], label=\"validation loss\", color=\"blue\", zorder=2, linewidth=1, alpha= 0.4)\n plt.hlines(1.0,0, epochs, colors=\"black\", linestyles=\"dotted\")\n plt.title(f'Trening av modell: {modell}')\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Accuracy / Loss\")\n plt.ylim(0, 2.)\n plt.yticks(np.append(np.arange(0, 1., 0.05), (np.arange(1, 2., 0.2) )))\n\n plt.xlim(0, epochs)\n plt.legend(loc=\"upper right\")\n plt.tight_layout(True)\n\n xint = []\n locs, labels = plt.xticks()\n for each in locs:\n xint.append(int(each))\n plt.xticks(xint)\n\n plt.savefig(f'model/this/{modell}.png')\n plt.show()","def plotHistory(history):\n \n acc = history.history['acc']\n val_acc = history.history['val_acc']\n loss = history.history['loss']\n val_loss = history.history['val_loss']\n\n epochs = range(len(acc))\n \n # Make and save the plot for our accuracy\n plt.plot(epochs, acc, 'bo', label='Training acc')\n plt.plot(epochs, val_acc, 'b', label='Validation acc')\n plt.title('Training and validation accuracy')\n plt.legend()\n plt.savefig(\"trainValAccSecond.png\")\n\n # Make and save the plots for our loss \n plt.figure()\n plt.plot(epochs, loss, 'bo', label='Training loss')\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n plt.show()\n plt.savefig(\"trainValLossSecond.png\")","def classificationError():\n print('Computing Classification Test Error')\n\n dl1, dl2 = CIFAR10TestLoader() \n err1, err2 = [], []\n\n # load every model \n with open('classification_error.csv','w') as clf:\n writer = csv.writer(clf)\n writer.writerow(['Classification Error Dataset 1','Classification Error Dataset 2'])\n\n for i in tqdm(range(5,95,2)):\n mtl = MTL()\n PATH = os.getcwd() + '/mtl_model_{d1}_vs_{d2}.pth'.format(d1=i, d2=100-i)\n mtl.load_state_dict(state_dict=torch.load(PATH))\n\n e1, e2 = accuracy(dl1, mtl), accuracy(dl2, mtl)\n err1.append(e1)\n err2.append(e2)\n writer.writerow([e1,e2])\n \n fig, ax_left = plt.subplots()\n ax_right = ax_left.twinx()\n ax_left.plot([0.05 + 0.02* i for i in range(45)], err1, color='black')\n ax_right.plot([0.05 + 0.02* i for i in range(45)], err2, color='red')\n ax_right.set_ylabel('Dataset 2 (red) accuracy')\n ax_left.set_ylabel('Dataset 1 (black) accuracy')\n ax_left.set_xlabel('Percentage of points from dataset 1 in training set')\n plt.title('Classification Accuracy over both datasets')\n plt.savefig('classification_error_plots.pdf')","def plot_train_history(self):\n plt.figure()\n plt.xlabel('Epochs')\n plt.ylabel('Loss')\n plt.plot(self.train_history.history['loss'])\n plt.plot(self.train_history.history['val_loss'])\n plt.legend(['Training', 'Validation'])\n\n plt.show()","def accuracy_hist(pred_proba_samples, labels):\n\tsampled_acc = sampled_accuracies(pred_proba_samples, labels)\n\tavg_accuracy = round(np.mean(sampled_acc) * 100, 3)\n\tprint(\"average accuracy across \" + str(pred_proba_samples.shape[0]) + \" samples: \" + str(avg_accuracy) + \"%\\n\")\n\tfig, ax = plt.subplots(figsize=(10,5))\n\tsns.distplot(100*sampled_acc, ax=ax, rug=True, kde=False)\n\tax.set_xlabel(\"Test set accuracy (%)\", fontsize=30)\n\tax.set_ylabel(\"Frequency density\", fontsize=30);\n\tax.tick_params(\"both\", labelsize=15)\n\treturn sampled_acc","def show_training(history: tf.keras.callbacks.History) -> None:\n hist = history.history\n\n if \"loss\" not in hist:\n print(\"Error: 'loss' values not found in the history\")\n return\n\n # plot training\n plt.figure(figsize=(14, 4))\n plt.subplot(121)\n plt.plot(hist[\"loss\"], label=\"Training\")\n if \"val_loss\" in hist:\n plt.plot(hist[\"val_loss\"], label=\"Validation\")\n plt.xlabel(\"epoch\")\n plt.ylabel(\"loss\")\n plt.legend()\n\n if \"accuracy\" in hist:\n plt.subplot(122)\n plt.plot(hist[\"accuracy\"], label=\"Training\")\n if \"val_accuracy\" in hist:\n plt.plot(hist[\"val_accuracy\"], label=\"Validation\")\n plt.xlabel(\"epoch\")\n plt.ylabel(\"accuracy\")\n plt.legend()\n\n plt.suptitle(\"Training history\")\n plt.show()\n\n # show final results\n print(\"\\nTraining loss: \\t{:.4f}\".format(hist[\"loss\"][-1]))\n if \"val_loss\" in hist:\n print(\"Validation loss: \\t{:.4f}\".format(hist[\"val_loss\"][-1]))\n if \"accuracy\" in hist:\n print(\"\\nTraining accuracy: \\t{:.3f}\".format(hist[\"accuracy\"][-1]))\n if \"val_accuracy\" in hist:\n print(\"Validation accuracy:\\t{:.3f}\".format(hist[\"val_accuracy\"][-1]))","def plot_train_test_data(train, test):\n fig = plt.figure()\n ax1 = fig.add_subplot(1, 2, 1)\n ax1.spy(train, precision=0.01, markersize=0.5)\n ax1.set_xlabel(\"Users\")\n ax1.set_ylabel(\"Items\")\n ax1.set_title(\"Training data\")\n ax2 = fig.add_subplot(1, 2, 2)\n ax2.spy(test, precision=0.01, markersize=0.5)\n ax2.set_xlabel(\"Users\")\n ax2.set_ylabel(\"Items\")\n ax2.set_title(\"Test data\")\n plt.tight_layout()\n plt.savefig(\"train_test\")\n plt.show()","def plot_train_test_data(train, test):\n fig = plt.figure(figsize=(16, 8))\n ax1 = fig.add_subplot(1, 2, 1)\n ax1.spy(train, precision=0.01, markersize=0.05, aspect=\"auto\")\n ax1.set_xlabel(\"Users\")\n ax1.set_ylabel(\"Items\")\n ax1.set_title(\"Training data\")\n ax2 = fig.add_subplot(1, 2, 2)\n ax2.spy(test, precision=0.01, markersize=0.05, aspect=\"auto\")\n ax2.set_xlabel(\"Users\")\n ax2.set_ylabel(\"Items\")\n ax2.set_title(\"Test data\")\n plt.tight_layout()\n plt.savefig(\"train_test\")\n plt.show()","def plot_roc_acc(self,x_test,y_test):\n if self.validated:\n preds = self.model_cv.predict_proba(x_test[self.feats])\n fpr, tpr, thresholds = metrics.roc_curve(y_test, preds[:,1])\n auc = metrics.roc_auc_score(y_test, preds[:,1])\n\n # get accuracy of class0 and class1 predictions at different thresholds\n acc_0 = []\n acc_1 = []\n for ind,th in enumerate(thresholds):\n binary_preds = pred_from_prob(preds,th)\n acc_1.append(accuracy_score(y_test[np.where(y_test==1)],binary_preds[np.where(y_test==1)]))\n acc_0.append(accuracy_score(y_test[np.where(y_test==0)],binary_preds[np.where(y_test==0)]))\n\n # set up plotting parameters\n sns.set()\n mpl.rcParams['figure.figsize']=[15.0,5.0]\n mpl.rcParams['lines.linewidth']=2.0\n mpl.rcParams['xtick.labelsize']=13\n mpl.rcParams['ytick.labelsize']=13\n mpl.rcParams['axes.labelsize']=15\n mpl.rcParams['axes.labelweight']='heavy'\n mpl.rcParams['axes.titlesize']=18\n mpl.rcParams['axes.titleweight']='heavy'\n mpl.rcParams['legend.fontsize']=12\n\n # build the plots- ROC in subplot 1, accuracy in subplot 2\n plt.subplot(1,2,1)\n plt.plot(fpr,tpr,'r*', label='roc auc={:.4f}'.format(auc))\n plt.plot(np.linspace(0,1,20),np.linspace(0,1,20),'k--')\n plt.xlabel('FPR')\n plt.ylabel('TPR')\n plt.title('ROC')\n plt.legend(frameon=False)\n plt.xlim([0.0,1.0])\n plt.ylim([0.0,1.0])\n\n plt.subplot(1,2,2)\n plt.plot(thresholds,acc_0,'go--',label='cases: 0',alpha=0.3)\n plt.plot(thresholds,acc_1,'yo--',label='cases: 1')\n plt.plot(thresholds[::5],fpr[::5],'c*',alpha=0.2,label='fpr')\n\n plt.xlim([0,1])\n plt.xlim([0,1])\n\n plt.xlabel('threshold')\n plt.ylabel('accuracy')\n plt.title('accuracy')\n\n plt.legend(frameon=False)\n\n plt.show()\n return None\n else:\n raise err.NotYetFittedModelError('You should train the model with method train_CV first \\n')","def learning_viz(self) :\n self.train\n history = self.history\n plot_loss(history)","def run_analyses(y_predict_train, y_train, y_predict, y_test):\n # calculate metrics\n _, training_error = output_error(y_predict_train, y_train)\n (precision, recall, f1, _), testing_error = output_error(y_predict, y_test)\n \n # print out metrics\n print 'Average Precision:', np.average(precision)\n print 'Average Recall:', np.average(recall)\n print 'Average F1:', np.average(f1)\n print 'Training Error:', training_error\n print 'Testing Error:', testing_error","def plot_training_results(clfs, train_scores, test_scores):\n\n # Set graph format\n sns.set_style(\"whitegrid\")\n sns.set_context(\"paper\", font_scale=1, rc={\"lines.linewidth\": 1})\n ax = plt.subplot(111)\n w = 0.5\n x = np.arange(len(train_scores))\n ax.set_yticks(x + w)\n ax.legend((train_scores[0], test_scores[0]), (\"Train Scores\", \"Test Scores\"))\n names = ['SVC', 'LR', 'KNN', 'GNB', 'ADA', 'RF']\n\n # Loop throuugh classifiers\n # clfnames = []\n # for i in range(0, len(clfs)):\n # # Define temporary variables\n # clfname = clfnames[i]\n # # clf_name = clf.__class__.__name__\n # # Create and store name\n # name = \"{}\".format(clf_name)\n # names.append(name)\n\n # Plot all names in horizontal bar plot\n ax.set_yticklabels((names), fontsize=20)\n plt.xlim(0.5, 0.56)\n plt.barh(x, test_scores, color='b', alpha=0.6)\n plt.title(\"Test Data Accuracy Scores\", fontsize=30)\n fig = plt.figure(1)\n\n plt.show()","def plot_learning_curve(self, estimators, title, labels, colors, X, y, \n ylim=None, cv=None, n_jobs=1, train_sizes=np.linspace(.1, 1.0, 10)):\n plt.figure(figsize = (6,8))\n plt.title(title)\n if ylim is not None:\n plt.ylim(*ylim)\n plt.xlabel(\"Training examples\")\n plt.ylabel(\"Accuracy\")\n for i in range(len(estimators)): \n estimator = estimators[i]\n line_label = labels[i]\n line_color = colors[i]\n train_sizes, train_scores, test_scores = learning_curve(\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\n train_scores_mean = np.mean(train_scores, axis=1)\n train_scores_std = np.std(train_scores, axis=1)\n test_scores_mean = np.mean(test_scores, axis=1)\n test_scores_std = np.std(test_scores, axis=1)\n\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\n train_scores_mean + train_scores_std, alpha=0.1,\n color=line_color[0])\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\n test_scores_mean + test_scores_std, alpha=0.1, color=line_color[1])\n plt.plot(train_sizes, train_scores_mean, \"o-\", color=line_color[0],\n label=line_label[0])#\"Training accuracy\"\n plt.plot(train_sizes, test_scores_mean, \"o-\", color=line_color[1],\n label=line_label[1]) #\"Cross-validation accuracy\"\n\n plt.grid() \n plt.legend(bbox_to_anchor=(0., 1.05, 1., .105),loc=3, mode=\"expand\",\n borderaxespad=0.)\n plt.savefig(\"../Figures/\" + title + \".png\", bbox_inches=\"tight\")\n return plt","def train(self, x_train, y_train, x_val, y_val):\n pass","def visualize_train_data(train_df, fname):\r\n logger = custom_logger.CustomLogger(run_id+':'+file_id)\r\n fig, axs = plt.subplots(3, figsize=(15,15))\r\n fig.suptitle('EPEX Intraday Continuous market electricity prices')\r\n\r\n axs[0].plot(train_df.index, train_df['low'], color='red')\r\n axs[0].set_title(\"Lowest Price\")\r\n axs[0].set(xlabel='time', ylabel='price (Euros)')\r\n\r\n axs[1].plot(train_df.index, train_df['high'], color='green')\r\n axs[1].set_title(\"Highest Pice\")\r\n axs[1].set(xlabel='time', ylabel='price (Euros)')\r\n\r\n axs[2].plot(train_df.index, train_df['weight_avg'], color='blue')\r\n axs[2].set_title(\"volume-weighted Average Price\")\r\n axs[2].set(xlabel='time', ylabel='price (Euros)')\r\n\r\n fig.savefig(os.path.join(unique_op_dir, fname))\r\n logger.info('Training data plots stored at ', os.path.join(unique_op_dir, fname))","def plot_training_curve(path):\n import matplotlib.pyplot as plt\n train_err = np.loadtxt(\"{}_train_err.csv\".format(path))\n val_err = np.loadtxt(\"{}_val_err.csv\".format(path))\n train_loss = np.loadtxt(\"{}_train_loss.csv\".format(path))\n val_loss = np.loadtxt(\"{}_val_loss.csv\".format(path))\n plt.title(\"Train vs Validation Error\")\n n = len(train_err) # number of epochs\n plt.plot(range(1,n+1), train_err, label=\"Train\")\n plt.plot(range(1,n+1), val_err, label=\"Validation\")\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Error\")\n plt.legend(loc='best')\n plt.show()\n plt.title(\"Train vs Validation Loss\")\n plt.plot(range(1,n+1), train_loss, label=\"Train\")\n plt.plot(range(1,n+1), val_loss, label=\"Validation\")\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.legend(loc='best')\n plt.show()","def model_evaluate(model,x_train,n_y_array,x_val, vald_array):\n\n scores = model.evaluate(x_train, n_y_array, verbose=1)\n\n scores2 = model.evaluate(x_val, vald_array, verbose=1)\n\n\n print(\"for traininf set\")\n\n print(\"%s: %.2f%%\" % (model.metrics_names[1], scores[1]*100))\n\n print(\"%s: %.2f%%\" % (model.metrics_names[0], scores[0]))\n\n\n\n print(\"for validation set : \") \n\n print(\"%s: %.2f%%\" % (model.metrics_names[1], scores2[1]*100))\n\n print(\"%s: %.2f%%\" % (model.metrics_names[0], scores2[0]))","def _accuracy(self, data_loader):\n self._net.eval()\n num_correct = 0.0\n num_total = 0.0\n batchindex = 0\n for X, y in tqdm(data_loader):\n # Data.\n batchindex = batchindex + 1\n X = X.to(self.device)\n y = y.to(self.device)\n # y = torch.tensor(y.to(device))\n\n # Prediction.\n score = self._net(X)\n _, prediction = torch.max(score.data, 1)\n num_total += y.size(0)\n num_correct += torch.sum(prediction == y.data)\n self._net.train() # Set the model to training phase\n return 100 * num_correct.float() / num_total","def plot_training_history(history, title_str=''):\n acc = history.history['accuracy']\n val_acc = history.history['val_accuracy']\n loss = history.history['loss']\n val_loss = history.history['val_loss']\n \n epochs = range(len(acc))\n\n plt.plot(epochs, acc, 'r', label='Training accuracy')\n plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n plt.title('Training and validation accuracy ' + title_str)\n\n ymin = min([min(acc), min(val_acc)])\n\n axes = plt.gca()\n axes.set_xlim([0, len(acc)])\n axes.set_ylim([ymin, 1])\n\n plt.legend(loc=0)\n plt.figure()\n plt.show\n \n plt.plot(epochs, loss, 'r', label='Training loss')\n plt.plot(epochs, loss, 'b', label='Validation loss')\n plt.title('Training and validation loss ' + title_str)\n\n ymin = min([min(loss), min(val_loss)])\n\n axes = plt.gca()\n axes.set_xlim([0, len(loss)])\n axes.set_ylim([ymin, 1])\n\n plt.legend(loc=0)\n plt.figure()\n plt.show()"],"string":"[\n \"def plot_accuracy(self):\\n plot_title, img_title = self.prep_titles(\\\"\\\")\\n test_legend = ['training data', 'test data']\\n\\n # Data for plotting x- and y-axis\\n x = np.arange(1, CFG.EPOCHS + 1)\\n y = [self.tr_accuracy, self.test_accuracy]\\n\\n # prints x and y-axis values\\n print(f'x: {x}')\\n print(f'training: {self.tr_accuracy}')\\n print(f'test: {self.test_accuracy}')\\n\\n plt.figure(figsize=(CFG.FIG_WIDTH, CFG.FIG_HEIGHT))\\n\\n # Create the lineplot\\n for line in range(2):\\n ax = sns.lineplot(x=x, y=y[line], color=CFG.COLOR_ACCURACY[line], label=test_legend[line])\\n\\n if CFG.ANNOTATE:\\n ax.set(xlabel='Epochs',\\n ylabel='Accuracy (%)',\\n title=plot_title,\\n xlim=(1, CFG.EPOCHS + 2),\\n ylim=(0, 119))\\n\\n for line in range(2):\\n for e in range(0, CFG.EPOCHS):\\n if y[line][e] > CFG.ANNOTATE_LEVEL:\\n value = \\\"{:.2f}\\\".format(y[line][e])\\n label = \\\"epoch \\\" + str(e + 1) + \\\"\\\\n\\\" + value + \\\"%\\\"\\n plt.annotate(label,\\n xy=(x[e], y[line][e]),\\n alpha=1,\\n size=9,\\n rotation=45,\\n textcoords='offset pixels', xytext=(0, 7),\\n ha='left', va='bottom')\\n else:\\n ax.set(xlabel='Epochs',\\n ylabel='Accuracy (%)',\\n title=plot_title,\\n xlim=(1, CFG.EPOCHS),\\n ylim=(0, 102))\\n\\n ax.legend(loc='best')\\n\\n self.save_plot(img_title)\\n plt.show()\",\n \"def cross_validation_visualization_accuracy(epochs, accs, save=False, filename=\\\"cross_validation_acc\\\"):\\n plt.plot(epochs, accs, marker=\\\".\\\", color='r', label='accuracy')\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"accuracy\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n if (save):\\n plt.savefig(filename)\",\n \"def plot_acc(acc_v, acc_t, save_plots_path):\\n\\n plt.figure()\\n plt.plot(acc_v, label='Validation acc')\\n plt.plot(acc_t, label='Training acc')\\n plt.legend()\\n title = 'Accuracy per epoch'\\n plt.title(title)\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Accuracy\\\")\\n plt.savefig(save_plots_path + \\\"swag_accuracy_plot.png\\\")\",\n \"def main():\\n args = parse_args()\\n\\n with open(args.train_details_json, mode='r', encoding='utf-8') as json_f:\\n results_dict = json.load(json_f)[-1]\\n\\n losses_plot = plt.figure()\\n plt.plot(range(1, len(results_dict['train_loss']) + 1),\\n results_dict['train_loss'])\\n plt.plot(range(1, len(results_dict['val_loss']) + 1),\\n results_dict['val_loss'])\\n plt.plot(range(1, len(results_dict['test_loss']) + 1),\\n results_dict['test_loss'])\\n plt.legend(['train', 'val', 'test'])\\n plt.title(f'loss vs epoch for {args.model} model on {args.dataset} dataset')\\n plt.xlabel('epoch')\\n plt.ylabel('loss')\\n plt.grid(True)\\n losses_plot.set_size_inches((8, 8))\\n losses_plot.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_losses_plot.png'))\\n\\n accuracies_plot = plt.figure()\\n plt.plot(range(1, len(results_dict['train_acc']) + 1),\\n results_dict['train_acc'])\\n plt.plot(range(1, len(results_dict['val_acc']) + 1),\\n results_dict['val_acc'])\\n plt.plot(range(1, len(results_dict['test_acc']) + 1),\\n results_dict['test_acc'])\\n plt.legend(['train', 'val', 'test'])\\n plt.title(f'accuracy vs epoch for {args.model} '\\n f'model on {args.dataset} dataset')\\n plt.xlabel('epoch')\\n plt.ylabel('accuracy')\\n plt.grid(True)\\n accuracies_plot.set_size_inches((8, 8))\\n accuracies_plot.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_accuracies_plot.png'))\",\n \"def make_accuracy_plot(num_trials=10):\\n data = load_digits()\\n # print data.DESCR\\n train_percentages = range(5, 95, 5)\\n test_accuracies = numpy.zeros(len(train_percentages))\\n\\n for i in range(len(train_percentages)):\\n individual_trial_accuracies = []\\n for j in range(num_trials):\\n X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, train_size=train_percentages[i]*.01)\\n model = LogisticRegression(C=10**-10)\\n model.fit(X_train, y_train)\\n individual_trial_accuracies.append(model.score(X_test, y_test))\\n test_accuracies[i] = numpy.mean(individual_trial_accuracies)\\n\\n fig = plt.figure()\\n plt.plot(train_percentages, test_accuracies, 'b')\\n plt.xlabel('Percentage of Data Used for Training')\\n plt.ylabel('Accuracy on Test Set')\\n plt.show()\",\n \"def train_visualization(output_path): \\n log_path = output_path + 'output.log'\\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\\n n_epoch = len(Train_Cost)\\n\\n x1 = range(n_epoch)\\n x2 = range(n_epoch)\\n y1 = Train_Cost\\n y2 = Valid_Cost\\n y3 = Test_Cost\\n y4 = Train_Acc\\n y5 = Valid_Acc\\n y6 = Test_Acc\\n plt.subplot(2, 1, 1)\\n plt.plot(x1, y1, label=\\\"Train_Cost\\\", linewidth=2)\\n plt.plot(x1, y2, label=\\\"Valid_Cost\\\", linewidth=2)\\n plt.plot(x1, y3, label=\\\"Test_Cost\\\", linewidth=2)\\n\\n plt.title('binary cross entropy vs. epoches')\\n plt.ylabel('binary cross entropy')\\n plt.legend(loc='best')\\n plt.subplot(2, 1, 2)\\n plt.plot(x2, y4, label=\\\"Train_Acc\\\", linewidth=2)\\n plt.plot(x2, y5, label=\\\"Valid_Acc\\\", linewidth=2)\\n plt.plot(x2, y6, label=\\\"Test_Acc\\\", linewidth=2)\\n plt.xlabel('Accuracy@20 vs. epoches')\\n plt.ylabel('Accuracy@20')\\n plt.legend(loc='best')\\n plt.savefig(output_path + 'loss_fig.png')\\n # plt.show()\",\n \"def plot_on_ax(ax, trn_ls, val_ls, ylabel=\\\"Accuracy\\\"):\\n ax.plot(trn_ls, 'o-', label='Training')\\n ax.plot(val_ls, 'x-', label='Validation')\\n ax.set_xlabel('Epochs')\\n ax.set_ylabel(ylabel)\\n ax.legend()\",\n \"def model_testing(X_train,y_train):\\n\\n # for testing amount of layers, each layer has 32 neurons\\n # layers = [[32, 32], [32, 32, 32], [32, 32, 32, 32], [32, 32, 32, 32],\\\\\\n # [32, 32, 32, 32, 32], [32, 32, 32, 32, 32, 32]]\\n layers = [[8], [16], [32], [64], [128], [256]]\\n\\n # activation = [\\\"linear\\\", \\\"sigmoid\\\", \\\"relu\\\", \\\"softmax\\\"]\\n activation = [\\\"relu\\\"]\\n runs = 1\\n for i, act in enumerate(activation):\\n val_accs = []\\n for layer in layers:\\n acc_avg = []\\n for run in range(runs):\\n model = create_model_testing(layer, act)\\n\\n # train model on full train set, with 80/20 CV split\\n training = model.fit(X_train, y_train, epochs=100, validation_split=0.2, verbose=0)\\n val_acc = np.mean(training.history['val_accuracy'])\\n print(\\\"Run \\\", run, \\\" - \\\", act + \\\" activation - layer \\\" + str(layer))\\n acc_avg.append(val_acc)\\n\\n # save average accuracy of runs\\n val_accs.append(round(np.mean(acc_avg)*100, 2))\\n print(\\\"accuracy: \\\" + str(np.mean(acc_avg)))\\n\\n # plot line for each activation method\\n plt.plot([1,2,4,8,16,32,64,128,256], val_accs, label=act)\\n # plt.plot(val_accs, label=act)\\n\\n # plotting\\n plt.title(\\\"Accuracy of neural network model with different layers (N=\\\" +\\\\\\n str(len(layers)) + \\\")\\\", fontsize=22)\\n plt.xlabel(\\\"Layers\\\", fontsize=20)\\n # plt.xticks(np.arange(1, len(val_accs) + 1, 1), fontsize=18)\\n plt.ylabel(\\\"Accuracy (%)\\\", fontsize=20)\\n plt.legend()\\n plt.subplots_adjust(bottom=.15, left=.15)\\n plt.savefig(\\\"results/linear-relu-\\\" + str(runs) + \\\"runs.png\\\")\\n plt.show()\",\n \"def plot_acc(model_dir):\\n ## extract loss from csv\\n file_dir = os.path.join(model_dir, 'acc.csv')\\n data = pd.read_csv(file_dir)\\n epochs = data['epoch'].ravel()\\n acc_train = data['acc_train'].ravel()\\n acc_test = data['acc_test'].ravel()\\n # epoch,acc_train,acc_test\\n\\n ## Theoretical Loss\\n fig, ax = plt.subplots(1, 1, figsize=(7, 5), sharey=True, sharex=True, dpi=400)\\n ax.plot(epochs, acc_train, label='train', color='green', alpha=0.8)\\n ax.plot(epochs, acc_test, label='test', color='red', alpha=0.8)\\n ax.set_ylabel('Accuracy', fontsize=10)\\n ax.set_xlabel('Epoch', fontsize=10)\\n ax.legend(loc='lower right', prop={\\\"size\\\": 15}, ncol=3, framealpha=0.5)\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n plt.tight_layout()\\n\\n ## create saving directory\\n acc_dir = os.path.join(model_dir, 'figures', 'acc')\\n os.makedirs(acc_dir, exist_ok=True)\\n file_name = os.path.join(acc_dir, 'accuracy.png')\\n plt.savefig(file_name, dpi=400)\\n print(\\\"Plot saved to: {}\\\".format(file_name))\\n file_name = os.path.join(acc_dir, 'accuracy.pdf')\\n plt.savefig(file_name, dpi=400)\\n plt.close()\\n print(\\\"Plot saved to: {}\\\".format(file_name))\",\n \"def plot_acc (history, acc='acc', val_acc='val_acc'):\\n \\n history_dict = history.history\\n acc = history_dict[acc]\\n val_acc = history_dict[val_acc]\\n loss_values = history_dict['loss']\\n epochs = range(1, len(loss_values) + 1)\\n\\n plt.plot (epochs, acc, 'bo', label='Training accuracy')\\n plt.plot (epochs, val_acc, 'b', label=\\\"validation accuracy\\\")\\n plt.title('Training and validation accuracy')\\n plt.xlabel('Epochs')\\n plt.ylabel('Accuracy')\\n plt.legend()\\n plt.show()\",\n \"def accuracy_plot(training, test, layers, data_size, n_neighbours, learning_rate, dropout_rate):\\n\\n plt.figure()\\n plt.plot(training, label=\\\"Training\\\")\\n plt.plot(test, label=\\\"Test\\\")\\n plt.xlabel(\\\"Iterations\\\", size='medium')\\n plt.ylabel(\\\"Accuracy function (%)\\\", size='medium')\\n plt.suptitle(\\\"Accuracy function while training the neural network\\\", size='medium', ha='center')\\n plt.title(\\\"layers: {} with dropout rate of {}, learning rate: {}\\\".format(layers, dropout_rate, learning_rate),\\n size='small', ha='center')\\n if n_neighbours == 0:\\n plt.figtext(0.83, 0.80, \\\"Neighbours\\\\nexcluded\\\", size='medium')\\n else:\\n plt.figtext(0.83, 0.80, \\\"{} neighbours\\\\nincluded\\\".format(n_neighbours), size='medium')\\n plt.figtext(0.83, 0.70, \\\"{}\\\\nsamples\\\".format(data_size), size='medium')\\n plt.legend(loc='right', bbox_to_anchor=(1.3, 0.5))\\n plt.subplots_adjust(right=0.8)\\n\\n working_dir = os.path.dirname(os.path.abspath(__file__))\\n saving(working_dir + \\\"/output_ANN/accuracy_plots/{}_accuracy_{}\\\".format(n_neighbours, data_size))\",\n \"def plot_eval_3(trained_model, X_val, y_val, image_name):\\n # FOR EACH CLASS\\n # val_pred = trained_model.predict_proba(X_val, num_iteration=iteration)\\n \\n iterations = trained_model.booster_.current_iteration()\\n# results = np.zeros((2, iterations))\\n results = np.zeros((iterations,))\\n for pos in range(iterations):\\n \\n # Calculate the current iteration (from 1 to iterations)\\n iteration = pos + 1\\n \\n # Predict validation set for the current iteration\\n# start_time = timeit.default_timer()\\n val_pred = trained_model.predict(X_val, num_iteration=iteration)\\n# end_time = timeit.default_timer()\\n# time = end_time - start_time\\n# speed = int(X_val.shape[0] / time)\\n \\n # Number of hits\\n val_ok = (val_pred == y_val)\\n \\n # Percentage of hits\\n val_acc = val_ok.sum() / val_ok.size\\n \\n # Actualize data for plotting results\\n# results[0][pos] = time\\n# results[1][pos] = val_acc\\n results[pos] = val_acc\\n \\n # Generate accuracy plot\\n plt.figure()\\n# plt.plot(results[0], results[1], 'b')\\n plt.plot(results, 'b')\\n plt.title('Validation accuracy')\\n plt.xlabel('iterations')\\n plt.ylabel('accuracy')\\n plt.legend()\\n \\n # Save validation plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_val_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def plot_observations():\\n plt.plot(history.history['loss'], label='training_loss')\\n plt.plot(history.history['val_loss'], label='val_loss ')\\n plt.xlabel('Epoch')\\n plt.ylabel('Loss')\\n plt.show()\\n\\n plt.plot(history.history['acc'], label='accuracy')\\n plt.plot(history.history['val_acc'], label='val_accuracy')\\n plt.xlabel('Epoch')\\n plt.ylabel('Accuracy')\\n plt.legend(loc='lower right')\\n plt.show()\\n\\n test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)\\n print(\\\"Test Accuracy:\\\", test_acc)\",\n \"def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc):\\n \\n green = '#72C29B'\\n orange = '#FFA577'\\n \\n with plt.xkcd():\\n # plot model loss\\n fig, ax1 = plt.subplots()\\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\\n label='training')\\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\\n linewidth=5, label='validation')\\n ax1.set_xlabel('# epoch')\\n ax1.set_ylabel('loss')\\n ax1.tick_params('y')\\n ax1.legend(loc='upper right', shadow=False)\\n # plot model accuracy\\n fig, ax2 = plt.subplots()\\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\\n label='training')\\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\\n linewidth=5, label='validation')\\n ax2.set_xlabel('# epoch')\\n ax2.set_ylabel('accuracy')\\n ax2.tick_params('y')\\n ax2.legend(loc='lower right', shadow=False)\\n plt.show()\",\n \"def cross_validation_visualization_accuracy_multiple(epochs, accs, save=False, filename=\\\"cross_validation_acc_multiple\\\"):\\n \\n for i in range(accs.shape[0]):\\n plt.plot(epochs, accs[i], marker=\\\".\\\", color='r', label=str(i+1)+'th accuracy')\\n \\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"accuracy\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n if (save):\\n plt.savefig(filename)\",\n \"def display_convergence_acc(train_accs, valid_accs):\\n if len(valid_accs) > 0:\\n plt.plot(len(train_accs), train_accs, color=\\\"red\\\")\\n plt.plot(len(valid_accs), valid_accs, color=\\\"blue\\\")\\n plt.legend([\\\"Train\\\", \\\"Valid\\\"])\\n else:\\n plt.plot(len(train_accs), train_accs, color=\\\"red\\\")\\n plt.legend([\\\"Train\\\"])\\n plt.xlabel('Epoch')\\n plt.ylabel('Accuracy')\\n plt.show()\",\n \"def plot_results(\\n train_data: tuple[Tensor, Tensor],\\n test_data: tuple[Tensor, Tensor],\\n correct_class: Tensor\\n):\\n #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(21,7), subplot_kw=dict(box_aspect=1))\\n fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(14,7), subplot_kw=dict(box_aspect=1))\\n fig2, ax3 = plt.subplots(figsize=(7,7), subplot_kw=dict(box_aspect=1))\\n ax1.set_title('Training data')\\n plot_dataset(train_data, ax1)\\n\\n ax2.set_title('Test data')\\n plot_dataset(test_data, ax2)\\n\\n ax3.set_title('Test prediction correctness')\\n plot_dataset((test_data[0], correct_class.int()), ax3, cmap={0: '#ff0000', 1: '#00ff00'})\\n \\n fig1.savefig('plots/datasets')\\n fig2.savefig('plots/predictions')\\n plt.show()\",\n \"def plot(self, ylog=False, category=\\\"Accuracy\\\", figsize=(12, 5)):\\n if self.CV == False: # no Cross Validation set case\\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\\n plt.suptitle(\\\"Training Curve for \\\" + self.loss, fontsize=12)\\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\\n ax[0].set_xlabel('Iteration')\\n ax[0].set_ylabel(\\\"Error\\\")\\n if ylog == True:\\n ax[0].set_yscale('log')\\n ax[0].legend()\\n ax[0].grid('on')\\n\\n if category == \\\"Accuracy\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'r-', label='Training Accuracy')\\n ax[1].set_ylabel(\\\"Accuracy\\\")\\n elif category == \\\"Error Rate\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'r-', label='Training Error Rate')\\n ax[1].set_ylabel(\\\"Error Rate\\\")\\n # ax[1].set_ylim((0, 1))\\n ax[1].set_xlabel('Iteration')\\n ax[1].legend(loc='best')\\n ax[1].grid('on')\\n plt.show()\\n if self.CV == True: # has Cross Validation set case\\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\\n plt.suptitle(\\\"Training Curve for \\\" + self.loss, fontsize=12)\\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\\n ax[0].plot(range(1, len(self.cvError) + 1), self.cvError, 'r-', label='CV Error')\\n ax[0].set_xlabel('Iteration')\\n ax[0].set_ylabel(\\\"Error\\\")\\n if ylog == True:\\n ax[0].set_yscale('log')\\n ax[0].legend()\\n ax[0].grid('on')\\n\\n if category == \\\"Accuracy\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'g-', label='Training Accuracy')\\n ax[1].plot(range(1, len(self.cvAcc) + 1), self.cvAcc, 'r-', label='CV Accuracy')\\n ax[1].set_ylabel(\\\"Accuracy\\\")\\n elif category == \\\"Error Rate\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'g-', label='Training Error Rate')\\n ax[1].plot(range(1, len(self.cvAcc) + 1), 1 - np.array(self.cvAcc), 'r-', label='CV Error Rate')\\n ax[1].set_ylabel(\\\"Error Rate\\\")\\n # ax[1].set_ylim((0, 1))\\n ax[1].set_xlabel('Iteration')\\n ax[1].legend(loc='best')\\n ax[1].grid('on')\\n plt.show()\\n\\n return fig, ax\",\n \"def create_val_plots(x_vals, vals_zeros,vals_ones):\\n plt.plot(x_vals, vals_zeros,label=\\\"non-fraud\\\")\\n plt.plot(x_vals, vals_ones,label=\\\"fraud\\\")\\n plt.title('Accuracy per number of iterations')\\n plt.xlabel('Number of Iterations')\\n plt.ylabel('Accuracy')\\n plt.xticks(np.arange(100, 210, 10))\\n plt.legend() \\n plt.show()\\n # plt.savefig('./analysis_deliverable/visualizations/accuracy_plot.png')\",\n \"def plot_train_results(metrics2record, loss_metric,\\n train_metrics, test_metrics):\\n pyplot.figure(figsize=(10, 5))\\n min_, max_ = np.min(loss_metric), np.max(loss_metric)\\n lg, = pyplot.plot(loss_metric)\\n pyplot.yticks(min_ + np.arange(5) * (max_ - min_))\\n # if learning_rate is not None:\\n # lg, = pyplot.plot(learning_rate)\\n pyplot.title('Loss')\\n pyplot.xlabel('Epoch')\\n pyplot.yscale('log')\\n pyplot.show()\\n\\n for prm in basic_metrics:\\n if prm in metrics2record:\\n leg = []\\n met_idx = metrics2record.index(prm)\\n pyplot.figure(figsize=(10, 5))\\n lg, = pyplot.plot(train_metrics[:, met_idx], label=('train'))\\n leg.append(lg)\\n lg, = pyplot.plot(test_metrics[:, met_idx], label=('test'))\\n leg.append(lg)\\n\\n pyplot.legend(handles=leg)\\n pyplot.title(prm)\\n pyplot.xlabel('Epoch')\\n pyplot.show()\\n\\n has_prf = any([(prm in PRF_metrics) for prm in metrics2record])\\n if has_prf:\\n pyplot.figure(figsize=(10, 5))\\n leg = []\\n for prm in PRF_metrics:\\n if prm in metrics2record:\\n met_idx = metrics2record.index(prm)\\n lg, = pyplot.plot(train_metrics[:, met_idx],\\n label=(prm + ':train'))\\n leg.append(lg)\\n\\n for prm in PRF_metrics:\\n if prm in metrics2record:\\n met_idx = metrics2record.index(prm)\\n lg, = pyplot.plot(test_metrics[:, met_idx],\\n label=(prm + ':test'))\\n leg.append(lg)\\n\\n pyplot.legend(handles=leg)\\n pyplot.title('Precision / Recall')\\n pyplot.xlabel('Epoch')\\n pyplot.show()\",\n \"def cross_validation_experiment(train_data, train_labels):\\n accuracies = []\\n for i in range(1, 200):\\n avg = cross_validation(train_data, train_labels, i, 10)\\n accuracies.append(avg)\\n fig = plt.figure()\\n dim = np.arange(1,len(accuracies)+1)\\n plt.plot(dim,accuracies, label='Accuracy')\\n plt.xlabel('k')\\n plt.ylabel('accuracy')\\n plt.grid()\\n plt.legend()\\n plt.tight_layout()\\n fig.savefig('knn_cross_validation.png')\\n best_k = np.argmax(accuracies)+1\\n return best_k\",\n \"def train_accuracy(self):\\n # Train accuarcy\\n add = np.ones(len(self.X_train))\\n X_add1 = np.c_[add, self.X_train]\\n pred_train = np.dot(X_add1, self.w_result.T)\\n pred_train[pred_train > 0] = 1\\n pred_train[pred_train < 0] = 0\\n print(pred_train)\\n train_check_lable = np.isclose(pred_train, self.y_train)\\n num_true_lable = np.sum(train_check_lable)\\n num_all_lable = np.size(train_check_lable)\\n train_accuracy = num_true_lable / num_all_lable\\n print(\\\"train_accuracy is: %f\\\" %train_accuracy)\\n return train_accuracy\",\n \"def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc, save_figure_path):\\n\\n green = '#72C29B'\\n orange = '#FFA577'\\n\\n with plt.xkcd():\\n fig, (ax1, ax2) = plt.subplots(2, figsize=(10, 8))\\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\\n label='training')\\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\\n linewidth=5, label='validation')\\n ax1.set_xlabel('# epoch')\\n ax1.set_ylabel('loss')\\n ax1.tick_params('y')\\n ax1.legend(loc='upper right', shadow=False)\\n ax1.set_title('Model loss through #epochs', fontweight='bold')\\n\\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\\n label='training')\\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\\n linewidth=5, label='validation')\\n ax2.set_xlabel('# epoch')\\n ax2.set_ylabel('accuracy')\\n ax2.tick_params('y')\\n ax2.legend(loc='lower right', shadow=False)\\n ax2.set_title('Model accuracy through #epochs', fontweight='bold')\\n\\n plt.tight_layout()\\n plt.show()\\n fig.savefig(save_figure_path)\\n plt.close(fig)\",\n \"def plot_training_info(case, metrics, save, history):\\n val = False\\n if 'val_accuracy' in history and 'val_loss' in history:\\n val = True\\n plt.ioff()\\n if 'accuracy' in metrics:\\n fig = plt.figure()\\n plt.plot(history['accuracy'])\\n if val:\\n plt.plot(history['val_accuracy'])\\n plt.title('model accuracy')\\n plt.ylabel('accuracy')\\n plt.xlabel('epoch')\\n if val:\\n plt.legend(['train', 'val'], loc='upper left')\\n else:\\n plt.legend(['train'], loc='upper left')\\n if save:\\n plt.savefig(case + 'accuracy.png')\\n plt.gcf().clear()\\n else:\\n plt.show()\\n plt.close(fig)\\n\\n # summarize history for loss\\n if 'loss' in metrics:\\n fig = plt.figure()\\n plt.plot(history['loss'])\\n if val:\\n plt.plot(history['val_loss'])\\n plt.title('model loss')\\n plt.ylabel('loss')\\n plt.xlabel('epoch')\\n # plt.ylim(1e-3, 1e-2)\\n plt.yscale(\\\"log\\\")\\n if val:\\n plt.legend(['train', 'val'], loc='upper left')\\n else:\\n plt.legend(['train'], loc='upper left')\\n if save:\\n plt.savefig(case + 'loss.png')\\n plt.gcf().clear()\\n else:\\n plt.show()\\n plt.close(fig)\",\n \"def acc_loss_graph(self):\\n acc = self.history['accuracy']\\n val_acc = self.history['val_accuracy']\\n loss = self.history['loss']\\n val_loss = self.history['val_loss']\\n plt.figure(figsize=(15, 5))\\n plt.subplot(1, 2, 1)\\n plt.plot(acc, label='Train')\\n plt.plot(val_acc, label='Val')\\n plt.legend(loc='lower right')\\n plt.ylabel('Accuracy')\\n plt.xlabel('Epoch')\\n plt.ylim([min(plt.ylim()), 1])\\n plt.title('Accuracy')\\n\\n plt.subplot(1, 2, 2)\\n plt.plot(loss, label='Train')\\n plt.plot(val_loss, label='Val')\\n plt.legend(loc='lower right')\\n plt.ylabel('Loss')\\n plt.xlabel('Epoch')\\n plt.ylim([0, max(plt.ylim())])\\n plt.title('Loss')\\n plt.show();\",\n \"def train_nn(train_nn_results, label, title, yaxis):\\n plt.figure(figsize=(12,5))\\n for i in range(len(label)):\\n plt.plot(train_nn_results[i], label=label[i], alpha=0.75)\\n plt.title(title)\\n plt.xlabel('epoch')\\n plt.ylabel(yaxis)\\n plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')\\n plt.tight_layout()\\n plt.show()\",\n \"def create(self, train: List[float], validation: List[float]) -> None:\\n self.ax.plot(train)\\n self.ax.plot(validation)\\n self.ax.set_xlabel('epochs')\\n if self.loss:\\n self.ax.set_ylabel('loss')\\n else:\\n self.ax.set_ylabel('accuracy')\\n self.ax.legend(['train', 'validation'])\",\n \"def test(self, plot=False):\\n accuracy_list = []\\n fobj_avg = self.load_stats()\\n\\n for ii in range(settings.PARS['maxIters']):\\n model = self.load_model(ii)\\n D1 = model['D']\\n W1 = model['W']\\n\\n # classification\\n tic = time.time()\\n accuracy_list.append(self.classification(D1, W1)[1])\\n toc = time.time()\\n print(\\n 'Final recognition rate for OnlineDL is : {} , objective function value: {}, time: {}'\\n .format(accuracy_list[ii], fobj_avg[ii], toc-tic)\\n )\\n\\n accuracy_list = np.asarray(accuracy_list)\\n\\n print('Best recognition rate for OnlineDL is {} at iteration {}'.format(\\n accuracy_list.max(), accuracy_list.argmax()))\\n\\n if plot:\\n # plot the objective function values for all iterations\\n plt.clf()\\n plt.plot(list(fobj_avg.keys()), list(fobj_avg.values()), 'mo--', linewidth=2)\\n plt.xlabel('Iterations')\\n plt.ylabel('Average objective function value')\\n plt.xticks(list(range(0, 20)), list(range(1, 21)))\\n plt.show()\\n\\n plt.clf()\\n plt.plot(accuracy_list, 'rs--', linewidth=2)\\n plt.xticks(list(range(0, 20)), list(range(1, 21)))\\n plt.xlabel('Iterations')\\n plt.ylabel('Accuracy')\\n plt.show()\",\n \"def plot_metric_values(self, threshold=0):\\n epochs_range = np.arange(threshold, len(self.accuracies), 1)\\n plt.plot(epochs_range, self.accuracies[threshold:], color='red', marker='o')\\n plt.title('Accuracy on test data. Eta={:.2f} Lambda={:2.2f}'.format(self.eta, self.lambda_r))\\n plt.xlabel('Epochs')\\n plt.ylabel('Accuracy')\\n plt.grid(True)\\n plt.show()\",\n \"def predict(x_train, y_train, x_test, y_test, fn, params):\\n y_train_predicted = fn(x_train, None, *params)\\n y_train_predicted = (y_train_predicted >= 0.5) * 1\\n y_test_predicted = fn(x_test, None, *params)\\n y_test_predicted = (y_test_predicted >= 0.5) * 1\\n\\n train_acc = np.sum(y_train_predicted == y_train) / x_train.shape[0]\\n test_acc = np.sum(y_test_predicted == y_test) / x_test.shape[0]\\n print('train accuracy =', train_acc)\\n print('test accuracy =', test_acc)\\n scatter_plot(x_train, y_train_predicted, x_test, y_test_predicted, 'predicted 0', 'predicted 1')\",\n \"def plotgraph(readfile='archivo.csv', outfiles='',cost_function='Categorical Cross Entropy'):\\r\\n plt.rcParams['figure.figsize']=(12,9)\\r\\n \\r\\n df=pd.read_csv(str(readfile), header=None)\\r\\n df=df.rename(columns={0:'cost_train', 1:'acc_train', 2:'cost_test', 3:'acc_test'})\\r\\n\\r\\n plt.figure(1)\\r\\n plt.title('Accuracy', fontsize=20, fontweight='bold')\\r\\n train=plt.scatter(np.arange(1,len(df)+1,1), df['acc_train'].values*100, color='red',\\r\\n marker='x',s=100)\\r\\n test=plt.scatter(np.arange(1,len(df)+1,1), df['acc_test'].values*100, color='blue',\\r\\n marker='o',s=100)\\r\\n plt.legend([train,test],['Training set', 'Test set'], fontsize=18)\\r\\n plt.xlabel('Epochs',fontsize=20, fontweight='bold')\\r\\n plt.xticks(fontsize=16)\\r\\n plt.yticks(fontsize=16)\\r\\n plt.ylabel('Accuracy %', fontsize=20, fontweight='bold')\\r\\n plt.annotate(str(round(df['acc_train'].values[-1]*100,2))+' %', xy=(len(df),int(df['acc_train'].values[-1]*100)), \\r\\n xytext=(len(df),int(df['acc_train'].values[-1]*100-1)), fontsize=14, fontweight='bold')\\r\\n plt.annotate(str(round(df['acc_test'].values[-1]*100,2))+' %', xy=(len(df),int(df['acc_test'].values[-1]*100)),\\r\\n xytext=(len(df),int(df['acc_test'].values[-1]*100+2)), fontsize=14, fontweight='bold')\\r\\n plt.savefig('Accuracy'+'_'+str(outfiles)+'.png')\\r\\n \\r\\n plt.figure(2)\\r\\n plt.title(str(cost_function), fontsize=20, fontweight='bold')\\r\\n train=plt.scatter(np.arange(1,len(df)+1,1), df['cost_train'].values, color='red',\\r\\n marker='x',s=100)\\r\\n test=plt.scatter(np.arange(1,len(df)+1,1), df['cost_test'].values, color='blue',\\r\\n marker='o',s=100)\\r\\n plt.legend([train,test],['Training set', 'Test set'], fontsize=18)\\r\\n plt.xlabel('Epochs',fontsize=20, fontweight='bold')\\r\\n plt.xticks(fontsize=16)\\r\\n plt.yticks(fontsize=16)\\r\\n plt.ylabel('Cost function', fontsize=20, fontweight='bold')\\r\\n plt.annotate(str(round(df['cost_train'].values[-1],4)), xy=(len(df),df['cost_train'].values[-1]), \\r\\n xytext=(len(df),1.1*df['cost_train'].values[-1]), fontsize=14, fontweight='bold')\\r\\n plt.annotate(str(round(df['cost_test'].values[-1],4)), xy=(len(df),df['cost_test'].values[-1]),\\r\\n xytext=(len(df),1.1*df['cost_test'].values[-1]+0.05), fontsize=14, fontweight='bold')\\r\\n plt.savefig('Cost function'+'_'+str(outfiles)+'.png')\\r\\n plt.close('all')\\r\\n\\r\\n return\",\n \"def plot_acc_and_loss(trn_hist, val_hist):\\n assert isinstance(trn_hist, np.ndarray) and isinstance(val_hist, np.ndarray)\\n fig, (ax_acc, ax_loss) = plt.subplots(1, 2, figsize=(10, 4))\\n plot_on_ax(ax_acc, trn_hist[:,0], val_hist[:,0], \\\"Accuracy\\\")\\n plot_on_ax(ax_loss, trn_hist[:,1], val_hist[:,1], \\\"Loss\\\")\\n plt.show()\",\n \"def plot_results(self):\\n\\n\\n f1, ax1 = plt.subplots()\\n h1, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"trainLoss\\\"],\\\\\\n \\\"b-\\\", label=\\\"Loss - Train\\\")\\n h2, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"validLoss\\\"],\\\\\\n \\\"b.\\\", label=\\\"Loss - Validation\\\")\\n\\n ax1.set_ylabel(\\\"Loss\\\", color = \\\"blue\\\")\\n ax1.tick_params(\\\"y\\\", color = \\\"blue\\\")\\n ax1.yaxis.label.set_color(\\\"blue\\\")\\n ax1.set_xlabel(\\\"Training Steps [{}]\\\".format(self.FLAGS.eval_every))\\n\\n ax2 = ax1.twinx()\\n h3, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"trainAccr\\\"], \\\"r-\\\",\\\\\\n label = \\\"Accuracy - Train\\\")\\n h4, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"validAccr\\\"], \\\"r.\\\",\\\\\\n label = \\\"Accuracy - Validation\\\")\\n\\n ax2.set_ylabel(\\\"Accuracy\\\", color = \\\"red\\\")\\n ax2.tick_params(\\\"y\\\", color = \\\"red\\\")\\n ax2.yaxis.label.set_color(\\\"red\\\")\\n\\n hds = [h1,h2,h3,h4]\\n lbs = [l.get_label() for l in hds]\\n ax1.legend(hds, lbs)\\n f1.tight_layout()\\n plt.savefig(\\\"trainingHistory.png\\\")\\n\\n plt.close(f1)\\n #plt.show()\",\n \"def see_evaluation(epoch, training_acc, test_acc):\\n print (\\\"Epoch \\\", epoch, \\\"Training acc: \\\", training_acc*100, \\\"Test acc: \\\", test_acc*100)\",\n \"def show_learning_curve(self):\\n\\n # Loop output classes\\n for c in range(1,self.n_output_classes):\\n # Get data\\n x_values = np.array(self.n_class_samples_list[c])\\n accuracy = np.array(self.accuracy_list[c])\\n precision = np.array(self.precision_list[c])\\n recall = np.array(self.recall_list[c])\\n F1 = np.array(self.F1_list[c])\\n\\n # Make plot\\n with sns.axes_style(\\\"ticks\\\"):\\n fig,ax = plt.subplots()\\n plt.plot([np.min(x_values),np.max(x_values)],[0.5,0.5],\\n color='#777777',linestyle='--')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.66,0.66],\\n color='#777777',linestyle=':')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.8,0.8],\\n color='#777777',linestyle=':')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.9,0.9],\\n color='#777777',linestyle=':')\\n\\n plt.plot( x_values, accuracy, color='#000000',\\n linewidth=1, label='Accuracy' )\\n plt.plot( x_values, precision, color='#0000aa',\\n linewidth=1, label='Precision' )\\n plt.plot( x_values, recall, color='#00aa00',\\n linewidth=1, label='Recall' )\\n plt.plot( x_values, F1, color='#aa0000',\\n linewidth=2, label='F1' )\\n\\n plt.yticks( [0, 0.5, 0.66, 0.8, 0.9, 1.0],\\n ['0','0.5','0.66','0.8','0.9','1.0'], ha='right' )\\n plt.xlim(np.max(x_values)*-0.02,np.max(x_values)*1.02)\\n plt.ylim(-0.02,1.02)\\n plt.xlabel('Number of training samples')\\n plt.ylabel('Performance')\\n plt.title('Learning curve, class {}'.format(c))\\n sns.despine(ax=ax, offset=0, trim=True)\\n lgnd = plt.legend(loc=4, ncol=1, frameon=True, fontsize=9)\\n lgnd.get_frame().set_facecolor('#ffffff')\\n ax.spines['left'].set_bounds(0,1)\\n ax.spines['bottom'].set_bounds(np.min(x_values),np.max(x_values))\",\n \"def plot_predictions(net, x_train, y_train, idx_train, x_val, y_val, idx_val):\\n fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(20, 30))\\n pred1 = net.predict(x_val, batch_size=batch_size)\\n # print(\\\"pred1.shape:\\\", pred1.shape)\\n ax1.plot(idx_val, y_val, label=\\\"Actual Data\\\", marker=\\\"+\\\")\\n ax1.plot(idx_val, pred1, label=\\\"Prediction\\\", marker=\\\"o\\\")\\n # ax1.set_ylim(-0.1, 1.1)\\n ax1.set_xlabel(\\\"Year\\\")\\n ax1.set_ylabel(\\\"Sunspot Numbers\\\")\\n ax1.legend()\\n ax1.set_title(\\\"Predicted vs Actual Validation Data\\\")\\n\\n pred2 = net.predict(x_train, batch_size=batch_size)\\n # print(\\\"pred2.shape:\\\", pred2.shape)\\n ax2.plot(idx_train, y_train, label=\\\"Actual Data\\\", marker=\\\"+\\\")\\n ax2.plot(idx_train, pred2, label=\\\"Prediction\\\", marker=\\\"o\\\")\\n # ax2.set_ylim(-0.1, 1.1)\\n ax2.set_xlabel(\\\"Year\\\")\\n ax2.set_ylabel(\\\"Sunspot Numbers\\\")\\n ax2.legend()\\n ax2.set_title(\\\"Predicted vs Actual Training Data\\\")\\n\\n plt.tight_layout()\\n\\n filename = \\\"img/\\\"\\n filename += datetime.now().strftime(\\\"%y%m%d_%H%M\\\")\\n filename += \\\"_predicted_vs_actual_data.png\\\"\\n fig.savefig(filename, format=\\\"png\\\")\",\n \"def plot_eval_1(trained_model, image_name):\\n # Get training evaluation data\\n train_accuracy = trained_model.history['acc']\\n train_val_accuracy = trained_model.history['val_acc']\\n train_loss = trained_model.history['loss']\\n train_val_loss = trained_model.history['val_loss']\\n \\n # Generate accuracy plot\\n epochs = range(len(train_accuracy))\\n plt.figure()\\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n \\n # Save accuracy plot\\n plot_file = os.path.join(OUTPUT_DIR,\\n \\\"{}_training_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\\n \\n # Generate loss plot\\n plt.figure()\\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n \\n # Save loss plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_training_loss\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def make_accuracy_plot(ax,\\n groundtruth_boxes,\\n hpu_boxes,\\n cpu_boxes,\\n hpu_strategy,\\n label,\\n N=10,\\n num_graph_points=20,\\n match_mode=\\\"ellipse\\\",\\n):\\n print \\\"Making plot for\\\", repr(label)\\n print \\\"TODO: this should graph seconds per image\\\"\\n mix_fractions = np.linspace(0, 1.0, num_graph_points)\\n # Plot confidence intervals\\n min_ci = []\\n max_ci = []\\n mean_accs = []\\n stderr_accs = []\\n for mix_fraction in mix_fractions:\\n accuracies = [\\n maximum_F_score(\\n groundtruth_boxes,\\n hpu_strategy(hpu_boxes, cpu_boxes, mix_fraction),\\n match_mode=match_mode,\\n )\\n for _ in xrange(N)\\n ]\\n mean_accs.append(np.mean(accuracies))\\n stderr_accs.append(np.std(accuracies, ddof=1) / np.sqrt(N))\\n #print mix_fraction, np.mean(accuracies)\\n ax.errorbar(mix_fractions, mean_accs, stderr_accs, label=label)\\n ax.set_xlabel(\\\"Fraction of HPU-labeled images\\\")\\n ax.set_ylabel(\\\"Maximum F-score\\\")\",\n \"def _plot_train_test_experiment(mtrain, mval, metric_name, isState):\\n # axes\\n f, axes = plt.subplots(2,2,figsize=(12,10))\\n ltrain = _plot_experiment(mtrain, axes[:,0], metric_name, isTrain=True)\\n lval = _plot_experiment(mval, axes[:,1], metric_name, isTrain=False)\\n # title\\n target = \\\"State\\\" if isState else \\\"Output\\\"\\n f.suptitle(f\\\"{target} Errors\\\")\\n f.tight_layout()\\n return f, axes\",\n \"def train_model_and_plot_results(**kwargs):\\n epochs = kwargs[\\\"epochs\\\"]\\n\\n history, model = train_model(**kwargs)\\n\\n dice = history.history['dice_loss']\\n val_dice = history.history['val_dice_loss']\\n\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n\\n epochs_range = range(epochs)\\n\\n plt.figure(figsize=(16, 8))\\n plt.subplot(1, 2, 1)\\n plt.plot(epochs_range, dice, label='Training Dice Loss')\\n plt.plot(epochs_range, val_dice, label='Validation Dice Loss')\\n plt.legend(loc='upper right')\\n plt.title('Training and Validation Dice Loss')\\n\\n plt.subplot(1, 2, 2)\\n plt.plot(epochs_range, loss, label='Training Loss')\\n plt.plot(epochs_range, val_loss, label='Validation Loss')\\n plt.legend(loc='upper right')\\n plt.title('Training and Validation Loss')\\n\\n plt.show()\",\n \"def visualize_train_history(history):\\n cat_acc = history.history['categorical_accuracy']\\n val_cat_acc = history.history['val_categorical_accuracy']\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n\\n epochs = range(1, len(cat_acc) + 1)\\n\\n plt.plot(epochs, cat_acc, 'bo', label='Training cat_acc')\\n plt.plot(epochs, val_cat_acc, 'b', label='Validation cat_acc')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n\\n plt.figure()\\n\\n plt.plot(epochs, loss, 'bo', label='Training loss')\\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n\\n plt.show()\",\n \"def graph_ACC(history,title):\\n _, ax = plt.subplots()\\n ax.set_title(title)\\n try:\\n ax.plot(history.history['acc'], label='Train')\\n ax.plot(history.history['val_acc'], label='Test')\\n except:\\n ax.plot(history['acc'], label='Train')\\n ax.plot(history['val_acc'], label='Test')\\n ax.set_xlabel(\\\"Epochs\\\")\\n ax.set_ylabel(\\\"Accuracy\\\")\\n ax.legend()\",\n \"def accuracy_plot(LS_sizes, data_fun):\\r\\n\\r\\n opt_neigh = []\\r\\n\\r\\n #plot of optimal n_neighbors as a function of the LS size\\r\\n\\r\\n for size in LS_sizes:\\r\\n\\r\\n acc = []\\r\\n neighbors_values = np.arange(1,size+1,1)\\r\\n\\r\\n # For a given LS size, plots of accuracy(n_neighbors)\\r\\n\\r\\n for value in neighbors_values:\\r\\n\\r\\n X_train, y_train, X_test, y_test = data_fun(n_ts=500, n_ls=size)\\r\\n\\r\\n clf = KNeighborsClassifier(n_neighbors = value)\\r\\n clf = clf.fit(X_train, y_train)\\r\\n acc.append(clf.score(X_test,y_test))\\r\\n\\r\\n plt.figure()\\r\\n plt.plot(neighbors_values,acc, '.')\\r\\n plt.title(\\\"Evolution of accuracy as a function \\\\nof n_neighbors for LS_size = {} samples, for {}.\\\".format(size, data_fun.__name__))\\r\\n plt.savefig(\\\"acc(n_neigh)_{}_{}.pdf\\\".format(size, data_fun.__name__))\\r\\n\\r\\n opt_neigh.append(np.argmax(acc)+1)\\r\\n\\r\\n plt.figure()\\r\\n plt.plot(LS_sizes, opt_neigh, '.')\\r\\n plt.title(\\\"Optimal n_neighbors as a function \\\\nof the size of the learning sample, for {}.\\\".format(data_fun.__name__))\\r\\n plt.savefig(\\\"opt_n_neigh(LS_size)_{}.pdf\\\".format(data_fun.__name__))\",\n \"def plt_accuracy(self, lamda_choice, weights_initial):\\n weights_random = []\\n train_accuracy = []\\n test_accuracy = []\\n for i in range(len(lamda_choice)):\\n self.lamda = lamda_choice[i]\\n self.fit(weights_initial)\\n pred_result = self.predict()\\n test_ac = self.evaluate(pred_result)\\n test_accuracy.append(test_ac)\\n train_ac = self.train_accuracy() \\n train_accuracy.append(train_ac)\\n weights_random.append(self.w_result[-1])\\n # print best lamda with highest accuracy\\n print(\\\"choose lambda: %f\\\" % lamda_choice[np.argmax(train_accuracy)])\\n labels = [\\\"Train_accuracy\\\", \\\"Test_accuracy\\\"]\\n fig, ax = plt.subplots()\\n ax.plot(lamda_choice, train_accuracy, 'o-', label='Train_accuracy')\\n ax.plot(lamda_choice, test_accuracy, 'o-', label='Test_accuracy')\\n # Draw absolute weight value corresponding the random feature\\n fig, ax = plt.subplots()\\n ax.plot(lamda_choice, weights_random, label='Weight for random')\\n plt.show()\\n # find the best lamda\\n self.lamda = lamda_choice[np.argmax(train_accuracy)]\",\n \"def test(self, training_set, original_test_set, imitation_test_set ):\\n\\n plt.figure()\\n\\n training_axis = np.arange(len(training_set))\\n original_test_axis = np.arange(len(original_test_set))+len(training_axis)\\n imitation_test_axis = np.arange(len(imitation_test_set))+len(training_axis)+len(original_test_set)\\n\\n training_scores = []\\n original_test_scores = []\\n imitation_test_scores = []\\n\\n for signature in training_set:\\n vectorized_signature = signature.tolist()\\n score = -1*self.model.score(vectorized_signature)\\n training_scores.append(score)\\n\\n for signature in original_test_set:\\n vectorized_signature = signature.tolist()\\n score = -1*self.model.score(vectorized_signature)\\n original_test_scores.append(score)\\n\\n for signature in imitation_test_set:\\n vectorized_signature = signature.tolist()\\n score = -1*self.model.score(vectorized_signature)\\n imitation_test_scores.append(score)\\n\\n accuracy, threshold = self.evaluate(training_scores, original_test_scores, imitation_test_scores)\\n\\n xaxis = np.arange(len(imitation_test_set)+len(training_axis)+len(original_test_set))\\n plt.plot( xaxis, threshold*np.ones(len(xaxis)), \\\"--\\\", label=\\\"Threshold\\\" )\\n plt.scatter(training_axis,training_scores, label=\\\"Training data\\\")\\n plt.scatter(original_test_axis, original_test_scores, c=\\\"g\\\", label=\\\"Original Test data\\\")\\n plt.scatter(imitation_test_axis, imitation_test_scores, c=\\\"r\\\", label=\\\"Imitated Test data\\\")\\n plt.legend(loc=\\\"best\\\")\\n plt.title(f\\\"{self.user} data. Accuracy={accuracy} \\\")\\n plt.ylabel(\\\"Score\\\")\\n plt.xlabel(\\\"File\\\")\\n plt.savefig(f\\\"{self.n_components}_{self.user}.png\\\")\\n\\n Model.accuracies.append(accuracy)\",\n \"def acc_plotter(model_history, ax = None):\\n \\n import matplotlib.pyplot as plt\\n import seaborn as sns\\n \\n training_loss = model_history['loss']\\n\\n acc = model_history['accuracy']\\n \\n val_acc = model_history['val_accuracy']\\n\\n epoch_count = range(1,len(training_loss)+1)\\n \\n sns.set(font_scale=1.15)\\n \\n sns.lineplot(\\n x=epoch_count,\\n y=acc,\\n ax=ax\\n )\\n \\n sns.lineplot(\\n x=epoch_count,\\n y=val_acc,\\n ax=ax\\n )\\n\\n ax.set_title('Accuracy Curves: Pre-Trained VGG-16 with 2 Trained Layers',fontsize=19)\\n \\n ax.set_ylabel('Accuracy',fontsize=18)\\n \\n ax.set_xlabel('Epochs',fontsize=18)\\n\\n plt.legend(['Training Accuracy', 'Validation Accuracy'])\\n\\n plt.show()\",\n \"def visualize_training(features, labels, pl):\\n print(\\\"Visualizing training\\\")\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n\\n # Take out each feature type, one at a time\\n label_map = get_label_map(labels)\\n\\n for key in label_map.keys():\\n like_ind = label_map[key]\\n like_data = np.array([features[i] for i in like_ind])\\n\\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\\n\\n # get limits\\n xmin = features.column_min(0) - .5\\n xmax = features.column_max(0) + .5\\n ymin = features.column_min(1) - .5\\n ymax = features.column_max(1) + .5\\n\\n plt.xlim(xmin,xmax)\\n plt.ylim(ymin,ymax)\\n\\n # Track the current dividing line, as well as the number of epochs passed\\n divider, = plt.plot([],[])\\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\\n\\n def update(i):\\n \\\"\\\"\\\"\\n 1.) Get the next set of weights from the tracker\\n 2.) Calculate and draw the new divider line\\n 3.) Update the epoch counter\\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\\n \\\"\\\"\\\"\\n epoch = i//features.instance_count\\n w = pl.weights_tracker[i]\\n a = pl.accuracy_tracker[epoch]\\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\\n epoch_tracker.set_text(\\\"{} {}\\\".format(epoch + 1, a))\\n\\n # Keep a shadow of the hyperplane at the end of each epoch\\n if i % features.instance_count == 0:\\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\\n\\n return divider\\n\\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\\n plt.legend()\\n\\n # optional save file\\n if len(sys.argv) >= 3 :\\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\\n\\n plt.show()\",\n \"def evaluate(self):\\n predictions = self.model.predict(self.test[0])\\n accuracy = accuracy_score(self.test[1], predictions)\\n print(\\\"Accuracy:\\\", str(accuracy * 100) + \\\"%\\\")\\n self.plot_results(predictions)\",\n \"def plot_train_val_loss(path_to_file, train_filename, val_filename):\\n path = '../'\\n labels = ['gen_total_loss', 'gen_loss', 'l1_loss', 'disc_total_loss', 'disc_gen_loss', 'disc_real_loss']\\n with open(path_to_file + train_filename + '.csv', newline='') as f:\\n reader = csv.reader(f)\\n train_data = np.array(list(reader))\\n with open(path_to_file + val_filename + '.csv', newline='') as f:\\n reader = csv.reader(f)\\n val_data = np.array(list(reader))\\n\\n if train_data.shape == val_data.shape:\\n # change label number for the type of loss that should be plotted\\n label = 0\\n print(train_data.shape, val_data.shape)\\n epoch_count = range(1, train_data.shape[0] + 1)\\n plt.figure()\\n plt.plot(epoch_count, val_data[:len(epoch_count), label].astype('float32'))\\n plt.plot(epoch_count, train_data[:len(epoch_count), label].astype('float32'))\\n plt.legend(['validation', 'train'])\\n plt.xlabel('Epoch')\\n plt.ylabel(labels[label])\\n plt.show()\",\n \"def plot_loss_and_acc(history):\\n hist = history.history\\n x_arr = np.arange(len(hist['loss'])) + 1\\n fig = plt.figure(figsize=(12,4))\\n ax = fig.add_subplot(1,2,1)\\n ax.plot(x_arr, hist['loss'], '-o', label='Train loss')\\n ax.plot(x_arr, hist['val_loss'], '--<', label='Validation loss')\\n ax.legend(fontsize=15)\\n ax.set_xlabel('Epoch', size=15)\\n ax.set_ylabel('Loss', size=15)\\n\\n ax = fig.add_subplot(1,2,2)\\n ax.plot(x_arr, hist['accuracy'], '-o', label='Train acc.')\\n ax.plot(x_arr, hist['val_accuracy'], '--<', label='Validation acc.')\\n ax.legend(fontsize=15)\\n ax.set_xlabel('Epoch', size=15),\\n ax.set_ylabel('Accuracy', size=15)\\n plt.show()\",\n \"def plot_training_history(history, metric):\\n \\n val_metric = 'val_'+metric\\n acc = history.history[metric]\\n val_acc = history.history[val_metric]\\n \\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n \\n epochs_range = history.epoch\\n \\n plt.figure(figsize=(8, 8))\\n plt.subplot(2, 1, 1)\\n plt.plot(epochs_range, acc, label='Training Acc.')\\n plt.plot(epochs_range, val_acc, label='Validation Acc.')\\n plt.legend(loc='best',)\\n plt.title('Training and Validation Accuracy')\\n \\n plt.subplot(2, 1, 2)\\n plt.plot(epochs_range, loss, label='Training Loss')\\n plt.plot(epochs_range, val_loss, label='Validation Loss')\\n plt.legend(loc='best')\\n plt.title('Training and Validation Loss')\\n plt.show()\",\n \"def save_accuracy_chart(self):\\n history = self.model.history.history\\n fig = plt.figure()\\n plt.plot(history['accuracy'], label='Training Accuracy')\\n plt.plot(history['val_accuracy'],label='Validation Set Accuracy')\\n plt.legend()\\n fig.savefig('model_accuracy.png')\",\n \"def plot_eval_2(trained_model, image_name):\\n # Get training evaluation data\\n train_accuracy = trained_model.history['acc']\\n train_val_accuracy = trained_model.history['val_acc']\\n train_loss = trained_model.history['loss']\\n train_val_loss = trained_model.history['val_loss']\\n \\n # Generate accuracy plot\\n epochs = range(len(train_accuracy))\\n plt.figure()\\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n \\n # Save accuracy plot\\n plot_file = os.path.join(OUTPUT_DIR,\\n \\\"{}_training_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\\n \\n # Generate loss plot\\n plt.figure()\\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n \\n # Save loss plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_training_loss\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def calc_params_train_val(history):\\r\\n # Metric of each feature\\r\\n acc_params = ['covid_severity_output_categorical_accuracy',\\r\\n 'pleural_regular_output_binary_accuracy',\\r\\n 'consolidation_output_binary_accuracy']\\r\\n precision_params = ['covid_severity_output_precision',\\r\\n 'pleural_regular_output_precision_1',\\r\\n 'consolidation_output_precision_2']\\r\\n recall_params = ['covid_severity_output_recall',\\r\\n 'pleural_regular_output_recall_1',\\r\\n 'consolidation_output_recall_2']\\r\\n AUC_params = ['covid_severity_output_auc',\\r\\n 'pleural_regular_output_auc_1',\\r\\n 'consolidation_output_auc_2']\\r\\n mae_params = ['covid_severity_output_mae',\\r\\n 'pleural_regular_output_mae',\\r\\n 'consolidation_output_mae']\\r\\n\\r\\n # Accuracy\\r\\n for acc_param in acc_params:\\r\\n plt.clf()\\r\\n fig = go.Figure()\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[acc_param],\\r\\n name='Train'))\\r\\n val_acc_param = 'val_' + acc_param\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[val_acc_param],\\r\\n name='Validation'))\\r\\n title_acc_param = 'Accuracy for ' + acc_param + ' feature'\\r\\n fig.update_layout(height=500,\\r\\n width=700,\\r\\n title=title_acc_param,\\r\\n xaxis_title='Epoch',\\r\\n yaxis_title='Accuracy')\\r\\n fig.show()\\r\\n\\r\\n # Precision\\r\\n for precision_param in precision_params:\\r\\n plt.clf()\\r\\n fig = go.Figure()\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[precision_param],\\r\\n name='Train'))\\r\\n val_precision_param = 'val_' + precision_param\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[val_precision_param],\\r\\n name='Validation'))\\r\\n title_precision_param = 'Precision for ' + precision_param + ' feature'\\r\\n fig.update_layout(height=500,\\r\\n width=700,\\r\\n title=title_precision_param,\\r\\n xaxis_title='Epoch',\\r\\n yaxis_title='Precision')\\r\\n fig.show()\\r\\n\\r\\n # Recall\\r\\n for recall_param in recall_params:\\r\\n plt.clf()\\r\\n fig = go.Figure()\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[recall_param],\\r\\n name='Train'))\\r\\n val_recall_param = 'val_' + recall_param\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[val_recall_param],\\r\\n name='Validation'))\\r\\n title_recall_param = 'Recall for ' + recall_param + ' feature'\\r\\n fig.update_layout(height=500,\\r\\n width=700,\\r\\n title=title_recall_param,\\r\\n xaxis_title='Epoch',\\r\\n yaxis_title='Recall')\\r\\n fig.show()\\r\\n\\r\\n # AUC\\r\\n for AUC_param in AUC_params:\\r\\n plt.clf()\\r\\n fig = go.Figure()\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[AUC_param],\\r\\n name='Train'))\\r\\n val_AUC_param = 'val_' + AUC_param\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[val_AUC_param],\\r\\n name='Validation'))\\r\\n title_AUC_param = 'AUC for ' + AUC_param + ' feature'\\r\\n fig.update_layout(height=500,\\r\\n width=700,\\r\\n title=title_AUC_param,\\r\\n xaxis_title='Epoch',\\r\\n yaxis_title='AUC')\\r\\n fig.show()\\r\\n\\r\\n # MAE\\r\\n for mae_param in mae_params:\\r\\n plt.clf()\\r\\n fig = go.Figure()\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[mae_param],\\r\\n name='Train'))\\r\\n val_mae_param = 'val_' + mae_param\\r\\n fig.add_trace(go.Scatter(\\r\\n y=history.history[val_mae_param],\\r\\n name='Validation'))\\r\\n title_mae_param = 'mae for ' + mae_param + ' feature'\\r\\n fig.update_layout(height=500,\\r\\n width=700,\\r\\n title=title_mae_param,\\r\\n xaxis_title='Epoch',\\r\\n yaxis_title='mae')\\r\\n fig.show()\",\n \"def finetune_n_estimators(savefigure=False):\\n res = np.array(np.load('npy-data/result_n_estimators_tuning_acc_auc_crossval_train.npy'))\\n acc, auc = res[:int(len(res)/2)], res[int(len(res)/2):]\\n plt.plot([j*10 for j in range(1,31)],acc,[j*10 for j in range(1,31)],auc)\\n plt.xlabel('Number of trees')\\n plt.ylabel('Accuracy/AUC score')\\n plt.legend([\\\"Accuracy\\\",\\\"ROC AUC\\\"])\\n if savefigure:\\n plt.savefig('img/accuracy_n_estimators_tuning_acc_auc_crossval.pdf', bbox_inches='tight')\\n plt.show()\",\n \"def plot_testacc_numlabels(dataset, models, results, path, suffix):\\n res = results[results['dataset'] == dataset]\\n plt.close()\\n for mod in models:\\n res_model = res[res['model'] == mod]\\n res_model.sort_values(by=['num_labels'], inplace=True)\\n plt.scatter(res_model['num_labels'], res_model['test_acc'],\\n label=mod, marker='o')\\n plt.ylabel('test accuracy')\\n plt.xlabel('num labels')\\n plt.title('Dataset: {}'.format(dataset))\\n plt.legend()\\n plt.tight_layout()\\n if suffix is None:\\n plt.savefig('{}{}_performance.png'.format(path, dataset))\\n else:\\n plt.savefig('{}{}_performance_{}.png'.format(path, dataset,\\n suffix))\",\n \"def plots(self, history):\\n print(history.history.keys())\\n plt.plot(history.history['acc'])\\n plt.plot(history.history['val_acc'])\\n plt.title('model accuracy')\\n plt.ylabel('accuracy')\\n plt.xlabel('epoch')\\n plt.legend(['train','test'], loc='upper left')\\n plt.show()\\n\\n plt.plot(history.history['loss'])\\n plt.plot(history.history['val_loss'])\\n plt.title('model loss')\\n plt.ylabel('loss')\\n plt.xlabel('epoch')\\n plt.legend(['train','test'], loc='upper left')\\n plt.show()\",\n \"def acc_loss_graph(accuracies, losses):\\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))\\n\\n for experiment_id in accuracies.keys():\\n ax1.plot(accuracies[experiment_id], label=experiment_id)\\n ax1.legend()\\n ax1.set_title('Validation Accuracy')\\n fig.tight_layout()\\n\\n for experiment_id in accuracies.keys():\\n ax2.plot(losses[experiment_id], label=experiment_id)\\n ax2.legend()\\n ax2.set_title('Validation Loss');\\n\\n fig.tight_layout()\",\n \"def plot_accuracy_and_loss(histories=None):\\n fig = subplots.make_subplots(rows=2, cols=2, subplot_titles=('Training accuracy', 'Validation accuracy',\\n 'Training loss ', 'Validation loss'))\\n\\n def append_trace(model_name, acc, val_acc, loss, val_loss, epochs):\\n e = list(range(epochs))\\n color = random.choice(hex_colors_only)\\n trace_ta = create_trace(e, acc, model_name, color)\\n trace_va = create_trace(e, val_acc, model_name, color)\\n trace_tl = create_trace(e, loss, model_name, color)\\n trace_vl = create_trace(e, val_loss, model_name, color)\\n\\n fig.append_trace(trace_ta, 1, 1)\\n fig.append_trace(trace_va, 1, 2)\\n fig.append_trace(trace_tl, 2, 1)\\n fig.append_trace(trace_vl, 2, 2)\\n\\n if histories is None:\\n df_accuracies, df_losses = get_tensorboard_scalars()\\n for model_name in df_accuracies.model_name.unique():\\n df_acc = df_accuracies.loc[df_accuracies.model_name == model_name]\\n df_l = df_losses.loc[df_losses.model_name == model_name]\\n\\n acc = df_acc.loc[df_acc.result_of == 'train'].accuracy.values.tolist()\\n val_acc = df_acc.loc[df_acc.result_of == 'validation'].accuracy.values.tolist()\\n loss = df_l.loc[df_l.result_of == 'train'].loss.values.tolist()\\n val_loss = df_l.loc[df_l.result_of == 'validation'].loss.values.tolist()\\n epochs = len(df_acc)\\n\\n append_trace(model_name, acc, val_acc, loss, val_loss, epochs)\\n\\n else:\\n for model_name, history in histories.items():\\n acc = history['accuracy']\\n val_acc = history['val_accuracy']\\n loss = history['loss']\\n val_loss = history['val_loss']\\n epochs = list(range(1, len(acc) + 1))\\n\\n append_trace(model_name, acc, val_acc, loss, val_loss, epochs)\\n fig['layout']['xaxis'].update(title='Epoch')\\n fig['layout']['xaxis2'].update(title='Epoch')\\n fig['layout']['yaxis'].update(title='Accuracy', range=[0, 1])\\n fig['layout']['yaxis2'].update(title='Loss', range=[0, 1])\\n\\n iplot(fig, filename='accuracies-losses')\",\n \"def plot_learning_curve(X_train_all, X_val_all, y_train_all, y_val_all, train_sizes, title):\\n\\n errors_df = pd.DataFrame(columns = ['train_size', 'train_acc', 'val_acc'])\\n\\n # Loop through example sizes and get the training and validation error\\n for train_size in train_sizes:\\n # Select Subset of Data\\n X_train = X_train_all[:train_size]\\n X_val = X_val_all[:train_size]\\n y_train = y_train_all[:train_size]\\n y_val = y_val_all[:train_size]\\n\\n # Initialize Model\\n model = svm.SVC(kernel='linear')\\n\\n # Fit model\\n print(f\\\"Training {title} using {train_size} examples\\\")\\n model.fit(X_train, y_train)\\n\\n # Get Predictions \\n train_pred = model.predict(X_train)\\n val_pred = model.predict(X_val)\\n\\n # Get Accuracy Score for X_Train and X_Val\\n errors = pd.DataFrame({\\n 'train_size': [train_size],\\n 'train_acc': [accuracy_score(y_train, train_pred)],\\n 'val_acc': [accuracy_score(y_val, val_pred)]\\n })\\n \\n # Concatenate Dataframes\\n errors_df = pd.concat([errors_df, errors])\\n\\n # Plot Learning Curve\\n fig, ax = plt.subplots()\\n\\n errors_df.plot(x='train_size', y='train_acc',kind='line', ax=ax)\\n errors_df.plot(x='train_size', y='val_acc',kind='line', color='red', ax=ax)\\n\\n ax.set_xlabel(\\\"Training Size\\\")\\n ax.set_ylabel(\\\"Accuracy\\\")\\n ax.set_title(title)\\n\\n # Save Figure\\n plt.savefig('figs/' + title + '_learning_curve.png')\",\n \"def train(self):\\n y_list = []\\n y_hat_list = []\\n for ex_dict in ut.EXAMPLES_LIST:\\n y_list.append(ex_dict[1])\\n y_hat_list.append(self.predict(ex_dict[0]))\\n\\n acc = ut.compute_accuracy(y_hat_list, y_list)\\n return acc\",\n \"def check_test_accuracy(self):\\n print('\\\\n# Evaluate on test data')\\n results = self.model.evaluate(self.data.test_dataset)\\n print('\\\\ntest loss, test acc:', results)\",\n \"def evaluate_test(model, history, class_labels, train_X, test_X, train_y, test_y):\\n train_loss, train_acc = model.evaluate(train_X, train_y, verbose=0)\\n test_loss, test_acc = model.evaluate(test_X, test_y, verbose=0)\\n print('Accuracy \\\\n Train: %.3f, Test: %.3f' % (train_acc, test_acc))\\n print('Loss \\\\n Train: %.3f, Test: %.3f \\\\n' % (train_loss, test_loss))\\n # plot loss during training\\n plt.subplots_adjust(hspace = .5, wspace = 0.5)\\n plt.subplot(211)\\n plt.title('Loss', weight='bold')\\n plt.plot(history.history['loss'], label='train')\\n plt.plot(history.history['val_loss'], label='val')\\n plt.legend()\\n # plot accuracy during training\\n plt.subplot(212)\\n plt.title('Accuracy', weight='bold')\\n plt.plot(history.history['acc'], label='train')\\n plt.plot(history.history['val_acc'], label='val')\\n plt.legend()\\n plt.show()\\n print('\\\\n')\\n # predict probabilities for test set\\n yhat_probs = model.predict(test_X, verbose=0)\\n # predict classes for test set\\n yhat_classes = model.predict_classes(test_X, verbose=0)\\n # reduce to 1d array\\n yhat_probs = yhat_probs[:, 0]\\n yhat_classes = yhat_classes[:, 0]\\n # calculate metrics\\n report = metrics.classification_report(test_y, yhat_classes, target_names=class_labels)\\n confusion_matrix = metrics.confusion_matrix(test_y, yhat_classes)\\n plot_confusion_matrix(confusion_matrix, class_labels)\\n print('\\\\n')\\n return report\",\n \"def plot_data(losses, accuracies, name):\\n # convert accuracies to percentages\\n accuracies['Train'] = [acc * 100 for acc in accuracies['Train']]\\n accuracies['Valid'] = [acc * 100 for acc in accuracies['Valid']]\\n # set fontsize\\n plt.rcParams.update({'font.size': 13})\\n fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(8,5))\\n ax1.set_xlabel('Number of Epochs')\\n ax1.set_ylabel('Cross Entropy Loss')\\n ax1.set_ylim(0,2)\\n ax1.plot(losses['Train'], label='Training')\\n ax1.plot(losses['Valid'], label='Validation')\\n ax1.legend(loc='upper right')\\n\\n ax2.set_xlabel('Number of Epochs')\\n ax2.set_ylabel('Accuracy (%)')\\n ax2.set_ylim(0,100)\\n ax2.plot(accuracies['Train'], label='Training')\\n ax2.plot(accuracies['Valid'], label='Validation')\\n ax2.legend(loc='upper left')\\n\\n fig.tight_layout()\\n fig.savefig('../outputs/' + name)\",\n \"def plot_data():\\n \\n [X_train, X_dev, X_test, Y_train, Y_dev, Y_test, numOutputNodes] = load_data('regression') \\n \\n traindev = np.concatenate((Y_train, Y_dev), 1)\\n traindevtest = np.concatenate((traindev, Y_test), 1)\\n tdt = traindevtest.reshape(traindevtest.shape[1],)\\n\\n Y_train = Y_train.reshape(Y_train.shape[1],)\\n Y_dev = Y_dev.reshape(Y_dev.shape[1],)\\n Y_test = Y_test.reshape(Y_test.shape[1],)\\n\\n sigma = np.round(np.std(tdt), 3)\\n mu = np.round(np.mean(tdt), 3)\\n\\n # plots histogram of all data together, indicating values of mean and standard deviation\\n plt.figure(1)\\n plt.hist(tdt)\\n plt.title(\\\"{} data points, mu = {}, sigma = {}\\\".format(tdt.size, mu, sigma))\\n plt.xlabel(\\\"average Fe coordination number\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.show()\\n\\n # plots histogram where the training, cross-validation, and test sets have separate bars\\n plt.figure(2)\\n plt.hist([Y_train, Y_dev, Y_test], label = ['training', 'cross-validation', 'test'], density = True)\\n plt.xlabel(\\\"average Fe coordination number\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.legend()\\n plt.show()\\n\\n # below is graphing for the charge data, as opposed to the averaged spectrum data\\n [X_train1, X_dev1, X_test1, _, _, _, Y_train1, Y_dev1, Y_test1, numOutputNodes1] = load_data('multi_task')\\n traindev1 = np.concatenate((Y_train1, Y_dev1), 1)\\n traindevtest1 = np.concatenate((traindev1, Y_test1), 1)\\n tdt1 = traindevtest1.reshape(traindevtest1.shape[1],)\\n\\n Y_train1 = Y_train1.reshape(Y_train1.shape[1],)\\n Y_dev1 = Y_dev1.reshape(Y_dev1.shape[1],)\\n Y_test1 = Y_test1.reshape(Y_test1.shape[1],)\\n\\n sigma = np.round(np.std(tdt1), 3)\\n mu = np.round(np.mean(tdt1), 3)\\n\\n # plots histogram of all data together, indicating values of mean and standard deviation\\n plt.figure(3)\\n plt.hist(tdt1)\\n plt.title(\\\"{} data points, mu = {}, sigma = {}\\\".format(tdt1.size, mu, sigma))\\n plt.xlabel(\\\"charge\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.show()\\n\\n # plots histogram where the training, cross-validation, and test sets have separate bars\\n plt.figure(4)\\n plt.hist([Y_train1, Y_dev1, Y_test1], label = ['training', 'cross-validation', 'test'], density = True)\\n plt.xlabel(\\\"charge\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.legend()\\n plt.show()\\n\\n return None\",\n \"def plot_loss_curves(results):\\n loss = results[\\\"train_loss\\\"]\\n test_loss = results[\\\"test_loss\\\"]\\n\\n accuracy = results[\\\"train_acc\\\"]\\n test_accuracy = results[\\\"test_acc\\\"]\\n\\n epochs = range(len(results[\\\"train_loss\\\"]))\\n\\n plt.figure(figsize=(15, 7))\\n\\n # Plot loss\\n plt.subplot(1, 2, 1)\\n plt.plot(epochs, loss, label=\\\"train_loss\\\")\\n plt.plot(epochs, test_loss, label=\\\"test_loss\\\")\\n plt.title(\\\"Loss\\\")\\n plt.xlabel(\\\"Epochs\\\")\\n plt.legend()\\n\\n # Plot accuracy\\n plt.subplot(1, 2, 2)\\n plt.plot(epochs, accuracy, label=\\\"train_accuracy\\\")\\n plt.plot(epochs, test_accuracy, label=\\\"test_accuracy\\\")\\n plt.title(\\\"Accuracy\\\")\\n plt.xlabel(\\\"Epochs\\\")\\n plt.legend()\",\n \"def example():\\n accShape, accTexture, accFinal = train_and_eval_all_models()\\n print(f'Accuracy -- only shape: {accShape}; only texture: {accTexture}; combined: {accFinal}.')\",\n \"def cross_validation_visualization(lambds, score_tr, score_te):\\n plt.semilogx(lambds, score_tr, marker=\\\".\\\", color='b', label='train score');\\n plt.semilogx(lambds, score_te, marker=\\\".\\\", color='r', label='test score');\\n plt.xlabel(\\\"lambda\\\")\\n plt.ylabel(\\\"score\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation_test\\\")\",\n \"def plot_run_basic():\\n # Define files prefix, model variables to plot and title\\n str_learning_rate = ['lr_', 'learning_rate', 'Learning rate', 'LR']\\n str_f_number = ['f_', 'F', 'Filter number', 'F']\\n str_regular = ['reg_param_', 'reg_par', 'Regularization', 'RP']\\n\\n fig = plt.figure(figsize=(16,12))\\n # Plot learning rate\\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_learning_rate[0], str_learning_rate[1])\\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_learning_rate[2], str_learning_rate[3], [2,2,1])\\n # Plot F number\\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_f_number[0], str_f_number[1])\\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_f_number[2], str_f_number[3], [2,2,2])\\n # Plot Regularization\\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_regular[0], str_regular[1])\\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_regular[2], str_regular[3], [2,2,3])\\n plt.suptitle('Validation accuracy - Sweep parameters', fontsize=20)\\n plt.show();\\n \\n # Save as PDF file if wanted\\n if DataLoader.SAVE_FIGURE:\\n DataLoader.save_plot(fig, 'sweep_parameters_CNN.pdf')\",\n \"def plot_results(sgd_train_acc, sgd_train_std, sgd_heldout_acc, sgd_heldout_std, sgd_test_acc,\\n dt_train_acc, dt_train_std, dt_heldout_acc, dt_heldout_std, dt_test_acc,\\n dt4_train_acc, dt4_train_std, dt4_heldout_acc, dt4_heldout_std, dt4_test_acc,\\n stumps_train_acc, stumps_train_std, stumps_heldout_acc, stumps_heldout_std, stumps_test_acc):\\n train_x_pos = [0, 4, 8, 12]\\n cv_x_pos = [1, 5, 9, 13]\\n test_x_pos = [2, 6, 10, 14]\\n ticks = cv_x_pos\\n\\n labels = ['sgd', 'dt', 'dt4', 'stumps (4 x 50)']\\n\\n train_accs = [sgd_train_acc, dt_train_acc, dt4_train_acc, stumps_train_acc]\\n train_errors = [sgd_train_std, dt_train_std, dt4_train_std, stumps_train_std]\\n\\n cv_accs = [sgd_heldout_acc, dt_heldout_acc, dt4_heldout_acc, stumps_heldout_acc]\\n cv_errors = [sgd_heldout_std, dt_heldout_std, dt4_heldout_std, stumps_heldout_std]\\n\\n test_accs = [sgd_test_acc, dt_test_acc, dt4_test_acc, stumps_test_acc]\\n\\n fig, ax = plt.subplots()\\n ax.bar(train_x_pos, train_accs, yerr=train_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='train')\\n ax.bar(cv_x_pos, cv_accs, yerr=cv_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='held-out')\\n ax.bar(test_x_pos, test_accs, align='center', alpha=0.5, capsize=10, label='test')\\n ax.set_ylabel('Accuracy')\\n ax.set_xticks(ticks)\\n ax.set_xticklabels(labels)\\n ax.set_title('Models')\\n ax.yaxis.grid(True)\\n ax.legend()\\n plt.tight_layout()\",\n \"def plot_training_history(history):\\n fig, (ax_loss, ax_acc) = plt.subplots(1, 2, figsize=(15, 5))\\n ax_loss.plot(history.epoch, history.history[\\\"loss\\\"], label=\\\"Train loss\\\")\\n ax_loss.plot(history.epoch, history.history[\\\"val_loss\\\"], label=\\\"Validation loss\\\")\\n ax_loss.legend()\\n ax_acc.plot(history.epoch, history.history[\\\"iou_score\\\"], label=\\\"Train iou\\\")\\n ax_acc.plot(history.epoch, history.history[\\\"val_iou_score\\\"], label=\\\"Validation iou\\\")\\n ax_acc.legend()\",\n \"def plot_errors(loss_train, loss_val, jet):\\n plt.plot(list(range(len(loss_train))), loss_train, 'g', label='Training loss')\\n plt.plot(list(range(len(loss_val))), loss_val, 'b', label='Validation loss')\\n plt.title('Training and Validation loss for jet: {jet}'.format(jet=jet))\\n plt.xlabel('Epochs')\\n plt.ylabel('Loss')\\n plt.legend()\\n plt.show()\",\n \"def plot_train_test_data(train, test):\\n fig = plt.figure()\\n ax1 = fig.add_subplot(1, 2, 1)\\n ax1.spy(train, precision=0.01, markersize=0.5)\\n ax1.set_xlabel(\\\"Users\\\")\\n ax1.set_ylabel(\\\"Items\\\")\\n ax1.set_title(\\\"Training data\\\")\\n ax2 = fig.add_subplot(1, 2, 2)\\n ax2.spy(test, precision=0.01, markersize=0.5)\\n ax2.set_xlabel(\\\"Users\\\")\\n ax2.set_ylabel(\\\"Items\\\")\\n ax2.set_title(\\\"Test data\\\")\\n plt.tight_layout()\\n plt.savefig(\\\"../results/train_test\\\")\\n plt.show()\",\n \"def show_accuracy(self):\\r\\n return round(accuracy_score(self.actual, self.predicted),2)\",\n \"def plot_train(func):\\n def plotting_func(model, train_config, arch, data_loader, epoch, handle_dict, optimizers):\\n output_dict = func(model, train_config, arch, data_loader, epoch, optimizers)\\n metrics = [output_dict['avg_elbo'], output_dict['avg_cond_log_like'], output_dict['avg_kl']]\\n plot_average_metrics(metrics, epoch, handle_dict, 'Train')\\n plot_param_grad_mags(output_dict['avg_param_grad_mags'], epoch, handle_dict)\\n plot_state_grad_mags(output_dict['avg_state_grad_mags'], epoch, handle_dict)\\n plot_opt_lr(optimizers, epoch, handle_dict)\\n return output_dict, handle_dict\\n return plotting_func\",\n \"def accuracy(self, X_train, X_test):\\n loss, accuracy = self.estimator.evaluate(X_test, X_train)\\n return accuracy\",\n \"def __init__(self, experiment_count: int, total_tr_data: int, tr_accuracy: [int], total_test_data: int,\\n test_accuracy: [int], function_name: str, batch_size: int, title: str=\\\"CNN Accuracy Plot\\\"):\\n self.title = title\\n self.total_tr_data = total_tr_data\\n self.total_test_data = total_test_data\\n\\n # accuracy and last epoch\\n self.tr_accuracy = tr_accuracy.ravel()\\n self.last_epoch = str(int(self.tr_accuracy[CFG.EPOCHS - 1]))\\n self.last_epoch_per = self.tr_accuracy[CFG.EPOCHS - 1]\\n self.tr_mean = np.mean(self.tr_accuracy[-(CFG.EPOCHS - 10):])\\n self.tr_mean_str = \\\"{:.2f}\\\".format(self.tr_mean)\\n\\n self.test_accuracy = test_accuracy.ravel()\\n self.last_epoch = str(int(self.test_accuracy[CFG.EPOCHS - 1]))\\n self.last_epoch_per = self.test_accuracy[CFG.EPOCHS - 1]\\n self.test_mean = np.mean(self.test_accuracy[-(CFG.EPOCHS - 10):])\\n self.test_mean_str = \\\"{:.2f}\\\".format(self.test_mean)\\n\\n # hyperparameters and string equivalents (for formatting easily in overleaf)\\n self.function_name = function_name\\n self.batch_size = batch_size\\n\\n # data table specifications\\n self.cell_length = len(str(\\\" \\\" + str(self.total_tr_data) + \\\"/\\\" + str(self.total_tr_data) + \\\" \\\"))\\n self.total_cells = 3\\n self.max_length = (self.cell_length + 1) * (self.total_cells)\\n self.tablefile = \\\"table.txt\\\"\\n self.experiment_count = experiment_count\",\n \"def plot_train_and_valid_curves(ax, train_points, valid_points, learning_rate_updates_epoch, best_per_lr, mode=\\\"loss\\\"):\\n if mode==\\\"loss\\\":\\n name = \\\"Loss\\\"\\n names = \\\"losses\\\"\\n factor = [1.2, 1.22]\\n loc_legend = 1\\n elif mode ==\\\"acc\\\":\\n name = \\\"Accuracy\\\"\\n names = \\\"acc\\\"\\n factor = [0.9, 0.88]\\n loc_legend = 4\\n else:\\n print \\\"Mode not understood. Available modes : 'loss' and 'acc'\\\"\\n return\\n\\n #ax = plt.subplot(1,1,1)#\\n # Plot training and valid loss curves\\n ax.plot(np.arange(len(train_points)),train_points, c=\\\"k\\\", zorder=1)\\n ax.plot(np.arange(len(valid_points)),valid_points, c=\\\"k\\\", zorder=1)\\n ax.scatter(np.arange(len(train_points)),train_points, c=\\\"b\\\", label=\\\"Train %s\\\"%names, zorder=2)\\n ax.scatter(np.arange(len(valid_points)),valid_points, c=\\\"r\\\", label=\\\"Valid %s\\\"%names, zorder=2)\\n # Plot vertical line when the learning rate was updated\\n first = True\\n for elem in learning_rate_updates_epoch:\\n if first:\\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\\\"k\\\", label=\\\"LR updates\\\", linestyle=\\\"--\\\")\\n first = False\\n else:\\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\\\"k\\\", linestyle=\\\"--\\\")\\n # Plot best model in each region\\n first = True\\n for i,elem in enumerate(best_per_lr):\\n if first:\\n x = elem[0]\\n y = elem[1]\\n plt.scatter(x,y, c=\\\"g\\\", label=\\\"Best models\\\", marker=\\\"*\\\", zorder=3, s=100)\\n plt.plot([x,x],[y,factor[0]*y], c=\\\"g\\\")\\n plt.text(x,factor[1]*y, \\\"Epoch %d\\\"%(x), fontsize=8)\\n first = False\\n else:\\n x = elem[0]+learning_rate_updates_epoch[i-1]\\n y = elem[1]\\n plt.scatter(x,y, c=\\\"g\\\", marker=\\\"*\\\", zorder=3, s=100)\\n plt.plot()\\n plt.plot([x,x],[y,factor[0]*y], c=\\\"g\\\")\\n plt.text(x,factor[1]*y, \\\"Epoch %d\\\"%(x), fontsize=8)\\n # Xlim, Ylim, labels, legend...\\n ax.set_ylim([0,1])\\n ax.set_xlim([0,len(train_points)+5])\\n ax.set_xlabel(\\\"Epochs\\\")\\n ax.set_ylabel(name)\\n handles,labels = ax.get_legend_handles_labels()\\n sorted_zip = sorted(zip([2,0,1,3],handles, labels))\\n index, handles, labels = zip(*sorted_zip)\\n ax.legend(handles,labels, loc=loc_legend, prop={'size':10})\",\n \"def _accuracy(net, data_loader):\\n net.train(False)\\n\\n num_correct = 0\\n num_total = 0\\n for X, y in data_loader:\\n # Data.\\n X = torch.autograd.Variable(X.cuda())\\n y = torch.autograd.Variable(y.cuda())\\n X.requires_grad = True\\n # Prediction.\\n score = net(X)\\n _, prediction = torch.max(score.data, 1)\\n num_total += y.size(0)\\n num_correct += torch.sum(prediction == y.data).item()\\n net.train(True) # Set the model to training phase\\n return 100 * num_correct / num_total\",\n \"def graph_results(loss, acc):\\n N = len(loss)\\n x = np.linspace(0, N, N)\\n plt.subplot(1,2,1)\\n plt.plot(x, loss)\\n plt.subplot(1,2,2)\\n plt.plot(x,acc)\\n plt.show()\",\n \"def validate_and_plot_one_class(normal,outliers):\\n print \\\"running a validation\\\"\\n \\n #classifier\\n \\n train_data = genfromtxt(normal, delimiter='\\\\t',skip_header=0)\\n test_data = genfromtxt(outliers, delimiter='\\\\t',skip_header=0)\\n\\n outliers_proportion = float(test_data.shape[0])/(float(train_data.shape[0])+float(test_data.shape[0]))\\n outliers_proportion=0.01\\n\\n clf = OneClassSVMClassifier(normal,outliers_proportion,0.95,0.05)\\n #processing data without targets\\n X_train = clf.scale(train_data)\\n X_test = clf.scale(test_data)\\n\\n y_pred_train = clf.predict(X_train)\\n y_pred_test = clf.predict(X_test)\\n n_error_train = y_pred_train[y_pred_train == 1].size\\n n_error_test = y_pred_test[y_pred_test == -1].size\\n \\n X=np.vstack((X_train,X_test))\\n y_score = clf.predict(X)\\n\\n Y1=np.ones((X_train.shape[0],))\\n Y2=(np.ones((X_test.shape[0],))*-1)\\n y_true=np.concatenate((Y1,Y2))\\n \\n # Compute ROC curve and area the curve\\n fpr, tpr, thresholds = metrics.roc_curve(y_true,y_score)\\n roc_auc = metrics.auc(fpr, tpr)\\n print \\\"Area under the ROC curve : %f\\\" % roc_auc\\n \\n # Plot ROC curve\\n\\n fig = matplotlib.pyplot.gcf()\\n fig.set_size_inches(6.5,6.5)\\n #font = {'family' : 'sans-serif',\\n # 'weight' : 'normal',\\n # 'size' : 18}\\n\\n #matplotlib.rc('font', **font)\\n pl.clf()\\n #modify plot area\\n #modify tick label font size\\n ax = pl.gca() # get the current axes\\n for l in ax.get_xticklabels() + ax.get_yticklabels():\\n l.set_fontsize('x-large')\\n\\n #color from html code table, linewidth x2.0\\n pl.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc,color=\\\"#00CC66\\\",linewidth=3.0)\\n# pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\\\"#009900\\\",linewidth=3.0)\\n# pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\\n# pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\\n# pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\\n #for more lines with different kernels\\n #default_kernel=\\\"sigmoid\\\";clf = hermes.OneClassSVMClassifier(train,0.00,0.0,0.0595,default_kernel);y_score_sigmoid = clf.predict(X);fpr_sigmoid, tpr_sigmoid, thresholds_sigmoid = metrics.roc_curve(y_true,y_score_sigmoid);roc_auc_sigmoid = metrics.auc(fpr_sigmoid, tpr_sigmoid);fpr_sigmoid;tpr_sigmoid;roc_auc_sigmoid\\n #pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\\\"#00CC66\\\",linewidth=2.0)\\n #pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\\n #pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\\n #pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\\n pl.plot([0, 1], [0, 1], 'k--')\\n #modify base font size\\n pl.xlim([0.0, 1.0])\\n pl.ylim([0.0, 1.0])\\n pl.xlabel('False positive rate',fontsize='xx-large')\\n pl.ylabel('True positive rate',fontsize='xx-large')\\n #pl.title('Receiver operating characteristic example')\\n pl.legend(loc=\\\"lower right\\\",prop={'size':18})\\n pl.show()\\n sys.exit(0)\\n ##the code here below was used to create the ROC curve for europar 13\",\n \"def plot_train_history(modell=config.model):\\n history = pd.read_csv(f'model/this/{modell}_history.csv')\\n epochs = len(history.epoch)\\n\\n plt.style.use(\\\"ggplot\\\")\\n plt.rcParams['figure.figsize'] = (5, 9)\\n plt.plot(np.arange(0, epochs), history[\\\"accuracy\\\"], label=\\\"model accuracy\\\", color=\\\"red\\\", zorder=10, linewidth=2)\\n plt.plot(np.arange(0, epochs), history[\\\"loss\\\"], label=\\\"training loss\\\", color=\\\"blue\\\", zorder=9, linewidth=2)\\n plt.plot(np.arange(0, epochs), history[\\\"val_accuracy\\\"], label=\\\"validation accuracy\\\", color=\\\"red\\\", zorder=1, linewidth=1, alpha= 0.4)\\n plt.plot(np.arange(0, epochs), history[\\\"val_loss\\\"], label=\\\"validation loss\\\", color=\\\"blue\\\", zorder=2, linewidth=1, alpha= 0.4)\\n plt.hlines(1.0,0, epochs, colors=\\\"black\\\", linestyles=\\\"dotted\\\")\\n plt.title(f'Trening av modell: {modell}')\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Accuracy / Loss\\\")\\n plt.ylim(0, 2.)\\n plt.yticks(np.append(np.arange(0, 1., 0.05), (np.arange(1, 2., 0.2) )))\\n\\n plt.xlim(0, epochs)\\n plt.legend(loc=\\\"upper right\\\")\\n plt.tight_layout(True)\\n\\n xint = []\\n locs, labels = plt.xticks()\\n for each in locs:\\n xint.append(int(each))\\n plt.xticks(xint)\\n\\n plt.savefig(f'model/this/{modell}.png')\\n plt.show()\",\n \"def plotHistory(history):\\n \\n acc = history.history['acc']\\n val_acc = history.history['val_acc']\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n\\n epochs = range(len(acc))\\n \\n # Make and save the plot for our accuracy\\n plt.plot(epochs, acc, 'bo', label='Training acc')\\n plt.plot(epochs, val_acc, 'b', label='Validation acc')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n plt.savefig(\\\"trainValAccSecond.png\\\")\\n\\n # Make and save the plots for our loss \\n plt.figure()\\n plt.plot(epochs, loss, 'bo', label='Training loss')\\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n plt.show()\\n plt.savefig(\\\"trainValLossSecond.png\\\")\",\n \"def classificationError():\\n print('Computing Classification Test Error')\\n\\n dl1, dl2 = CIFAR10TestLoader() \\n err1, err2 = [], []\\n\\n # load every model \\n with open('classification_error.csv','w') as clf:\\n writer = csv.writer(clf)\\n writer.writerow(['Classification Error Dataset 1','Classification Error Dataset 2'])\\n\\n for i in tqdm(range(5,95,2)):\\n mtl = MTL()\\n PATH = os.getcwd() + '/mtl_model_{d1}_vs_{d2}.pth'.format(d1=i, d2=100-i)\\n mtl.load_state_dict(state_dict=torch.load(PATH))\\n\\n e1, e2 = accuracy(dl1, mtl), accuracy(dl2, mtl)\\n err1.append(e1)\\n err2.append(e2)\\n writer.writerow([e1,e2])\\n \\n fig, ax_left = plt.subplots()\\n ax_right = ax_left.twinx()\\n ax_left.plot([0.05 + 0.02* i for i in range(45)], err1, color='black')\\n ax_right.plot([0.05 + 0.02* i for i in range(45)], err2, color='red')\\n ax_right.set_ylabel('Dataset 2 (red) accuracy')\\n ax_left.set_ylabel('Dataset 1 (black) accuracy')\\n ax_left.set_xlabel('Percentage of points from dataset 1 in training set')\\n plt.title('Classification Accuracy over both datasets')\\n plt.savefig('classification_error_plots.pdf')\",\n \"def plot_train_history(self):\\n plt.figure()\\n plt.xlabel('Epochs')\\n plt.ylabel('Loss')\\n plt.plot(self.train_history.history['loss'])\\n plt.plot(self.train_history.history['val_loss'])\\n plt.legend(['Training', 'Validation'])\\n\\n plt.show()\",\n \"def accuracy_hist(pred_proba_samples, labels):\\n\\tsampled_acc = sampled_accuracies(pred_proba_samples, labels)\\n\\tavg_accuracy = round(np.mean(sampled_acc) * 100, 3)\\n\\tprint(\\\"average accuracy across \\\" + str(pred_proba_samples.shape[0]) + \\\" samples: \\\" + str(avg_accuracy) + \\\"%\\\\n\\\")\\n\\tfig, ax = plt.subplots(figsize=(10,5))\\n\\tsns.distplot(100*sampled_acc, ax=ax, rug=True, kde=False)\\n\\tax.set_xlabel(\\\"Test set accuracy (%)\\\", fontsize=30)\\n\\tax.set_ylabel(\\\"Frequency density\\\", fontsize=30);\\n\\tax.tick_params(\\\"both\\\", labelsize=15)\\n\\treturn sampled_acc\",\n \"def show_training(history: tf.keras.callbacks.History) -> None:\\n hist = history.history\\n\\n if \\\"loss\\\" not in hist:\\n print(\\\"Error: 'loss' values not found in the history\\\")\\n return\\n\\n # plot training\\n plt.figure(figsize=(14, 4))\\n plt.subplot(121)\\n plt.plot(hist[\\\"loss\\\"], label=\\\"Training\\\")\\n if \\\"val_loss\\\" in hist:\\n plt.plot(hist[\\\"val_loss\\\"], label=\\\"Validation\\\")\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"loss\\\")\\n plt.legend()\\n\\n if \\\"accuracy\\\" in hist:\\n plt.subplot(122)\\n plt.plot(hist[\\\"accuracy\\\"], label=\\\"Training\\\")\\n if \\\"val_accuracy\\\" in hist:\\n plt.plot(hist[\\\"val_accuracy\\\"], label=\\\"Validation\\\")\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"accuracy\\\")\\n plt.legend()\\n\\n plt.suptitle(\\\"Training history\\\")\\n plt.show()\\n\\n # show final results\\n print(\\\"\\\\nTraining loss: \\\\t{:.4f}\\\".format(hist[\\\"loss\\\"][-1]))\\n if \\\"val_loss\\\" in hist:\\n print(\\\"Validation loss: \\\\t{:.4f}\\\".format(hist[\\\"val_loss\\\"][-1]))\\n if \\\"accuracy\\\" in hist:\\n print(\\\"\\\\nTraining accuracy: \\\\t{:.3f}\\\".format(hist[\\\"accuracy\\\"][-1]))\\n if \\\"val_accuracy\\\" in hist:\\n print(\\\"Validation accuracy:\\\\t{:.3f}\\\".format(hist[\\\"val_accuracy\\\"][-1]))\",\n \"def plot_train_test_data(train, test):\\n fig = plt.figure()\\n ax1 = fig.add_subplot(1, 2, 1)\\n ax1.spy(train, precision=0.01, markersize=0.5)\\n ax1.set_xlabel(\\\"Users\\\")\\n ax1.set_ylabel(\\\"Items\\\")\\n ax1.set_title(\\\"Training data\\\")\\n ax2 = fig.add_subplot(1, 2, 2)\\n ax2.spy(test, precision=0.01, markersize=0.5)\\n ax2.set_xlabel(\\\"Users\\\")\\n ax2.set_ylabel(\\\"Items\\\")\\n ax2.set_title(\\\"Test data\\\")\\n plt.tight_layout()\\n plt.savefig(\\\"train_test\\\")\\n plt.show()\",\n \"def plot_train_test_data(train, test):\\n fig = plt.figure(figsize=(16, 8))\\n ax1 = fig.add_subplot(1, 2, 1)\\n ax1.spy(train, precision=0.01, markersize=0.05, aspect=\\\"auto\\\")\\n ax1.set_xlabel(\\\"Users\\\")\\n ax1.set_ylabel(\\\"Items\\\")\\n ax1.set_title(\\\"Training data\\\")\\n ax2 = fig.add_subplot(1, 2, 2)\\n ax2.spy(test, precision=0.01, markersize=0.05, aspect=\\\"auto\\\")\\n ax2.set_xlabel(\\\"Users\\\")\\n ax2.set_ylabel(\\\"Items\\\")\\n ax2.set_title(\\\"Test data\\\")\\n plt.tight_layout()\\n plt.savefig(\\\"train_test\\\")\\n plt.show()\",\n \"def plot_roc_acc(self,x_test,y_test):\\n if self.validated:\\n preds = self.model_cv.predict_proba(x_test[self.feats])\\n fpr, tpr, thresholds = metrics.roc_curve(y_test, preds[:,1])\\n auc = metrics.roc_auc_score(y_test, preds[:,1])\\n\\n # get accuracy of class0 and class1 predictions at different thresholds\\n acc_0 = []\\n acc_1 = []\\n for ind,th in enumerate(thresholds):\\n binary_preds = pred_from_prob(preds,th)\\n acc_1.append(accuracy_score(y_test[np.where(y_test==1)],binary_preds[np.where(y_test==1)]))\\n acc_0.append(accuracy_score(y_test[np.where(y_test==0)],binary_preds[np.where(y_test==0)]))\\n\\n # set up plotting parameters\\n sns.set()\\n mpl.rcParams['figure.figsize']=[15.0,5.0]\\n mpl.rcParams['lines.linewidth']=2.0\\n mpl.rcParams['xtick.labelsize']=13\\n mpl.rcParams['ytick.labelsize']=13\\n mpl.rcParams['axes.labelsize']=15\\n mpl.rcParams['axes.labelweight']='heavy'\\n mpl.rcParams['axes.titlesize']=18\\n mpl.rcParams['axes.titleweight']='heavy'\\n mpl.rcParams['legend.fontsize']=12\\n\\n # build the plots- ROC in subplot 1, accuracy in subplot 2\\n plt.subplot(1,2,1)\\n plt.plot(fpr,tpr,'r*', label='roc auc={:.4f}'.format(auc))\\n plt.plot(np.linspace(0,1,20),np.linspace(0,1,20),'k--')\\n plt.xlabel('FPR')\\n plt.ylabel('TPR')\\n plt.title('ROC')\\n plt.legend(frameon=False)\\n plt.xlim([0.0,1.0])\\n plt.ylim([0.0,1.0])\\n\\n plt.subplot(1,2,2)\\n plt.plot(thresholds,acc_0,'go--',label='cases: 0',alpha=0.3)\\n plt.plot(thresholds,acc_1,'yo--',label='cases: 1')\\n plt.plot(thresholds[::5],fpr[::5],'c*',alpha=0.2,label='fpr')\\n\\n plt.xlim([0,1])\\n plt.xlim([0,1])\\n\\n plt.xlabel('threshold')\\n plt.ylabel('accuracy')\\n plt.title('accuracy')\\n\\n plt.legend(frameon=False)\\n\\n plt.show()\\n return None\\n else:\\n raise err.NotYetFittedModelError('You should train the model with method train_CV first \\\\n')\",\n \"def learning_viz(self) :\\n self.train\\n history = self.history\\n plot_loss(history)\",\n \"def run_analyses(y_predict_train, y_train, y_predict, y_test):\\n # calculate metrics\\n _, training_error = output_error(y_predict_train, y_train)\\n (precision, recall, f1, _), testing_error = output_error(y_predict, y_test)\\n \\n # print out metrics\\n print 'Average Precision:', np.average(precision)\\n print 'Average Recall:', np.average(recall)\\n print 'Average F1:', np.average(f1)\\n print 'Training Error:', training_error\\n print 'Testing Error:', testing_error\",\n \"def plot_training_results(clfs, train_scores, test_scores):\\n\\n # Set graph format\\n sns.set_style(\\\"whitegrid\\\")\\n sns.set_context(\\\"paper\\\", font_scale=1, rc={\\\"lines.linewidth\\\": 1})\\n ax = plt.subplot(111)\\n w = 0.5\\n x = np.arange(len(train_scores))\\n ax.set_yticks(x + w)\\n ax.legend((train_scores[0], test_scores[0]), (\\\"Train Scores\\\", \\\"Test Scores\\\"))\\n names = ['SVC', 'LR', 'KNN', 'GNB', 'ADA', 'RF']\\n\\n # Loop throuugh classifiers\\n # clfnames = []\\n # for i in range(0, len(clfs)):\\n # # Define temporary variables\\n # clfname = clfnames[i]\\n # # clf_name = clf.__class__.__name__\\n # # Create and store name\\n # name = \\\"{}\\\".format(clf_name)\\n # names.append(name)\\n\\n # Plot all names in horizontal bar plot\\n ax.set_yticklabels((names), fontsize=20)\\n plt.xlim(0.5, 0.56)\\n plt.barh(x, test_scores, color='b', alpha=0.6)\\n plt.title(\\\"Test Data Accuracy Scores\\\", fontsize=30)\\n fig = plt.figure(1)\\n\\n plt.show()\",\n \"def plot_learning_curve(self, estimators, title, labels, colors, X, y, \\n ylim=None, cv=None, n_jobs=1, train_sizes=np.linspace(.1, 1.0, 10)):\\n plt.figure(figsize = (6,8))\\n plt.title(title)\\n if ylim is not None:\\n plt.ylim(*ylim)\\n plt.xlabel(\\\"Training examples\\\")\\n plt.ylabel(\\\"Accuracy\\\")\\n for i in range(len(estimators)): \\n estimator = estimators[i]\\n line_label = labels[i]\\n line_color = colors[i]\\n train_sizes, train_scores, test_scores = learning_curve(\\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\\n train_scores_mean = np.mean(train_scores, axis=1)\\n train_scores_std = np.std(train_scores, axis=1)\\n test_scores_mean = np.mean(test_scores, axis=1)\\n test_scores_std = np.std(test_scores, axis=1)\\n\\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\\n train_scores_mean + train_scores_std, alpha=0.1,\\n color=line_color[0])\\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\\n test_scores_mean + test_scores_std, alpha=0.1, color=line_color[1])\\n plt.plot(train_sizes, train_scores_mean, \\\"o-\\\", color=line_color[0],\\n label=line_label[0])#\\\"Training accuracy\\\"\\n plt.plot(train_sizes, test_scores_mean, \\\"o-\\\", color=line_color[1],\\n label=line_label[1]) #\\\"Cross-validation accuracy\\\"\\n\\n plt.grid() \\n plt.legend(bbox_to_anchor=(0., 1.05, 1., .105),loc=3, mode=\\\"expand\\\",\\n borderaxespad=0.)\\n plt.savefig(\\\"../Figures/\\\" + title + \\\".png\\\", bbox_inches=\\\"tight\\\")\\n return plt\",\n \"def train(self, x_train, y_train, x_val, y_val):\\n pass\",\n \"def visualize_train_data(train_df, fname):\\r\\n logger = custom_logger.CustomLogger(run_id+':'+file_id)\\r\\n fig, axs = plt.subplots(3, figsize=(15,15))\\r\\n fig.suptitle('EPEX Intraday Continuous market electricity prices')\\r\\n\\r\\n axs[0].plot(train_df.index, train_df['low'], color='red')\\r\\n axs[0].set_title(\\\"Lowest Price\\\")\\r\\n axs[0].set(xlabel='time', ylabel='price (Euros)')\\r\\n\\r\\n axs[1].plot(train_df.index, train_df['high'], color='green')\\r\\n axs[1].set_title(\\\"Highest Pice\\\")\\r\\n axs[1].set(xlabel='time', ylabel='price (Euros)')\\r\\n\\r\\n axs[2].plot(train_df.index, train_df['weight_avg'], color='blue')\\r\\n axs[2].set_title(\\\"volume-weighted Average Price\\\")\\r\\n axs[2].set(xlabel='time', ylabel='price (Euros)')\\r\\n\\r\\n fig.savefig(os.path.join(unique_op_dir, fname))\\r\\n logger.info('Training data plots stored at ', os.path.join(unique_op_dir, fname))\",\n \"def plot_training_curve(path):\\n import matplotlib.pyplot as plt\\n train_err = np.loadtxt(\\\"{}_train_err.csv\\\".format(path))\\n val_err = np.loadtxt(\\\"{}_val_err.csv\\\".format(path))\\n train_loss = np.loadtxt(\\\"{}_train_loss.csv\\\".format(path))\\n val_loss = np.loadtxt(\\\"{}_val_loss.csv\\\".format(path))\\n plt.title(\\\"Train vs Validation Error\\\")\\n n = len(train_err) # number of epochs\\n plt.plot(range(1,n+1), train_err, label=\\\"Train\\\")\\n plt.plot(range(1,n+1), val_err, label=\\\"Validation\\\")\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Error\\\")\\n plt.legend(loc='best')\\n plt.show()\\n plt.title(\\\"Train vs Validation Loss\\\")\\n plt.plot(range(1,n+1), train_loss, label=\\\"Train\\\")\\n plt.plot(range(1,n+1), val_loss, label=\\\"Validation\\\")\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Loss\\\")\\n plt.legend(loc='best')\\n plt.show()\",\n \"def model_evaluate(model,x_train,n_y_array,x_val, vald_array):\\n\\n scores = model.evaluate(x_train, n_y_array, verbose=1)\\n\\n scores2 = model.evaluate(x_val, vald_array, verbose=1)\\n\\n\\n print(\\\"for traininf set\\\")\\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[1], scores[1]*100))\\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[0], scores[0]))\\n\\n\\n\\n print(\\\"for validation set : \\\") \\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[1], scores2[1]*100))\\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[0], scores2[0]))\",\n \"def _accuracy(self, data_loader):\\n self._net.eval()\\n num_correct = 0.0\\n num_total = 0.0\\n batchindex = 0\\n for X, y in tqdm(data_loader):\\n # Data.\\n batchindex = batchindex + 1\\n X = X.to(self.device)\\n y = y.to(self.device)\\n # y = torch.tensor(y.to(device))\\n\\n # Prediction.\\n score = self._net(X)\\n _, prediction = torch.max(score.data, 1)\\n num_total += y.size(0)\\n num_correct += torch.sum(prediction == y.data)\\n self._net.train() # Set the model to training phase\\n return 100 * num_correct.float() / num_total\",\n \"def plot_training_history(history, title_str=''):\\n acc = history.history['accuracy']\\n val_acc = history.history['val_accuracy']\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n \\n epochs = range(len(acc))\\n\\n plt.plot(epochs, acc, 'r', label='Training accuracy')\\n plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy ' + title_str)\\n\\n ymin = min([min(acc), min(val_acc)])\\n\\n axes = plt.gca()\\n axes.set_xlim([0, len(acc)])\\n axes.set_ylim([ymin, 1])\\n\\n plt.legend(loc=0)\\n plt.figure()\\n plt.show\\n \\n plt.plot(epochs, loss, 'r', label='Training loss')\\n plt.plot(epochs, loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss ' + title_str)\\n\\n ymin = min([min(loss), min(val_loss)])\\n\\n axes = plt.gca()\\n axes.set_xlim([0, len(loss)])\\n axes.set_ylim([ymin, 1])\\n\\n plt.legend(loc=0)\\n plt.figure()\\n plt.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82207394","0.7538035","0.7494659","0.74623656","0.7418454","0.7315145","0.72615117","0.72388804","0.7238736","0.71817374","0.7173168","0.71567535","0.7148802","0.71439624","0.7055238","0.70549214","0.7051441","0.7018947","0.70176554","0.70033777","0.7001087","0.6958237","0.6939887","0.6918762","0.69102395","0.68957645","0.68901664","0.6884202","0.68812746","0.6877989","0.6861459","0.68359375","0.67855304","0.676801","0.6762611","0.67358005","0.6708029","0.6707698","0.6698784","0.6689324","0.6684138","0.6678899","0.66575336","0.66552967","0.66399175","0.66269225","0.66193837","0.6603766","0.6601602","0.6595419","0.6591567","0.65886754","0.6588018","0.6576763","0.65656537","0.6563575","0.65621495","0.6561807","0.6554814","0.6538236","0.6526339","0.6521073","0.65197664","0.64932895","0.6483726","0.6476397","0.6470617","0.64556885","0.64505553","0.6446605","0.6446581","0.6438081","0.64114857","0.64106303","0.6409704","0.640137","0.639599","0.6391665","0.637596","0.6373166","0.63729477","0.6371565","0.6368899","0.63671625","0.63620657","0.63571674","0.6351272","0.6342535","0.633625","0.6335624","0.6332028","0.6317152","0.63162553","0.63105524","0.63084435","0.6301581","0.6277638","0.6276913","0.62736684","0.6272024"],"string":"[\n \"0.82207394\",\n \"0.7538035\",\n \"0.7494659\",\n \"0.74623656\",\n \"0.7418454\",\n \"0.7315145\",\n \"0.72615117\",\n \"0.72388804\",\n \"0.7238736\",\n \"0.71817374\",\n \"0.7173168\",\n \"0.71567535\",\n \"0.7148802\",\n \"0.71439624\",\n \"0.7055238\",\n \"0.70549214\",\n \"0.7051441\",\n \"0.7018947\",\n \"0.70176554\",\n \"0.70033777\",\n \"0.7001087\",\n \"0.6958237\",\n \"0.6939887\",\n \"0.6918762\",\n \"0.69102395\",\n \"0.68957645\",\n \"0.68901664\",\n \"0.6884202\",\n \"0.68812746\",\n \"0.6877989\",\n \"0.6861459\",\n \"0.68359375\",\n \"0.67855304\",\n \"0.676801\",\n \"0.6762611\",\n \"0.67358005\",\n \"0.6708029\",\n \"0.6707698\",\n \"0.6698784\",\n \"0.6689324\",\n \"0.6684138\",\n \"0.6678899\",\n \"0.66575336\",\n \"0.66552967\",\n \"0.66399175\",\n \"0.66269225\",\n \"0.66193837\",\n \"0.6603766\",\n \"0.6601602\",\n \"0.6595419\",\n \"0.6591567\",\n \"0.65886754\",\n \"0.6588018\",\n \"0.6576763\",\n \"0.65656537\",\n \"0.6563575\",\n \"0.65621495\",\n \"0.6561807\",\n \"0.6554814\",\n \"0.6538236\",\n \"0.6526339\",\n \"0.6521073\",\n \"0.65197664\",\n \"0.64932895\",\n \"0.6483726\",\n \"0.6476397\",\n \"0.6470617\",\n \"0.64556885\",\n \"0.64505553\",\n \"0.6446605\",\n \"0.6446581\",\n \"0.6438081\",\n \"0.64114857\",\n \"0.64106303\",\n \"0.6409704\",\n \"0.640137\",\n \"0.639599\",\n \"0.6391665\",\n \"0.637596\",\n \"0.6373166\",\n \"0.63729477\",\n \"0.6371565\",\n \"0.6368899\",\n \"0.63671625\",\n \"0.63620657\",\n \"0.63571674\",\n \"0.6351272\",\n \"0.6342535\",\n \"0.633625\",\n \"0.6335624\",\n \"0.6332028\",\n \"0.6317152\",\n \"0.63162553\",\n \"0.63105524\",\n \"0.63084435\",\n \"0.6301581\",\n \"0.6277638\",\n \"0.6276913\",\n \"0.62736684\",\n \"0.6272024\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7705123"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":21488,"cells":{"query":{"kind":"string","value":"Plot the loss during training for the train and val datasets. Arguments"},"document":{"kind":"string","value":"def plot_loss(model_fit, save_folder): \n train_loss = model_fit.history['loss']\n val_loss = model_fit.history['val_loss']\n epoch_axis = np.arange(1, len(train_loss) + 1)\n plt.title('Train vs Validation Loss')\n plt.plot(epoch_axis, train_loss, 'b', label='Train Loss')\n plt.plot(epoch_axis, val_loss,'r', label='Val Loss')\n plt.xlim([1, len(train_loss)])\n plt.xticks(np.arange(min(epoch_axis), max(epoch_axis) + 1, round((len(train_loss) / 10) + 0.5)))\n plt.legend(loc='upper right')\n plt.ylabel('Loss')\n plt.xlabel('Epochs')\n plt.savefig(save_folder + '/loss.png')\n plt.show()\n plt.close()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def loss_plot(train_loss, val_loss, filename):\n\tplt.plot(train_loss)\n\tplt.plot(val_loss)\n\tplt.ylabel('Loss')\n\tplt.xlabel('Epochs')\n\tplt.legend(['Train', 'Val'], loc='upper right')\n\tplt.savefig(filename)\n\tplt.close()","def plot_loss():\n df = pd.read_csv('data/loss.csv', encoding='utf-8')\n loss = df['loss'].values\n val_loss = df['val_loss'].values\n x = [i for i in range(1, len(loss) + 1)]\n\n plt.plot(x, loss, label='Train loss')\n plt.plot(x, val_loss, label='Val loss')\n\n plt.xlabel('Epochs')\n plt.ylabel('Contrastive Loss')\n plt.title('Train and test loss')\n plt.grid(True)\n plt.legend(shadow=True, fontsize='x-large')\n\n plt.show()","def plot_loss(stats):\r\n plt.plot(stats['train_loss_ind'], stats['train_loss'], label='Training loss')\r\n plt.plot(stats['val_loss_ind'], stats['val_loss'], label='Validation loss')\r\n plt.legend()\r\n plt.xlabel('Number of iterations')\r\n plt.ylabel('Loss')\r\n plt.show()","def plot_loss(training_errors, validation_errors):\n plt.xscale('Log')\n plt.xlabel('Epochs')\n plt.ylabel('Mean Actual Error')\n plt.plot(training_errors, label = \"Training Error\", \\\n color = 'blue')\n plt.plot(validation_errors, label = \"Validation Error\", \\\n color = 'red')\n plt.legend()\n # Saves plot automatically, adjust filename as needed.\n plt.savefig('reservoir_05whdens_100h_7spec_test_3.png')\n plt.show()","def plot_errors(loss_train, loss_val, jet):\n plt.plot(list(range(len(loss_train))), loss_train, 'g', label='Training loss')\n plt.plot(list(range(len(loss_val))), loss_val, 'b', label='Validation loss')\n plt.title('Training and Validation loss for jet: {jet}'.format(jet=jet))\n plt.xlabel('Epochs')\n plt.ylabel('Loss')\n plt.legend()\n plt.show()","def plot_train_val_loss(path_to_file, train_filename, val_filename):\n path = '../'\n labels = ['gen_total_loss', 'gen_loss', 'l1_loss', 'disc_total_loss', 'disc_gen_loss', 'disc_real_loss']\n with open(path_to_file + train_filename + '.csv', newline='') as f:\n reader = csv.reader(f)\n train_data = np.array(list(reader))\n with open(path_to_file + val_filename + '.csv', newline='') as f:\n reader = csv.reader(f)\n val_data = np.array(list(reader))\n\n if train_data.shape == val_data.shape:\n # change label number for the type of loss that should be plotted\n label = 0\n print(train_data.shape, val_data.shape)\n epoch_count = range(1, train_data.shape[0] + 1)\n plt.figure()\n plt.plot(epoch_count, val_data[:len(epoch_count), label].astype('float32'))\n plt.plot(epoch_count, train_data[:len(epoch_count), label].astype('float32'))\n plt.legend(['validation', 'train'])\n plt.xlabel('Epoch')\n plt.ylabel(labels[label])\n plt.show()","def plot_loss(x, loss_train, loss_valid, title):\n plt.figure()\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.title(title)\n plt.plot(x, loss_train, '-b', label='Training')\n plt.plot(x, loss_valid, '-r', linestyle=(0, (1, 2)), label='Validation')\n plt.legend([\"Training\", \"Validation\"], loc=\"upper right\", frameon=False)\n plt.yscale(\"log\")\n # plt.show()\n plt.savefig('{}.png'.format(title))","def plot_losses(train, test, mode):\n\tplt.figure()\n\tplt.plot(range(len(train)), train, 'r', label='Training')\n\tplt.plot(range(len(test)), test, 'b', label='Testing')\n\tplt.title('MSE Loss (batch type: ' + mode + ')')\n\tplt.legend()\n\tplt.show()","def plot_loss(self):\n train_elbo_range = range(len(self.train_elbo_hist))\n val_elbo_range = range(len(self.val_elbo_hist))\n train_loss_range = range(len(self.train_loss_hist))\n val_loss_range = range(len(self.val_loss_hist))\n\n fig, ax = plt.subplots(2, 2)\n ax[0][0].plot(train_elbo_range, self.train_elbo_hist)\n ax[0][0].title.set_text(\"Train ELBO\")\n ax[0][1].plot(val_elbo_range, self.val_elbo_hist)\n ax[0][1].title.set_text(\"Val ELBO\")\n ax[1][0].plot(train_loss_range, self.train_loss_hist)\n ax[1][0].title.set_text(\"Train MSE\")\n ax[1][1].plot(val_loss_range, self.val_loss_hist)\n ax[1][1].title.set_text(\"Val MSE\")\n plt.tight_layout()\n plt.show()","def plot_loss (history):\n \n history_dict = history.history\n loss_values = history_dict['loss']\n val_loss_values = history_dict['val_loss']\n epochs = range(1, len(loss_values) + 1)\n\n plt.plot (epochs, loss_values, 'bo', label='Training loss')\n plt.plot (epochs, val_loss_values, 'b', label=\"validation loss\")\n plt.title('Training and validation loss')\n plt.xlabel('Epochs')\n plt.ylabel('Loss')\n plt.legend()\n plt.show()","def plot_curve(self):\n x1 = np.arange(self.init_epoch, self.params.num_epoch+1, dtype=np.int).tolist()\n x2 = np.linspace(self.init_epoch, self.epoch,\n num=(self.epoch-self.init_epoch)//self.params.val_every+1, dtype=np.int64)\n plt.plot(x1, self.train_loss, label='train_loss')\n plt.plot(x2, self.val_loss, label='val_loss')\n plt.legend(loc='best')\n plt.title('Train/Val loss')\n plt.grid()\n plt.xlabel('Epoch')\n plt.ylabel('Loss')\n plt.show()","def plot_loss_vs_epoch(history, var_train, var_val, show=False):\n plt.figure(figsize=(10, 8))\n plt.grid(True)\n plt.plot(history.history['loss']/var_train, marker=\"o\")\n plt.plot(history.history['val_loss']/var_val, marker=\"o\")\n plt.title('Model Loss')\n plt.ylabel('Loss (Normalised to variance of dataset)')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validation'])\n # plt.ylim(bottom=0)\n filename = \"img/\"\n filename += datetime.now().strftime(\"%y%m%d_%H%M\")\n filename += \"_model_loss.png\"\n plt.savefig(filename)\n\n if show:\n plt.show()","def loss_graph(self, training_costs, test_costs, learning_rate, training_accuracy, test_accuracy, val_accuracy,\n layers, data_size, n_neighbours, dropout_layer, dropout_rate):\n\n plt.plot(training_costs, label=\"Training loss\")\n plt.plot(test_costs, label=\"Test loss\")\n plt.xlabel(\"Iterations\", size='medium')\n plt.ylabel(\"Cost function (%)\", size='medium')\n plt.suptitle(\"Cost function while training the neural network\", size='medium', ha='center')\n if True in dropout_layer:\n plt.title(\"layers: {}, dropout rate: {}, learning rate: {}\".format(layers, dropout_rate, learning_rate),\n size='small', ha='center')\n else:\n plt.title(\"layers: {}, learning rate: {}\".format(layers, learning_rate), size='small', ha='center')\n plt.figtext(0.77, 0.35, \"Training accuracy\\n{0:.2f}%\".format(training_accuracy), size='medium')\n plt.figtext(0.77, 0.25, \"Test accuracy\\n{0:.2f}%\".format(test_accuracy), size='medium')\n plt.figtext(0.77, 0.15, \"Validation accuracy\\n{0:.2f}%\".format(val_accuracy), size='medium')\n if n_neighbours == 0:\n plt.figtext(0.77, 0.80, \"Neighbours\\nexcluded\", size='medium')\n else:\n plt.figtext(0.77, 0.80, \"{} neighbours\\nincluded\".format(n_neighbours), size='medium')\n plt.figtext(0.77, 0.70, \"{}\\nsamples\".format(data_size))\n plt.legend(loc='right', bbox_to_anchor=(1.39, 0.5))\n plt.subplots_adjust(right=0.75)\n working_dir = os.path.dirname(os.path.abspath(__file__))\n saving(working_dir + \"/output_ANN/loss_plots/{}_error_{}\".format(n_neighbours, data_size))","def plot_loss(self):\n plt.plot(self.loss[10:], 'g+', label = \"loss\")\n plt.plot(self.loss[10:], 'r--', label = \"loss (smooth)\")\n plt.title(f\"Graph of loss after {len(self.loss)} steps of Gradient Descent.\")\n plt.xlabel('steps')\n plt.ylabel('loss')\n plt.legend()\n plt.show()","def plot_loss(G_losses, D_losses):\n plt.figure(figsize=(10,5))\n plt.title(\"Generator and Discriminator Loss During Training\")\n plt.plot(G_losses,label=\"G\")\n plt.plot(D_losses,label=\"D\")\n plt.xlabel(\"iterations\")\n plt.ylabel(\"Loss\")\n plt.legend()\n plt.show()","def graph(trainingLoss, validationLoss = None):\n style.use('fivethirtyeight')\n fig = plt.figure()\n ax1 = fig.add_subplot(1, 1, 1)\n ax1.cla()\n if validationLoss is not None:\n ax1.plot(np.array(range(len(trainingLoss))) + 1, validationLoss, label=\"Validation loss\")\n# print('Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}'.format(len(trainingLoss), trainingLoss[-1], validationLoss[-1]))\n# else:\n# print('Epoch: {} \\tTraining Loss: {:.6f}'.format(len(trainingLoss), trainingLoss[-1]))\n ax1.plot(np.array(range(len(trainingLoss))) + 1, trainingLoss, label=\"Training loss\")\n plt.legend(loc='best')\n plt.tight_layout()\n plt.show()","def train_visualization(output_path): \n log_path = output_path + 'output.log'\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\n n_epoch = len(Train_Cost)\n\n x1 = range(n_epoch)\n x2 = range(n_epoch)\n y1 = Train_Cost\n y2 = Valid_Cost\n y3 = Test_Cost\n y4 = Train_Acc\n y5 = Valid_Acc\n y6 = Test_Acc\n plt.subplot(2, 1, 1)\n plt.plot(x1, y1, label=\"Train_Cost\", linewidth=2)\n plt.plot(x1, y2, label=\"Valid_Cost\", linewidth=2)\n plt.plot(x1, y3, label=\"Test_Cost\", linewidth=2)\n\n plt.title('binary cross entropy vs. epoches')\n plt.ylabel('binary cross entropy')\n plt.legend(loc='best')\n plt.subplot(2, 1, 2)\n plt.plot(x2, y4, label=\"Train_Acc\", linewidth=2)\n plt.plot(x2, y5, label=\"Valid_Acc\", linewidth=2)\n plt.plot(x2, y6, label=\"Test_Acc\", linewidth=2)\n plt.xlabel('Accuracy@20 vs. epoches')\n plt.ylabel('Accuracy@20')\n plt.legend(loc='best')\n plt.savefig(output_path + 'loss_fig.png')\n # plt.show()","def plot_loss_curves(results):\n loss = results[\"train_loss\"]\n test_loss = results[\"test_loss\"]\n\n accuracy = results[\"train_acc\"]\n test_accuracy = results[\"test_acc\"]\n\n epochs = range(len(results[\"train_loss\"]))\n\n plt.figure(figsize=(15, 7))\n\n # Plot loss\n plt.subplot(1, 2, 1)\n plt.plot(epochs, loss, label=\"train_loss\")\n plt.plot(epochs, test_loss, label=\"test_loss\")\n plt.title(\"Loss\")\n plt.xlabel(\"Epochs\")\n plt.legend()\n\n # Plot accuracy\n plt.subplot(1, 2, 2)\n plt.plot(epochs, accuracy, label=\"train_accuracy\")\n plt.plot(epochs, test_accuracy, label=\"test_accuracy\")\n plt.title(\"Accuracy\")\n plt.xlabel(\"Epochs\")\n plt.legend()","def cross_validation_visualization(lambdas, loss_train, loss_test):\n plt.semilogx(lambdas, loss_train, marker=\".\", color='b', label='train error')\n plt.semilogx(lambdas, loss_test, marker=\".\", color='r', label='test error')\n plt.xlabel(\"lambda\")\n plt.ylabel(\"rmse\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation_mse\")","def plot_loss(path, current_epoch, train_loss, test_loss):\n plotname = os.path.join(path, \"training_loss_curve.png\")\n fig = plt.figure()\n plt.axes().set_facecolor(\"#fbc9bc\")\n plt.plot(\n range(1, current_epoch + 1), train_loss, color=\"#ff6050\", label=\"Training Loss\"\n )\n plt.plot(range(1, current_epoch + 1), test_loss, color=\"#19214e\", label=\"Test Loss\")\n plt.xlabel(\"Epoch Count\")\n plt.ylabel(\"Model Loss\")\n plt.legend()\n fig.savefig(plotname, bbox_inches=\"tight\")\n plt.close()","def plot_loss(history, name):\n\n plt.plot(history.history['loss'])\n plt.plot(history.history['val_loss'])\n plt.title('model loss')\n plt.ylabel('loss')\n plt.xlabel('epoch')\n plt.legend(['train', 'val'], loc='upper left')\n # plt.show()\n plt.savefig(name, format=\"png\")","def learning_viz(self) :\n self.train\n history = self.history\n plot_loss(history)","def acc_loss_graph(self):\n acc = self.history['accuracy']\n val_acc = self.history['val_accuracy']\n loss = self.history['loss']\n val_loss = self.history['val_loss']\n plt.figure(figsize=(15, 5))\n plt.subplot(1, 2, 1)\n plt.plot(acc, label='Train')\n plt.plot(val_acc, label='Val')\n plt.legend(loc='lower right')\n plt.ylabel('Accuracy')\n plt.xlabel('Epoch')\n plt.ylim([min(plt.ylim()), 1])\n plt.title('Accuracy')\n\n plt.subplot(1, 2, 2)\n plt.plot(loss, label='Train')\n plt.plot(val_loss, label='Val')\n plt.legend(loc='lower right')\n plt.ylabel('Loss')\n plt.xlabel('Epoch')\n plt.ylim([0, max(plt.ylim())])\n plt.title('Loss')\n plt.show();","def Plot_loss(history_object): \n ### print the keys contained in the history object\n print(history_object.history.keys())\n print(history_object.history['loss'])\n print(history_object.history['val_loss'])\n\n ### plot the training and validation loss for each epoch\n plt.plot(history_object.history['loss'])\n plt.plot(history_object.history['val_loss'])\n plt.title('model mean squared error loss')\n plt.ylabel('mean squared error loss')\n plt.xlabel('epoch')\n plt.legend(['training set', 'validation set'], loc='upper right')\n plt.show()","def plot_loss(experiment_name, model='pix2pix'):\n \n # load data file\n data = pd.read_csv(os.path.join('./checkpoints', experiment_name, 'loss_log.txt'), skiprows=1, sep='\\s*', engine='python', header=None)\n \n if model == 'pix2pix':\n epoch = data[1].str.replace(',', '').astype('int')\n iters = data[3].str.replace(',', '').astype('int') / 1928\n epoch = epoch + iters - 1\n \n # convert string to float32 data\n G_GAN = data[9].astype('float32')\n G_L1 = data[11].astype('float32')\n D_real = data[13].astype('float32')\n D_fake = data[15].astype('float32')\n \n plt.figure(figsize=(15,8))\n plt.xlabel('epoch', fontsize=18, labelpad=20)\n plt.ylabel('loss', fontsize=18, labelpad=20)\n plt.title(experiment_name + 'loss over time', fontsize=18, pad=30)\n plt.plot(epoch.values, G_GAN.values, 'b', label='G_GAN')\n plt.plot(epoch.values, G_L1.values, 'C1', label='G_L1')\n plt.plot(epoch.values, D_real.values, 'g', label='D_real')\n plt.plot(epoch.values, D_fake.values, 'r', label='D_fake')\n plt.tick_params(labelsize=14)\n plt.legend(loc='best', fontsize=14)\n plt.grid(True)\n # save the png image into the corresponding dir \n plt.savefig(os.path.join('./results', experiment_name, 'test_latest', experiment_name + '.png'))\n plt.show()\n \n if model == 'cyclegan':\n epoch = data[1].str.replace(',', '').astype('int')\n iters = data[3].str.replace(',', '').astype('int') / 1928\n epoch = epoch + iters - 1\n\n D_A = data[9].astype('float32')\n G_A = data[11].astype('float32')\n cycle_A = data[13].astype('float32')\n idt_A = data[15].astype('float32')\n \n D_B = data[17].astype('float32')\n G_B = data[19].astype('float32')\n cycle_B = data[21].astype('float32')\n idt_B = data[23].astype('float32')\n \n plt.figure(figsize=(15,8))\n plt.xlabel('epoch', fontsize=18, labelpad=20)\n plt.ylabel('loss', fontsize=18, labelpad=20)\n plt.title(experiment_name + 'loss over time', fontsize=18, pad=30)\n plt.plot(epoch.values, D_A.values, 'C1', label='D_A')\n plt.plot(epoch.values, G_A.values, 'C2', label='G_A')\n plt.plot(epoch.values, cycle_A.values, 'C3', label='cycle_A')\n plt.plot(epoch.values, idt_A.values, 'C4', label='idt_A')\n plt.plot(epoch.values, D_B.values, 'C5', label='D_B')\n plt.plot(epoch.values, G_B.values, 'C6', label='G_B')\n plt.plot(epoch.values, cycle_B.values, 'C7', label='cycle_B')\n plt.plot(epoch.values, idt_B.values, 'C8', label='idt_B')\n plt.tick_params(labelsize=14)\n plt.legend(loc='best', fontsize=14)\n plt.grid(True)\n plt.savefig(os.path.join('./results', experiment_name, 'test_latest', experiment_name + '.png'))\n plt.show()","def plot_loss_curve(num_epochs, losses):\n plt.xlabel('Epochs')\n plt.ylabel('Loss') \n plt.title('Loss Curve') \n plt.plot(range(num_epochs), losses)\n plt.show()","def main():\n args = parse_args()\n\n with open(args.train_details_json, mode='r', encoding='utf-8') as json_f:\n results_dict = json.load(json_f)[-1]\n\n losses_plot = plt.figure()\n plt.plot(range(1, len(results_dict['train_loss']) + 1),\n results_dict['train_loss'])\n plt.plot(range(1, len(results_dict['val_loss']) + 1),\n results_dict['val_loss'])\n plt.plot(range(1, len(results_dict['test_loss']) + 1),\n results_dict['test_loss'])\n plt.legend(['train', 'val', 'test'])\n plt.title(f'loss vs epoch for {args.model} model on {args.dataset} dataset')\n plt.xlabel('epoch')\n plt.ylabel('loss')\n plt.grid(True)\n losses_plot.set_size_inches((8, 8))\n losses_plot.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_losses_plot.png'))\n\n accuracies_plot = plt.figure()\n plt.plot(range(1, len(results_dict['train_acc']) + 1),\n results_dict['train_acc'])\n plt.plot(range(1, len(results_dict['val_acc']) + 1),\n results_dict['val_acc'])\n plt.plot(range(1, len(results_dict['test_acc']) + 1),\n results_dict['test_acc'])\n plt.legend(['train', 'val', 'test'])\n plt.title(f'accuracy vs epoch for {args.model} '\n f'model on {args.dataset} dataset')\n plt.xlabel('epoch')\n plt.ylabel('accuracy')\n plt.grid(True)\n accuracies_plot.set_size_inches((8, 8))\n accuracies_plot.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_accuracies_plot.png'))","def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc):\n \n green = '#72C29B'\n orange = '#FFA577'\n \n with plt.xkcd():\n # plot model loss\n fig, ax1 = plt.subplots()\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\n label='training')\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\n linewidth=5, label='validation')\n ax1.set_xlabel('# epoch')\n ax1.set_ylabel('loss')\n ax1.tick_params('y')\n ax1.legend(loc='upper right', shadow=False)\n # plot model accuracy\n fig, ax2 = plt.subplots()\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\n label='training')\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\n linewidth=5, label='validation')\n ax2.set_xlabel('# epoch')\n ax2.set_ylabel('accuracy')\n ax2.tick_params('y')\n ax2.legend(loc='lower right', shadow=False)\n plt.show()","def plotErrors(losses, model_title ='Shallow Network, SGD, Batch Size = 10'):\n fig, axes = plt.subplots()\n\n x = np.arange(len(losses))\n\n axes.plot(x, losses)\n axes.set_ylabel(\"Loss (cross entropy)\")\n axes.set_xlabel(\"Number of iterations\")\n axes.set_title(model_title) \n\n plt.show() \n\n return None","def plotLoss():\n # ssr\n ssr = np.log(gradientDescent(X, y)[1])\n # number of iterations \n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\n # plot reduction of ssr\n plt.plot(iterations, ssr)\n # xlabel\n plt.xlabel(\"Iteration\")\n # ylabel\n plt.ylabel(\"SSR\")\n # title\n plt.title(\"Reduction of SSR by number of Iterations\")\n # show plot \n plt.show()","def plot_loss_acc(name,score):\n plt.title(name)\n plt.xlabel('Epoch Number')\n plt.ylabel(name.split(sep=' ')[1])\n plt.plot(score)\n plt.savefig(\"graphs/\"+name+\".png\")","def display_convergence_error(train_losses, valid_losses):\n if len(valid_losses) > 0:\n plt.plot(len(train_losses), train_losses, color=\"red\")\n plt.plot(len(valid_losses), valid_losses, color=\"blue\")\n plt.legend([\"Train\", \"Valid\"])\n else:\n plt.plot(len(train_losses), train_losses, color=\"red\")\n plt.legend([\"Train\"])\n plt.xlabel('Epoch')\n plt.ylabel('Loss')\n plt.show()","def training(self, dataset, \n epochs, r_loss, beta, \n test= None ,Plotter=None):\n\n losses = []\n val_losses = []\n fidelities = []\n val_fidelities = []\n epochs = range(epochs)\n\n for i in tqdm(epochs, desc='Epochs'):\n losses_epochs = []\n fidelity_epochs =[]\n for step, x in enumerate(dataset):\n\n loss, fidelity = self.training_step(x, r_loss, beta)\n \n # Logging.\n losses_epochs.append(float(loss))\n fidelity_epochs.append(float(fidelity))\n \n losses.append(np.mean(losses_epochs))\n fidelities.append(np.mean(fidelity_epochs))\n \n if test:\n val_losses_epochs = []\n val_fidelity_epochs = []\n\n for step, x in enumerate(test):\n\n val_loss, val_fidelity = self.validating_step(x, r_loss, beta)\n \n # Logging.\n val_losses_epochs.append(float(val_loss))\n val_fidelity_epochs.append(float(val_fidelity))\n \n val_losses.append(np.mean(val_losses_epochs))\n val_fidelities.append(np.mean(val_fidelity_epochs))\n\n if Plotter != None:\n if test:\n Plotter.plot([losses,val_losses]) \n else:\n Plotter.plot(losses)\n \n\n return losses, val_losses, fidelities, val_fidelities","def calc_loss_train_val(history):\r\n # overall loss\r\n fig = go.Figure()\r\n fig.add_trace(go.Scattergl(\r\n y=history.history['loss'],\r\n name='Train'))\r\n fig.add_trace(go.Scattergl(\r\n y=history.history['val_loss'],\r\n name='Validation'))\r\n fig.update_layout(height=500,\r\n width=700,\r\n title='Overall loss',\r\n xaxis_title='Epoch',\r\n yaxis_title='Loss')\r\n fig.show()","def create(self, train: List[float], validation: List[float]) -> None:\n self.ax.plot(train)\n self.ax.plot(validation)\n self.ax.set_xlabel('epochs')\n if self.loss:\n self.ax.set_ylabel('loss')\n else:\n self.ax.set_ylabel('accuracy')\n self.ax.legend(['train', 'validation'])","def visualization(epochs, mse_tr, mse_te):\n plt.semilogx(epochs, mse_tr, marker=\".\", color='b', label='train error')\n plt.semilogx(epochs, mse_te, marker=\".\", color='r', label='test error')\n plt.xlabel(\"k\")\n plt.ylabel(\"rmse\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation\")","def plot_learning_curve(X_train_all, X_val_all, y_train_all, y_val_all, train_sizes, title):\n\n errors_df = pd.DataFrame(columns = ['train_size', 'train_acc', 'val_acc'])\n\n # Loop through example sizes and get the training and validation error\n for train_size in train_sizes:\n # Select Subset of Data\n X_train = X_train_all[:train_size]\n X_val = X_val_all[:train_size]\n y_train = y_train_all[:train_size]\n y_val = y_val_all[:train_size]\n\n # Initialize Model\n model = svm.SVC(kernel='linear')\n\n # Fit model\n print(f\"Training {title} using {train_size} examples\")\n model.fit(X_train, y_train)\n\n # Get Predictions \n train_pred = model.predict(X_train)\n val_pred = model.predict(X_val)\n\n # Get Accuracy Score for X_Train and X_Val\n errors = pd.DataFrame({\n 'train_size': [train_size],\n 'train_acc': [accuracy_score(y_train, train_pred)],\n 'val_acc': [accuracy_score(y_val, val_pred)]\n })\n \n # Concatenate Dataframes\n errors_df = pd.concat([errors_df, errors])\n\n # Plot Learning Curve\n fig, ax = plt.subplots()\n\n errors_df.plot(x='train_size', y='train_acc',kind='line', ax=ax)\n errors_df.plot(x='train_size', y='val_acc',kind='line', color='red', ax=ax)\n\n ax.set_xlabel(\"Training Size\")\n ax.set_ylabel(\"Accuracy\")\n ax.set_title(title)\n\n # Save Figure\n plt.savefig('figs/' + title + '_learning_curve.png')","def plot_training_curve(path):\n import matplotlib.pyplot as plt\n train_err = np.loadtxt(\"{}_train_err.csv\".format(path))\n val_err = np.loadtxt(\"{}_val_err.csv\".format(path))\n train_loss = np.loadtxt(\"{}_train_loss.csv\".format(path))\n val_loss = np.loadtxt(\"{}_val_loss.csv\".format(path))\n plt.title(\"Train vs Validation Error\")\n n = len(train_err) # number of epochs\n plt.plot(range(1,n+1), train_err, label=\"Train\")\n plt.plot(range(1,n+1), val_err, label=\"Validation\")\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Error\")\n plt.legend(loc='best')\n plt.show()\n plt.title(\"Train vs Validation Loss\")\n plt.plot(range(1,n+1), train_loss, label=\"Train\")\n plt.plot(range(1,n+1), val_loss, label=\"Validation\")\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.legend(loc='best')\n plt.show()","def loss_plotter(model_history, ax=None):\n \n import matplotlib.pyplot as plt\n import seaborn as sns\n\n training_loss = model_history['loss']\n \n test_loss = model_history['val_loss']\n\n epoch_count = range(1,len(training_loss)+1)\n \n sns.set(font_scale=1.15)\n \n ax = sns.lineplot(\n x=epoch_count,\n y=training_loss,\n ax=ax\n )\n \n ax = sns.lineplot(\n x=epoch_count,\n y=test_loss,\n ax=ax\n )\n\n ax.set_title(\n 'Loss Curves: Pre-Trained VGG-16 with 2 Trained Layers',\n fontsize=19\n )\n ax.set_ylabel(\n 'Loss',\n fontsize=18\n )\n ax.set_xlabel(\n 'Epochs',\n fontsize=18\n )\n\n plt.legend(['Training Loss', 'Validation Loss'])\n plt.show()","def plot_training_info(case, metrics, save, history):\n val = False\n if 'val_accuracy' in history and 'val_loss' in history:\n val = True\n plt.ioff()\n if 'accuracy' in metrics:\n fig = plt.figure()\n plt.plot(history['accuracy'])\n if val:\n plt.plot(history['val_accuracy'])\n plt.title('model accuracy')\n plt.ylabel('accuracy')\n plt.xlabel('epoch')\n if val:\n plt.legend(['train', 'val'], loc='upper left')\n else:\n plt.legend(['train'], loc='upper left')\n if save:\n plt.savefig(case + 'accuracy.png')\n plt.gcf().clear()\n else:\n plt.show()\n plt.close(fig)\n\n # summarize history for loss\n if 'loss' in metrics:\n fig = plt.figure()\n plt.plot(history['loss'])\n if val:\n plt.plot(history['val_loss'])\n plt.title('model loss')\n plt.ylabel('loss')\n plt.xlabel('epoch')\n # plt.ylim(1e-3, 1e-2)\n plt.yscale(\"log\")\n if val:\n plt.legend(['train', 'val'], loc='upper left')\n else:\n plt.legend(['train'], loc='upper left')\n if save:\n plt.savefig(case + 'loss.png')\n plt.gcf().clear()\n else:\n plt.show()\n plt.close(fig)","def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc, save_figure_path):\n\n green = '#72C29B'\n orange = '#FFA577'\n\n with plt.xkcd():\n fig, (ax1, ax2) = plt.subplots(2, figsize=(10, 8))\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\n label='training')\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\n linewidth=5, label='validation')\n ax1.set_xlabel('# epoch')\n ax1.set_ylabel('loss')\n ax1.tick_params('y')\n ax1.legend(loc='upper right', shadow=False)\n ax1.set_title('Model loss through #epochs', fontweight='bold')\n\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\n label='training')\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\n linewidth=5, label='validation')\n ax2.set_xlabel('# epoch')\n ax2.set_ylabel('accuracy')\n ax2.tick_params('y')\n ax2.legend(loc='lower right', shadow=False)\n ax2.set_title('Model accuracy through #epochs', fontweight='bold')\n\n plt.tight_layout()\n plt.show()\n fig.savefig(save_figure_path)\n plt.close(fig)","def plot_loss(model_dir):\n ## extract loss from csv\n file_dir = os.path.join(model_dir, 'losses.csv')\n data = pd.read_csv(file_dir)\n epochs = data['epoch'].ravel()\n loss = data['loss'].ravel()\n\n fig, ax = plt.subplots(1, 1, figsize=(7, 5), sharey=True, sharex=True, dpi=400)\n ax.plot(epochs, loss, #label=r'Loss', \n color='green', linewidth=1.0, alpha=0.8)\n ax.set_ylabel('Loss', fontsize=10)\n ax.set_xlabel('Number of iterations', fontsize=10)\n ax.legend(loc='lower right', prop={\"size\": 15}, ncol=3, framealpha=0.5)\n ax.set_title(\"Loss\")\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n plt.tight_layout()\n\n ## create saving directory\n loss_dir = os.path.join(model_dir, 'figures', 'loss')\n os.makedirs(loss_dir, exist_ok=True)\n file_name = os.path.join(loss_dir, 'loss.png')\n plt.savefig(file_name, dpi=400)\n print(\"Plot saved to: {}\".format(file_name))\n file_name = os.path.join(loss_dir, 'loss.pdf')\n plt.savefig(file_name, dpi=400)\n plt.close()\n print(\"Plot saved to: {}\".format(file_name))","def loss(self, data):\n loss, smoothed, lr = data\n\n curves = []\n\n curve_keys = ['color', 'linestyle', 'linewidth', 'alpha']\n\n if loss is not None:\n loss_name = self.config.get('label', f\"loss #{self.index + 1}\")\n loss_label = f'{loss_name} ⟶ {loss[-1]:2.3f}'\n final_window = self.config.get('final_window', None)\n if final_window is not None:\n final_window = min(final_window, len(loss))\n final = np.mean(loss[-final_window:])\n loss_label += f\"\\nmean over last {final_window} iterations={final:2.3f}\"\n\n loss_config = self.config.filter(keys=curve_keys, prefix='curve_')\n loss_curve = self.ax.plot(loss, label=loss_label, **loss_config)\n curves.extend(loss_curve)\n\n if smoothed is not None:\n smoothed_color = scale_lightness(loss_config['color'], scale=.5)\n smooth_window = self.config.get('window')\n smoothed_label = self.config.get('smoothed_label', loss_name)\n smoothed_label = smoothed_label + '\\n' if smoothed_label else ''\n smoothed_label += f'smoothed with window {smooth_window}'\n smoothed_curve = self.ax.plot(smoothed, label=smoothed_label, color=smoothed_color, linestyle='--')\n curves.extend(smoothed_curve)\n\n if lr is not None:\n lr_ax = self.ax if loss is None else self.twin_ax\n lr_label = f'learning rate №{self.index + 1} ⟶ {lr[-1]:.0e}'\n lr_config = self.config.filter(keys=curve_keys, prefix='lr_')\n lr_curve = lr_ax.plot(lr, label=lr_label, **lr_config)\n lr_ax.set_ylabel('Learning rate', fontsize=12)\n curves.extend(lr_curve)\n\n return curves","def graph_results(loss, acc):\n N = len(loss)\n x = np.linspace(0, N, N)\n plt.subplot(1,2,1)\n plt.plot(x, loss)\n plt.subplot(1,2,2)\n plt.plot(x,acc)\n plt.show()","def plot_eval_2(trained_model, image_name):\n # Get training evaluation data\n train_accuracy = trained_model.history['acc']\n train_val_accuracy = trained_model.history['val_acc']\n train_loss = trained_model.history['loss']\n train_val_loss = trained_model.history['val_loss']\n \n # Generate accuracy plot\n epochs = range(len(train_accuracy))\n plt.figure()\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\n plt.title('Training and validation accuracy')\n plt.legend()\n \n # Save accuracy plot\n plot_file = os.path.join(OUTPUT_DIR,\n \"{}_training_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')\n \n # Generate loss plot\n plt.figure()\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n \n # Save loss plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_training_loss\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def plot_cost(c_v, c_t, save_plots_path):\n\n plt.figure()\n plt.plot(c_v, label='Validation loss')\n plt.plot(c_t, label='Training loss')\n plt.legend()\n title = 'Loss per epoch'\n plt.title(title)\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.savefig(save_plots_path + \"swag_loss_plot.png\")","def plot_train_results(metrics2record, loss_metric,\n train_metrics, test_metrics):\n pyplot.figure(figsize=(10, 5))\n min_, max_ = np.min(loss_metric), np.max(loss_metric)\n lg, = pyplot.plot(loss_metric)\n pyplot.yticks(min_ + np.arange(5) * (max_ - min_))\n # if learning_rate is not None:\n # lg, = pyplot.plot(learning_rate)\n pyplot.title('Loss')\n pyplot.xlabel('Epoch')\n pyplot.yscale('log')\n pyplot.show()\n\n for prm in basic_metrics:\n if prm in metrics2record:\n leg = []\n met_idx = metrics2record.index(prm)\n pyplot.figure(figsize=(10, 5))\n lg, = pyplot.plot(train_metrics[:, met_idx], label=('train'))\n leg.append(lg)\n lg, = pyplot.plot(test_metrics[:, met_idx], label=('test'))\n leg.append(lg)\n\n pyplot.legend(handles=leg)\n pyplot.title(prm)\n pyplot.xlabel('Epoch')\n pyplot.show()\n\n has_prf = any([(prm in PRF_metrics) for prm in metrics2record])\n if has_prf:\n pyplot.figure(figsize=(10, 5))\n leg = []\n for prm in PRF_metrics:\n if prm in metrics2record:\n met_idx = metrics2record.index(prm)\n lg, = pyplot.plot(train_metrics[:, met_idx],\n label=(prm + ':train'))\n leg.append(lg)\n\n for prm in PRF_metrics:\n if prm in metrics2record:\n met_idx = metrics2record.index(prm)\n lg, = pyplot.plot(test_metrics[:, met_idx],\n label=(prm + ':test'))\n leg.append(lg)\n\n pyplot.legend(handles=leg)\n pyplot.title('Precision / Recall')\n pyplot.xlabel('Epoch')\n pyplot.show()","def acc_loss_graph(accuracies, losses):\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))\n\n for experiment_id in accuracies.keys():\n ax1.plot(accuracies[experiment_id], label=experiment_id)\n ax1.legend()\n ax1.set_title('Validation Accuracy')\n fig.tight_layout()\n\n for experiment_id in accuracies.keys():\n ax2.plot(losses[experiment_id], label=experiment_id)\n ax2.legend()\n ax2.set_title('Validation Loss');\n\n fig.tight_layout()","def plot_train_history(self):\n plt.figure()\n plt.xlabel('Epochs')\n plt.ylabel('Loss')\n plt.plot(self.train_history.history['loss'])\n plt.plot(self.train_history.history['val_loss'])\n plt.legend(['Training', 'Validation'])\n\n plt.show()","def update_error_plot_values(self):\n check_is_dir(\"mp_plotdata\")\n check_is_dir(\"mp_plotdata/\"+self.name)\n\n data_train = self.get_data.evaluate_on_train_data(n_samples=50)\n data_validation = self.get_data.evaluate_on_validation_data(n_samples=50)\n\n for data, _set in zip([data_train, data_validation], [\"train\", \"validation\"]):\n object_real_samples = data[\"object_real_samples\"].reshape(\n -1,self.get_data.N, self.get_data.N, 1)\n object_imag_samples = data[\"object_imag_samples\"].reshape(\n -1,self.get_data.N, self.get_data.N, 1)\n diffraction_samples = data[\"diffraction_samples\"].reshape(\n -1,self.get_data.N, self.get_data.N, 1)\n\n filename = \"mp_plotdata/\"+self.name+\"/\"+_set+\"_log.dat\"\n if not os.path.exists(filename):\n with open(filename, \"w\") as file:\n file.write(\"# time[s] epoch real_loss imag_loss reconstruction_loss\\n\")\n\n # real loss\n real_loss = self.sess.run(self.nn_nodes[\"real_loss\"],\n feed_dict={self.x:diffraction_samples,\n self.real_actual:object_real_samples})\n\n # imaginary loss\n imag_loss = self.sess.run(self.nn_nodes[\"imag_loss\"],\n feed_dict={self.x:diffraction_samples,\n self.imag_actual:object_imag_samples})\n\n # reconstruction\n reconstruction_loss = self.sess.run(self.nn_nodes[\"reconstruction_loss\"],\n feed_dict={self.x:diffraction_samples})\n\n datastring = \"\"\n datastring+= str(time.time())\n datastring+= \" \"\n datastring+= str(self.epoch)\n datastring+= \" \"\n datastring+= str(real_loss)\n datastring+= \" \"\n datastring+= str(imag_loss)\n datastring+= \" \"\n datastring+= str(reconstruction_loss)\n datastring+= \"\\n\"\n\n with open(filename, \"a\") as file:\n file.write(datastring)\n\n\n for key in self.experimental_traces.keys():\n trace = self.experimental_traces[key]\n\n # reconstruction\n reconstruction_loss = self.sess.run(self.nn_nodes[\"reconstruction_loss\"],\n feed_dict={self.x:trace})\n\n logger_name = key+\"_reconstructed\"\n filename = \"mp_plotdata/\"+self.name+\"/\"+logger_name+\".dat\"\n if not os.path.exists(filename):\n with open(filename, \"w\") as file:\n file.write(\"# time[s] epoch reconstruction_loss\\n\")\n\n datastring = \"\"\n datastring+= str(time.time())\n datastring+= \" \"\n datastring+= str(self.epoch)\n datastring+= \" \"\n datastring+= str(reconstruction_loss)\n datastring+= \"\\n\"\n with open(filename, \"a\") as file:\n file.write(datastring)","def cross_validation_visualization(lambds, score_tr, score_te):\n plt.semilogx(lambds, score_tr, marker=\".\", color='b', label='train score');\n plt.semilogx(lambds, score_te, marker=\".\", color='r', label='test score');\n plt.xlabel(\"lambda\")\n plt.ylabel(\"score\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation_test\")","def plot_loss(loss_values_dict, save_name):\n fig, ax = plt.subplots(figsize=(10, 10))\n # Add each method to the plot\n for (method_name, loss_val_array) in loss_values_dict.items():\n print(method_name, len(loss_val_array))\n ax.plot(range(len(loss_val_array)), loss_val_array, label=method_name)\n ax.legend(loc='upper right')\n plt.xlabel('iteration')\n plt.ylabel('loss')\n plt.title('Grad Descent in Hyperbolic Space')\n plt.savefig(save_name)","def plot_eval_1(trained_model, image_name):\n # Get training evaluation data\n train_accuracy = trained_model.history['acc']\n train_val_accuracy = trained_model.history['val_acc']\n train_loss = trained_model.history['loss']\n train_val_loss = trained_model.history['val_loss']\n \n # Generate accuracy plot\n epochs = range(len(train_accuracy))\n plt.figure()\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\n plt.title('Training and validation accuracy')\n plt.legend()\n \n # Save accuracy plot\n plot_file = os.path.join(OUTPUT_DIR,\n \"{}_training_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')\n \n # Generate loss plot\n plt.figure()\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n \n # Save loss plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_training_loss\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def error_plot(training_costs, test_costs, learning_rate, accuracy, test_accuracy, val_accuracy, layers, data_size,\n n_neighbours, dropout_rate):\n\n plt.plot(training_costs, label=\"Training loss\")\n plt.plot(test_costs, label=\"Test loss\")\n plt.xlabel(\"Iterations\", size='medium')\n plt.ylabel(\"Cost function (%)\", size='medium')\n plt.suptitle(\"Cost function while training the neural network\", size='medium', ha='center')\n plt.title(\"layers: {} with dropout rate of {}, learning rate: {}\".format(layers, dropout_rate, learning_rate),\n size='small', ha='center')\n plt.figtext(0.77, 0.35, \"Training accuracy\\n{0:.2f}%\".format(accuracy), size='medium')\n plt.figtext(0.77, 0.25, \"Test accuracy\\n{0:.2f}%\".format(test_accuracy), size='medium')\n plt.figtext(0.77, 0.15, \"Validation accuracy\\n{0:.2f}%\".format(val_accuracy), size='medium')\n if n_neighbours == 0:\n plt.figtext(0.77, 0.80, \"Neighbours\\nexcluded\", size='medium')\n else:\n plt.figtext(0.77, 0.80, \"{} neighbours\\nincluded\".format(n_neighbours), size='medium')\n plt.figtext(0.77, 0.70, \"{}\\nsamples\".format(data_size))\n plt.legend(loc='right', bbox_to_anchor=(1.39, 0.5))\n plt.subplots_adjust(right=0.75)\n working_dir = os.path.dirname(os.path.abspath(__file__))\n saving(working_dir + \"/output_ANN/error_plots/{}_error_{}\".format(n_neighbours, data_size))","def plot(self, ylog=False, category=\"Accuracy\", figsize=(12, 5)):\n if self.CV == False: # no Cross Validation set case\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\n plt.suptitle(\"Training Curve for \" + self.loss, fontsize=12)\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\n ax[0].set_xlabel('Iteration')\n ax[0].set_ylabel(\"Error\")\n if ylog == True:\n ax[0].set_yscale('log')\n ax[0].legend()\n ax[0].grid('on')\n\n if category == \"Accuracy\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'r-', label='Training Accuracy')\n ax[1].set_ylabel(\"Accuracy\")\n elif category == \"Error Rate\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'r-', label='Training Error Rate')\n ax[1].set_ylabel(\"Error Rate\")\n # ax[1].set_ylim((0, 1))\n ax[1].set_xlabel('Iteration')\n ax[1].legend(loc='best')\n ax[1].grid('on')\n plt.show()\n if self.CV == True: # has Cross Validation set case\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\n plt.suptitle(\"Training Curve for \" + self.loss, fontsize=12)\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\n ax[0].plot(range(1, len(self.cvError) + 1), self.cvError, 'r-', label='CV Error')\n ax[0].set_xlabel('Iteration')\n ax[0].set_ylabel(\"Error\")\n if ylog == True:\n ax[0].set_yscale('log')\n ax[0].legend()\n ax[0].grid('on')\n\n if category == \"Accuracy\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'g-', label='Training Accuracy')\n ax[1].plot(range(1, len(self.cvAcc) + 1), self.cvAcc, 'r-', label='CV Accuracy')\n ax[1].set_ylabel(\"Accuracy\")\n elif category == \"Error Rate\":\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'g-', label='Training Error Rate')\n ax[1].plot(range(1, len(self.cvAcc) + 1), 1 - np.array(self.cvAcc), 'r-', label='CV Error Rate')\n ax[1].set_ylabel(\"Error Rate\")\n # ax[1].set_ylim((0, 1))\n ax[1].set_xlabel('Iteration')\n ax[1].legend(loc='best')\n ax[1].grid('on')\n plt.show()\n\n return fig, ax","def train(X_train, y_train, X_test, y_test, net):\n \n # convert X, y to tensors:\n X_train = torch.tensor(X_train, dtype=torch.float32)\n y_train = torch.tensor(y_train, dtype=torch.float32)\n \n X_test = torch.tensor(X_test, dtype=torch.float32)\n y_test = torch.tensor(y_test, dtype=torch.float32)\n\n # iterator:\n train_set = TensorDataset(X_train, y_train)\n train_loader = DataLoader(train_set, batch_size, shuffle=True)\n\n test_set = TensorDataset(X_test, y_test)\n test_loader = DataLoader(test_set, batch_size, shuffle=True)\n\n # optimizer:\n optimizer = torch.optim.Adam(net.parameters(), lr=lr)\n loss = nn.MSELoss()\n\n # loss accumulator:\n time_line = []\n train_metric = []\n test_metric = []\n\n # loop:\n for epoch in range(epochs):\n # update parameters:\n for Xb, yb in train_loader:\n train_ls = loss(net(Xb), yb)\n optimizer.zero_grad()\n train_ls.backward()\n optimizer.step()\n # update train and test losses:\n with torch.no_grad():\n if not epoch % 50:\n time_line.append(epoch)\n metric = 0\n for Xb, yb in train_loader:\n metric += loss(net(Xb), yb) / batch_size\n train_metric.append(metric)\n metric = 0\n for Xb, yb in test_loader:\n metric += loss(net(Xb), yb) / batch_size\n test_metric.append(metric)\n # verbose:\n print('Epoch: ', epoch)\n\n # final report of the losses: \n print('Train loss.....{0:6.3f}'.format(train_metric[-1]))\n print('Test loss......{0:6.3f}'.format(test_metric[-1]))\n\n # plot losses with respect to epochs:\n plt.plot(time_line, train_metric, color='b')\n plt.plot(time_line, test_metric, color='r')\n plt.show()","def plot(training_losses, validation_losses, epochs, directory_name):\n plt.figure(figsize=(20, 10))\n\n x = np.linspace(1, epochs, epochs)\n training_losses = np.array(training_losses)\n validation_losses = np.array(validation_losses)\n\n plt.title(\"Learning curve over Epochs\")\n\n plt.xlabel(\"Epochs\")\n plt.ylabel(\"Average Loss\")\n\n plt.plot(x, training_losses, color='purple', marker=\".\", label='Training loss')\n plt.plot(x, validation_losses, color='orange', marker=\".\", label='Validation loss')\n plt.legend()\n plt.savefig('./' + directory_name + '/Learning_curves-' + str(epochs) + '.png')\n pass","def visualize_train(train_data_full, train_labels, train_data, thetas, losses, niter):\n fig1, ax1 = plt.subplots()\n ax1.scatter(train_data_full[\"Weight\"], train_data_full[\"Height\"], color = 'blue')\n\n # De-standarize\n train_mean = train_data_full[\"Weight\"].mean()\n train_std = train_data_full[\"Weight\"].std()\n train_data_for_plot = train_mean + train_data[\"Weight\"] * train_std\n\n ax1.plot(train_data_for_plot, predict(train_data, thetas[niter - 1]), color = 'red', linewidth = 2)\n ax1.set_xlabel(\"Height\")\n ax1.set_ylabel(\"Weight\")\n\n fig2, ax2 = plt.subplots()\n ax2.plot(range(len(losses)), losses, color = 'blue', linewidth = 2)\n ax2.set_xlabel(\"Iteration\")\n ax2.set_ylabel(\"MSE\")\n\n fig3, ax3 = plt.subplots()\n np_gradient_ws = np.array(thetas)\n\n w = np.linspace(min(np_gradient_ws[:, 0]), max(np_gradient_ws[:, 0]), len(np_gradient_ws[:, 0]))\n b = np.linspace(min(np_gradient_ws[:, 1]), max(np_gradient_ws[:, 1]), len(np_gradient_ws[:, 1]))\n x, y = np.meshgrid(w, b)\n z = compute_z_loss(train_labels, train_data, np.stack((w,b)).T)\n cp = ax3.contourf(x, y, z, cmap = plt.cm.jet)\n fig3.colorbar(cp, ax = ax3)\n ax3.plot(3.54794951, 66.63949115837143, color = 'red', marker = '*', markersize = 20)\n if niter > 0:\n thetas_to_plot = np_gradient_ws[:niter]\n ax3.plot(thetas_to_plot[:, 0], thetas_to_plot[:, 1], marker = 'o', color = 'w', markersize = 10)\n ax3.set_xlabel(r'$w$')\n ax3.set_ylabel(r'$b$')\n return fig1, fig2, fig3","def plot_loss_metrics(history_file):\n history = pickle.load(open(history_file, \"rb\"))\n loss, metric, val_loss, val_metric = islice(history.keys(), 4)\n n_epochs = len(history[loss])\n\n plt.style.use(\"ggplot\")\n fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(13, 8))\n\n ax1.set_title(loss)\n ax1.plot(np.arange(1, n_epochs + 1), history[loss], label='train')\n ax1.plot(np.arange(1, n_epochs + 1), history[val_loss], label='test')\n ax1.legend()\n\n ax2.set_title(metric)\n ax2.plot(np.arange(1, n_epochs + 1), history[metric], label='train')\n ax2.plot(np.arange(1, n_epochs + 1), history[val_metric], label='test')\n ax2.set_xlabel('Epochs')\n ax2.set_xlim((1, n_epochs + 1))\n xa = ax2.get_xaxis()\n xa.set_major_locator(MaxNLocator(integer=True))\n ax2.legend()\n plt.savefig(history_file + '.png')\n plt.show()","def plot_data(x, y, epochs):\n\n fig = plt.figure()\n ax = fig.gca()\n\n ax.set_ylim(0, int(np.max(y)+0.5))\n ax.set_xlim(0, np.max(x))\n ax.yaxis.grid(True)\n ax.grid(which='minor', axis='x', alpha=0.2)\n ax.grid(which='major', axis='x', alpha=0.5)\n major_ticks = np.arange(0, np.max(x), 88)\n minor_ticks = np.arange(0, np.max(x), 16)\n ax.set_xticks(major_ticks)\n ax.set_xticks(minor_ticks, minor=True)\n\n fig.canvas.draw()\n labels = [\"{:2d}\".format(int(int(item.get_text())/88)) for item in ax.get_xticklabels()]\n ax.set_xticklabels(labels)\n\n plt.title(\"Model Loss over {} Epochs\".format(epochs))\n plt.scatter(x, y, s=50, alpha=0.5, label='cross_entropy')\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.legend(loc='upper right')\n plt.show()","def plot_loss(logdir, stats):\n progress_path = os.path.join(logdir, \"progress.csv\")\n reader = csv.reader(open(progress_path, \"rt\"), delimiter=\",\")\n raw_data = list(reader)\n\n headers = raw_data[0]\n data = np.array(raw_data[1:]).astype(\"float\")\n\n vis_headers_x = [\"Epoch\"]\n vis_header_idx_x = [headers.index(x) for x in vis_headers_x]\n data_x = data[:, vis_header_idx_x[0]]\n\n vis_header_idx_y = [headers.index(y) for y in stats]\n data_y_mean = []\n for idx in vis_header_idx_y:\n data_y_mean.append(data[:, idx])\n\n for i in range(len(data_y_mean)):\n fig, ax = plt.subplots()\n ax.plot(data_x, data_y_mean[i], color=\"gray\", label=stats[i])\n\n ax.legend()\n ax.set_xlabel(vis_headers_x[0])\n ax.grid(True)\n\n fig_path = os.path.join(logdir, stats[i].split(\"/\")[-1] + \".png\")\n fig.savefig(fig_path, dpi=320)","def plot_observations():\n plt.plot(history.history['loss'], label='training_loss')\n plt.plot(history.history['val_loss'], label='val_loss ')\n plt.xlabel('Epoch')\n plt.ylabel('Loss')\n plt.show()\n\n plt.plot(history.history['acc'], label='accuracy')\n plt.plot(history.history['val_acc'], label='val_accuracy')\n plt.xlabel('Epoch')\n plt.ylabel('Accuracy')\n plt.legend(loc='lower right')\n plt.show()\n\n test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)\n print(\"Test Accuracy:\", test_acc)","def show_training_history(self):\n hist = [i.history[\"loss\"][0] for i in self.history]\n plt.plot(hist)","def plot_train_and_valid_curves(ax, train_points, valid_points, learning_rate_updates_epoch, best_per_lr, mode=\"loss\"):\n if mode==\"loss\":\n name = \"Loss\"\n names = \"losses\"\n factor = [1.2, 1.22]\n loc_legend = 1\n elif mode ==\"acc\":\n name = \"Accuracy\"\n names = \"acc\"\n factor = [0.9, 0.88]\n loc_legend = 4\n else:\n print \"Mode not understood. Available modes : 'loss' and 'acc'\"\n return\n\n #ax = plt.subplot(1,1,1)#\n # Plot training and valid loss curves\n ax.plot(np.arange(len(train_points)),train_points, c=\"k\", zorder=1)\n ax.plot(np.arange(len(valid_points)),valid_points, c=\"k\", zorder=1)\n ax.scatter(np.arange(len(train_points)),train_points, c=\"b\", label=\"Train %s\"%names, zorder=2)\n ax.scatter(np.arange(len(valid_points)),valid_points, c=\"r\", label=\"Valid %s\"%names, zorder=2)\n # Plot vertical line when the learning rate was updated\n first = True\n for elem in learning_rate_updates_epoch:\n if first:\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\"k\", label=\"LR updates\", linestyle=\"--\")\n first = False\n else:\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\"k\", linestyle=\"--\")\n # Plot best model in each region\n first = True\n for i,elem in enumerate(best_per_lr):\n if first:\n x = elem[0]\n y = elem[1]\n plt.scatter(x,y, c=\"g\", label=\"Best models\", marker=\"*\", zorder=3, s=100)\n plt.plot([x,x],[y,factor[0]*y], c=\"g\")\n plt.text(x,factor[1]*y, \"Epoch %d\"%(x), fontsize=8)\n first = False\n else:\n x = elem[0]+learning_rate_updates_epoch[i-1]\n y = elem[1]\n plt.scatter(x,y, c=\"g\", marker=\"*\", zorder=3, s=100)\n plt.plot()\n plt.plot([x,x],[y,factor[0]*y], c=\"g\")\n plt.text(x,factor[1]*y, \"Epoch %d\"%(x), fontsize=8)\n # Xlim, Ylim, labels, legend...\n ax.set_ylim([0,1])\n ax.set_xlim([0,len(train_points)+5])\n ax.set_xlabel(\"Epochs\")\n ax.set_ylabel(name)\n handles,labels = ax.get_legend_handles_labels()\n sorted_zip = sorted(zip([2,0,1,3],handles, labels))\n index, handles, labels = zip(*sorted_zip)\n ax.legend(handles,labels, loc=loc_legend, prop={'size':10})","def plot_loss(self):\n #x = [k for k in range(self.rep)]\n loss = self.min_list[:,0]//100 #For clarity\n #plt.plot(x,self.min_list[:,0])\n plt.hist(loss,density=True)\n plt.xlabel(self.list_name + '_loss//100')\n plt.ylabel('Frequency')\n #plt.xticks(range(8),[0,250,500,750,1000,1250,1500,1750])\n plt.title('Distribution of '+self.list_name+'_loss ('+str(self.rep)+' iterations)')\n plt.savefig('img/stats/'+self.list_name+'_lossFrequency_'+self.model_name+'.png')\n plt.show()","def plot_loss_and_acc(history):\n hist = history.history\n x_arr = np.arange(len(hist['loss'])) + 1\n fig = plt.figure(figsize=(12,4))\n ax = fig.add_subplot(1,2,1)\n ax.plot(x_arr, hist['loss'], '-o', label='Train loss')\n ax.plot(x_arr, hist['val_loss'], '--<', label='Validation loss')\n ax.legend(fontsize=15)\n ax.set_xlabel('Epoch', size=15)\n ax.set_ylabel('Loss', size=15)\n\n ax = fig.add_subplot(1,2,2)\n ax.plot(x_arr, hist['accuracy'], '-o', label='Train acc.')\n ax.plot(x_arr, hist['val_accuracy'], '--<', label='Validation acc.')\n ax.legend(fontsize=15)\n ax.set_xlabel('Epoch', size=15),\n ax.set_ylabel('Accuracy', size=15)\n plt.show()","def training(self, dataset, \n epochs, r_loss, beta, \n Plotter=None):\n\n losses = []\n epochs = range(epochs)\n\n for i in tqdm(epochs, desc='Epochs'):\n losses_epochs = []\n for step, x in enumerate(dataset):\n\n loss = self.training_step(x, r_loss, beta)\n \n # Logging.\n losses_epochs.append(float(loss))\n losses.append(np.mean(losses_epochs))\n \n if Plotter != None:\n Plotter.plot(losses)\n\n return losses","def summarize_diagnostics(self):\n # plot loss\n pyplot.subplot(211)\n pyplot.title('Cross Entropy Loss')\n pyplot.plot(self.history.history['loss'], color='blue', label='train')\n pyplot.plot(self.history.history['val_loss'], color='orange', label='test')\n # plot accuracy\n pyplot.subplot(212)\n pyplot.title('Classification Accuracy')\n pyplot.plot(self.history.history['accuracy'], color='blue', label='train')\n pyplot.plot(self.history.history['val_accuracy'], color='orange', label='test')\n # save plot to file\n pyplot.savefig(f'{self.project_home / \"o\"}/{self.model.name}_plot.png')\n pyplot.close()","def plot_error(self, maxstep=20):\n plt.ion()\n plt.xlabel(\"step\")\n plt.ylabel(\"Ave Logloss (bits)\")\n train_errors = []\n if self.dataset.test:\n test_errors = []\n for i in range(maxstep):\n self.learn(1)\n train_errors.append( sum(self.logloss(tple) for tple in self.dataset.train)\n /len(self.dataset.train))\n if self.dataset.test:\n test_errors.append( sum(self.logloss(tple) for tple in self.dataset.test)\n /len(self.dataset.test))\n plt.plot(range(1,maxstep+1),train_errors,\n label=str(self.num_classes)+\" classes. Training set\")\n if self.dataset.test:\n plt.plot(range(1,maxstep+1),test_errors,\n label=str(self.num_classes)+\" classes. Test set\")\n plt.legend()\n plt.draw()","def plot_fit_history(fit_history_obj):\r\n plt.plot(fit_history_obj.history['loss'])\r\n plt.plot(fit_history_obj.history['val_loss'])\r\n plt.title('model mean squared error loss')\r\n plt.ylabel('mean squared error loss')\r\n plt.xlabel('epoch')\r\n plt.legend(['training set', 'validation set'], loc='upper right')\r\n plt.show()","def plot_acc_and_loss(trn_hist, val_hist):\n assert isinstance(trn_hist, np.ndarray) and isinstance(val_hist, np.ndarray)\n fig, (ax_acc, ax_loss) = plt.subplots(1, 2, figsize=(10, 4))\n plot_on_ax(ax_acc, trn_hist[:,0], val_hist[:,0], \"Accuracy\")\n plot_on_ax(ax_loss, trn_hist[:,1], val_hist[:,1], \"Loss\")\n plt.show()","def train_nn(train_nn_results, label, title, yaxis):\n plt.figure(figsize=(12,5))\n for i in range(len(label)):\n plt.plot(train_nn_results[i], label=label[i], alpha=0.75)\n plt.title(title)\n plt.xlabel('epoch')\n plt.ylabel(yaxis)\n plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')\n plt.tight_layout()\n plt.show()","def plot_results(self):\n\n\n f1, ax1 = plt.subplots()\n h1, = ax1.plot(self.history[\"step\"], self.history[\"trainLoss\"],\\\n \"b-\", label=\"Loss - Train\")\n h2, = ax1.plot(self.history[\"step\"], self.history[\"validLoss\"],\\\n \"b.\", label=\"Loss - Validation\")\n\n ax1.set_ylabel(\"Loss\", color = \"blue\")\n ax1.tick_params(\"y\", color = \"blue\")\n ax1.yaxis.label.set_color(\"blue\")\n ax1.set_xlabel(\"Training Steps [{}]\".format(self.FLAGS.eval_every))\n\n ax2 = ax1.twinx()\n h3, = ax2.plot(self.history[\"step\"], self.history[\"trainAccr\"], \"r-\",\\\n label = \"Accuracy - Train\")\n h4, = ax2.plot(self.history[\"step\"], self.history[\"validAccr\"], \"r.\",\\\n label = \"Accuracy - Validation\")\n\n ax2.set_ylabel(\"Accuracy\", color = \"red\")\n ax2.tick_params(\"y\", color = \"red\")\n ax2.yaxis.label.set_color(\"red\")\n\n hds = [h1,h2,h3,h4]\n lbs = [l.get_label() for l in hds]\n ax1.legend(hds, lbs)\n f1.tight_layout()\n plt.savefig(\"trainingHistory.png\")\n\n plt.close(f1)\n #plt.show()","def train_model_and_plot_results(**kwargs):\n epochs = kwargs[\"epochs\"]\n\n history, model = train_model(**kwargs)\n\n dice = history.history['dice_loss']\n val_dice = history.history['val_dice_loss']\n\n loss = history.history['loss']\n val_loss = history.history['val_loss']\n\n epochs_range = range(epochs)\n\n plt.figure(figsize=(16, 8))\n plt.subplot(1, 2, 1)\n plt.plot(epochs_range, dice, label='Training Dice Loss')\n plt.plot(epochs_range, val_dice, label='Validation Dice Loss')\n plt.legend(loc='upper right')\n plt.title('Training and Validation Dice Loss')\n\n plt.subplot(1, 2, 2)\n plt.plot(epochs_range, loss, label='Training Loss')\n plt.plot(epochs_range, val_loss, label='Validation Loss')\n plt.legend(loc='upper right')\n plt.title('Training and Validation Loss')\n\n plt.show()","def plot_data():\n \n [X_train, X_dev, X_test, Y_train, Y_dev, Y_test, numOutputNodes] = load_data('regression') \n \n traindev = np.concatenate((Y_train, Y_dev), 1)\n traindevtest = np.concatenate((traindev, Y_test), 1)\n tdt = traindevtest.reshape(traindevtest.shape[1],)\n\n Y_train = Y_train.reshape(Y_train.shape[1],)\n Y_dev = Y_dev.reshape(Y_dev.shape[1],)\n Y_test = Y_test.reshape(Y_test.shape[1],)\n\n sigma = np.round(np.std(tdt), 3)\n mu = np.round(np.mean(tdt), 3)\n\n # plots histogram of all data together, indicating values of mean and standard deviation\n plt.figure(1)\n plt.hist(tdt)\n plt.title(\"{} data points, mu = {}, sigma = {}\".format(tdt.size, mu, sigma))\n plt.xlabel(\"average Fe coordination number\")\n plt.ylabel(\"frequency\")\n plt.show()\n\n # plots histogram where the training, cross-validation, and test sets have separate bars\n plt.figure(2)\n plt.hist([Y_train, Y_dev, Y_test], label = ['training', 'cross-validation', 'test'], density = True)\n plt.xlabel(\"average Fe coordination number\")\n plt.ylabel(\"frequency\")\n plt.legend()\n plt.show()\n\n # below is graphing for the charge data, as opposed to the averaged spectrum data\n [X_train1, X_dev1, X_test1, _, _, _, Y_train1, Y_dev1, Y_test1, numOutputNodes1] = load_data('multi_task')\n traindev1 = np.concatenate((Y_train1, Y_dev1), 1)\n traindevtest1 = np.concatenate((traindev1, Y_test1), 1)\n tdt1 = traindevtest1.reshape(traindevtest1.shape[1],)\n\n Y_train1 = Y_train1.reshape(Y_train1.shape[1],)\n Y_dev1 = Y_dev1.reshape(Y_dev1.shape[1],)\n Y_test1 = Y_test1.reshape(Y_test1.shape[1],)\n\n sigma = np.round(np.std(tdt1), 3)\n mu = np.round(np.mean(tdt1), 3)\n\n # plots histogram of all data together, indicating values of mean and standard deviation\n plt.figure(3)\n plt.hist(tdt1)\n plt.title(\"{} data points, mu = {}, sigma = {}\".format(tdt1.size, mu, sigma))\n plt.xlabel(\"charge\")\n plt.ylabel(\"frequency\")\n plt.show()\n\n # plots histogram where the training, cross-validation, and test sets have separate bars\n plt.figure(4)\n plt.hist([Y_train1, Y_dev1, Y_test1], label = ['training', 'cross-validation', 'test'], density = True)\n plt.xlabel(\"charge\")\n plt.ylabel(\"frequency\")\n plt.legend()\n plt.show()\n\n return None","def plot_train(func):\n def plotting_func(model, train_config, arch, data_loader, epoch, handle_dict, optimizers):\n output_dict = func(model, train_config, arch, data_loader, epoch, optimizers)\n metrics = [output_dict['avg_elbo'], output_dict['avg_cond_log_like'], output_dict['avg_kl']]\n plot_average_metrics(metrics, epoch, handle_dict, 'Train')\n plot_param_grad_mags(output_dict['avg_param_grad_mags'], epoch, handle_dict)\n plot_state_grad_mags(output_dict['avg_state_grad_mags'], epoch, handle_dict)\n plot_opt_lr(optimizers, epoch, handle_dict)\n return output_dict, handle_dict\n return plotting_func","def train_test_error(e_train, e_test, model_params):\n\n fig = plt.figure(figsize=FIG_SIZE)\n plt.plot(model_params, e_train, label='Training Set')\n plt.plot(model_params, e_train, label='Test Set')\n plt.xlabel('Model Parameter')\n plt.ylabel('MSE of model')\n plt.legend()\n\n return fig","def train_plot_update(self, pred_, validate_y, steps_displayed, elastic_losses = None, restart_triggered = False):\n if self.interactive:\n display.clear_output(wait=True) \n \n pred_2plot = pred_.detach().to(\"cpu\")\n if not self.ODE_order:\n validate_y_2plot = validate_y.detach().to(\"cpu\")\n try:\n self.ax[1].clear()\n self.ax[0].clear()\n except:\n pass\n\n \n\n labels = \"best value\", \"all samples\"\n #log2 = np.log(2)\n\n # Plot 1: the training history of the bayesian optimization\n # if not self.log_score:\n # self.ax[0].plot(np.log(self.errorz_step), alpha = 0.5, color = \"blue\", label = labels[0] )\n # self.ax[0].plot(np.log(self.errorz), alpha = 0.2, color = \"green\", label = labels[1])\n # else:\n font_dict = {\"prop\" : {\"size\":14}}\n ticks_font_size = 14\n\n self.ax[0].plot(10**np.array(self.errorz_step), alpha = 0.5, color = \"blue\", label = labels[0] )\n self.ax[0].plot(10**np.array(self.errorz), alpha = 0.2, color = \"green\", label = labels[1])\n #self.ax[0].set_title(\"log(error) vs Thompson Sampling step\")\n self.ax[0].set_ylabel(f\"log({self.scoring_method})\")\n self.ax[0].set_xlabel(\"BO step\")\n self.ax[0].set_ylabel(\"Error\")\n self.ax[0].legend(**font_dict)\n self.ax[0].set_yscale(\"log\")\n #self.ax[0].set_ylim(10**-8,1)\n # self.ax[0].set_xtickslabels(fontsize= ticks_font_size )\n # self.ax[0].set_ytickslabels(fontsize= ticks_font_size )\n \n #plot 2: the turbo state #plot 2: the turbo state\n self.ax[1].axhline(np.log(self.state.length_max)/self.log2, color = 'green', label = 'max length')\n self.ax[1].set_title(\"TURBO state\")\n self.ax[1].plot(np.log(self.length_progress)/self.log2, color = 'blue', label = 'current length')\n self.ax[1].axhline(np.log(self.state.length_min)/self.log2, color = 'red', label = 'target length')\n self.ax[1].legend() \n\n #plot 3 (most recent prediction)\n self.ax[2].clear()\n if not self.ODE_order:\n self.ax[2].plot(validate_y_2plot.to(\"cpu\"), alpha = 0.5, color = \"blue\", label = \"val set\") #[:steps_displayed]\n self.ax[2].set_ylim(self.y.min().item() - 0.1, self.y.max().item() )\n self.ax[2].plot(pred_2plot[:steps_displayed], alpha = 0.3, color = \"red\", label = \"latest pred\")\n \n self.ax[2].set_title(\"Val Set Prediction\")\n self.ax[2].set_ylabel(\"y\")\n self.ax[2].set_xlabel(r'$t$')\n\n pl.legend()\n pl.tight_layout()\n\n display.display(pl.gcf())\n\n #clear the plot outputt and then re-plot","def plot_on_ax(ax, trn_ls, val_ls, ylabel=\"Accuracy\"):\n ax.plot(trn_ls, 'o-', label='Training')\n ax.plot(val_ls, 'x-', label='Validation')\n ax.set_xlabel('Epochs')\n ax.set_ylabel(ylabel)\n ax.legend()","def show_solver_history(solver, plot_train=True, plot_val=True, color='black'):\n mpl.rcParams['text.color'] = color\n mpl.rcParams['axes.labelcolor'] = color\n mpl.rcParams['xtick.color'] = color\n mpl.rcParams['ytick.color'] = color\n\n print(\"Stop reason: %s\" % solver.stop_reason)\n print(\"Stop time: %fs\" % solver.training_time_s)\n\n has_gender_loss = np.array(solver.history['val_gender_loss']).sum() > 0.\n has_rec_loss = np.array(solver.history['val_rec_loss']).sum() > 0.\n\n train_loss = np.array(solver.history['train_loss'])\n\n if has_rec_loss:\n train_rec_loss = np.array(solver.history['train_rec_loss'])\n val_rec_loss = np.array(solver.history['val_rec_loss'])\n if has_gender_loss:\n train_gender_loss = np.array(solver.history['train_gender_loss'])\n val_gender_loss = np.array(solver.history['val_gender_loss'])\n\n plt.figure(figsize=(20, 10))\n\n if plot_train:\n if has_rec_loss:\n plt.plot(np.linspace(1, len(train_loss), len(train_rec_loss)),\n train_rec_loss, label='Train Reconstruction loss')\n if has_gender_loss:\n plt.plot(np.linspace(1, len(train_loss), len(train_gender_loss)),\n train_gender_loss, label='ATrain Gender loss')\n\n if plot_val:\n if has_rec_loss:\n plt.plot(np.linspace(1, len(train_loss), len(val_rec_loss)),\n val_rec_loss, label='Val Reconstruction loss')\n if has_gender_loss:\n plt.plot(np.linspace(1, len(train_loss), len(val_gender_loss)),\n val_gender_loss, label='Val Gender loss')\n\n plt.xlabel(\"Iterations\", fontsize=18)\n plt.ylabel(\"Train/Val loss\", fontsize=18)\n plt.xticks(fontsize=14)\n plt.yticks(fontsize=14)\n legend = plt.legend(fontsize=14)\n for text in legend.get_texts():\n text.set_color(\"black\")\n\n plt.show()\n\n if has_rec_loss:\n print(\"Final training reconstruction loss: {}\".format(\n train_rec_loss[-1]))\n print(\"Final validation reconstruction loss: {}\".format(\n val_rec_loss[-1]))\n if has_gender_loss:\n print(\"Final training gender loss: {}\".format(train_gender_loss[-1]))\n print(\"Final validation gender loss: {}\".format(val_gender_loss[-1]))","def plot_metrics(history):\n\n pyplot.plot(history.history['loss'], label='loss')\n\n pyplot.plot(history.history['val_loss'], label='val_loss')\n\n pyplot.legend()\n\n pyplot.show()","def learning_curve():\n loss = []\n val_loss = []\n data_size = []\n\n x_slid, y_slid = sliding_window_main(x, y)\n x_train, y_train, x_val, y_val, x_test, y_test = data_splitting_main(x_slid, y_slid)\n m_tot = x_train.shape[0]\n\n batch_step = 50\n try:\n for m in range(batch_size, m_tot, batch_step*batch_size):\n print(\"Training: \", m)\n net = create_network()\n history = trainer(net, x_train[:m], y_train[:m], x_val, y_val)\n loss.append(history.history[\"loss\"][-1])\n val_loss.append(history.history[\"val_loss\"][-1])\n data_size.append(m)\n\n print(\"Loss:\", loss[-1])\n print()\n\n finally:\n plt.plot(data_size, loss, label=\"Loss\", marker=\"o\")\n plt.plot(data_size, val_loss, label=\"Val Loss\", marker=\"o\")\n plt.xlabel(\"m\")\n plt.ylabel(\"Losses\")\n plt.title(\"Model Loss\")\n plt.legend()\n plt.savefig(\"img/\" + datetime.now().strftime(\"%y%m%d_%H%M\") + \"_learning_curve.png\")\n plt.show()\n plt.close()\n\n return loss, val_loss","def plot_train_test_errors(train_errors, test_errors, lambda_str , K , path, rng):\n plt.plot(range(rng), train_errors, marker='o', label='Training Data');\n plt.plot(range(rng), test_errors, marker='v', label='Test Data');\n plt.title('ALS-WR Learning Curve, lambda = %s, K = %d'%(lambda_str, K))\n plt.xlabel('Number of Epochs');\n plt.ylabel('RMSE');\n plt.legend()\n plt.grid()\n plt.savefig(\"../results/test_train_rmse_\"+path)\n plt.show()","def fit(self, plot_loss=True):\n adam = optim.Adam(self.learning_rate)\n self.svi = SVI(\n self.vae_model, \n self.vae_guide, \n adam, \n Trace_ELBO()\n )\n # encoder_nn = self.vae_encoder()\n # decoder_nn = self.vae_decoder()\n rng_key, rng_key_samp, rng_key_init = random.split(self.rng_key, 3)\n\n self.gp_predictive = Predictive(self.gp.sample, num_samples=self.batch_size)\n\n # initialise with a sample batch\n sample_batch = self.gp_predictive(rng_key=rng_key_samp, x=self.x)\n \n svi_state = self.svi.init(rng_key_init, sample_batch['y'])\n test_loss_list = []\n\n for i in range(self.num_epochs):\n rng_key, rng_key_train, rng_key_test = random.split(rng_key, 3)\n t_start = time.time()\n\n _, svi_state = self.epoch_train(rng_key_train, svi_state)\n test_loss = self.eval_test(rng_key_test, svi_state)\n test_loss_list += [test_loss]\n\n print(\n \"Epoch {}: loss = {} ({:.2f} s.)\".format(\n i, test_loss, time.time() - t_start\n )\n )\n \n if np.isnan(test_loss): break\n\n if plot_loss:\n plt.figure()\n plt.plot(np.arange(0, self.num_epochs, 1)[0:len(test_loss_list)], test_loss_list)\n plt.xlabel(\"epochs\")\n plt.ylabel(\"test error\")\n plt.savefig('src/test/plots/vae_lost.png')\n plt.show()\n plt.close()\n\n # return optimal parameters for decoder\n return self.svi.get_params(svi_state)[\"decoder$params\"]","def visualize_loss_weights_siamese(cross_val_results, plot_filepath):\n\n siamese_model_scores_2, siamese_model_stds_2 = cross_val_results\n\n def organize_data(scores, stds):\n \"\"\"\n Helper function to organize score means and standard deviations across loss weight values as pandas.Dataframe\n\n :param scores: dictionary of score means {loss_weights: score_mean}\n :param stds: dictionary of score stds {loss_weights: score_std}\n\n :returns: tuple of 2 pandas.Dataframe objects containing mean and std data\n \"\"\"\n\n scores = pd.Series(list(scores.values()),\n index=map(str, scores.keys()),\n name=\"SCORE MEAN\")\n scores.index.name = \"AUXILIARY LOSS WEIGHTS\"\n stds = pd.Series(list(stds.values()),\n index=map(str, stds.keys()),\n name=\"SCORE STD\")\n stds.index.name = \"AUXILIARY LOSS WEIGHTS\"\n return scores, stds\n\n siamese_model_scores_2, siamese_model_stds_2 = organize_data(siamese_model_scores_2, siamese_model_stds_2)\n\n plt.figure(figsize=(10, 5))\n siamese_model_scores_2.plot.line(yerr=siamese_model_stds_2,\n capsize=5,\n ylim=(0.3, 1.1),\n colormap=colormap_brg_darker)\n plt.title(\"Cross validation results for the\\nsiamese auxiliary loss weights\", fontsize=18)\n plt.xlabel(\"Loss weights\", fontsize=14)\n plt.ylabel(\"Average accuracy\", fontsize=14)\n plt.xticks(fontsize=12, rotation=30)\n plt.yticks(fontsize=12)\n plt.tight_layout()\n plt.savefig(fname=plot_filepath, dpi=\"figure\", format=\"eps\")\n plt.close()","def plotHistory(history):\n \n acc = history.history['acc']\n val_acc = history.history['val_acc']\n loss = history.history['loss']\n val_loss = history.history['val_loss']\n\n epochs = range(len(acc))\n \n # Make and save the plot for our accuracy\n plt.plot(epochs, acc, 'bo', label='Training acc')\n plt.plot(epochs, val_acc, 'b', label='Validation acc')\n plt.title('Training and validation accuracy')\n plt.legend()\n plt.savefig(\"trainValAccSecond.png\")\n\n # Make and save the plots for our loss \n plt.figure()\n plt.plot(epochs, loss, 'bo', label='Training loss')\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n plt.show()\n plt.savefig(\"trainValLossSecond.png\")","def error_values(X_train,X_test,Y_train,Y_test):\n #setting up parameters and variables for plotting \n n_train = X_train.shape[0]\n n_test = X_test.shape[0]\n d = X_train.shape[1]\n hdnode = 100\n w1 = np.random.normal(0,0.001,d*hdnode).reshape((d,hdnode))\n d1 = np.zeros((d,hdnode))\n w2 = np.random.normal(0,0.001,hdnode).reshape((hdnode,1))\n d2 = np.zeros(hdnode)\n h = np.zeros(hdnode)\n mb = 100 #minibatch size\n m = int(n_train/mb)\n batch = np.arange(m) \n lr = 0.00020\n EP = 20000 #needed for initializing \n ep = 0\n yh = np.zeros((n_train,1))\n yh2 = np.zeros((n_test,1))\n L_train= np.zeros(EP+1)\n L_test = np.zeros(EP+1)\n Y_train = Y_train.reshape(len(Y_train),1)\n #activation function for the hidden layer is tanh\n \n def g(A):\n return (np.tanh(A))\n\n def gd(A):\n return (1-np.square(np.tanh(A)))\n \n #setting up how long the epoch will run\n EP = 200\n ep = 0\n while ep < EP:\n ep += 1\n yh = g(X_train.dot(w1)).dot(w2)\n yh2 = g(X_test.dot(w1)).dot(w2)\n L_train[ep] = LA.norm(yh-Y_train.reshape(len(Y_train),1))/n_train\n L_test[ep] = LA.norm(yh2-Y_test.reshape(len(Y_test),1))/n_test\n \n np.random.shuffle(batch)\n for i in range(m):\n st = batch[i]*mb\n ed = (batch[i]+1)*mb\n h = g(X_train[st:ed].dot(w1))\n y = h.dot(w2)\n d2 = h.T.dot(Y_train[st:ed]-y)\n d1 = X_train[st:ed].T.dot(np.multiply((Y_train[st:ed]-y).dot(w2.T),gd(X_train[st:ed].dot(w1))))\n w2 += lr*d2\n w1 += lr*d1\n return yh, yh2","def plot_loss(path_to_loss, file_name):\n path = '../'\n labels = ['gen_total_loss', 'gen_loss', 'l1_loss', 'disc_total_loss', 'disc_gen_loss', 'disc_real_loss']\n with open(path_to_loss + file_name + '.csv', newline='') as f:\n reader = csv.reader(f)\n data = np.array(list(reader))\n\n try:\n os.mkdir(path + 'lossfig/losses_' + file_name)\n except:\n pass\n\n epoch_count = range(1, data.shape[0] + 1)\n for i in range(data.shape[1]):\n plt.figure()\n plt.plot(epoch_count, data[:, i].astype('float32'))\n plt.xlabel('Epoch')\n plt.ylabel(labels[i])\n plt.savefig(path + 'lossfig/losses_' + file_name + '/' + labels[i] + '.png')\n\n plt.figure()\n for i in range(data.shape[1]):\n plt.plot(epoch_count, data[:, i].astype('float32'))\n plt.legend(labels)\n plt.xlabel('Epoch')\n plt.ylabel('loss')\n plt.savefig(path + 'lossfig/losses_' + file_name + '/all_loss.png')","def plot_training_history(history):\n fig, (ax_loss, ax_acc) = plt.subplots(1, 2, figsize=(15, 5))\n ax_loss.plot(history.epoch, history.history[\"loss\"], label=\"Train loss\")\n ax_loss.plot(history.epoch, history.history[\"val_loss\"], label=\"Validation loss\")\n ax_loss.legend()\n ax_acc.plot(history.epoch, history.history[\"iou_score\"], label=\"Train iou\")\n ax_acc.plot(history.epoch, history.history[\"val_iou_score\"], label=\"Validation iou\")\n ax_acc.legend()","def plot_training_history(history, metric):\n \n val_metric = 'val_'+metric\n acc = history.history[metric]\n val_acc = history.history[val_metric]\n \n loss = history.history['loss']\n val_loss = history.history['val_loss']\n \n epochs_range = history.epoch\n \n plt.figure(figsize=(8, 8))\n plt.subplot(2, 1, 1)\n plt.plot(epochs_range, acc, label='Training Acc.')\n plt.plot(epochs_range, val_acc, label='Validation Acc.')\n plt.legend(loc='best',)\n plt.title('Training and Validation Accuracy')\n \n plt.subplot(2, 1, 2)\n plt.plot(epochs_range, loss, label='Training Loss')\n plt.plot(epochs_range, val_loss, label='Validation Loss')\n plt.legend(loc='best')\n plt.title('Training and Validation Loss')\n plt.show()","def visualize_training(features, labels, pl):\n print(\"Visualizing training\")\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n # Take out each feature type, one at a time\n label_map = get_label_map(labels)\n\n for key in label_map.keys():\n like_ind = label_map[key]\n like_data = np.array([features[i] for i in like_ind])\n\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\n\n # get limits\n xmin = features.column_min(0) - .5\n xmax = features.column_max(0) + .5\n ymin = features.column_min(1) - .5\n ymax = features.column_max(1) + .5\n\n plt.xlim(xmin,xmax)\n plt.ylim(ymin,ymax)\n\n # Track the current dividing line, as well as the number of epochs passed\n divider, = plt.plot([],[])\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\n\n def update(i):\n \"\"\"\n 1.) Get the next set of weights from the tracker\n 2.) Calculate and draw the new divider line\n 3.) Update the epoch counter\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\n \"\"\"\n epoch = i//features.instance_count\n w = pl.weights_tracker[i]\n a = pl.accuracy_tracker[epoch]\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\n epoch_tracker.set_text(\"{} {}\".format(epoch + 1, a))\n\n # Keep a shadow of the hyperplane at the end of each epoch\n if i % features.instance_count == 0:\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\n\n return divider\n\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\n plt.legend()\n\n # optional save file\n if len(sys.argv) >= 3 :\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\n\n plt.show()","def plot_metrics(self, title=None, fig_size=None, col_count=3):\n metric_names = self.tracked_metrics()\n metric_vals = {metric_name: self.metrics_history[metric_name][\"epoch_vals\"] for metric_name in metric_names}\n if self.include_val_metrics:\n # also has validation metrics\n for metric_name in metric_names:\n metric_vals[f\"val_{metric_name}\"] = self.metrics_history[f\"val_{metric_name}\"][\"epoch_vals\"]\n\n # we will plot a max of 3 metrics per row\n MAX_COL_COUNT = col_count\n col_count = MAX_COL_COUNT if len(metric_names) > MAX_COL_COUNT else len(metric_names)\n row_count = len(metric_names) // MAX_COL_COUNT\n row_count += 1 if len(metric_names) % MAX_COL_COUNT != 0 else 0\n # we'll always have \"loss\" metric in list, so safest to pick!\n x_vals = np.arange(1, len(metric_vals[\"loss\"]) + 1)\n\n with sns.axes_style(\"darkgrid\"):\n sns.set_context(\"notebook\") # , font_scale = 1.2)\n sns.set_style(\n {\"font.sans-serif\": [\"Segoe UI\", \"Calibri\", \"SF Pro Display\", \"Arial\", \"DejaVu Sans\", \"Sans\"]}\n )\n fig_size = (16, 5) if fig_size is None else fig_size\n\n if len(metric_names) == 1:\n # only loss\n plt.figure(figsize=fig_size)\n plt.plot(x_vals, metric_vals[\"loss\"], lw=2, markersize=7, color=\"steelblue\", marker=\"o\")\n if self.include_val_metrics:\n plt.plot(x_vals, metric_vals[\"val_loss\"], lw=2, markersize=7, color=\"firebrick\", marker=\"o\")\n legend = [\"train\", \"valid\"] if self.include_val_metrics else [\"train\"]\n plt_title = (\n f\"Training & Cross-validation Loss vs Epochs\" if len(legend) == 2 else f\"Training Loss vs Epochs\"\n )\n plt.title(plt_title)\n plt.legend(legend, loc=\"best\")\n else:\n f, ax = plt.subplots(row_count, col_count, figsize=fig_size)\n for r in range(row_count):\n for c in range(col_count):\n index = r * (col_count - 1) + c\n if index < len(metric_names):\n metric_name = metric_names[index]\n if row_count == 1:\n ax[c].plot(x_vals, metric_vals[metric_name], lw=2, markersize=7, marker=\"o\")\n else:\n ax[r, c].plot(x_vals, metric_vals[metric_name], lw=2, markersize=7, marker=\"o\")\n if self.include_val_metrics:\n if row_count == 1:\n ax[c].plot(\n x_vals, metric_vals[f\"val_{metric_name}\"], lw=2, markersize=7, marker=\"o\"\n )\n else:\n ax[r, c].plot(\n x_vals, metric_vals[f\"val_{metric_name}\"], lw=2, markersize=7, marker=\"o\"\n )\n legend = [\"train\", \"valid\"] if self.include_val_metrics else [\"train\"]\n ax_title = (\n f\"Training & Cross-validation '{metric_name}' vs Epochs\"\n if len(legend) == 2\n else f\"Training '{metric_name}' vs Epochs\"\n )\n if row_count == 1:\n ax[c].legend(legend, loc=\"best\")\n ax[c].set_title(ax_title)\n else:\n ax[r, c].legend(legend, loc=\"best\")\n ax[r, c].set_title(ax_title)\n\n if title is not None:\n plt.suptitle(title)\n\n plt.show()","def train_with_validation_provided(self, features, labels, val_features, val_labels):\n hist = self.model.fit(\n features, labels, batch_size=self.config['training']['batch_size'],\n epochs=self.config['training']['epochs'],\n validation_data=(val_features, val_labels),\n validation_freq=self.config['training']['validation_frequency'],\n callbacks=[TensorBoard(log_dir=self.config['model']['tensorboard_dir'])])\n return hist","def plot_data(losses, accuracies, name):\n # convert accuracies to percentages\n accuracies['Train'] = [acc * 100 for acc in accuracies['Train']]\n accuracies['Valid'] = [acc * 100 for acc in accuracies['Valid']]\n # set fontsize\n plt.rcParams.update({'font.size': 13})\n fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(8,5))\n ax1.set_xlabel('Number of Epochs')\n ax1.set_ylabel('Cross Entropy Loss')\n ax1.set_ylim(0,2)\n ax1.plot(losses['Train'], label='Training')\n ax1.plot(losses['Valid'], label='Validation')\n ax1.legend(loc='upper right')\n\n ax2.set_xlabel('Number of Epochs')\n ax2.set_ylabel('Accuracy (%)')\n ax2.set_ylim(0,100)\n ax2.plot(accuracies['Train'], label='Training')\n ax2.plot(accuracies['Valid'], label='Validation')\n ax2.legend(loc='upper left')\n\n fig.tight_layout()\n fig.savefig('../outputs/' + name)","def learning_curve(dataframe:object, analysis_type:str, loss_skip_15pct:bool=False):\n\n\t\t# Spline seems to crash with too many points.\n\t\tif (dataframe.shape[0] >= 400):\n\t\t\tline_shape = 'linear'\n\t\telif (dataframe.shape[0] < 400):\n\t\t\tline_shape = 'spline'\n\n\t\tdf_loss = dataframe[['loss','val_loss']]\n\t\tdf_loss = df_loss.rename(columns={\"loss\": \"train_loss\", \"val_loss\": \"validation_loss\"})\n\t\tdf_loss = df_loss.round(3)\n\n\t\tif loss_skip_15pct:\n\t\t\tdf_loss = df_loss.tail(round(df_loss.shape[0]*.85))\n\n\t\tfig_loss = px.line(\n\t\t\tdf_loss\n\t\t\t, title = '<i>Training History: Loss</i>'\n\t\t\t, line_shape = line_shape\n\t\t)\n\t\tfig_loss.update_layout(\n\t\t\txaxis_title = \"Epochs\"\n\t\t\t, yaxis_title = \"Loss\"\n\t\t\t, legend_title = None\n\t\t\t, font_family = \"Avenir\"\n\t\t\t, font_color = \"#FAFAFA\"\n\t\t\t, plot_bgcolor = \"#181B1E\"\n\t\t\t, paper_bgcolor = \"#181B1E\"\n\t\t\t, height = 400\n\t\t\t, hoverlabel = dict(\n\t\t\t\tbgcolor = \"#0F0F0F\"\n\t\t\t\t, font_size = 15\n\t\t\t\t, font_family = \"Avenir\"\n\t\t\t)\n\t\t\t, yaxis = dict(\n\t\t\t\tside = \"right\"\n\t\t\t\t, tickmode = 'auto'# When loss is initially high, the 0.1 tickmarks are overwhelming.\n\t\t\t\t, tick0 = -1\n\t\t\t\t, nticks = 9\n\t\t\t)\n\t\t\t, legend = dict(\n\t\t\t\torientation=\"h\"\n\t\t\t\t, yanchor=\"bottom\"\n\t\t\t\t, y=1.02\n\t\t\t\t, xanchor=\"right\"\n\t\t\t\t, x=1\n\t\t\t)\n\t\t\t, margin = dict(\n\t\t\t\tt = 5\n\t\t\t\t, b = 0\n\t\t\t),\n\t\t)\n\t\tfig_loss.update_xaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\n\t\tfig_loss.update_yaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\n\n\t\tif (\"classification\" in analysis_type):\n\t\t\tdf_acc = dataframe[['accuracy', 'val_accuracy']]\n\t\t\tdf_acc = df_acc.rename(columns={\"accuracy\": \"train_accuracy\", \"val_accuracy\": \"validation_accuracy\"})\n\t\t\tdf_acc = df_acc.round(3)\n\n\t\t\tfig_acc = px.line(\n\t\t\tdf_acc\n\t\t\t\t, title = '<i>Training History: Accuracy</i>'\n\t\t\t\t, line_shape = line_shape\n\t\t\t)\n\t\t\tfig_acc.update_layout(\n\t\t\t\txaxis_title = \"epochs\"\n\t\t\t\t, yaxis_title = \"accuracy\"\n\t\t\t\t, legend_title = None\n\t\t\t\t, font_family = \"Avenir\"\n\t\t\t\t, font_color = \"#FAFAFA\"\n\t\t\t\t, plot_bgcolor = \"#181B1E\"\n\t\t\t\t, paper_bgcolor = \"#181B1E\"\n\t\t\t\t, height = 400\n\t\t\t\t, hoverlabel = dict(\n\t\t\t\t\tbgcolor = \"#0F0F0F\"\n\t\t\t\t\t, font_size = 15\n\t\t\t\t\t, font_family = \"Avenir\"\n\t\t\t\t)\n\t\t\t\t, yaxis = dict(\n\t\t\t\tside = \"right\"\n\t\t\t\t, tickmode = 'linear'\n\t\t\t\t, tick0 = 0.0\n\t\t\t\t, dtick = 0.05\n\t\t\t\t)\n\t\t\t\t, legend = dict(\n\t\t\t\t\torientation=\"h\"\n\t\t\t\t\t, yanchor=\"bottom\"\n\t\t\t\t\t, y=1.02\n\t\t\t\t\t, xanchor=\"right\"\n\t\t\t\t\t, x=1\n\t\t\t\t)\n\t\t\t\t, margin = dict(\n\t\t\t\t\tt = 5\n\t\t\t\t),\n\t\t\t)\n\t\t\tfig_acc.update_xaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\n\t\t\tfig_acc.update_yaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\n\t\t\tfig_acc.show()\n\t\tfig_loss.show()","def plots(self, history):\n print(history.history.keys())\n plt.plot(history.history['acc'])\n plt.plot(history.history['val_acc'])\n plt.title('model accuracy')\n plt.ylabel('accuracy')\n plt.xlabel('epoch')\n plt.legend(['train','test'], loc='upper left')\n plt.show()\n\n plt.plot(history.history['loss'])\n plt.plot(history.history['val_loss'])\n plt.title('model loss')\n plt.ylabel('loss')\n plt.xlabel('epoch')\n plt.legend(['train','test'], loc='upper left')\n plt.show()","def plot_history(H, epochs):\n plt.style.use(\"fivethirtyeight\")\n plt.figure()\n plt.plot(np.arange(0, epochs), H.history[\"loss\"], label=\"train_loss\")\n plt.plot(np.arange(0, epochs), H.history[\"val_loss\"], label=\"val_loss\")\n plt.plot(np.arange(0, epochs), H.history[\"accuracy\"], label=\"train_acc\")\n plt.plot(np.arange(0, epochs), H.history[\"val_accuracy\"], label=\"val_acc\")\n plt.title(\"Training Loss and Accuracy\")\n plt.xlabel(\"Epoch #\")\n plt.ylabel(\"Loss/Accuracy\")\n plt.legend()\n plt.tight_layout()\n plt.show()","def train(self,X,Y,show_loss_history=True):\n\n n_data = len(X)\n n_batches = int(n_data / self.batch_size)\n\n loss_history = np.zeros([n_batches,self.epochs])\n\n print(\"\\nStarting training\")\n print(\"{} samples\".format(n_data))\n print(\"{} epochs\".format(self.epochs))\n print(\"{} batches\".format(n_batches))\n\n for epoch in tqdm(range(self.epochs)):\n for batch in tqdm(range(n_batches)):\n\n X_batch = X[self.batch_size*batch:self.batch_size*(batch+1)]\n Y_batch = Y[self.batch_size*batch:self.batch_size*(batch+1)]\n loss = self.train_batch(X_batch,Y_batch)\n\n loss_history[batch,epoch] = loss\n\n if show_loss_history:\n loss_history = np.mean(loss_history,axis=0)\n n_epochs = np.array(range(len(loss_history))) + 1\n\n plt.plot(n_epochs,loss_history)\n plt.xlabel(\"Number of epochs\")\n plt.ylabel(\"Loss\")\n plt.show()","def plot_loss_history(data=None, title=None, name=None, path=None):\n # TODO: add labels to loss history\n plt.figure(random.randint(a=1, b=100))\n plt.title(title)\n plt.plot(data)\n plt.savefig('{}/{}.png'.format(path, name))","def cross_validation_visualization_mean(epochs, means, save=False, filename = \"cross_validation_mean\"):\n plt.plot(epochs, means, marker=\".\", color='b', label='means')\n plt.xlabel(\"epoch\")\n plt.ylabel(\"mean loss\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n if (save):\n plt.savefig(filename)"],"string":"[\n \"def loss_plot(train_loss, val_loss, filename):\\n\\tplt.plot(train_loss)\\n\\tplt.plot(val_loss)\\n\\tplt.ylabel('Loss')\\n\\tplt.xlabel('Epochs')\\n\\tplt.legend(['Train', 'Val'], loc='upper right')\\n\\tplt.savefig(filename)\\n\\tplt.close()\",\n \"def plot_loss():\\n df = pd.read_csv('data/loss.csv', encoding='utf-8')\\n loss = df['loss'].values\\n val_loss = df['val_loss'].values\\n x = [i for i in range(1, len(loss) + 1)]\\n\\n plt.plot(x, loss, label='Train loss')\\n plt.plot(x, val_loss, label='Val loss')\\n\\n plt.xlabel('Epochs')\\n plt.ylabel('Contrastive Loss')\\n plt.title('Train and test loss')\\n plt.grid(True)\\n plt.legend(shadow=True, fontsize='x-large')\\n\\n plt.show()\",\n \"def plot_loss(stats):\\r\\n plt.plot(stats['train_loss_ind'], stats['train_loss'], label='Training loss')\\r\\n plt.plot(stats['val_loss_ind'], stats['val_loss'], label='Validation loss')\\r\\n plt.legend()\\r\\n plt.xlabel('Number of iterations')\\r\\n plt.ylabel('Loss')\\r\\n plt.show()\",\n \"def plot_loss(training_errors, validation_errors):\\n plt.xscale('Log')\\n plt.xlabel('Epochs')\\n plt.ylabel('Mean Actual Error')\\n plt.plot(training_errors, label = \\\"Training Error\\\", \\\\\\n color = 'blue')\\n plt.plot(validation_errors, label = \\\"Validation Error\\\", \\\\\\n color = 'red')\\n plt.legend()\\n # Saves plot automatically, adjust filename as needed.\\n plt.savefig('reservoir_05whdens_100h_7spec_test_3.png')\\n plt.show()\",\n \"def plot_errors(loss_train, loss_val, jet):\\n plt.plot(list(range(len(loss_train))), loss_train, 'g', label='Training loss')\\n plt.plot(list(range(len(loss_val))), loss_val, 'b', label='Validation loss')\\n plt.title('Training and Validation loss for jet: {jet}'.format(jet=jet))\\n plt.xlabel('Epochs')\\n plt.ylabel('Loss')\\n plt.legend()\\n plt.show()\",\n \"def plot_train_val_loss(path_to_file, train_filename, val_filename):\\n path = '../'\\n labels = ['gen_total_loss', 'gen_loss', 'l1_loss', 'disc_total_loss', 'disc_gen_loss', 'disc_real_loss']\\n with open(path_to_file + train_filename + '.csv', newline='') as f:\\n reader = csv.reader(f)\\n train_data = np.array(list(reader))\\n with open(path_to_file + val_filename + '.csv', newline='') as f:\\n reader = csv.reader(f)\\n val_data = np.array(list(reader))\\n\\n if train_data.shape == val_data.shape:\\n # change label number for the type of loss that should be plotted\\n label = 0\\n print(train_data.shape, val_data.shape)\\n epoch_count = range(1, train_data.shape[0] + 1)\\n plt.figure()\\n plt.plot(epoch_count, val_data[:len(epoch_count), label].astype('float32'))\\n plt.plot(epoch_count, train_data[:len(epoch_count), label].astype('float32'))\\n plt.legend(['validation', 'train'])\\n plt.xlabel('Epoch')\\n plt.ylabel(labels[label])\\n plt.show()\",\n \"def plot_loss(x, loss_train, loss_valid, title):\\n plt.figure()\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Loss\\\")\\n plt.title(title)\\n plt.plot(x, loss_train, '-b', label='Training')\\n plt.plot(x, loss_valid, '-r', linestyle=(0, (1, 2)), label='Validation')\\n plt.legend([\\\"Training\\\", \\\"Validation\\\"], loc=\\\"upper right\\\", frameon=False)\\n plt.yscale(\\\"log\\\")\\n # plt.show()\\n plt.savefig('{}.png'.format(title))\",\n \"def plot_losses(train, test, mode):\\n\\tplt.figure()\\n\\tplt.plot(range(len(train)), train, 'r', label='Training')\\n\\tplt.plot(range(len(test)), test, 'b', label='Testing')\\n\\tplt.title('MSE Loss (batch type: ' + mode + ')')\\n\\tplt.legend()\\n\\tplt.show()\",\n \"def plot_loss(self):\\n train_elbo_range = range(len(self.train_elbo_hist))\\n val_elbo_range = range(len(self.val_elbo_hist))\\n train_loss_range = range(len(self.train_loss_hist))\\n val_loss_range = range(len(self.val_loss_hist))\\n\\n fig, ax = plt.subplots(2, 2)\\n ax[0][0].plot(train_elbo_range, self.train_elbo_hist)\\n ax[0][0].title.set_text(\\\"Train ELBO\\\")\\n ax[0][1].plot(val_elbo_range, self.val_elbo_hist)\\n ax[0][1].title.set_text(\\\"Val ELBO\\\")\\n ax[1][0].plot(train_loss_range, self.train_loss_hist)\\n ax[1][0].title.set_text(\\\"Train MSE\\\")\\n ax[1][1].plot(val_loss_range, self.val_loss_hist)\\n ax[1][1].title.set_text(\\\"Val MSE\\\")\\n plt.tight_layout()\\n plt.show()\",\n \"def plot_loss (history):\\n \\n history_dict = history.history\\n loss_values = history_dict['loss']\\n val_loss_values = history_dict['val_loss']\\n epochs = range(1, len(loss_values) + 1)\\n\\n plt.plot (epochs, loss_values, 'bo', label='Training loss')\\n plt.plot (epochs, val_loss_values, 'b', label=\\\"validation loss\\\")\\n plt.title('Training and validation loss')\\n plt.xlabel('Epochs')\\n plt.ylabel('Loss')\\n plt.legend()\\n plt.show()\",\n \"def plot_curve(self):\\n x1 = np.arange(self.init_epoch, self.params.num_epoch+1, dtype=np.int).tolist()\\n x2 = np.linspace(self.init_epoch, self.epoch,\\n num=(self.epoch-self.init_epoch)//self.params.val_every+1, dtype=np.int64)\\n plt.plot(x1, self.train_loss, label='train_loss')\\n plt.plot(x2, self.val_loss, label='val_loss')\\n plt.legend(loc='best')\\n plt.title('Train/Val loss')\\n plt.grid()\\n plt.xlabel('Epoch')\\n plt.ylabel('Loss')\\n plt.show()\",\n \"def plot_loss_vs_epoch(history, var_train, var_val, show=False):\\n plt.figure(figsize=(10, 8))\\n plt.grid(True)\\n plt.plot(history.history['loss']/var_train, marker=\\\"o\\\")\\n plt.plot(history.history['val_loss']/var_val, marker=\\\"o\\\")\\n plt.title('Model Loss')\\n plt.ylabel('Loss (Normalised to variance of dataset)')\\n plt.xlabel('Epoch')\\n plt.legend(['Train', 'Validation'])\\n # plt.ylim(bottom=0)\\n filename = \\\"img/\\\"\\n filename += datetime.now().strftime(\\\"%y%m%d_%H%M\\\")\\n filename += \\\"_model_loss.png\\\"\\n plt.savefig(filename)\\n\\n if show:\\n plt.show()\",\n \"def loss_graph(self, training_costs, test_costs, learning_rate, training_accuracy, test_accuracy, val_accuracy,\\n layers, data_size, n_neighbours, dropout_layer, dropout_rate):\\n\\n plt.plot(training_costs, label=\\\"Training loss\\\")\\n plt.plot(test_costs, label=\\\"Test loss\\\")\\n plt.xlabel(\\\"Iterations\\\", size='medium')\\n plt.ylabel(\\\"Cost function (%)\\\", size='medium')\\n plt.suptitle(\\\"Cost function while training the neural network\\\", size='medium', ha='center')\\n if True in dropout_layer:\\n plt.title(\\\"layers: {}, dropout rate: {}, learning rate: {}\\\".format(layers, dropout_rate, learning_rate),\\n size='small', ha='center')\\n else:\\n plt.title(\\\"layers: {}, learning rate: {}\\\".format(layers, learning_rate), size='small', ha='center')\\n plt.figtext(0.77, 0.35, \\\"Training accuracy\\\\n{0:.2f}%\\\".format(training_accuracy), size='medium')\\n plt.figtext(0.77, 0.25, \\\"Test accuracy\\\\n{0:.2f}%\\\".format(test_accuracy), size='medium')\\n plt.figtext(0.77, 0.15, \\\"Validation accuracy\\\\n{0:.2f}%\\\".format(val_accuracy), size='medium')\\n if n_neighbours == 0:\\n plt.figtext(0.77, 0.80, \\\"Neighbours\\\\nexcluded\\\", size='medium')\\n else:\\n plt.figtext(0.77, 0.80, \\\"{} neighbours\\\\nincluded\\\".format(n_neighbours), size='medium')\\n plt.figtext(0.77, 0.70, \\\"{}\\\\nsamples\\\".format(data_size))\\n plt.legend(loc='right', bbox_to_anchor=(1.39, 0.5))\\n plt.subplots_adjust(right=0.75)\\n working_dir = os.path.dirname(os.path.abspath(__file__))\\n saving(working_dir + \\\"/output_ANN/loss_plots/{}_error_{}\\\".format(n_neighbours, data_size))\",\n \"def plot_loss(self):\\n plt.plot(self.loss[10:], 'g+', label = \\\"loss\\\")\\n plt.plot(self.loss[10:], 'r--', label = \\\"loss (smooth)\\\")\\n plt.title(f\\\"Graph of loss after {len(self.loss)} steps of Gradient Descent.\\\")\\n plt.xlabel('steps')\\n plt.ylabel('loss')\\n plt.legend()\\n plt.show()\",\n \"def plot_loss(G_losses, D_losses):\\n plt.figure(figsize=(10,5))\\n plt.title(\\\"Generator and Discriminator Loss During Training\\\")\\n plt.plot(G_losses,label=\\\"G\\\")\\n plt.plot(D_losses,label=\\\"D\\\")\\n plt.xlabel(\\\"iterations\\\")\\n plt.ylabel(\\\"Loss\\\")\\n plt.legend()\\n plt.show()\",\n \"def graph(trainingLoss, validationLoss = None):\\n style.use('fivethirtyeight')\\n fig = plt.figure()\\n ax1 = fig.add_subplot(1, 1, 1)\\n ax1.cla()\\n if validationLoss is not None:\\n ax1.plot(np.array(range(len(trainingLoss))) + 1, validationLoss, label=\\\"Validation loss\\\")\\n# print('Epoch: {} \\\\tTraining Loss: {:.6f} \\\\tValidation Loss: {:.6f}'.format(len(trainingLoss), trainingLoss[-1], validationLoss[-1]))\\n# else:\\n# print('Epoch: {} \\\\tTraining Loss: {:.6f}'.format(len(trainingLoss), trainingLoss[-1]))\\n ax1.plot(np.array(range(len(trainingLoss))) + 1, trainingLoss, label=\\\"Training loss\\\")\\n plt.legend(loc='best')\\n plt.tight_layout()\\n plt.show()\",\n \"def train_visualization(output_path): \\n log_path = output_path + 'output.log'\\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\\n n_epoch = len(Train_Cost)\\n\\n x1 = range(n_epoch)\\n x2 = range(n_epoch)\\n y1 = Train_Cost\\n y2 = Valid_Cost\\n y3 = Test_Cost\\n y4 = Train_Acc\\n y5 = Valid_Acc\\n y6 = Test_Acc\\n plt.subplot(2, 1, 1)\\n plt.plot(x1, y1, label=\\\"Train_Cost\\\", linewidth=2)\\n plt.plot(x1, y2, label=\\\"Valid_Cost\\\", linewidth=2)\\n plt.plot(x1, y3, label=\\\"Test_Cost\\\", linewidth=2)\\n\\n plt.title('binary cross entropy vs. epoches')\\n plt.ylabel('binary cross entropy')\\n plt.legend(loc='best')\\n plt.subplot(2, 1, 2)\\n plt.plot(x2, y4, label=\\\"Train_Acc\\\", linewidth=2)\\n plt.plot(x2, y5, label=\\\"Valid_Acc\\\", linewidth=2)\\n plt.plot(x2, y6, label=\\\"Test_Acc\\\", linewidth=2)\\n plt.xlabel('Accuracy@20 vs. epoches')\\n plt.ylabel('Accuracy@20')\\n plt.legend(loc='best')\\n plt.savefig(output_path + 'loss_fig.png')\\n # plt.show()\",\n \"def plot_loss_curves(results):\\n loss = results[\\\"train_loss\\\"]\\n test_loss = results[\\\"test_loss\\\"]\\n\\n accuracy = results[\\\"train_acc\\\"]\\n test_accuracy = results[\\\"test_acc\\\"]\\n\\n epochs = range(len(results[\\\"train_loss\\\"]))\\n\\n plt.figure(figsize=(15, 7))\\n\\n # Plot loss\\n plt.subplot(1, 2, 1)\\n plt.plot(epochs, loss, label=\\\"train_loss\\\")\\n plt.plot(epochs, test_loss, label=\\\"test_loss\\\")\\n plt.title(\\\"Loss\\\")\\n plt.xlabel(\\\"Epochs\\\")\\n plt.legend()\\n\\n # Plot accuracy\\n plt.subplot(1, 2, 2)\\n plt.plot(epochs, accuracy, label=\\\"train_accuracy\\\")\\n plt.plot(epochs, test_accuracy, label=\\\"test_accuracy\\\")\\n plt.title(\\\"Accuracy\\\")\\n plt.xlabel(\\\"Epochs\\\")\\n plt.legend()\",\n \"def cross_validation_visualization(lambdas, loss_train, loss_test):\\n plt.semilogx(lambdas, loss_train, marker=\\\".\\\", color='b', label='train error')\\n plt.semilogx(lambdas, loss_test, marker=\\\".\\\", color='r', label='test error')\\n plt.xlabel(\\\"lambda\\\")\\n plt.ylabel(\\\"rmse\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation_mse\\\")\",\n \"def plot_loss(path, current_epoch, train_loss, test_loss):\\n plotname = os.path.join(path, \\\"training_loss_curve.png\\\")\\n fig = plt.figure()\\n plt.axes().set_facecolor(\\\"#fbc9bc\\\")\\n plt.plot(\\n range(1, current_epoch + 1), train_loss, color=\\\"#ff6050\\\", label=\\\"Training Loss\\\"\\n )\\n plt.plot(range(1, current_epoch + 1), test_loss, color=\\\"#19214e\\\", label=\\\"Test Loss\\\")\\n plt.xlabel(\\\"Epoch Count\\\")\\n plt.ylabel(\\\"Model Loss\\\")\\n plt.legend()\\n fig.savefig(plotname, bbox_inches=\\\"tight\\\")\\n plt.close()\",\n \"def plot_loss(history, name):\\n\\n plt.plot(history.history['loss'])\\n plt.plot(history.history['val_loss'])\\n plt.title('model loss')\\n plt.ylabel('loss')\\n plt.xlabel('epoch')\\n plt.legend(['train', 'val'], loc='upper left')\\n # plt.show()\\n plt.savefig(name, format=\\\"png\\\")\",\n \"def learning_viz(self) :\\n self.train\\n history = self.history\\n plot_loss(history)\",\n \"def acc_loss_graph(self):\\n acc = self.history['accuracy']\\n val_acc = self.history['val_accuracy']\\n loss = self.history['loss']\\n val_loss = self.history['val_loss']\\n plt.figure(figsize=(15, 5))\\n plt.subplot(1, 2, 1)\\n plt.plot(acc, label='Train')\\n plt.plot(val_acc, label='Val')\\n plt.legend(loc='lower right')\\n plt.ylabel('Accuracy')\\n plt.xlabel('Epoch')\\n plt.ylim([min(plt.ylim()), 1])\\n plt.title('Accuracy')\\n\\n plt.subplot(1, 2, 2)\\n plt.plot(loss, label='Train')\\n plt.plot(val_loss, label='Val')\\n plt.legend(loc='lower right')\\n plt.ylabel('Loss')\\n plt.xlabel('Epoch')\\n plt.ylim([0, max(plt.ylim())])\\n plt.title('Loss')\\n plt.show();\",\n \"def Plot_loss(history_object): \\n ### print the keys contained in the history object\\n print(history_object.history.keys())\\n print(history_object.history['loss'])\\n print(history_object.history['val_loss'])\\n\\n ### plot the training and validation loss for each epoch\\n plt.plot(history_object.history['loss'])\\n plt.plot(history_object.history['val_loss'])\\n plt.title('model mean squared error loss')\\n plt.ylabel('mean squared error loss')\\n plt.xlabel('epoch')\\n plt.legend(['training set', 'validation set'], loc='upper right')\\n plt.show()\",\n \"def plot_loss(experiment_name, model='pix2pix'):\\n \\n # load data file\\n data = pd.read_csv(os.path.join('./checkpoints', experiment_name, 'loss_log.txt'), skiprows=1, sep='\\\\s*', engine='python', header=None)\\n \\n if model == 'pix2pix':\\n epoch = data[1].str.replace(',', '').astype('int')\\n iters = data[3].str.replace(',', '').astype('int') / 1928\\n epoch = epoch + iters - 1\\n \\n # convert string to float32 data\\n G_GAN = data[9].astype('float32')\\n G_L1 = data[11].astype('float32')\\n D_real = data[13].astype('float32')\\n D_fake = data[15].astype('float32')\\n \\n plt.figure(figsize=(15,8))\\n plt.xlabel('epoch', fontsize=18, labelpad=20)\\n plt.ylabel('loss', fontsize=18, labelpad=20)\\n plt.title(experiment_name + 'loss over time', fontsize=18, pad=30)\\n plt.plot(epoch.values, G_GAN.values, 'b', label='G_GAN')\\n plt.plot(epoch.values, G_L1.values, 'C1', label='G_L1')\\n plt.plot(epoch.values, D_real.values, 'g', label='D_real')\\n plt.plot(epoch.values, D_fake.values, 'r', label='D_fake')\\n plt.tick_params(labelsize=14)\\n plt.legend(loc='best', fontsize=14)\\n plt.grid(True)\\n # save the png image into the corresponding dir \\n plt.savefig(os.path.join('./results', experiment_name, 'test_latest', experiment_name + '.png'))\\n plt.show()\\n \\n if model == 'cyclegan':\\n epoch = data[1].str.replace(',', '').astype('int')\\n iters = data[3].str.replace(',', '').astype('int') / 1928\\n epoch = epoch + iters - 1\\n\\n D_A = data[9].astype('float32')\\n G_A = data[11].astype('float32')\\n cycle_A = data[13].astype('float32')\\n idt_A = data[15].astype('float32')\\n \\n D_B = data[17].astype('float32')\\n G_B = data[19].astype('float32')\\n cycle_B = data[21].astype('float32')\\n idt_B = data[23].astype('float32')\\n \\n plt.figure(figsize=(15,8))\\n plt.xlabel('epoch', fontsize=18, labelpad=20)\\n plt.ylabel('loss', fontsize=18, labelpad=20)\\n plt.title(experiment_name + 'loss over time', fontsize=18, pad=30)\\n plt.plot(epoch.values, D_A.values, 'C1', label='D_A')\\n plt.plot(epoch.values, G_A.values, 'C2', label='G_A')\\n plt.plot(epoch.values, cycle_A.values, 'C3', label='cycle_A')\\n plt.plot(epoch.values, idt_A.values, 'C4', label='idt_A')\\n plt.plot(epoch.values, D_B.values, 'C5', label='D_B')\\n plt.plot(epoch.values, G_B.values, 'C6', label='G_B')\\n plt.plot(epoch.values, cycle_B.values, 'C7', label='cycle_B')\\n plt.plot(epoch.values, idt_B.values, 'C8', label='idt_B')\\n plt.tick_params(labelsize=14)\\n plt.legend(loc='best', fontsize=14)\\n plt.grid(True)\\n plt.savefig(os.path.join('./results', experiment_name, 'test_latest', experiment_name + '.png'))\\n plt.show()\",\n \"def plot_loss_curve(num_epochs, losses):\\n plt.xlabel('Epochs')\\n plt.ylabel('Loss') \\n plt.title('Loss Curve') \\n plt.plot(range(num_epochs), losses)\\n plt.show()\",\n \"def main():\\n args = parse_args()\\n\\n with open(args.train_details_json, mode='r', encoding='utf-8') as json_f:\\n results_dict = json.load(json_f)[-1]\\n\\n losses_plot = plt.figure()\\n plt.plot(range(1, len(results_dict['train_loss']) + 1),\\n results_dict['train_loss'])\\n plt.plot(range(1, len(results_dict['val_loss']) + 1),\\n results_dict['val_loss'])\\n plt.plot(range(1, len(results_dict['test_loss']) + 1),\\n results_dict['test_loss'])\\n plt.legend(['train', 'val', 'test'])\\n plt.title(f'loss vs epoch for {args.model} model on {args.dataset} dataset')\\n plt.xlabel('epoch')\\n plt.ylabel('loss')\\n plt.grid(True)\\n losses_plot.set_size_inches((8, 8))\\n losses_plot.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_losses_plot.png'))\\n\\n accuracies_plot = plt.figure()\\n plt.plot(range(1, len(results_dict['train_acc']) + 1),\\n results_dict['train_acc'])\\n plt.plot(range(1, len(results_dict['val_acc']) + 1),\\n results_dict['val_acc'])\\n plt.plot(range(1, len(results_dict['test_acc']) + 1),\\n results_dict['test_acc'])\\n plt.legend(['train', 'val', 'test'])\\n plt.title(f'accuracy vs epoch for {args.model} '\\n f'model on {args.dataset} dataset')\\n plt.xlabel('epoch')\\n plt.ylabel('accuracy')\\n plt.grid(True)\\n accuracies_plot.set_size_inches((8, 8))\\n accuracies_plot.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_accuracies_plot.png'))\",\n \"def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc):\\n \\n green = '#72C29B'\\n orange = '#FFA577'\\n \\n with plt.xkcd():\\n # plot model loss\\n fig, ax1 = plt.subplots()\\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\\n label='training')\\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\\n linewidth=5, label='validation')\\n ax1.set_xlabel('# epoch')\\n ax1.set_ylabel('loss')\\n ax1.tick_params('y')\\n ax1.legend(loc='upper right', shadow=False)\\n # plot model accuracy\\n fig, ax2 = plt.subplots()\\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\\n label='training')\\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\\n linewidth=5, label='validation')\\n ax2.set_xlabel('# epoch')\\n ax2.set_ylabel('accuracy')\\n ax2.tick_params('y')\\n ax2.legend(loc='lower right', shadow=False)\\n plt.show()\",\n \"def plotErrors(losses, model_title ='Shallow Network, SGD, Batch Size = 10'):\\n fig, axes = plt.subplots()\\n\\n x = np.arange(len(losses))\\n\\n axes.plot(x, losses)\\n axes.set_ylabel(\\\"Loss (cross entropy)\\\")\\n axes.set_xlabel(\\\"Number of iterations\\\")\\n axes.set_title(model_title) \\n\\n plt.show() \\n\\n return None\",\n \"def plotLoss():\\n # ssr\\n ssr = np.log(gradientDescent(X, y)[1])\\n # number of iterations \\n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\\n # plot reduction of ssr\\n plt.plot(iterations, ssr)\\n # xlabel\\n plt.xlabel(\\\"Iteration\\\")\\n # ylabel\\n plt.ylabel(\\\"SSR\\\")\\n # title\\n plt.title(\\\"Reduction of SSR by number of Iterations\\\")\\n # show plot \\n plt.show()\",\n \"def plot_loss_acc(name,score):\\n plt.title(name)\\n plt.xlabel('Epoch Number')\\n plt.ylabel(name.split(sep=' ')[1])\\n plt.plot(score)\\n plt.savefig(\\\"graphs/\\\"+name+\\\".png\\\")\",\n \"def display_convergence_error(train_losses, valid_losses):\\n if len(valid_losses) > 0:\\n plt.plot(len(train_losses), train_losses, color=\\\"red\\\")\\n plt.plot(len(valid_losses), valid_losses, color=\\\"blue\\\")\\n plt.legend([\\\"Train\\\", \\\"Valid\\\"])\\n else:\\n plt.plot(len(train_losses), train_losses, color=\\\"red\\\")\\n plt.legend([\\\"Train\\\"])\\n plt.xlabel('Epoch')\\n plt.ylabel('Loss')\\n plt.show()\",\n \"def training(self, dataset, \\n epochs, r_loss, beta, \\n test= None ,Plotter=None):\\n\\n losses = []\\n val_losses = []\\n fidelities = []\\n val_fidelities = []\\n epochs = range(epochs)\\n\\n for i in tqdm(epochs, desc='Epochs'):\\n losses_epochs = []\\n fidelity_epochs =[]\\n for step, x in enumerate(dataset):\\n\\n loss, fidelity = self.training_step(x, r_loss, beta)\\n \\n # Logging.\\n losses_epochs.append(float(loss))\\n fidelity_epochs.append(float(fidelity))\\n \\n losses.append(np.mean(losses_epochs))\\n fidelities.append(np.mean(fidelity_epochs))\\n \\n if test:\\n val_losses_epochs = []\\n val_fidelity_epochs = []\\n\\n for step, x in enumerate(test):\\n\\n val_loss, val_fidelity = self.validating_step(x, r_loss, beta)\\n \\n # Logging.\\n val_losses_epochs.append(float(val_loss))\\n val_fidelity_epochs.append(float(val_fidelity))\\n \\n val_losses.append(np.mean(val_losses_epochs))\\n val_fidelities.append(np.mean(val_fidelity_epochs))\\n\\n if Plotter != None:\\n if test:\\n Plotter.plot([losses,val_losses]) \\n else:\\n Plotter.plot(losses)\\n \\n\\n return losses, val_losses, fidelities, val_fidelities\",\n \"def calc_loss_train_val(history):\\r\\n # overall loss\\r\\n fig = go.Figure()\\r\\n fig.add_trace(go.Scattergl(\\r\\n y=history.history['loss'],\\r\\n name='Train'))\\r\\n fig.add_trace(go.Scattergl(\\r\\n y=history.history['val_loss'],\\r\\n name='Validation'))\\r\\n fig.update_layout(height=500,\\r\\n width=700,\\r\\n title='Overall loss',\\r\\n xaxis_title='Epoch',\\r\\n yaxis_title='Loss')\\r\\n fig.show()\",\n \"def create(self, train: List[float], validation: List[float]) -> None:\\n self.ax.plot(train)\\n self.ax.plot(validation)\\n self.ax.set_xlabel('epochs')\\n if self.loss:\\n self.ax.set_ylabel('loss')\\n else:\\n self.ax.set_ylabel('accuracy')\\n self.ax.legend(['train', 'validation'])\",\n \"def visualization(epochs, mse_tr, mse_te):\\n plt.semilogx(epochs, mse_tr, marker=\\\".\\\", color='b', label='train error')\\n plt.semilogx(epochs, mse_te, marker=\\\".\\\", color='r', label='test error')\\n plt.xlabel(\\\"k\\\")\\n plt.ylabel(\\\"rmse\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation\\\")\",\n \"def plot_learning_curve(X_train_all, X_val_all, y_train_all, y_val_all, train_sizes, title):\\n\\n errors_df = pd.DataFrame(columns = ['train_size', 'train_acc', 'val_acc'])\\n\\n # Loop through example sizes and get the training and validation error\\n for train_size in train_sizes:\\n # Select Subset of Data\\n X_train = X_train_all[:train_size]\\n X_val = X_val_all[:train_size]\\n y_train = y_train_all[:train_size]\\n y_val = y_val_all[:train_size]\\n\\n # Initialize Model\\n model = svm.SVC(kernel='linear')\\n\\n # Fit model\\n print(f\\\"Training {title} using {train_size} examples\\\")\\n model.fit(X_train, y_train)\\n\\n # Get Predictions \\n train_pred = model.predict(X_train)\\n val_pred = model.predict(X_val)\\n\\n # Get Accuracy Score for X_Train and X_Val\\n errors = pd.DataFrame({\\n 'train_size': [train_size],\\n 'train_acc': [accuracy_score(y_train, train_pred)],\\n 'val_acc': [accuracy_score(y_val, val_pred)]\\n })\\n \\n # Concatenate Dataframes\\n errors_df = pd.concat([errors_df, errors])\\n\\n # Plot Learning Curve\\n fig, ax = plt.subplots()\\n\\n errors_df.plot(x='train_size', y='train_acc',kind='line', ax=ax)\\n errors_df.plot(x='train_size', y='val_acc',kind='line', color='red', ax=ax)\\n\\n ax.set_xlabel(\\\"Training Size\\\")\\n ax.set_ylabel(\\\"Accuracy\\\")\\n ax.set_title(title)\\n\\n # Save Figure\\n plt.savefig('figs/' + title + '_learning_curve.png')\",\n \"def plot_training_curve(path):\\n import matplotlib.pyplot as plt\\n train_err = np.loadtxt(\\\"{}_train_err.csv\\\".format(path))\\n val_err = np.loadtxt(\\\"{}_val_err.csv\\\".format(path))\\n train_loss = np.loadtxt(\\\"{}_train_loss.csv\\\".format(path))\\n val_loss = np.loadtxt(\\\"{}_val_loss.csv\\\".format(path))\\n plt.title(\\\"Train vs Validation Error\\\")\\n n = len(train_err) # number of epochs\\n plt.plot(range(1,n+1), train_err, label=\\\"Train\\\")\\n plt.plot(range(1,n+1), val_err, label=\\\"Validation\\\")\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Error\\\")\\n plt.legend(loc='best')\\n plt.show()\\n plt.title(\\\"Train vs Validation Loss\\\")\\n plt.plot(range(1,n+1), train_loss, label=\\\"Train\\\")\\n plt.plot(range(1,n+1), val_loss, label=\\\"Validation\\\")\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Loss\\\")\\n plt.legend(loc='best')\\n plt.show()\",\n \"def loss_plotter(model_history, ax=None):\\n \\n import matplotlib.pyplot as plt\\n import seaborn as sns\\n\\n training_loss = model_history['loss']\\n \\n test_loss = model_history['val_loss']\\n\\n epoch_count = range(1,len(training_loss)+1)\\n \\n sns.set(font_scale=1.15)\\n \\n ax = sns.lineplot(\\n x=epoch_count,\\n y=training_loss,\\n ax=ax\\n )\\n \\n ax = sns.lineplot(\\n x=epoch_count,\\n y=test_loss,\\n ax=ax\\n )\\n\\n ax.set_title(\\n 'Loss Curves: Pre-Trained VGG-16 with 2 Trained Layers',\\n fontsize=19\\n )\\n ax.set_ylabel(\\n 'Loss',\\n fontsize=18\\n )\\n ax.set_xlabel(\\n 'Epochs',\\n fontsize=18\\n )\\n\\n plt.legend(['Training Loss', 'Validation Loss'])\\n plt.show()\",\n \"def plot_training_info(case, metrics, save, history):\\n val = False\\n if 'val_accuracy' in history and 'val_loss' in history:\\n val = True\\n plt.ioff()\\n if 'accuracy' in metrics:\\n fig = plt.figure()\\n plt.plot(history['accuracy'])\\n if val:\\n plt.plot(history['val_accuracy'])\\n plt.title('model accuracy')\\n plt.ylabel('accuracy')\\n plt.xlabel('epoch')\\n if val:\\n plt.legend(['train', 'val'], loc='upper left')\\n else:\\n plt.legend(['train'], loc='upper left')\\n if save:\\n plt.savefig(case + 'accuracy.png')\\n plt.gcf().clear()\\n else:\\n plt.show()\\n plt.close(fig)\\n\\n # summarize history for loss\\n if 'loss' in metrics:\\n fig = plt.figure()\\n plt.plot(history['loss'])\\n if val:\\n plt.plot(history['val_loss'])\\n plt.title('model loss')\\n plt.ylabel('loss')\\n plt.xlabel('epoch')\\n # plt.ylim(1e-3, 1e-2)\\n plt.yscale(\\\"log\\\")\\n if val:\\n plt.legend(['train', 'val'], loc='upper left')\\n else:\\n plt.legend(['train'], loc='upper left')\\n if save:\\n plt.savefig(case + 'loss.png')\\n plt.gcf().clear()\\n else:\\n plt.show()\\n plt.close(fig)\",\n \"def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc, save_figure_path):\\n\\n green = '#72C29B'\\n orange = '#FFA577'\\n\\n with plt.xkcd():\\n fig, (ax1, ax2) = plt.subplots(2, figsize=(10, 8))\\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\\n label='training')\\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\\n linewidth=5, label='validation')\\n ax1.set_xlabel('# epoch')\\n ax1.set_ylabel('loss')\\n ax1.tick_params('y')\\n ax1.legend(loc='upper right', shadow=False)\\n ax1.set_title('Model loss through #epochs', fontweight='bold')\\n\\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\\n label='training')\\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\\n linewidth=5, label='validation')\\n ax2.set_xlabel('# epoch')\\n ax2.set_ylabel('accuracy')\\n ax2.tick_params('y')\\n ax2.legend(loc='lower right', shadow=False)\\n ax2.set_title('Model accuracy through #epochs', fontweight='bold')\\n\\n plt.tight_layout()\\n plt.show()\\n fig.savefig(save_figure_path)\\n plt.close(fig)\",\n \"def plot_loss(model_dir):\\n ## extract loss from csv\\n file_dir = os.path.join(model_dir, 'losses.csv')\\n data = pd.read_csv(file_dir)\\n epochs = data['epoch'].ravel()\\n loss = data['loss'].ravel()\\n\\n fig, ax = plt.subplots(1, 1, figsize=(7, 5), sharey=True, sharex=True, dpi=400)\\n ax.plot(epochs, loss, #label=r'Loss', \\n color='green', linewidth=1.0, alpha=0.8)\\n ax.set_ylabel('Loss', fontsize=10)\\n ax.set_xlabel('Number of iterations', fontsize=10)\\n ax.legend(loc='lower right', prop={\\\"size\\\": 15}, ncol=3, framealpha=0.5)\\n ax.set_title(\\\"Loss\\\")\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n plt.tight_layout()\\n\\n ## create saving directory\\n loss_dir = os.path.join(model_dir, 'figures', 'loss')\\n os.makedirs(loss_dir, exist_ok=True)\\n file_name = os.path.join(loss_dir, 'loss.png')\\n plt.savefig(file_name, dpi=400)\\n print(\\\"Plot saved to: {}\\\".format(file_name))\\n file_name = os.path.join(loss_dir, 'loss.pdf')\\n plt.savefig(file_name, dpi=400)\\n plt.close()\\n print(\\\"Plot saved to: {}\\\".format(file_name))\",\n \"def loss(self, data):\\n loss, smoothed, lr = data\\n\\n curves = []\\n\\n curve_keys = ['color', 'linestyle', 'linewidth', 'alpha']\\n\\n if loss is not None:\\n loss_name = self.config.get('label', f\\\"loss #{self.index + 1}\\\")\\n loss_label = f'{loss_name} ⟶ {loss[-1]:2.3f}'\\n final_window = self.config.get('final_window', None)\\n if final_window is not None:\\n final_window = min(final_window, len(loss))\\n final = np.mean(loss[-final_window:])\\n loss_label += f\\\"\\\\nmean over last {final_window} iterations={final:2.3f}\\\"\\n\\n loss_config = self.config.filter(keys=curve_keys, prefix='curve_')\\n loss_curve = self.ax.plot(loss, label=loss_label, **loss_config)\\n curves.extend(loss_curve)\\n\\n if smoothed is not None:\\n smoothed_color = scale_lightness(loss_config['color'], scale=.5)\\n smooth_window = self.config.get('window')\\n smoothed_label = self.config.get('smoothed_label', loss_name)\\n smoothed_label = smoothed_label + '\\\\n' if smoothed_label else ''\\n smoothed_label += f'smoothed with window {smooth_window}'\\n smoothed_curve = self.ax.plot(smoothed, label=smoothed_label, color=smoothed_color, linestyle='--')\\n curves.extend(smoothed_curve)\\n\\n if lr is not None:\\n lr_ax = self.ax if loss is None else self.twin_ax\\n lr_label = f'learning rate №{self.index + 1} ⟶ {lr[-1]:.0e}'\\n lr_config = self.config.filter(keys=curve_keys, prefix='lr_')\\n lr_curve = lr_ax.plot(lr, label=lr_label, **lr_config)\\n lr_ax.set_ylabel('Learning rate', fontsize=12)\\n curves.extend(lr_curve)\\n\\n return curves\",\n \"def graph_results(loss, acc):\\n N = len(loss)\\n x = np.linspace(0, N, N)\\n plt.subplot(1,2,1)\\n plt.plot(x, loss)\\n plt.subplot(1,2,2)\\n plt.plot(x,acc)\\n plt.show()\",\n \"def plot_eval_2(trained_model, image_name):\\n # Get training evaluation data\\n train_accuracy = trained_model.history['acc']\\n train_val_accuracy = trained_model.history['val_acc']\\n train_loss = trained_model.history['loss']\\n train_val_loss = trained_model.history['val_loss']\\n \\n # Generate accuracy plot\\n epochs = range(len(train_accuracy))\\n plt.figure()\\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n \\n # Save accuracy plot\\n plot_file = os.path.join(OUTPUT_DIR,\\n \\\"{}_training_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\\n \\n # Generate loss plot\\n plt.figure()\\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n \\n # Save loss plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_training_loss\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def plot_cost(c_v, c_t, save_plots_path):\\n\\n plt.figure()\\n plt.plot(c_v, label='Validation loss')\\n plt.plot(c_t, label='Training loss')\\n plt.legend()\\n title = 'Loss per epoch'\\n plt.title(title)\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Loss\\\")\\n plt.savefig(save_plots_path + \\\"swag_loss_plot.png\\\")\",\n \"def plot_train_results(metrics2record, loss_metric,\\n train_metrics, test_metrics):\\n pyplot.figure(figsize=(10, 5))\\n min_, max_ = np.min(loss_metric), np.max(loss_metric)\\n lg, = pyplot.plot(loss_metric)\\n pyplot.yticks(min_ + np.arange(5) * (max_ - min_))\\n # if learning_rate is not None:\\n # lg, = pyplot.plot(learning_rate)\\n pyplot.title('Loss')\\n pyplot.xlabel('Epoch')\\n pyplot.yscale('log')\\n pyplot.show()\\n\\n for prm in basic_metrics:\\n if prm in metrics2record:\\n leg = []\\n met_idx = metrics2record.index(prm)\\n pyplot.figure(figsize=(10, 5))\\n lg, = pyplot.plot(train_metrics[:, met_idx], label=('train'))\\n leg.append(lg)\\n lg, = pyplot.plot(test_metrics[:, met_idx], label=('test'))\\n leg.append(lg)\\n\\n pyplot.legend(handles=leg)\\n pyplot.title(prm)\\n pyplot.xlabel('Epoch')\\n pyplot.show()\\n\\n has_prf = any([(prm in PRF_metrics) for prm in metrics2record])\\n if has_prf:\\n pyplot.figure(figsize=(10, 5))\\n leg = []\\n for prm in PRF_metrics:\\n if prm in metrics2record:\\n met_idx = metrics2record.index(prm)\\n lg, = pyplot.plot(train_metrics[:, met_idx],\\n label=(prm + ':train'))\\n leg.append(lg)\\n\\n for prm in PRF_metrics:\\n if prm in metrics2record:\\n met_idx = metrics2record.index(prm)\\n lg, = pyplot.plot(test_metrics[:, met_idx],\\n label=(prm + ':test'))\\n leg.append(lg)\\n\\n pyplot.legend(handles=leg)\\n pyplot.title('Precision / Recall')\\n pyplot.xlabel('Epoch')\\n pyplot.show()\",\n \"def acc_loss_graph(accuracies, losses):\\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))\\n\\n for experiment_id in accuracies.keys():\\n ax1.plot(accuracies[experiment_id], label=experiment_id)\\n ax1.legend()\\n ax1.set_title('Validation Accuracy')\\n fig.tight_layout()\\n\\n for experiment_id in accuracies.keys():\\n ax2.plot(losses[experiment_id], label=experiment_id)\\n ax2.legend()\\n ax2.set_title('Validation Loss');\\n\\n fig.tight_layout()\",\n \"def plot_train_history(self):\\n plt.figure()\\n plt.xlabel('Epochs')\\n plt.ylabel('Loss')\\n plt.plot(self.train_history.history['loss'])\\n plt.plot(self.train_history.history['val_loss'])\\n plt.legend(['Training', 'Validation'])\\n\\n plt.show()\",\n \"def update_error_plot_values(self):\\n check_is_dir(\\\"mp_plotdata\\\")\\n check_is_dir(\\\"mp_plotdata/\\\"+self.name)\\n\\n data_train = self.get_data.evaluate_on_train_data(n_samples=50)\\n data_validation = self.get_data.evaluate_on_validation_data(n_samples=50)\\n\\n for data, _set in zip([data_train, data_validation], [\\\"train\\\", \\\"validation\\\"]):\\n object_real_samples = data[\\\"object_real_samples\\\"].reshape(\\n -1,self.get_data.N, self.get_data.N, 1)\\n object_imag_samples = data[\\\"object_imag_samples\\\"].reshape(\\n -1,self.get_data.N, self.get_data.N, 1)\\n diffraction_samples = data[\\\"diffraction_samples\\\"].reshape(\\n -1,self.get_data.N, self.get_data.N, 1)\\n\\n filename = \\\"mp_plotdata/\\\"+self.name+\\\"/\\\"+_set+\\\"_log.dat\\\"\\n if not os.path.exists(filename):\\n with open(filename, \\\"w\\\") as file:\\n file.write(\\\"# time[s] epoch real_loss imag_loss reconstruction_loss\\\\n\\\")\\n\\n # real loss\\n real_loss = self.sess.run(self.nn_nodes[\\\"real_loss\\\"],\\n feed_dict={self.x:diffraction_samples,\\n self.real_actual:object_real_samples})\\n\\n # imaginary loss\\n imag_loss = self.sess.run(self.nn_nodes[\\\"imag_loss\\\"],\\n feed_dict={self.x:diffraction_samples,\\n self.imag_actual:object_imag_samples})\\n\\n # reconstruction\\n reconstruction_loss = self.sess.run(self.nn_nodes[\\\"reconstruction_loss\\\"],\\n feed_dict={self.x:diffraction_samples})\\n\\n datastring = \\\"\\\"\\n datastring+= str(time.time())\\n datastring+= \\\" \\\"\\n datastring+= str(self.epoch)\\n datastring+= \\\" \\\"\\n datastring+= str(real_loss)\\n datastring+= \\\" \\\"\\n datastring+= str(imag_loss)\\n datastring+= \\\" \\\"\\n datastring+= str(reconstruction_loss)\\n datastring+= \\\"\\\\n\\\"\\n\\n with open(filename, \\\"a\\\") as file:\\n file.write(datastring)\\n\\n\\n for key in self.experimental_traces.keys():\\n trace = self.experimental_traces[key]\\n\\n # reconstruction\\n reconstruction_loss = self.sess.run(self.nn_nodes[\\\"reconstruction_loss\\\"],\\n feed_dict={self.x:trace})\\n\\n logger_name = key+\\\"_reconstructed\\\"\\n filename = \\\"mp_plotdata/\\\"+self.name+\\\"/\\\"+logger_name+\\\".dat\\\"\\n if not os.path.exists(filename):\\n with open(filename, \\\"w\\\") as file:\\n file.write(\\\"# time[s] epoch reconstruction_loss\\\\n\\\")\\n\\n datastring = \\\"\\\"\\n datastring+= str(time.time())\\n datastring+= \\\" \\\"\\n datastring+= str(self.epoch)\\n datastring+= \\\" \\\"\\n datastring+= str(reconstruction_loss)\\n datastring+= \\\"\\\\n\\\"\\n with open(filename, \\\"a\\\") as file:\\n file.write(datastring)\",\n \"def cross_validation_visualization(lambds, score_tr, score_te):\\n plt.semilogx(lambds, score_tr, marker=\\\".\\\", color='b', label='train score');\\n plt.semilogx(lambds, score_te, marker=\\\".\\\", color='r', label='test score');\\n plt.xlabel(\\\"lambda\\\")\\n plt.ylabel(\\\"score\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation_test\\\")\",\n \"def plot_loss(loss_values_dict, save_name):\\n fig, ax = plt.subplots(figsize=(10, 10))\\n # Add each method to the plot\\n for (method_name, loss_val_array) in loss_values_dict.items():\\n print(method_name, len(loss_val_array))\\n ax.plot(range(len(loss_val_array)), loss_val_array, label=method_name)\\n ax.legend(loc='upper right')\\n plt.xlabel('iteration')\\n plt.ylabel('loss')\\n plt.title('Grad Descent in Hyperbolic Space')\\n plt.savefig(save_name)\",\n \"def plot_eval_1(trained_model, image_name):\\n # Get training evaluation data\\n train_accuracy = trained_model.history['acc']\\n train_val_accuracy = trained_model.history['val_acc']\\n train_loss = trained_model.history['loss']\\n train_val_loss = trained_model.history['val_loss']\\n \\n # Generate accuracy plot\\n epochs = range(len(train_accuracy))\\n plt.figure()\\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n \\n # Save accuracy plot\\n plot_file = os.path.join(OUTPUT_DIR,\\n \\\"{}_training_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\\n \\n # Generate loss plot\\n plt.figure()\\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n \\n # Save loss plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_training_loss\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def error_plot(training_costs, test_costs, learning_rate, accuracy, test_accuracy, val_accuracy, layers, data_size,\\n n_neighbours, dropout_rate):\\n\\n plt.plot(training_costs, label=\\\"Training loss\\\")\\n plt.plot(test_costs, label=\\\"Test loss\\\")\\n plt.xlabel(\\\"Iterations\\\", size='medium')\\n plt.ylabel(\\\"Cost function (%)\\\", size='medium')\\n plt.suptitle(\\\"Cost function while training the neural network\\\", size='medium', ha='center')\\n plt.title(\\\"layers: {} with dropout rate of {}, learning rate: {}\\\".format(layers, dropout_rate, learning_rate),\\n size='small', ha='center')\\n plt.figtext(0.77, 0.35, \\\"Training accuracy\\\\n{0:.2f}%\\\".format(accuracy), size='medium')\\n plt.figtext(0.77, 0.25, \\\"Test accuracy\\\\n{0:.2f}%\\\".format(test_accuracy), size='medium')\\n plt.figtext(0.77, 0.15, \\\"Validation accuracy\\\\n{0:.2f}%\\\".format(val_accuracy), size='medium')\\n if n_neighbours == 0:\\n plt.figtext(0.77, 0.80, \\\"Neighbours\\\\nexcluded\\\", size='medium')\\n else:\\n plt.figtext(0.77, 0.80, \\\"{} neighbours\\\\nincluded\\\".format(n_neighbours), size='medium')\\n plt.figtext(0.77, 0.70, \\\"{}\\\\nsamples\\\".format(data_size))\\n plt.legend(loc='right', bbox_to_anchor=(1.39, 0.5))\\n plt.subplots_adjust(right=0.75)\\n working_dir = os.path.dirname(os.path.abspath(__file__))\\n saving(working_dir + \\\"/output_ANN/error_plots/{}_error_{}\\\".format(n_neighbours, data_size))\",\n \"def plot(self, ylog=False, category=\\\"Accuracy\\\", figsize=(12, 5)):\\n if self.CV == False: # no Cross Validation set case\\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\\n plt.suptitle(\\\"Training Curve for \\\" + self.loss, fontsize=12)\\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\\n ax[0].set_xlabel('Iteration')\\n ax[0].set_ylabel(\\\"Error\\\")\\n if ylog == True:\\n ax[0].set_yscale('log')\\n ax[0].legend()\\n ax[0].grid('on')\\n\\n if category == \\\"Accuracy\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'r-', label='Training Accuracy')\\n ax[1].set_ylabel(\\\"Accuracy\\\")\\n elif category == \\\"Error Rate\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'r-', label='Training Error Rate')\\n ax[1].set_ylabel(\\\"Error Rate\\\")\\n # ax[1].set_ylim((0, 1))\\n ax[1].set_xlabel('Iteration')\\n ax[1].legend(loc='best')\\n ax[1].grid('on')\\n plt.show()\\n if self.CV == True: # has Cross Validation set case\\n fig, ax = plt.subplots(nrows=1, ncols=2, figsize=figsize)\\n plt.suptitle(\\\"Training Curve for \\\" + self.loss, fontsize=12)\\n ax[0].plot(range(1, len(self.trainError) + 1), self.trainError, 'g-', label='Training Error')\\n ax[0].plot(range(1, len(self.cvError) + 1), self.cvError, 'r-', label='CV Error')\\n ax[0].set_xlabel('Iteration')\\n ax[0].set_ylabel(\\\"Error\\\")\\n if ylog == True:\\n ax[0].set_yscale('log')\\n ax[0].legend()\\n ax[0].grid('on')\\n\\n if category == \\\"Accuracy\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), self.trainAcc, 'g-', label='Training Accuracy')\\n ax[1].plot(range(1, len(self.cvAcc) + 1), self.cvAcc, 'r-', label='CV Accuracy')\\n ax[1].set_ylabel(\\\"Accuracy\\\")\\n elif category == \\\"Error Rate\\\":\\n ax[1].plot(range(1, len(self.trainAcc) + 1), 1 - np.array(self.trainAcc), 'g-', label='Training Error Rate')\\n ax[1].plot(range(1, len(self.cvAcc) + 1), 1 - np.array(self.cvAcc), 'r-', label='CV Error Rate')\\n ax[1].set_ylabel(\\\"Error Rate\\\")\\n # ax[1].set_ylim((0, 1))\\n ax[1].set_xlabel('Iteration')\\n ax[1].legend(loc='best')\\n ax[1].grid('on')\\n plt.show()\\n\\n return fig, ax\",\n \"def train(X_train, y_train, X_test, y_test, net):\\n \\n # convert X, y to tensors:\\n X_train = torch.tensor(X_train, dtype=torch.float32)\\n y_train = torch.tensor(y_train, dtype=torch.float32)\\n \\n X_test = torch.tensor(X_test, dtype=torch.float32)\\n y_test = torch.tensor(y_test, dtype=torch.float32)\\n\\n # iterator:\\n train_set = TensorDataset(X_train, y_train)\\n train_loader = DataLoader(train_set, batch_size, shuffle=True)\\n\\n test_set = TensorDataset(X_test, y_test)\\n test_loader = DataLoader(test_set, batch_size, shuffle=True)\\n\\n # optimizer:\\n optimizer = torch.optim.Adam(net.parameters(), lr=lr)\\n loss = nn.MSELoss()\\n\\n # loss accumulator:\\n time_line = []\\n train_metric = []\\n test_metric = []\\n\\n # loop:\\n for epoch in range(epochs):\\n # update parameters:\\n for Xb, yb in train_loader:\\n train_ls = loss(net(Xb), yb)\\n optimizer.zero_grad()\\n train_ls.backward()\\n optimizer.step()\\n # update train and test losses:\\n with torch.no_grad():\\n if not epoch % 50:\\n time_line.append(epoch)\\n metric = 0\\n for Xb, yb in train_loader:\\n metric += loss(net(Xb), yb) / batch_size\\n train_metric.append(metric)\\n metric = 0\\n for Xb, yb in test_loader:\\n metric += loss(net(Xb), yb) / batch_size\\n test_metric.append(metric)\\n # verbose:\\n print('Epoch: ', epoch)\\n\\n # final report of the losses: \\n print('Train loss.....{0:6.3f}'.format(train_metric[-1]))\\n print('Test loss......{0:6.3f}'.format(test_metric[-1]))\\n\\n # plot losses with respect to epochs:\\n plt.plot(time_line, train_metric, color='b')\\n plt.plot(time_line, test_metric, color='r')\\n plt.show()\",\n \"def plot(training_losses, validation_losses, epochs, directory_name):\\n plt.figure(figsize=(20, 10))\\n\\n x = np.linspace(1, epochs, epochs)\\n training_losses = np.array(training_losses)\\n validation_losses = np.array(validation_losses)\\n\\n plt.title(\\\"Learning curve over Epochs\\\")\\n\\n plt.xlabel(\\\"Epochs\\\")\\n plt.ylabel(\\\"Average Loss\\\")\\n\\n plt.plot(x, training_losses, color='purple', marker=\\\".\\\", label='Training loss')\\n plt.plot(x, validation_losses, color='orange', marker=\\\".\\\", label='Validation loss')\\n plt.legend()\\n plt.savefig('./' + directory_name + '/Learning_curves-' + str(epochs) + '.png')\\n pass\",\n \"def visualize_train(train_data_full, train_labels, train_data, thetas, losses, niter):\\n fig1, ax1 = plt.subplots()\\n ax1.scatter(train_data_full[\\\"Weight\\\"], train_data_full[\\\"Height\\\"], color = 'blue')\\n\\n # De-standarize\\n train_mean = train_data_full[\\\"Weight\\\"].mean()\\n train_std = train_data_full[\\\"Weight\\\"].std()\\n train_data_for_plot = train_mean + train_data[\\\"Weight\\\"] * train_std\\n\\n ax1.plot(train_data_for_plot, predict(train_data, thetas[niter - 1]), color = 'red', linewidth = 2)\\n ax1.set_xlabel(\\\"Height\\\")\\n ax1.set_ylabel(\\\"Weight\\\")\\n\\n fig2, ax2 = plt.subplots()\\n ax2.plot(range(len(losses)), losses, color = 'blue', linewidth = 2)\\n ax2.set_xlabel(\\\"Iteration\\\")\\n ax2.set_ylabel(\\\"MSE\\\")\\n\\n fig3, ax3 = plt.subplots()\\n np_gradient_ws = np.array(thetas)\\n\\n w = np.linspace(min(np_gradient_ws[:, 0]), max(np_gradient_ws[:, 0]), len(np_gradient_ws[:, 0]))\\n b = np.linspace(min(np_gradient_ws[:, 1]), max(np_gradient_ws[:, 1]), len(np_gradient_ws[:, 1]))\\n x, y = np.meshgrid(w, b)\\n z = compute_z_loss(train_labels, train_data, np.stack((w,b)).T)\\n cp = ax3.contourf(x, y, z, cmap = plt.cm.jet)\\n fig3.colorbar(cp, ax = ax3)\\n ax3.plot(3.54794951, 66.63949115837143, color = 'red', marker = '*', markersize = 20)\\n if niter > 0:\\n thetas_to_plot = np_gradient_ws[:niter]\\n ax3.plot(thetas_to_plot[:, 0], thetas_to_plot[:, 1], marker = 'o', color = 'w', markersize = 10)\\n ax3.set_xlabel(r'$w$')\\n ax3.set_ylabel(r'$b$')\\n return fig1, fig2, fig3\",\n \"def plot_loss_metrics(history_file):\\n history = pickle.load(open(history_file, \\\"rb\\\"))\\n loss, metric, val_loss, val_metric = islice(history.keys(), 4)\\n n_epochs = len(history[loss])\\n\\n plt.style.use(\\\"ggplot\\\")\\n fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(13, 8))\\n\\n ax1.set_title(loss)\\n ax1.plot(np.arange(1, n_epochs + 1), history[loss], label='train')\\n ax1.plot(np.arange(1, n_epochs + 1), history[val_loss], label='test')\\n ax1.legend()\\n\\n ax2.set_title(metric)\\n ax2.plot(np.arange(1, n_epochs + 1), history[metric], label='train')\\n ax2.plot(np.arange(1, n_epochs + 1), history[val_metric], label='test')\\n ax2.set_xlabel('Epochs')\\n ax2.set_xlim((1, n_epochs + 1))\\n xa = ax2.get_xaxis()\\n xa.set_major_locator(MaxNLocator(integer=True))\\n ax2.legend()\\n plt.savefig(history_file + '.png')\\n plt.show()\",\n \"def plot_data(x, y, epochs):\\n\\n fig = plt.figure()\\n ax = fig.gca()\\n\\n ax.set_ylim(0, int(np.max(y)+0.5))\\n ax.set_xlim(0, np.max(x))\\n ax.yaxis.grid(True)\\n ax.grid(which='minor', axis='x', alpha=0.2)\\n ax.grid(which='major', axis='x', alpha=0.5)\\n major_ticks = np.arange(0, np.max(x), 88)\\n minor_ticks = np.arange(0, np.max(x), 16)\\n ax.set_xticks(major_ticks)\\n ax.set_xticks(minor_ticks, minor=True)\\n\\n fig.canvas.draw()\\n labels = [\\\"{:2d}\\\".format(int(int(item.get_text())/88)) for item in ax.get_xticklabels()]\\n ax.set_xticklabels(labels)\\n\\n plt.title(\\\"Model Loss over {} Epochs\\\".format(epochs))\\n plt.scatter(x, y, s=50, alpha=0.5, label='cross_entropy')\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Loss\\\")\\n plt.legend(loc='upper right')\\n plt.show()\",\n \"def plot_loss(logdir, stats):\\n progress_path = os.path.join(logdir, \\\"progress.csv\\\")\\n reader = csv.reader(open(progress_path, \\\"rt\\\"), delimiter=\\\",\\\")\\n raw_data = list(reader)\\n\\n headers = raw_data[0]\\n data = np.array(raw_data[1:]).astype(\\\"float\\\")\\n\\n vis_headers_x = [\\\"Epoch\\\"]\\n vis_header_idx_x = [headers.index(x) for x in vis_headers_x]\\n data_x = data[:, vis_header_idx_x[0]]\\n\\n vis_header_idx_y = [headers.index(y) for y in stats]\\n data_y_mean = []\\n for idx in vis_header_idx_y:\\n data_y_mean.append(data[:, idx])\\n\\n for i in range(len(data_y_mean)):\\n fig, ax = plt.subplots()\\n ax.plot(data_x, data_y_mean[i], color=\\\"gray\\\", label=stats[i])\\n\\n ax.legend()\\n ax.set_xlabel(vis_headers_x[0])\\n ax.grid(True)\\n\\n fig_path = os.path.join(logdir, stats[i].split(\\\"/\\\")[-1] + \\\".png\\\")\\n fig.savefig(fig_path, dpi=320)\",\n \"def plot_observations():\\n plt.plot(history.history['loss'], label='training_loss')\\n plt.plot(history.history['val_loss'], label='val_loss ')\\n plt.xlabel('Epoch')\\n plt.ylabel('Loss')\\n plt.show()\\n\\n plt.plot(history.history['acc'], label='accuracy')\\n plt.plot(history.history['val_acc'], label='val_accuracy')\\n plt.xlabel('Epoch')\\n plt.ylabel('Accuracy')\\n plt.legend(loc='lower right')\\n plt.show()\\n\\n test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)\\n print(\\\"Test Accuracy:\\\", test_acc)\",\n \"def show_training_history(self):\\n hist = [i.history[\\\"loss\\\"][0] for i in self.history]\\n plt.plot(hist)\",\n \"def plot_train_and_valid_curves(ax, train_points, valid_points, learning_rate_updates_epoch, best_per_lr, mode=\\\"loss\\\"):\\n if mode==\\\"loss\\\":\\n name = \\\"Loss\\\"\\n names = \\\"losses\\\"\\n factor = [1.2, 1.22]\\n loc_legend = 1\\n elif mode ==\\\"acc\\\":\\n name = \\\"Accuracy\\\"\\n names = \\\"acc\\\"\\n factor = [0.9, 0.88]\\n loc_legend = 4\\n else:\\n print \\\"Mode not understood. Available modes : 'loss' and 'acc'\\\"\\n return\\n\\n #ax = plt.subplot(1,1,1)#\\n # Plot training and valid loss curves\\n ax.plot(np.arange(len(train_points)),train_points, c=\\\"k\\\", zorder=1)\\n ax.plot(np.arange(len(valid_points)),valid_points, c=\\\"k\\\", zorder=1)\\n ax.scatter(np.arange(len(train_points)),train_points, c=\\\"b\\\", label=\\\"Train %s\\\"%names, zorder=2)\\n ax.scatter(np.arange(len(valid_points)),valid_points, c=\\\"r\\\", label=\\\"Valid %s\\\"%names, zorder=2)\\n # Plot vertical line when the learning rate was updated\\n first = True\\n for elem in learning_rate_updates_epoch:\\n if first:\\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\\\"k\\\", label=\\\"LR updates\\\", linestyle=\\\"--\\\")\\n first = False\\n else:\\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\\\"k\\\", linestyle=\\\"--\\\")\\n # Plot best model in each region\\n first = True\\n for i,elem in enumerate(best_per_lr):\\n if first:\\n x = elem[0]\\n y = elem[1]\\n plt.scatter(x,y, c=\\\"g\\\", label=\\\"Best models\\\", marker=\\\"*\\\", zorder=3, s=100)\\n plt.plot([x,x],[y,factor[0]*y], c=\\\"g\\\")\\n plt.text(x,factor[1]*y, \\\"Epoch %d\\\"%(x), fontsize=8)\\n first = False\\n else:\\n x = elem[0]+learning_rate_updates_epoch[i-1]\\n y = elem[1]\\n plt.scatter(x,y, c=\\\"g\\\", marker=\\\"*\\\", zorder=3, s=100)\\n plt.plot()\\n plt.plot([x,x],[y,factor[0]*y], c=\\\"g\\\")\\n plt.text(x,factor[1]*y, \\\"Epoch %d\\\"%(x), fontsize=8)\\n # Xlim, Ylim, labels, legend...\\n ax.set_ylim([0,1])\\n ax.set_xlim([0,len(train_points)+5])\\n ax.set_xlabel(\\\"Epochs\\\")\\n ax.set_ylabel(name)\\n handles,labels = ax.get_legend_handles_labels()\\n sorted_zip = sorted(zip([2,0,1,3],handles, labels))\\n index, handles, labels = zip(*sorted_zip)\\n ax.legend(handles,labels, loc=loc_legend, prop={'size':10})\",\n \"def plot_loss(self):\\n #x = [k for k in range(self.rep)]\\n loss = self.min_list[:,0]//100 #For clarity\\n #plt.plot(x,self.min_list[:,0])\\n plt.hist(loss,density=True)\\n plt.xlabel(self.list_name + '_loss//100')\\n plt.ylabel('Frequency')\\n #plt.xticks(range(8),[0,250,500,750,1000,1250,1500,1750])\\n plt.title('Distribution of '+self.list_name+'_loss ('+str(self.rep)+' iterations)')\\n plt.savefig('img/stats/'+self.list_name+'_lossFrequency_'+self.model_name+'.png')\\n plt.show()\",\n \"def plot_loss_and_acc(history):\\n hist = history.history\\n x_arr = np.arange(len(hist['loss'])) + 1\\n fig = plt.figure(figsize=(12,4))\\n ax = fig.add_subplot(1,2,1)\\n ax.plot(x_arr, hist['loss'], '-o', label='Train loss')\\n ax.plot(x_arr, hist['val_loss'], '--<', label='Validation loss')\\n ax.legend(fontsize=15)\\n ax.set_xlabel('Epoch', size=15)\\n ax.set_ylabel('Loss', size=15)\\n\\n ax = fig.add_subplot(1,2,2)\\n ax.plot(x_arr, hist['accuracy'], '-o', label='Train acc.')\\n ax.plot(x_arr, hist['val_accuracy'], '--<', label='Validation acc.')\\n ax.legend(fontsize=15)\\n ax.set_xlabel('Epoch', size=15),\\n ax.set_ylabel('Accuracy', size=15)\\n plt.show()\",\n \"def training(self, dataset, \\n epochs, r_loss, beta, \\n Plotter=None):\\n\\n losses = []\\n epochs = range(epochs)\\n\\n for i in tqdm(epochs, desc='Epochs'):\\n losses_epochs = []\\n for step, x in enumerate(dataset):\\n\\n loss = self.training_step(x, r_loss, beta)\\n \\n # Logging.\\n losses_epochs.append(float(loss))\\n losses.append(np.mean(losses_epochs))\\n \\n if Plotter != None:\\n Plotter.plot(losses)\\n\\n return losses\",\n \"def summarize_diagnostics(self):\\n # plot loss\\n pyplot.subplot(211)\\n pyplot.title('Cross Entropy Loss')\\n pyplot.plot(self.history.history['loss'], color='blue', label='train')\\n pyplot.plot(self.history.history['val_loss'], color='orange', label='test')\\n # plot accuracy\\n pyplot.subplot(212)\\n pyplot.title('Classification Accuracy')\\n pyplot.plot(self.history.history['accuracy'], color='blue', label='train')\\n pyplot.plot(self.history.history['val_accuracy'], color='orange', label='test')\\n # save plot to file\\n pyplot.savefig(f'{self.project_home / \\\"o\\\"}/{self.model.name}_plot.png')\\n pyplot.close()\",\n \"def plot_error(self, maxstep=20):\\n plt.ion()\\n plt.xlabel(\\\"step\\\")\\n plt.ylabel(\\\"Ave Logloss (bits)\\\")\\n train_errors = []\\n if self.dataset.test:\\n test_errors = []\\n for i in range(maxstep):\\n self.learn(1)\\n train_errors.append( sum(self.logloss(tple) for tple in self.dataset.train)\\n /len(self.dataset.train))\\n if self.dataset.test:\\n test_errors.append( sum(self.logloss(tple) for tple in self.dataset.test)\\n /len(self.dataset.test))\\n plt.plot(range(1,maxstep+1),train_errors,\\n label=str(self.num_classes)+\\\" classes. Training set\\\")\\n if self.dataset.test:\\n plt.plot(range(1,maxstep+1),test_errors,\\n label=str(self.num_classes)+\\\" classes. Test set\\\")\\n plt.legend()\\n plt.draw()\",\n \"def plot_fit_history(fit_history_obj):\\r\\n plt.plot(fit_history_obj.history['loss'])\\r\\n plt.plot(fit_history_obj.history['val_loss'])\\r\\n plt.title('model mean squared error loss')\\r\\n plt.ylabel('mean squared error loss')\\r\\n plt.xlabel('epoch')\\r\\n plt.legend(['training set', 'validation set'], loc='upper right')\\r\\n plt.show()\",\n \"def plot_acc_and_loss(trn_hist, val_hist):\\n assert isinstance(trn_hist, np.ndarray) and isinstance(val_hist, np.ndarray)\\n fig, (ax_acc, ax_loss) = plt.subplots(1, 2, figsize=(10, 4))\\n plot_on_ax(ax_acc, trn_hist[:,0], val_hist[:,0], \\\"Accuracy\\\")\\n plot_on_ax(ax_loss, trn_hist[:,1], val_hist[:,1], \\\"Loss\\\")\\n plt.show()\",\n \"def train_nn(train_nn_results, label, title, yaxis):\\n plt.figure(figsize=(12,5))\\n for i in range(len(label)):\\n plt.plot(train_nn_results[i], label=label[i], alpha=0.75)\\n plt.title(title)\\n plt.xlabel('epoch')\\n plt.ylabel(yaxis)\\n plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')\\n plt.tight_layout()\\n plt.show()\",\n \"def plot_results(self):\\n\\n\\n f1, ax1 = plt.subplots()\\n h1, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"trainLoss\\\"],\\\\\\n \\\"b-\\\", label=\\\"Loss - Train\\\")\\n h2, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"validLoss\\\"],\\\\\\n \\\"b.\\\", label=\\\"Loss - Validation\\\")\\n\\n ax1.set_ylabel(\\\"Loss\\\", color = \\\"blue\\\")\\n ax1.tick_params(\\\"y\\\", color = \\\"blue\\\")\\n ax1.yaxis.label.set_color(\\\"blue\\\")\\n ax1.set_xlabel(\\\"Training Steps [{}]\\\".format(self.FLAGS.eval_every))\\n\\n ax2 = ax1.twinx()\\n h3, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"trainAccr\\\"], \\\"r-\\\",\\\\\\n label = \\\"Accuracy - Train\\\")\\n h4, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"validAccr\\\"], \\\"r.\\\",\\\\\\n label = \\\"Accuracy - Validation\\\")\\n\\n ax2.set_ylabel(\\\"Accuracy\\\", color = \\\"red\\\")\\n ax2.tick_params(\\\"y\\\", color = \\\"red\\\")\\n ax2.yaxis.label.set_color(\\\"red\\\")\\n\\n hds = [h1,h2,h3,h4]\\n lbs = [l.get_label() for l in hds]\\n ax1.legend(hds, lbs)\\n f1.tight_layout()\\n plt.savefig(\\\"trainingHistory.png\\\")\\n\\n plt.close(f1)\\n #plt.show()\",\n \"def train_model_and_plot_results(**kwargs):\\n epochs = kwargs[\\\"epochs\\\"]\\n\\n history, model = train_model(**kwargs)\\n\\n dice = history.history['dice_loss']\\n val_dice = history.history['val_dice_loss']\\n\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n\\n epochs_range = range(epochs)\\n\\n plt.figure(figsize=(16, 8))\\n plt.subplot(1, 2, 1)\\n plt.plot(epochs_range, dice, label='Training Dice Loss')\\n plt.plot(epochs_range, val_dice, label='Validation Dice Loss')\\n plt.legend(loc='upper right')\\n plt.title('Training and Validation Dice Loss')\\n\\n plt.subplot(1, 2, 2)\\n plt.plot(epochs_range, loss, label='Training Loss')\\n plt.plot(epochs_range, val_loss, label='Validation Loss')\\n plt.legend(loc='upper right')\\n plt.title('Training and Validation Loss')\\n\\n plt.show()\",\n \"def plot_data():\\n \\n [X_train, X_dev, X_test, Y_train, Y_dev, Y_test, numOutputNodes] = load_data('regression') \\n \\n traindev = np.concatenate((Y_train, Y_dev), 1)\\n traindevtest = np.concatenate((traindev, Y_test), 1)\\n tdt = traindevtest.reshape(traindevtest.shape[1],)\\n\\n Y_train = Y_train.reshape(Y_train.shape[1],)\\n Y_dev = Y_dev.reshape(Y_dev.shape[1],)\\n Y_test = Y_test.reshape(Y_test.shape[1],)\\n\\n sigma = np.round(np.std(tdt), 3)\\n mu = np.round(np.mean(tdt), 3)\\n\\n # plots histogram of all data together, indicating values of mean and standard deviation\\n plt.figure(1)\\n plt.hist(tdt)\\n plt.title(\\\"{} data points, mu = {}, sigma = {}\\\".format(tdt.size, mu, sigma))\\n plt.xlabel(\\\"average Fe coordination number\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.show()\\n\\n # plots histogram where the training, cross-validation, and test sets have separate bars\\n plt.figure(2)\\n plt.hist([Y_train, Y_dev, Y_test], label = ['training', 'cross-validation', 'test'], density = True)\\n plt.xlabel(\\\"average Fe coordination number\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.legend()\\n plt.show()\\n\\n # below is graphing for the charge data, as opposed to the averaged spectrum data\\n [X_train1, X_dev1, X_test1, _, _, _, Y_train1, Y_dev1, Y_test1, numOutputNodes1] = load_data('multi_task')\\n traindev1 = np.concatenate((Y_train1, Y_dev1), 1)\\n traindevtest1 = np.concatenate((traindev1, Y_test1), 1)\\n tdt1 = traindevtest1.reshape(traindevtest1.shape[1],)\\n\\n Y_train1 = Y_train1.reshape(Y_train1.shape[1],)\\n Y_dev1 = Y_dev1.reshape(Y_dev1.shape[1],)\\n Y_test1 = Y_test1.reshape(Y_test1.shape[1],)\\n\\n sigma = np.round(np.std(tdt1), 3)\\n mu = np.round(np.mean(tdt1), 3)\\n\\n # plots histogram of all data together, indicating values of mean and standard deviation\\n plt.figure(3)\\n plt.hist(tdt1)\\n plt.title(\\\"{} data points, mu = {}, sigma = {}\\\".format(tdt1.size, mu, sigma))\\n plt.xlabel(\\\"charge\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.show()\\n\\n # plots histogram where the training, cross-validation, and test sets have separate bars\\n plt.figure(4)\\n plt.hist([Y_train1, Y_dev1, Y_test1], label = ['training', 'cross-validation', 'test'], density = True)\\n plt.xlabel(\\\"charge\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.legend()\\n plt.show()\\n\\n return None\",\n \"def plot_train(func):\\n def plotting_func(model, train_config, arch, data_loader, epoch, handle_dict, optimizers):\\n output_dict = func(model, train_config, arch, data_loader, epoch, optimizers)\\n metrics = [output_dict['avg_elbo'], output_dict['avg_cond_log_like'], output_dict['avg_kl']]\\n plot_average_metrics(metrics, epoch, handle_dict, 'Train')\\n plot_param_grad_mags(output_dict['avg_param_grad_mags'], epoch, handle_dict)\\n plot_state_grad_mags(output_dict['avg_state_grad_mags'], epoch, handle_dict)\\n plot_opt_lr(optimizers, epoch, handle_dict)\\n return output_dict, handle_dict\\n return plotting_func\",\n \"def train_test_error(e_train, e_test, model_params):\\n\\n fig = plt.figure(figsize=FIG_SIZE)\\n plt.plot(model_params, e_train, label='Training Set')\\n plt.plot(model_params, e_train, label='Test Set')\\n plt.xlabel('Model Parameter')\\n plt.ylabel('MSE of model')\\n plt.legend()\\n\\n return fig\",\n \"def train_plot_update(self, pred_, validate_y, steps_displayed, elastic_losses = None, restart_triggered = False):\\n if self.interactive:\\n display.clear_output(wait=True) \\n \\n pred_2plot = pred_.detach().to(\\\"cpu\\\")\\n if not self.ODE_order:\\n validate_y_2plot = validate_y.detach().to(\\\"cpu\\\")\\n try:\\n self.ax[1].clear()\\n self.ax[0].clear()\\n except:\\n pass\\n\\n \\n\\n labels = \\\"best value\\\", \\\"all samples\\\"\\n #log2 = np.log(2)\\n\\n # Plot 1: the training history of the bayesian optimization\\n # if not self.log_score:\\n # self.ax[0].plot(np.log(self.errorz_step), alpha = 0.5, color = \\\"blue\\\", label = labels[0] )\\n # self.ax[0].plot(np.log(self.errorz), alpha = 0.2, color = \\\"green\\\", label = labels[1])\\n # else:\\n font_dict = {\\\"prop\\\" : {\\\"size\\\":14}}\\n ticks_font_size = 14\\n\\n self.ax[0].plot(10**np.array(self.errorz_step), alpha = 0.5, color = \\\"blue\\\", label = labels[0] )\\n self.ax[0].plot(10**np.array(self.errorz), alpha = 0.2, color = \\\"green\\\", label = labels[1])\\n #self.ax[0].set_title(\\\"log(error) vs Thompson Sampling step\\\")\\n self.ax[0].set_ylabel(f\\\"log({self.scoring_method})\\\")\\n self.ax[0].set_xlabel(\\\"BO step\\\")\\n self.ax[0].set_ylabel(\\\"Error\\\")\\n self.ax[0].legend(**font_dict)\\n self.ax[0].set_yscale(\\\"log\\\")\\n #self.ax[0].set_ylim(10**-8,1)\\n # self.ax[0].set_xtickslabels(fontsize= ticks_font_size )\\n # self.ax[0].set_ytickslabels(fontsize= ticks_font_size )\\n \\n #plot 2: the turbo state #plot 2: the turbo state\\n self.ax[1].axhline(np.log(self.state.length_max)/self.log2, color = 'green', label = 'max length')\\n self.ax[1].set_title(\\\"TURBO state\\\")\\n self.ax[1].plot(np.log(self.length_progress)/self.log2, color = 'blue', label = 'current length')\\n self.ax[1].axhline(np.log(self.state.length_min)/self.log2, color = 'red', label = 'target length')\\n self.ax[1].legend() \\n\\n #plot 3 (most recent prediction)\\n self.ax[2].clear()\\n if not self.ODE_order:\\n self.ax[2].plot(validate_y_2plot.to(\\\"cpu\\\"), alpha = 0.5, color = \\\"blue\\\", label = \\\"val set\\\") #[:steps_displayed]\\n self.ax[2].set_ylim(self.y.min().item() - 0.1, self.y.max().item() )\\n self.ax[2].plot(pred_2plot[:steps_displayed], alpha = 0.3, color = \\\"red\\\", label = \\\"latest pred\\\")\\n \\n self.ax[2].set_title(\\\"Val Set Prediction\\\")\\n self.ax[2].set_ylabel(\\\"y\\\")\\n self.ax[2].set_xlabel(r'$t$')\\n\\n pl.legend()\\n pl.tight_layout()\\n\\n display.display(pl.gcf())\\n\\n #clear the plot outputt and then re-plot\",\n \"def plot_on_ax(ax, trn_ls, val_ls, ylabel=\\\"Accuracy\\\"):\\n ax.plot(trn_ls, 'o-', label='Training')\\n ax.plot(val_ls, 'x-', label='Validation')\\n ax.set_xlabel('Epochs')\\n ax.set_ylabel(ylabel)\\n ax.legend()\",\n \"def show_solver_history(solver, plot_train=True, plot_val=True, color='black'):\\n mpl.rcParams['text.color'] = color\\n mpl.rcParams['axes.labelcolor'] = color\\n mpl.rcParams['xtick.color'] = color\\n mpl.rcParams['ytick.color'] = color\\n\\n print(\\\"Stop reason: %s\\\" % solver.stop_reason)\\n print(\\\"Stop time: %fs\\\" % solver.training_time_s)\\n\\n has_gender_loss = np.array(solver.history['val_gender_loss']).sum() > 0.\\n has_rec_loss = np.array(solver.history['val_rec_loss']).sum() > 0.\\n\\n train_loss = np.array(solver.history['train_loss'])\\n\\n if has_rec_loss:\\n train_rec_loss = np.array(solver.history['train_rec_loss'])\\n val_rec_loss = np.array(solver.history['val_rec_loss'])\\n if has_gender_loss:\\n train_gender_loss = np.array(solver.history['train_gender_loss'])\\n val_gender_loss = np.array(solver.history['val_gender_loss'])\\n\\n plt.figure(figsize=(20, 10))\\n\\n if plot_train:\\n if has_rec_loss:\\n plt.plot(np.linspace(1, len(train_loss), len(train_rec_loss)),\\n train_rec_loss, label='Train Reconstruction loss')\\n if has_gender_loss:\\n plt.plot(np.linspace(1, len(train_loss), len(train_gender_loss)),\\n train_gender_loss, label='ATrain Gender loss')\\n\\n if plot_val:\\n if has_rec_loss:\\n plt.plot(np.linspace(1, len(train_loss), len(val_rec_loss)),\\n val_rec_loss, label='Val Reconstruction loss')\\n if has_gender_loss:\\n plt.plot(np.linspace(1, len(train_loss), len(val_gender_loss)),\\n val_gender_loss, label='Val Gender loss')\\n\\n plt.xlabel(\\\"Iterations\\\", fontsize=18)\\n plt.ylabel(\\\"Train/Val loss\\\", fontsize=18)\\n plt.xticks(fontsize=14)\\n plt.yticks(fontsize=14)\\n legend = plt.legend(fontsize=14)\\n for text in legend.get_texts():\\n text.set_color(\\\"black\\\")\\n\\n plt.show()\\n\\n if has_rec_loss:\\n print(\\\"Final training reconstruction loss: {}\\\".format(\\n train_rec_loss[-1]))\\n print(\\\"Final validation reconstruction loss: {}\\\".format(\\n val_rec_loss[-1]))\\n if has_gender_loss:\\n print(\\\"Final training gender loss: {}\\\".format(train_gender_loss[-1]))\\n print(\\\"Final validation gender loss: {}\\\".format(val_gender_loss[-1]))\",\n \"def plot_metrics(history):\\n\\n pyplot.plot(history.history['loss'], label='loss')\\n\\n pyplot.plot(history.history['val_loss'], label='val_loss')\\n\\n pyplot.legend()\\n\\n pyplot.show()\",\n \"def learning_curve():\\n loss = []\\n val_loss = []\\n data_size = []\\n\\n x_slid, y_slid = sliding_window_main(x, y)\\n x_train, y_train, x_val, y_val, x_test, y_test = data_splitting_main(x_slid, y_slid)\\n m_tot = x_train.shape[0]\\n\\n batch_step = 50\\n try:\\n for m in range(batch_size, m_tot, batch_step*batch_size):\\n print(\\\"Training: \\\", m)\\n net = create_network()\\n history = trainer(net, x_train[:m], y_train[:m], x_val, y_val)\\n loss.append(history.history[\\\"loss\\\"][-1])\\n val_loss.append(history.history[\\\"val_loss\\\"][-1])\\n data_size.append(m)\\n\\n print(\\\"Loss:\\\", loss[-1])\\n print()\\n\\n finally:\\n plt.plot(data_size, loss, label=\\\"Loss\\\", marker=\\\"o\\\")\\n plt.plot(data_size, val_loss, label=\\\"Val Loss\\\", marker=\\\"o\\\")\\n plt.xlabel(\\\"m\\\")\\n plt.ylabel(\\\"Losses\\\")\\n plt.title(\\\"Model Loss\\\")\\n plt.legend()\\n plt.savefig(\\\"img/\\\" + datetime.now().strftime(\\\"%y%m%d_%H%M\\\") + \\\"_learning_curve.png\\\")\\n plt.show()\\n plt.close()\\n\\n return loss, val_loss\",\n \"def plot_train_test_errors(train_errors, test_errors, lambda_str , K , path, rng):\\n plt.plot(range(rng), train_errors, marker='o', label='Training Data');\\n plt.plot(range(rng), test_errors, marker='v', label='Test Data');\\n plt.title('ALS-WR Learning Curve, lambda = %s, K = %d'%(lambda_str, K))\\n plt.xlabel('Number of Epochs');\\n plt.ylabel('RMSE');\\n plt.legend()\\n plt.grid()\\n plt.savefig(\\\"../results/test_train_rmse_\\\"+path)\\n plt.show()\",\n \"def fit(self, plot_loss=True):\\n adam = optim.Adam(self.learning_rate)\\n self.svi = SVI(\\n self.vae_model, \\n self.vae_guide, \\n adam, \\n Trace_ELBO()\\n )\\n # encoder_nn = self.vae_encoder()\\n # decoder_nn = self.vae_decoder()\\n rng_key, rng_key_samp, rng_key_init = random.split(self.rng_key, 3)\\n\\n self.gp_predictive = Predictive(self.gp.sample, num_samples=self.batch_size)\\n\\n # initialise with a sample batch\\n sample_batch = self.gp_predictive(rng_key=rng_key_samp, x=self.x)\\n \\n svi_state = self.svi.init(rng_key_init, sample_batch['y'])\\n test_loss_list = []\\n\\n for i in range(self.num_epochs):\\n rng_key, rng_key_train, rng_key_test = random.split(rng_key, 3)\\n t_start = time.time()\\n\\n _, svi_state = self.epoch_train(rng_key_train, svi_state)\\n test_loss = self.eval_test(rng_key_test, svi_state)\\n test_loss_list += [test_loss]\\n\\n print(\\n \\\"Epoch {}: loss = {} ({:.2f} s.)\\\".format(\\n i, test_loss, time.time() - t_start\\n )\\n )\\n \\n if np.isnan(test_loss): break\\n\\n if plot_loss:\\n plt.figure()\\n plt.plot(np.arange(0, self.num_epochs, 1)[0:len(test_loss_list)], test_loss_list)\\n plt.xlabel(\\\"epochs\\\")\\n plt.ylabel(\\\"test error\\\")\\n plt.savefig('src/test/plots/vae_lost.png')\\n plt.show()\\n plt.close()\\n\\n # return optimal parameters for decoder\\n return self.svi.get_params(svi_state)[\\\"decoder$params\\\"]\",\n \"def visualize_loss_weights_siamese(cross_val_results, plot_filepath):\\n\\n siamese_model_scores_2, siamese_model_stds_2 = cross_val_results\\n\\n def organize_data(scores, stds):\\n \\\"\\\"\\\"\\n Helper function to organize score means and standard deviations across loss weight values as pandas.Dataframe\\n\\n :param scores: dictionary of score means {loss_weights: score_mean}\\n :param stds: dictionary of score stds {loss_weights: score_std}\\n\\n :returns: tuple of 2 pandas.Dataframe objects containing mean and std data\\n \\\"\\\"\\\"\\n\\n scores = pd.Series(list(scores.values()),\\n index=map(str, scores.keys()),\\n name=\\\"SCORE MEAN\\\")\\n scores.index.name = \\\"AUXILIARY LOSS WEIGHTS\\\"\\n stds = pd.Series(list(stds.values()),\\n index=map(str, stds.keys()),\\n name=\\\"SCORE STD\\\")\\n stds.index.name = \\\"AUXILIARY LOSS WEIGHTS\\\"\\n return scores, stds\\n\\n siamese_model_scores_2, siamese_model_stds_2 = organize_data(siamese_model_scores_2, siamese_model_stds_2)\\n\\n plt.figure(figsize=(10, 5))\\n siamese_model_scores_2.plot.line(yerr=siamese_model_stds_2,\\n capsize=5,\\n ylim=(0.3, 1.1),\\n colormap=colormap_brg_darker)\\n plt.title(\\\"Cross validation results for the\\\\nsiamese auxiliary loss weights\\\", fontsize=18)\\n plt.xlabel(\\\"Loss weights\\\", fontsize=14)\\n plt.ylabel(\\\"Average accuracy\\\", fontsize=14)\\n plt.xticks(fontsize=12, rotation=30)\\n plt.yticks(fontsize=12)\\n plt.tight_layout()\\n plt.savefig(fname=plot_filepath, dpi=\\\"figure\\\", format=\\\"eps\\\")\\n plt.close()\",\n \"def plotHistory(history):\\n \\n acc = history.history['acc']\\n val_acc = history.history['val_acc']\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n\\n epochs = range(len(acc))\\n \\n # Make and save the plot for our accuracy\\n plt.plot(epochs, acc, 'bo', label='Training acc')\\n plt.plot(epochs, val_acc, 'b', label='Validation acc')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n plt.savefig(\\\"trainValAccSecond.png\\\")\\n\\n # Make and save the plots for our loss \\n plt.figure()\\n plt.plot(epochs, loss, 'bo', label='Training loss')\\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n plt.show()\\n plt.savefig(\\\"trainValLossSecond.png\\\")\",\n \"def error_values(X_train,X_test,Y_train,Y_test):\\n #setting up parameters and variables for plotting \\n n_train = X_train.shape[0]\\n n_test = X_test.shape[0]\\n d = X_train.shape[1]\\n hdnode = 100\\n w1 = np.random.normal(0,0.001,d*hdnode).reshape((d,hdnode))\\n d1 = np.zeros((d,hdnode))\\n w2 = np.random.normal(0,0.001,hdnode).reshape((hdnode,1))\\n d2 = np.zeros(hdnode)\\n h = np.zeros(hdnode)\\n mb = 100 #minibatch size\\n m = int(n_train/mb)\\n batch = np.arange(m) \\n lr = 0.00020\\n EP = 20000 #needed for initializing \\n ep = 0\\n yh = np.zeros((n_train,1))\\n yh2 = np.zeros((n_test,1))\\n L_train= np.zeros(EP+1)\\n L_test = np.zeros(EP+1)\\n Y_train = Y_train.reshape(len(Y_train),1)\\n #activation function for the hidden layer is tanh\\n \\n def g(A):\\n return (np.tanh(A))\\n\\n def gd(A):\\n return (1-np.square(np.tanh(A)))\\n \\n #setting up how long the epoch will run\\n EP = 200\\n ep = 0\\n while ep < EP:\\n ep += 1\\n yh = g(X_train.dot(w1)).dot(w2)\\n yh2 = g(X_test.dot(w1)).dot(w2)\\n L_train[ep] = LA.norm(yh-Y_train.reshape(len(Y_train),1))/n_train\\n L_test[ep] = LA.norm(yh2-Y_test.reshape(len(Y_test),1))/n_test\\n \\n np.random.shuffle(batch)\\n for i in range(m):\\n st = batch[i]*mb\\n ed = (batch[i]+1)*mb\\n h = g(X_train[st:ed].dot(w1))\\n y = h.dot(w2)\\n d2 = h.T.dot(Y_train[st:ed]-y)\\n d1 = X_train[st:ed].T.dot(np.multiply((Y_train[st:ed]-y).dot(w2.T),gd(X_train[st:ed].dot(w1))))\\n w2 += lr*d2\\n w1 += lr*d1\\n return yh, yh2\",\n \"def plot_loss(path_to_loss, file_name):\\n path = '../'\\n labels = ['gen_total_loss', 'gen_loss', 'l1_loss', 'disc_total_loss', 'disc_gen_loss', 'disc_real_loss']\\n with open(path_to_loss + file_name + '.csv', newline='') as f:\\n reader = csv.reader(f)\\n data = np.array(list(reader))\\n\\n try:\\n os.mkdir(path + 'lossfig/losses_' + file_name)\\n except:\\n pass\\n\\n epoch_count = range(1, data.shape[0] + 1)\\n for i in range(data.shape[1]):\\n plt.figure()\\n plt.plot(epoch_count, data[:, i].astype('float32'))\\n plt.xlabel('Epoch')\\n plt.ylabel(labels[i])\\n plt.savefig(path + 'lossfig/losses_' + file_name + '/' + labels[i] + '.png')\\n\\n plt.figure()\\n for i in range(data.shape[1]):\\n plt.plot(epoch_count, data[:, i].astype('float32'))\\n plt.legend(labels)\\n plt.xlabel('Epoch')\\n plt.ylabel('loss')\\n plt.savefig(path + 'lossfig/losses_' + file_name + '/all_loss.png')\",\n \"def plot_training_history(history):\\n fig, (ax_loss, ax_acc) = plt.subplots(1, 2, figsize=(15, 5))\\n ax_loss.plot(history.epoch, history.history[\\\"loss\\\"], label=\\\"Train loss\\\")\\n ax_loss.plot(history.epoch, history.history[\\\"val_loss\\\"], label=\\\"Validation loss\\\")\\n ax_loss.legend()\\n ax_acc.plot(history.epoch, history.history[\\\"iou_score\\\"], label=\\\"Train iou\\\")\\n ax_acc.plot(history.epoch, history.history[\\\"val_iou_score\\\"], label=\\\"Validation iou\\\")\\n ax_acc.legend()\",\n \"def plot_training_history(history, metric):\\n \\n val_metric = 'val_'+metric\\n acc = history.history[metric]\\n val_acc = history.history[val_metric]\\n \\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n \\n epochs_range = history.epoch\\n \\n plt.figure(figsize=(8, 8))\\n plt.subplot(2, 1, 1)\\n plt.plot(epochs_range, acc, label='Training Acc.')\\n plt.plot(epochs_range, val_acc, label='Validation Acc.')\\n plt.legend(loc='best',)\\n plt.title('Training and Validation Accuracy')\\n \\n plt.subplot(2, 1, 2)\\n plt.plot(epochs_range, loss, label='Training Loss')\\n plt.plot(epochs_range, val_loss, label='Validation Loss')\\n plt.legend(loc='best')\\n plt.title('Training and Validation Loss')\\n plt.show()\",\n \"def visualize_training(features, labels, pl):\\n print(\\\"Visualizing training\\\")\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n\\n # Take out each feature type, one at a time\\n label_map = get_label_map(labels)\\n\\n for key in label_map.keys():\\n like_ind = label_map[key]\\n like_data = np.array([features[i] for i in like_ind])\\n\\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\\n\\n # get limits\\n xmin = features.column_min(0) - .5\\n xmax = features.column_max(0) + .5\\n ymin = features.column_min(1) - .5\\n ymax = features.column_max(1) + .5\\n\\n plt.xlim(xmin,xmax)\\n plt.ylim(ymin,ymax)\\n\\n # Track the current dividing line, as well as the number of epochs passed\\n divider, = plt.plot([],[])\\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\\n\\n def update(i):\\n \\\"\\\"\\\"\\n 1.) Get the next set of weights from the tracker\\n 2.) Calculate and draw the new divider line\\n 3.) Update the epoch counter\\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\\n \\\"\\\"\\\"\\n epoch = i//features.instance_count\\n w = pl.weights_tracker[i]\\n a = pl.accuracy_tracker[epoch]\\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\\n epoch_tracker.set_text(\\\"{} {}\\\".format(epoch + 1, a))\\n\\n # Keep a shadow of the hyperplane at the end of each epoch\\n if i % features.instance_count == 0:\\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\\n\\n return divider\\n\\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\\n plt.legend()\\n\\n # optional save file\\n if len(sys.argv) >= 3 :\\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\\n\\n plt.show()\",\n \"def plot_metrics(self, title=None, fig_size=None, col_count=3):\\n metric_names = self.tracked_metrics()\\n metric_vals = {metric_name: self.metrics_history[metric_name][\\\"epoch_vals\\\"] for metric_name in metric_names}\\n if self.include_val_metrics:\\n # also has validation metrics\\n for metric_name in metric_names:\\n metric_vals[f\\\"val_{metric_name}\\\"] = self.metrics_history[f\\\"val_{metric_name}\\\"][\\\"epoch_vals\\\"]\\n\\n # we will plot a max of 3 metrics per row\\n MAX_COL_COUNT = col_count\\n col_count = MAX_COL_COUNT if len(metric_names) > MAX_COL_COUNT else len(metric_names)\\n row_count = len(metric_names) // MAX_COL_COUNT\\n row_count += 1 if len(metric_names) % MAX_COL_COUNT != 0 else 0\\n # we'll always have \\\"loss\\\" metric in list, so safest to pick!\\n x_vals = np.arange(1, len(metric_vals[\\\"loss\\\"]) + 1)\\n\\n with sns.axes_style(\\\"darkgrid\\\"):\\n sns.set_context(\\\"notebook\\\") # , font_scale = 1.2)\\n sns.set_style(\\n {\\\"font.sans-serif\\\": [\\\"Segoe UI\\\", \\\"Calibri\\\", \\\"SF Pro Display\\\", \\\"Arial\\\", \\\"DejaVu Sans\\\", \\\"Sans\\\"]}\\n )\\n fig_size = (16, 5) if fig_size is None else fig_size\\n\\n if len(metric_names) == 1:\\n # only loss\\n plt.figure(figsize=fig_size)\\n plt.plot(x_vals, metric_vals[\\\"loss\\\"], lw=2, markersize=7, color=\\\"steelblue\\\", marker=\\\"o\\\")\\n if self.include_val_metrics:\\n plt.plot(x_vals, metric_vals[\\\"val_loss\\\"], lw=2, markersize=7, color=\\\"firebrick\\\", marker=\\\"o\\\")\\n legend = [\\\"train\\\", \\\"valid\\\"] if self.include_val_metrics else [\\\"train\\\"]\\n plt_title = (\\n f\\\"Training & Cross-validation Loss vs Epochs\\\" if len(legend) == 2 else f\\\"Training Loss vs Epochs\\\"\\n )\\n plt.title(plt_title)\\n plt.legend(legend, loc=\\\"best\\\")\\n else:\\n f, ax = plt.subplots(row_count, col_count, figsize=fig_size)\\n for r in range(row_count):\\n for c in range(col_count):\\n index = r * (col_count - 1) + c\\n if index < len(metric_names):\\n metric_name = metric_names[index]\\n if row_count == 1:\\n ax[c].plot(x_vals, metric_vals[metric_name], lw=2, markersize=7, marker=\\\"o\\\")\\n else:\\n ax[r, c].plot(x_vals, metric_vals[metric_name], lw=2, markersize=7, marker=\\\"o\\\")\\n if self.include_val_metrics:\\n if row_count == 1:\\n ax[c].plot(\\n x_vals, metric_vals[f\\\"val_{metric_name}\\\"], lw=2, markersize=7, marker=\\\"o\\\"\\n )\\n else:\\n ax[r, c].plot(\\n x_vals, metric_vals[f\\\"val_{metric_name}\\\"], lw=2, markersize=7, marker=\\\"o\\\"\\n )\\n legend = [\\\"train\\\", \\\"valid\\\"] if self.include_val_metrics else [\\\"train\\\"]\\n ax_title = (\\n f\\\"Training & Cross-validation '{metric_name}' vs Epochs\\\"\\n if len(legend) == 2\\n else f\\\"Training '{metric_name}' vs Epochs\\\"\\n )\\n if row_count == 1:\\n ax[c].legend(legend, loc=\\\"best\\\")\\n ax[c].set_title(ax_title)\\n else:\\n ax[r, c].legend(legend, loc=\\\"best\\\")\\n ax[r, c].set_title(ax_title)\\n\\n if title is not None:\\n plt.suptitle(title)\\n\\n plt.show()\",\n \"def train_with_validation_provided(self, features, labels, val_features, val_labels):\\n hist = self.model.fit(\\n features, labels, batch_size=self.config['training']['batch_size'],\\n epochs=self.config['training']['epochs'],\\n validation_data=(val_features, val_labels),\\n validation_freq=self.config['training']['validation_frequency'],\\n callbacks=[TensorBoard(log_dir=self.config['model']['tensorboard_dir'])])\\n return hist\",\n \"def plot_data(losses, accuracies, name):\\n # convert accuracies to percentages\\n accuracies['Train'] = [acc * 100 for acc in accuracies['Train']]\\n accuracies['Valid'] = [acc * 100 for acc in accuracies['Valid']]\\n # set fontsize\\n plt.rcParams.update({'font.size': 13})\\n fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(8,5))\\n ax1.set_xlabel('Number of Epochs')\\n ax1.set_ylabel('Cross Entropy Loss')\\n ax1.set_ylim(0,2)\\n ax1.plot(losses['Train'], label='Training')\\n ax1.plot(losses['Valid'], label='Validation')\\n ax1.legend(loc='upper right')\\n\\n ax2.set_xlabel('Number of Epochs')\\n ax2.set_ylabel('Accuracy (%)')\\n ax2.set_ylim(0,100)\\n ax2.plot(accuracies['Train'], label='Training')\\n ax2.plot(accuracies['Valid'], label='Validation')\\n ax2.legend(loc='upper left')\\n\\n fig.tight_layout()\\n fig.savefig('../outputs/' + name)\",\n \"def learning_curve(dataframe:object, analysis_type:str, loss_skip_15pct:bool=False):\\n\\n\\t\\t# Spline seems to crash with too many points.\\n\\t\\tif (dataframe.shape[0] >= 400):\\n\\t\\t\\tline_shape = 'linear'\\n\\t\\telif (dataframe.shape[0] < 400):\\n\\t\\t\\tline_shape = 'spline'\\n\\n\\t\\tdf_loss = dataframe[['loss','val_loss']]\\n\\t\\tdf_loss = df_loss.rename(columns={\\\"loss\\\": \\\"train_loss\\\", \\\"val_loss\\\": \\\"validation_loss\\\"})\\n\\t\\tdf_loss = df_loss.round(3)\\n\\n\\t\\tif loss_skip_15pct:\\n\\t\\t\\tdf_loss = df_loss.tail(round(df_loss.shape[0]*.85))\\n\\n\\t\\tfig_loss = px.line(\\n\\t\\t\\tdf_loss\\n\\t\\t\\t, title = '<i>Training History: Loss</i>'\\n\\t\\t\\t, line_shape = line_shape\\n\\t\\t)\\n\\t\\tfig_loss.update_layout(\\n\\t\\t\\txaxis_title = \\\"Epochs\\\"\\n\\t\\t\\t, yaxis_title = \\\"Loss\\\"\\n\\t\\t\\t, legend_title = None\\n\\t\\t\\t, font_family = \\\"Avenir\\\"\\n\\t\\t\\t, font_color = \\\"#FAFAFA\\\"\\n\\t\\t\\t, plot_bgcolor = \\\"#181B1E\\\"\\n\\t\\t\\t, paper_bgcolor = \\\"#181B1E\\\"\\n\\t\\t\\t, height = 400\\n\\t\\t\\t, hoverlabel = dict(\\n\\t\\t\\t\\tbgcolor = \\\"#0F0F0F\\\"\\n\\t\\t\\t\\t, font_size = 15\\n\\t\\t\\t\\t, font_family = \\\"Avenir\\\"\\n\\t\\t\\t)\\n\\t\\t\\t, yaxis = dict(\\n\\t\\t\\t\\tside = \\\"right\\\"\\n\\t\\t\\t\\t, tickmode = 'auto'# When loss is initially high, the 0.1 tickmarks are overwhelming.\\n\\t\\t\\t\\t, tick0 = -1\\n\\t\\t\\t\\t, nticks = 9\\n\\t\\t\\t)\\n\\t\\t\\t, legend = dict(\\n\\t\\t\\t\\torientation=\\\"h\\\"\\n\\t\\t\\t\\t, yanchor=\\\"bottom\\\"\\n\\t\\t\\t\\t, y=1.02\\n\\t\\t\\t\\t, xanchor=\\\"right\\\"\\n\\t\\t\\t\\t, x=1\\n\\t\\t\\t)\\n\\t\\t\\t, margin = dict(\\n\\t\\t\\t\\tt = 5\\n\\t\\t\\t\\t, b = 0\\n\\t\\t\\t),\\n\\t\\t)\\n\\t\\tfig_loss.update_xaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\\n\\t\\tfig_loss.update_yaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\\n\\n\\t\\tif (\\\"classification\\\" in analysis_type):\\n\\t\\t\\tdf_acc = dataframe[['accuracy', 'val_accuracy']]\\n\\t\\t\\tdf_acc = df_acc.rename(columns={\\\"accuracy\\\": \\\"train_accuracy\\\", \\\"val_accuracy\\\": \\\"validation_accuracy\\\"})\\n\\t\\t\\tdf_acc = df_acc.round(3)\\n\\n\\t\\t\\tfig_acc = px.line(\\n\\t\\t\\tdf_acc\\n\\t\\t\\t\\t, title = '<i>Training History: Accuracy</i>'\\n\\t\\t\\t\\t, line_shape = line_shape\\n\\t\\t\\t)\\n\\t\\t\\tfig_acc.update_layout(\\n\\t\\t\\t\\txaxis_title = \\\"epochs\\\"\\n\\t\\t\\t\\t, yaxis_title = \\\"accuracy\\\"\\n\\t\\t\\t\\t, legend_title = None\\n\\t\\t\\t\\t, font_family = \\\"Avenir\\\"\\n\\t\\t\\t\\t, font_color = \\\"#FAFAFA\\\"\\n\\t\\t\\t\\t, plot_bgcolor = \\\"#181B1E\\\"\\n\\t\\t\\t\\t, paper_bgcolor = \\\"#181B1E\\\"\\n\\t\\t\\t\\t, height = 400\\n\\t\\t\\t\\t, hoverlabel = dict(\\n\\t\\t\\t\\t\\tbgcolor = \\\"#0F0F0F\\\"\\n\\t\\t\\t\\t\\t, font_size = 15\\n\\t\\t\\t\\t\\t, font_family = \\\"Avenir\\\"\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\t, yaxis = dict(\\n\\t\\t\\t\\tside = \\\"right\\\"\\n\\t\\t\\t\\t, tickmode = 'linear'\\n\\t\\t\\t\\t, tick0 = 0.0\\n\\t\\t\\t\\t, dtick = 0.05\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\t, legend = dict(\\n\\t\\t\\t\\t\\torientation=\\\"h\\\"\\n\\t\\t\\t\\t\\t, yanchor=\\\"bottom\\\"\\n\\t\\t\\t\\t\\t, y=1.02\\n\\t\\t\\t\\t\\t, xanchor=\\\"right\\\"\\n\\t\\t\\t\\t\\t, x=1\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\t, margin = dict(\\n\\t\\t\\t\\t\\tt = 5\\n\\t\\t\\t\\t),\\n\\t\\t\\t)\\n\\t\\t\\tfig_acc.update_xaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\\n\\t\\t\\tfig_acc.update_yaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\\n\\t\\t\\tfig_acc.show()\\n\\t\\tfig_loss.show()\",\n \"def plots(self, history):\\n print(history.history.keys())\\n plt.plot(history.history['acc'])\\n plt.plot(history.history['val_acc'])\\n plt.title('model accuracy')\\n plt.ylabel('accuracy')\\n plt.xlabel('epoch')\\n plt.legend(['train','test'], loc='upper left')\\n plt.show()\\n\\n plt.plot(history.history['loss'])\\n plt.plot(history.history['val_loss'])\\n plt.title('model loss')\\n plt.ylabel('loss')\\n plt.xlabel('epoch')\\n plt.legend(['train','test'], loc='upper left')\\n plt.show()\",\n \"def plot_history(H, epochs):\\n plt.style.use(\\\"fivethirtyeight\\\")\\n plt.figure()\\n plt.plot(np.arange(0, epochs), H.history[\\\"loss\\\"], label=\\\"train_loss\\\")\\n plt.plot(np.arange(0, epochs), H.history[\\\"val_loss\\\"], label=\\\"val_loss\\\")\\n plt.plot(np.arange(0, epochs), H.history[\\\"accuracy\\\"], label=\\\"train_acc\\\")\\n plt.plot(np.arange(0, epochs), H.history[\\\"val_accuracy\\\"], label=\\\"val_acc\\\")\\n plt.title(\\\"Training Loss and Accuracy\\\")\\n plt.xlabel(\\\"Epoch #\\\")\\n plt.ylabel(\\\"Loss/Accuracy\\\")\\n plt.legend()\\n plt.tight_layout()\\n plt.show()\",\n \"def train(self,X,Y,show_loss_history=True):\\n\\n n_data = len(X)\\n n_batches = int(n_data / self.batch_size)\\n\\n loss_history = np.zeros([n_batches,self.epochs])\\n\\n print(\\\"\\\\nStarting training\\\")\\n print(\\\"{} samples\\\".format(n_data))\\n print(\\\"{} epochs\\\".format(self.epochs))\\n print(\\\"{} batches\\\".format(n_batches))\\n\\n for epoch in tqdm(range(self.epochs)):\\n for batch in tqdm(range(n_batches)):\\n\\n X_batch = X[self.batch_size*batch:self.batch_size*(batch+1)]\\n Y_batch = Y[self.batch_size*batch:self.batch_size*(batch+1)]\\n loss = self.train_batch(X_batch,Y_batch)\\n\\n loss_history[batch,epoch] = loss\\n\\n if show_loss_history:\\n loss_history = np.mean(loss_history,axis=0)\\n n_epochs = np.array(range(len(loss_history))) + 1\\n\\n plt.plot(n_epochs,loss_history)\\n plt.xlabel(\\\"Number of epochs\\\")\\n plt.ylabel(\\\"Loss\\\")\\n plt.show()\",\n \"def plot_loss_history(data=None, title=None, name=None, path=None):\\n # TODO: add labels to loss history\\n plt.figure(random.randint(a=1, b=100))\\n plt.title(title)\\n plt.plot(data)\\n plt.savefig('{}/{}.png'.format(path, name))\",\n \"def cross_validation_visualization_mean(epochs, means, save=False, filename = \\\"cross_validation_mean\\\"):\\n plt.plot(epochs, means, marker=\\\".\\\", color='b', label='means')\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"mean loss\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n if (save):\\n plt.savefig(filename)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81466526","0.80646133","0.80406374","0.79073626","0.7877066","0.78295696","0.77334934","0.7585977","0.7578295","0.7422468","0.735688","0.73400354","0.72983456","0.7278823","0.7261395","0.72606814","0.72324854","0.71921957","0.71786606","0.71336514","0.7109728","0.7099447","0.7084603","0.7079184","0.6993046","0.6990574","0.69563824","0.69517916","0.69488275","0.6915852","0.6910235","0.6893139","0.68649054","0.6849005","0.6841343","0.6839021","0.67550105","0.67397815","0.6739671","0.67336696","0.6731698","0.6729777","0.6704021","0.67024","0.6696225","0.66815567","0.66763693","0.66701794","0.6668642","0.6656666","0.6656619","0.6650098","0.6637005","0.6636109","0.66321784","0.6631741","0.6623094","0.66177034","0.6610453","0.6610436","0.6607121","0.66043574","0.6571354","0.65635043","0.6548611","0.65454483","0.65440625","0.65385705","0.65157115","0.65059364","0.6486741","0.64862484","0.64813334","0.6466002","0.6461155","0.64578533","0.64571327","0.6456189","0.64507014","0.6436788","0.6398262","0.6397042","0.6394737","0.6372186","0.63664556","0.63544124","0.63514686","0.63444716","0.6343354","0.6343266","0.6341907","0.6308635","0.6299567","0.6287449","0.62845665","0.6249069","0.6245679","0.6242702","0.6236466","0.62236345"],"string":"[\n \"0.81466526\",\n \"0.80646133\",\n \"0.80406374\",\n \"0.79073626\",\n \"0.7877066\",\n \"0.78295696\",\n \"0.77334934\",\n \"0.7585977\",\n \"0.7578295\",\n \"0.7422468\",\n \"0.735688\",\n \"0.73400354\",\n \"0.72983456\",\n \"0.7278823\",\n \"0.7261395\",\n \"0.72606814\",\n \"0.72324854\",\n \"0.71921957\",\n \"0.71786606\",\n \"0.71336514\",\n \"0.7109728\",\n \"0.7099447\",\n \"0.7084603\",\n \"0.7079184\",\n \"0.6993046\",\n \"0.6990574\",\n \"0.69563824\",\n \"0.69517916\",\n \"0.69488275\",\n \"0.6915852\",\n \"0.6910235\",\n \"0.6893139\",\n \"0.68649054\",\n \"0.6849005\",\n \"0.6841343\",\n \"0.6839021\",\n \"0.67550105\",\n \"0.67397815\",\n \"0.6739671\",\n \"0.67336696\",\n \"0.6731698\",\n \"0.6729777\",\n \"0.6704021\",\n \"0.67024\",\n \"0.6696225\",\n \"0.66815567\",\n \"0.66763693\",\n \"0.66701794\",\n \"0.6668642\",\n \"0.6656666\",\n \"0.6656619\",\n \"0.6650098\",\n \"0.6637005\",\n \"0.6636109\",\n \"0.66321784\",\n \"0.6631741\",\n \"0.6623094\",\n \"0.66177034\",\n \"0.6610453\",\n \"0.6610436\",\n \"0.6607121\",\n \"0.66043574\",\n \"0.6571354\",\n \"0.65635043\",\n \"0.6548611\",\n \"0.65454483\",\n \"0.65440625\",\n \"0.65385705\",\n \"0.65157115\",\n \"0.65059364\",\n \"0.6486741\",\n \"0.64862484\",\n \"0.64813334\",\n \"0.6466002\",\n \"0.6461155\",\n \"0.64578533\",\n \"0.64571327\",\n \"0.6456189\",\n \"0.64507014\",\n \"0.6436788\",\n \"0.6398262\",\n \"0.6397042\",\n \"0.6394737\",\n \"0.6372186\",\n \"0.63664556\",\n \"0.63544124\",\n \"0.63514686\",\n \"0.63444716\",\n \"0.6343354\",\n \"0.6343266\",\n \"0.6341907\",\n \"0.6308635\",\n \"0.6299567\",\n \"0.6287449\",\n \"0.62845665\",\n \"0.6249069\",\n \"0.6245679\",\n \"0.6242702\",\n \"0.6236466\",\n \"0.62236345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75181407"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":21489,"cells":{"query":{"kind":"string","value":"Plot and save the ROC with AUC value. Arguments"},"document":{"kind":"string","value":"def plot_ROC(model, x_test, y_test, save_folder): \n predicted = model.predict(x_test).ravel()\n actual = y_test.ravel()\n fpr, tpr, thresholds = roc_curve(actual, predicted, pos_label=None)\n roc_auc = auc(fpr, tpr)\n plt.title('Test ROC AUC')\n plt.plot(fpr, tpr, 'b', label='AUC = %0.3f' % roc_auc)\n plt.legend(loc='lower right')\n plt.plot([0,1],[0,1],'r--')\n plt.xlim([0.0,1.0])\n plt.ylim([0.0,1.0])\n plt.ylabel('True Positive Rate')\n plt.xlabel('False Positive Rate')\n plt.savefig(save_folder + '/ROC.png')\n plt.show()\n plt.close()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_roc(X,y,test_preds,fname=\"res/roc.png\"):\n\t#Retrieve multiple fpr and tpr values for different thresholds\n\tfpr, tpr, thresholds = roc_curve(y,test_preds)\n\tplt.plot(fpr, tpr)\n\tplt.title(auc(fpr, tpr))\n\tplt.savefig(fname, bbox_inches='tight')\n\tplt.close()","def plot_roc_acc(self,x_test,y_test):\n if self.validated:\n preds = self.model_cv.predict_proba(x_test[self.feats])\n fpr, tpr, thresholds = metrics.roc_curve(y_test, preds[:,1])\n auc = metrics.roc_auc_score(y_test, preds[:,1])\n\n # get accuracy of class0 and class1 predictions at different thresholds\n acc_0 = []\n acc_1 = []\n for ind,th in enumerate(thresholds):\n binary_preds = pred_from_prob(preds,th)\n acc_1.append(accuracy_score(y_test[np.where(y_test==1)],binary_preds[np.where(y_test==1)]))\n acc_0.append(accuracy_score(y_test[np.where(y_test==0)],binary_preds[np.where(y_test==0)]))\n\n # set up plotting parameters\n sns.set()\n mpl.rcParams['figure.figsize']=[15.0,5.0]\n mpl.rcParams['lines.linewidth']=2.0\n mpl.rcParams['xtick.labelsize']=13\n mpl.rcParams['ytick.labelsize']=13\n mpl.rcParams['axes.labelsize']=15\n mpl.rcParams['axes.labelweight']='heavy'\n mpl.rcParams['axes.titlesize']=18\n mpl.rcParams['axes.titleweight']='heavy'\n mpl.rcParams['legend.fontsize']=12\n\n # build the plots- ROC in subplot 1, accuracy in subplot 2\n plt.subplot(1,2,1)\n plt.plot(fpr,tpr,'r*', label='roc auc={:.4f}'.format(auc))\n plt.plot(np.linspace(0,1,20),np.linspace(0,1,20),'k--')\n plt.xlabel('FPR')\n plt.ylabel('TPR')\n plt.title('ROC')\n plt.legend(frameon=False)\n plt.xlim([0.0,1.0])\n plt.ylim([0.0,1.0])\n\n plt.subplot(1,2,2)\n plt.plot(thresholds,acc_0,'go--',label='cases: 0',alpha=0.3)\n plt.plot(thresholds,acc_1,'yo--',label='cases: 1')\n plt.plot(thresholds[::5],fpr[::5],'c*',alpha=0.2,label='fpr')\n\n plt.xlim([0,1])\n plt.xlim([0,1])\n\n plt.xlabel('threshold')\n plt.ylabel('accuracy')\n plt.title('accuracy')\n\n plt.legend(frameon=False)\n\n plt.show()\n return None\n else:\n raise err.NotYetFittedModelError('You should train the model with method train_CV first \\n')","def plot_final_roc(prediction_matrix, model_names, y_test, PATH = None):\n plt.figure(figsize=(10, 8))\n for i, model in enumerate(model_names): \n predictions = prediction_matrix[:,i]\n fpr, tpr, threshholds = roc_curve(y_test, predictions)\n sns.set_style('darkgrid', {'axes.facecolor': '0.9'})\n lw = 2\n plt.plot(fpr, tpr,\n lw=lw, label=f'{model_names[i]} AUC: {round(auc(fpr, tpr), 3)}')\n plt.plot([0, 1], [0, 1], lw=lw, linestyle='--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.yticks([i/20.0 for i in range(21)], size = 14)\n plt.xticks([i/20.0 for i in range(21)], rotation = 45, size = 14)\n plt.xlabel('False Positive Rate', size =16)\n plt.ylabel('True Positive Rate', size =16)\n plt.title('ROC Curve', size = 20)\n plt.legend(loc='lower right', prop = {\"size\" : 20})\n if PATH:\n plt.savefig(PATH, bbox_inches='tight', transparent = True)\n plt.show()","def Classification_ROC_Report(X,Y,model): \n \n # Plot Classification report, Confustion Matrix, ROC\n labels = {0: 'CNV', 1: 'DME', 2: 'DRUSEN', 3: 'NORMAL'}\n\n # get predictions on the test set\n y_hat = model.predict(X)\n #\n Y_pred_classes = np.argmax(y_hat,axis = 1) \n Y_true = np.argmax(Y,axis = 1)\n\n # Classification report\n ax=plt.figure(figsize=(15,5))\n ax = plt.subplot(1,3,1)\n rpt = sklearn.metrics.classification_report(np.argmax(Y, axis=1), np.argmax(y_hat, axis=1), target_names=list(labels.values()))\n ax.axis('off')\n ax.annotate(rpt, \n xy = (1.0,0.5), \n xytext = (0, 0), \n xycoords='axes fraction', textcoords='offset points',\n fontsize=13, ha='right', va='center') \n\n # Plot confusion matrix\n cm_df = Confusion_Matrix(Y,y_hat,labels,normalization=True)\n ax = plt.subplot(1,3,2)\n sns.heatmap(cm_df, annot=True)\n score = model.evaluate(X, Y, verbose=1)\n ax.set_title('Confusion Matrix\\nresult: {0:.2f} - loss: {0:.2f}'.format(score[1], score[0]))\n ax.set_ylabel('True label')\n ax.set_xlabel('Predicted label')\n\n # Plot ROC\n lw=2\n n_classes = 4\n fpr, tpr, roc_auc = ROC(Y,y_hat,n_classes)\n\n # Plot all ROC curves\n ax = plt.subplot(1,3,3)\n ax.plot(fpr[\"micro\"], tpr[\"micro\"],\n label='micro-average ROC curve (area = {0:0.2f})'\n ''.format(roc_auc[\"micro\"]),\n color='deeppink', linestyle=':', linewidth=4)\n\n ax.plot(fpr[\"macro\"], tpr[\"macro\"],\n label='macro-average ROC curve (area = {0:0.2f})'\n ''.format(roc_auc[\"macro\"]),\n color='navy', linestyle=':', linewidth=4)\n\n colors = cycle(['aqua', 'darkorange', 'cornflowerblue', '#4DBD33'])\n for i, color in zip(range(n_classes), colors):\n ax.plot(fpr[i], tpr[i], color=color, lw=lw,\n label='ROC curve of class {0} (area = {1:0.2f})'\n ''.format(labels[i], roc_auc[i]))\n\n ax.plot([0, 1], [0, 1], 'k--', lw=lw)\n ax.set_xlim([0.0, 1.0])\n ax.set_ylim([0.0, 1.05])\n ax.set_xlabel('False Positive Rate')\n ax.set_ylabel('True Positive Rate')\n ax.set_title('ROC')\n ax.legend(loc=\"lower right\")\n\n plt.tight_layout()\n plt.show()\n\n return","def plot_roc(self, out_tag):\n roc_fig = self.plotter.plot_roc(self.y_train, self.y_pred_train, self.train_weights, \n self.y_test, self.y_pred_test, self.test_weights, out_tag=out_tag\n )\n\n Utils.check_dir('{}/plotting/plots/{}'.format(os.getcwd(), out_tag))\n roc_fig.savefig('{0}/plotting/plots/{1}/{1}_ROC_curve.pdf'.format(os.getcwd(),out_tag))\n print('saving: {0}/plotting/plots/{1}/{1}_ROC_curve.pdf'.format(os.getcwd(),out_tag))\n plt.close()\n\n #for MVA ROC comparisons later on\n np.savez(\"{}/models/{}_ROC_comp_arrays\".format(os.getcwd(), out_tag), self.y_pred_test, self.y_pred_test, self.test_weights)","def roc_plot(label, fpr, tpr, roc_auc):\n plt.figure()\n for i in range(len(label)):\n plt.plot(fpr[i], tpr[i], label=label[i] + ' AUC = %0.2f' % roc_auc[i], alpha=0.75)\n plt.plot([0, 1], [0, 1], 'r--')\n plt.xlim([-0.01, 1.01])\n plt.ylim([-0.01, 1.01])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('ROC Curve')\n plt.legend(loc='lower right')\n plt.show()","def plot_ROC(y, prediction_prob, cnames, dataset_name, fname):\r\n plt.figure(figsize=(20, 10))\r\n for i in range(len(cnames)):\r\n fpr, tpr, _ = roc_curve(y, prediction_prob[i][:,1])\r\n auc = roc_auc_score(y, prediction_prob[i][:,1])\r\n plt.plot(fpr, tpr, label='%s (AUC = %.2f)'%(cnames[i], auc))\r\n plt.plot([0, 1], [0, 1], 'k--', lw=2)\r\n plt.xlim([0.0, 1.0])\r\n plt.ylim([0.0, 1.05])\r\n plt.xlabel('False Positive Rate')\r\n plt.ylabel('True Positive Rate')\r\n plt.title('ROC Curve - Binary Classification - %s'%(dataset_name))\r\n plt.legend(loc=\"lower right\")\r\n plt.savefig(fname, bbox_inches='tight')\r\n plt.close()","def plot_ROC():\r\n fpr = dict()\r\n tpr = dict()\r\n roc_auc = dict()\r\n threshold = dict()\r\n \r\n for i in range(n_classes):\r\n \r\n fpr[i], tpr[i], threshold[i] = roc_curve(y_test[:, i], y_pred[:, i])\r\n \r\n roc_auc[i] = auc(fpr[i], tpr[i])\r\n\r\n fig = plt.figure()\r\n ax = fig.add_subplot(1, 1, 1)\r\n ax.set_aspect('equal')\r\n colors = cycle(['aqua', 'red', 'purple', 'royalblue', 'black'])\r\n \r\n for i, color in zip(range(n_classes), colors):\r\n \r\n plt.plot(\r\n fpr[i],\r\n tpr[i],\r\n color=color,\r\n linewidth=3,\r\n #label='Class {0} (AUC {1:0.3f})'\r\n label='AUC {1:0.2f}' \r\n ''.format(i+1, roc_auc[i])\r\n )\r\n\r\n #plt.plot([0, 1], [0, 1], 'k--', linewidth=3)\r\n plt.xlim([-0.03, 1])\r\n plt.ylim([0, 1.03])\r\n ax.axhline(y=0, color='k', linewidth=4)\r\n ax.axhline(y=1.03, color='k', linewidth=4)\r\n ax.axvline(x=-0.03, color='k', linewidth=4)\r\n ax.axvline(x=1, color='k', linewidth=4) \r\n plt.xticks([0, 0.2, 0.4, 0.6, 0.8, 1.0], fontsize=16, fontweight='bold')\r\n plt.yticks([0, 0.2, 0.4, 0.6, 0.8, 1.0], fontsize=16, fontweight='bold')\r\n #plt.xlabel('False Positive Rate', fontweight='bold', fontsize=16)\r\n #plt.ylabel('True Positive Rate', fontweight='bold', fontsize=16)\r\n plt.legend(loc='lower right', prop={'size': 14, 'weight': 'bold'}) \r\n plt.grid(True)\r\n\r\n ROC_filename = 'ROC' + '_' + \\\r\n str(DNN_Model) + '_' + \\\r\n strftime(\"%d-%b-%Y-%H-%M-%S\", gmtime()) + '.png'\r\n \r\n plt.savefig(\r\n os.path.join(result_dir, ROC_filename),\r\n format='png',\r\n dpi=600\r\n )\r\n\r\n plt.show()\r\n plt.close()","def plot_roc(model, X_test, Y_test, verbose=False):\n\n y_true, y_pred = Y_test, model.predict(X_test)\n if verbose:\n print(\"CLASSIFICATION REPORT\")\n print(classification_report(y_true, y_pred))\n\n y_pred_prob = model.predict_proba(X_test)[:,1]\n\n fpr, tpr, _ = roc_curve(Y_test, y_pred_prob)\n\n if verbose:\n print(\"TESTING PROBABILITIES:\")\n for a,b in zip(Y_test,y_pred_prob):\n print(a,b)\n \n if verbose:\n print(\"ROC RAW DATA:\")\n for a,b in zip(fpr, tpr):\n print(a,b)","def plot_ROC_curve(model, X_train, X_test, y_train, y_test):\n \n # Model Metrics\n print model\n print \"*************************** Model Metrics *********************************\"\n print 'Accuracy: %s' % cross_val_score(model, X_train, y_train, scoring = 'accuracy', cv = 5).mean()\n print 'Precision: %s' % cross_val_score(model, X_train, y_train, scoring = 'precision', cv = 5).mean()\n print 'Recall: %s' % cross_val_score(model, X_train, y_train, scoring = 'recall_weighted', cv = 5).mean()\n print 'F1: %s' % cross_val_score(model, X_train, y_train, scoring = 'f1', cv = 5).mean()\n\n fitted = model.fit(X_train, y_train)\n try:\n y_score = fitted.predict_proba(X_test)[:,1]\n except:\n y_score = fitted.decision_function(X_test)\n \n # Confusion matrix\n print \"********************* Normalized Confusion Matrix *************************\"\n cm = confusion_matrix(y_test, fitted.predict(X_test))\n cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n \n print('Normalized confusion matrix')\n print(cm_normalized)\n plt.matshow(cm, cmap=plt.cm.Blues)\n plt.colorbar()\n plt.xlabel('Predicted Values')\n plt.ylabel('Actual Values')\n \n # Classification Report\n print \"********************* Classification Report********************************\" \n print classification_report(y_test, fitted.predict(X_test))\n \n print \"********************* ROC Curve *******************************************\"\n \n # ROC Curve\n fpr, tpr, _ = roc_curve(y_test, y_score)\n roc_auc = auc(fpr, tpr)\n \n plt.figure()\n plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc)\n plt.plot([0, 1], [0, 1], 'k--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Receiver operating characteristic')\n plt.legend(loc=\"lower right\")\n plt.show()","def AUC_ROC(true_vessel_arr, pred_vessel_arr):\n fpr, tpr, _ = roc_curve(true_vessel_arr.flatten(), pred_vessel_arr.flatten())\n \n AUC_ROC=roc_auc_score(true_vessel_arr.flatten(), pred_vessel_arr.flatten())\n print(\"AUC_ROC:\",AUC_ROC)\n\n plt.title('Receiver Operating Characteristic')\n plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' )\n plt.legend(loc = 'lower right')\n plt.plot([0, 1], [0, 1],'b--')\n plt.xlim([0, 1])\n plt.ylim([0, 1])\n plt.ylabel('True Positive Rate')\n plt.xlabel('False Positive Rate')\n plt.show()","def plotROC(attr, target, pred, save_as=None):\n fig, ax = plt.subplots()\n auc = metrics.roc_auc_score(target, pred)\n acc = metrics.accuracy_score(target, (pred >= 0.5).astype(int))\n fpr, tpr, _ = metrics.roc_curve(target, pred)\n plt.plot(fpr, tpr, lw = 2, label = attr.title())\n plt.legend(loc = 4, fontsize = 15)\n plt.title(('ROC Curve for {attr} (Accuracy = {acc:.3f}, AUC = {auc:.3f})'\n .format(attr = attr.title(), acc= acc, auc = auc)),\n fontsize = 15)\n plt.xlabel('False Positive Rate', fontsize = 15)\n plt.ylabel('True Positive Rate', fontsize = 15)\n if not save_as is None:\n plt.savefig(save_as)\n else:\n plt.show()","def do_roc(scores, true_labels, file_name='', directory='', plot=True):\n\n # fpr_0, tpr_0, _ = roc_curve(true_labels, scores[0])\n # roc_auc_0 = auc(fpr_0, tpr_0)\n # fpr_1, tpr_1, _ = roc_curve(true_labels, scores[1])\n # roc_auc_1 = auc(fpr_1, tpr_1)\n # fpr_2, tpr_2, _ = roc_curve(true_labels, scores[2])\n # roc_auc_2 = auc(fpr_2, tpr_2)\n # fpr_3, tpr_3, _ = roc_curve(true_labels, scores[3])\n # roc_auc_3 = auc(fpr_3, tpr_3)\n # fpr_4, tpr_4, _ = roc_curve(true_labels, scores[4])\n # roc_auc_4 = auc(fpr_4, tpr_4)\n # fpr_5, tpr_5, _ = roc_curve(true_labels, scores[5])\n # roc_auc_5 = auc(fpr_5, tpr_5)\n\n fpr, tpr, _ = roc_curve(true_labels, scores)\n roc_auc = auc(fpr, tpr) # compute area under the curve\n\n plt.figure(figsize=(10,10))\n plt.rcParams.update({'font.size': 50})\n # plt.plot(fpr_0, tpr_0, label='ROC curve (area = %0.3f)' % (roc_auc_0))\n # plt.plot(fpr_1, tpr_1, label='ROC curve (area = %0.3f)' % (roc_auc_1))\n # plt.plot(fpr_2, tpr_2, label='ROC curve (area = %0.3f)' % (roc_auc_2))\n # plt.plot(fpr_3, tpr_3, label='ROC curve (area = %0.3f)' % (roc_auc_3))\n # plt.plot(fpr_4, tpr_4, label='ROC curve (area = %0.3f)' % (roc_auc_4))\n plt.plot(fpr, tpr, color='lightblue',label='area = %0.3f' % (roc_auc))\n\n plt.plot([0, 1], [0, 1], 'k--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n# plt.title('Receiver operating characteristic')\n plt.legend(loc=\"lower right\")\n\n plt.savefig(directory + file_name + 'roc.eps', bbox_inches='tight', format='eps')\n plt.close()\n\n # return roc_auc","def plotROC(yscore, true, predtrue, datasets, title, outfile):\n fig = plt.figure()\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.0])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title(title)\n \n for i in range(len(datasets)):\n acc = accuracy_score(true[i], predtrue[i])\n fpr, tpr, _ = roc_curve(true[i], yscore[i][:,1])\n roc_auc = auc(fpr, tpr)\n plt.plot(fpr, tpr, label=datasets[i]+' (area = %0.2f, acc = %0.2f)' % (roc_auc,acc),linewidth=2)\n \n plt.legend(loc=\"lower right\")\n \n pdfplot = PdfPages(outfile);\n pdfplot.savefig(fig)\n pdfplot.close()","def auroc_helper(labels, preds):\r\n fpr, tpr, threshold = metrics.roc_curve(labels, preds)\r\n df = pd.DataFrame({'fpr': fpr,\r\n 'tpr': tpr,\r\n 'threshold': threshold})\r\n # uncomment for the best model to save\r\n # df.to_csv('/home/delvinso/nephro/output/all_custom_thresholds.csv', index = False)\r\n epoch_auc = metrics.auc(fpr, tpr)\r\n print('AUC: {}'.format(epoch_auc))\r\n\r\n # https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html\r\n f = plt.figure()\r\n lw = 2\r\n plt.plot(fpr, tpr, color='darkred',\r\n lw=lw, label='ROC curve (area = %0.3f)' % epoch_auc)\r\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\r\n plt.xlim([0.0, 1.0])\r\n plt.ylim([0.0, 1.05])\r\n plt.xlabel('1 - Specificity (FPR)')\r\n plt.ylabel('Sensitivity (TPR)')\r\n plt.title('ROC - Bladder vs Other')\r\n plt.legend(loc=\"lower right\")\r\n return f","def roc_writer(clf, y_true, y_prob, eval_folder, i=''):\n # make sure that y_true, y_prob are iterable\n if type(y_true[0]) is not np.ndarray: y_true = [y_true]\n if type(y_prob[0]) is not np.ndarray: y_prob = [y_prob]\n\n # make an image folder if you have to\n img_dir = eval_folder+'/images/'\n if not os.path.exists(img_dir):\n os.makedirs(img_dir)\n\n # get the classifier family name i.e., LogisticRegression\n clf_name = str(clf)[:str(clf).index('(')]+str(i)\n\n enum_list = range(0, len(y_true))\n roc_auc = []\n\n mean_tpr = 0.0\n mean_fpr = np.linspace(0,1,1000)\n\n # plot each fold's ROC curve, calculate mean ROC curve\n for i in enum_list:\n fpr, tpr, _ = metrics.roc_curve(y_true[i], y_prob[i])\n mean_tpr += interp(mean_fpr, fpr, tpr) \n mean_tpr[0] = 0.0\n roc_auc.append(metrics.roc_auc_score(y_true[i], y_prob[i]))\n plt.plot(fpr, tpr)\n\n mean_tpr /= len(y_true)\n mean_tpr[-1] = 1.0\n\n # make plot, plot mean ROC curve\n plt.title('Receiver Operating Characteristic')\n plt.plot(mean_fpr, mean_tpr, 'k--', label='Mean AUC = %0.2f\\nSE AUC = %0.3f'% (np.mean(roc_auc), np.std(roc_auc)))\n plt.legend(loc='lower right')\n plt.plot([0,1],[0,1],'r--')\n plt.xlim([0,1.0])\n plt.ylim([0,1.0])\n plt.ylabel('True Positive Rate')\n plt.xlabel('False Positive Rate')\n\n plt.savefig(img_dir+'ROC_Curve_'+clf_name+'.png')","def draw_roc(signal, background, output_dir=\".\", output_name=\"roc\", form=\".pdf\"):\n\n x, y = get_roc(signal, background)\n file_path = output_dir + \"/\"+ output_name + \"_X.cvs\"\n numpy.savetxt(file_path, x, delimiter=\",\")\n file_path = output_dir + \"/\"+ output_name + \"_Y.cvs\"\n numpy.savetxt(file_path, y, delimiter=\",\")\n output_name = output_name + form\n\n auc = metrics.auc(x, y, reorder=True)\n\n fig = plt.figure(1, figsize=(7, 7), dpi=300)\n fig.clear()\n\n # Create an axes instance\n ax = fig.add_subplot(111)\n\n ax.plot(x, y, '-', color='#B64926', lw=2, label=\"AUC: %.4f\" % auc)\n ax.margins(0.05)\n\n ax.set_xlabel(\"Background efficiency\")\n ax.set_ylabel(\"Signal efficiency\")\n \n fig.set_tight_layout(True)\n\n ax.legend(loc='lower right', numpoints=1, frameon=False)\n\n print(\"AUC: %.4f\" % auc)\n\n fig.savefig(os.path.join(output_dir, output_name))\n\n plt.close()\n\n def get_index(y, value):\n \"\"\"\n Find the last index of the element in y\n satistying y[index] <= value\n \"\"\"\n\n for i in range(len(y)):\n if y[i] <= value:\n continue\n\n return i\n\n print(\"Background efficiency for signal efficiency of 0.70: %f\" % x[get_index(y, 0.70)])\n print(\"Background efficiency for signal efficiency of 0.80: %f\" % x[get_index(y, 0.80)])\n print(\"Background efficiency for signal efficiency of 0.90: %f\" % x[get_index(y, 0.90)])","def compute_and_plot_ic_AUCROC(y_true, y_score, ic_name,\n filename, title='AUC/ROC Curve'):\n print(' Computing {} AUC score / ROC curve...'.format(ic_name))\n start = time()\n\n # calculate AUC\n auc = roc_auc_score(y_true, y_score)\n print(' AUC: %.3f' % auc)\n # calculate roc curve\n fpr, tpr, _ = roc_curve(y_true, y_score)\n print(' ROC curve size: {}'.format(len(fpr)))\n if len(fpr) > 10000: # Sample when curve has *a lot* of data-points\n # Take every other 50th data-point. Reduce size by factor 50.0\n fpr = fpr[0:len(fpr):50]\n tpr = tpr[0:len(tpr):50]\n\n print(' → sampled roc curve to {} data-points'.format(len(fpr)))\n\n end = time()\n print(' Computed in {}'.format(timedelta(seconds=end - start)))\n\n # plot no skill\n plt.plot([0, 1], [0, 1], linestyle='--')\n # plot the roc curve for the model\n plt.plot(fpr, tpr, marker='.')\n plt.title(title)\n plt.xlabel('AUC score: {:.3f}'.format(auc))\n\n # Save\n plt.savefig(join(VISUALS_FOLDERPATH, '{}-aucroc.svg'\n .format(filename)))\n plt.clf()","def roc(test_set_y_org,test_set_y_pred_prob,classes_unique,plot_curve=False,filename=\"./fig_roc.pdf\",colors=None,positive_class_for_two_classes=None,figwidth=5,figheight=5):\n from sklearn.metrics import roc_curve\n #from sklearn.metrics import auc\n from sklearn.metrics import roc_auc_score\n from scipy import interp\n import matplotlib as mpl\n mpl.use(\"pdf\")\n import matplotlib.pyplot as plt\n \n fpr = dict()\n tpr = dict()\n roc_auc = dict()\n n_classes=len(classes_unique)\n test_set_Y_org,test_set_y_org_unique=membership_vector_to_indicator_matrix(test_set_y_org)\n \n for c in range(n_classes):\n fpr[c], tpr[c], _ = roc_curve(test_set_Y_org[:, c], test_set_y_pred_prob[:, c])\n roc_auc[c] = roc_auc_score(test_set_Y_org[:, c], test_set_y_pred_prob[:, c])\n \n # Compute macro-average ROC curve and AUROC area\n # First aggregate all false positive rates\n all_fpr = np.unique(np.concatenate([fpr[c] for c in range(n_classes)]))\n # Then interpolate all ROC curves at this points\n mean_tpr = np.zeros_like(all_fpr)\n for c in range(n_classes):\n mean_tpr += interp(all_fpr, fpr[c], tpr[c])\n # Finally average it and compute AUC\n mean_tpr /= n_classes\n fpr[\"macro\"] = all_fpr\n tpr[\"macro\"] = mean_tpr\n #roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])\n \n # Compute micro-average PRC curve and PRC areas\n fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(test_set_Y_org.ravel(), test_set_y_pred_prob.ravel())\n roc_auc[\"macro\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob, average=\"macro\") # micro macro, weighted, or samples\n roc_auc[\"micro\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob,average=\"micro\") # micro macro, weighted, or samples\n roc_auc[\"weighted\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob, average=\"weighted\") # micro macro, weighted, or samples\n roc_auc[\"samples\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob, average=\"samples\") # micro macro, weighted, or samples\n\n if plot_curve:\n fig=plt.figure(num=1,figsize=(figwidth,figheight))\n ax=fig.add_subplot(1,1,1)\n ax.plot([0, 1], [0, 1], 'k--')\n if n_classes>2 or positive_class_for_two_classes is None:\n ax.plot(fpr[\"macro\"], tpr[\"macro\"], linewidth=1,color=colors[n_classes],label='macro-avg ROC (area={0:0.4f})'.format(roc_auc[\"macro\"]))\n \n for c in range(n_classes):\n if positive_class_for_two_classes is None or (n_classes==2 and positive_class_for_two_classes==c):\n ax.plot(fpr[c], tpr[c],linewidth=1,color=colors[c],label='ROC of {0} (area={1:0.4f})'.format(classes_unique[c], roc_auc[c]))\n \n # add some text for labels, title and axes ticks\n ax.set_ylim(0.0,1.0)\n ax.set_xlim(0.0,1.0)\n ax.set_ylabel(\"True Positive Rate\",fontsize=12)\n ax.set_xlabel(\"False Positive Rate\",fontsize=12) \n #ax.set_title(\"\",fontsize=15)\n ax.legend(loc=\"lower right\",fontsize=8)\n #plt.subplots_adjust(bottom=0.12) # may this is not working because of the following setting\n fig.savefig(filename,bbox_inches='tight')\n plt.close(fig)\n\n roc_auc_list=[roc_auc[c] for c in range(n_classes)]\n roc_auc_list.extend([roc_auc[\"macro\"],roc_auc[\"micro\"],roc_auc[\"weighted\"],roc_auc[\"samples\"]])\n roc_auc=np.array(roc_auc_list)\n names=[\"AUROC_\" + c for c in classes_unique]\n names.extend([\"macro\",\"micro\",\"weighted\",\"samples\"])\n names=np.array(names)\n return roc_auc,names","def roc(y_true, y_prob, ARGS):\n roc_auc = roc_auc_score(y_true, y_prob)\n if ARGS.graphs:\n fpr, tpr, _ = roc_curve(y_true, y_prob)\n plt.plot(fpr, tpr, color='darkorange', lw=2,\n label='ROC curve (Area = %0.3f)'% roc_auc)\n plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate (1 - Specifity)')\n plt.ylabel('True Positive Rate (Sensitivity)')\n plt.title('Receiver Operating Characteristic')\n plt.legend(loc=\"lower right\")\n print(f'ROC Curve saved to {ARGS.out_directory}/roc.png')\n plt.savefig(f'{ARGS.out_directory}/roc.png')\n else:\n print('ROC-AUC %0.3f' % roc_auc)","def plot_ROC(self, canvas):\n\t\tfpr = self.fpr_\n\t\ttpr = self.tpr_\n\t\tauc = self.class_auroc_\n\t\tclasses = self.classes_\n\t\tnum_classes = self.num_classes_\n\n\t\trcParams.update({'font.size': 7})\n\t\tcanvas.figure.clear()\n\t\tax = canvas.figure.subplots()\n\n\t\tax.plot(fpr['avg'], tpr['avg'], label='avg (area={0})'.format(self.avg_auroc_), \\\n\t\t\tcolor = 'black', linewidth=2, linestyle='--')\n\n\t\tcolors = cycle(['blue', 'orange', 'green', 'red', 'yellow', 'purple', 'cyan'])\n\t\tfor i, color in zip(range(0, num_classes), colors):\n\t\t\tax.plot(fpr[i], tpr[i], label='{0} (area={1})'.format(classes[i], auc[classes[i]]), \\\n\t\t\t\tcolor=color, linewidth=1)\n\n\t\tax.plot([0 ,1], [0, 1], color='lightgray', linewidth=1, linestyle='--')\n\t\tax.set_xlim([0.0, 1.0])\n\t\tax.set_ylim([0.0, 1.05])\n\t\tax.set_xlabel('FPR')\n\t\tax.set_ylabel('TPR')\n\t\tax.legend(loc='lower right')\n\n\t\tcanvas.figure.tight_layout()\n\t\tcanvas.draw()","def do_roc(scores, true_labels, file_name='', directory='', plot=True):\n fpr, tpr, _ = roc_curve(true_labels, scores)\n roc_auc = auc(fpr, tpr) # compute area under the curve\n if plot: \n plt.figure()\n plt.plot(fpr, tpr, label='ROC curve (area = %0.3f)' % (roc_auc))\n plt.plot([0, 1], [0, 1], 'k--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Receiver operating characteristic')\n plt.legend(loc=\"lower right\")\n\n plt.savefig(directory + file_name + 'roc.png')\n plt.close()\n\n return roc_auc","def _roc_plot_single(metrics, save_name):\n plt.figure()\n plt.plot([0, 1], [0, 1], \"k--\")\n plt.plot(metrics[\"fpr\"], metrics[\"tpr\"], \"r\", linewidth=2)\n plt.xscale(\"log\")\n plt.yscale(\"log\")\n plt.grid()\n plt.xlabel(\"True Positive Rate\")\n plt.ylabel(\"False Positive Rate\")\n plt.tight_layout()\n plt.savefig(save_name)","def _th_plot(self, y_true, y_pred_proba, pos_label, pos_label_ind,\n best_th_, q, tpr, fpr, th_, th_range, index, roc_auc_kwargs):\n fig, axs = plt.subplots(nrows=2, ncols=1)\n fig.set_size_inches(10, 10)\n # Roc score.\n y_type = sklearn.utils.multiclass.type_of_target(y_true)\n if y_type == \"binary\":\n roc_auc = sklearn.metrics.roc_auc_score(\n y_true, y_pred_proba[:, pos_label_ind], **roc_auc_kwargs)\n elif y_type == \"multiclass\":\n roc_auc = sklearn.metrics.roc_auc_score(\n y_true, y_pred_proba, **roc_auc_kwargs)\n else:\n assert False, f\"Unhandled y_type {y_type}\"\n # Roc curve.\n axs[0].plot(fpr, tpr, 'darkorange',\n label=f\"ROC curve (AUC = {roc_auc:.3f}).\")\n axs[0].scatter(fpr[index], tpr[index], c='b', marker=\"o\")\n axs[0].plot([0, 1], [0, 1], color='navy', linestyle='--')\n axs[0].set_xlabel('False Positive Rate')\n axs[0].set_ylabel('True Positive Rate')\n axs[0].set_title(f\"Receiver operating characteristic \"\n f\"(label '{pos_label}')\")\n axs[0].legend(loc=\"lower right\")\n # Metric q.\n axs[1].plot(th_, q, 'green')\n axs[1].vlines(best_th_, np.min(q), np.max(q))\n axs[1].vlines(th_range, np.min(q), np.max(q), colors='b',\n linestyles=':')\n axs[1].set_xlim([0.0, 1.0])\n axs[1].set_xlabel('Threshold')\n axs[1].set_ylabel('TPR/(TPR+FPR)')\n axs[1].set_title('Selected th values objective maximum')\n # plt.plot(th_, fpr, 'red')\n plt.show()","def plot_roc_auc(tree, reg, f_test, l_test):\n\n # Calculate probabilites for each model\n s_probs = [0 for _ in range(len(l_test))]\n tree_probs = tree.predict_proba(f_test)\n reg_probs = reg.predict_proba(f_test)\n\n # Only keep postive outcomes\n tree_probs = tree_probs[:, 1]\n reg_probs = reg_probs[:, 1]\n\n # Calculate AUC value for each model and 0.5\n s_auc = roc_auc_score(l_test, s_probs)\n tree_auc = roc_auc_score(l_test, tree_probs)\n reg_auc = roc_auc_score(l_test, reg_probs)\n\n print(f'Random prediction AUC: {s_auc:.3f}')\n print(f'Decision Tree AUC: {tree_auc:.3f}')\n print(f'Logistic Regression AUC: {reg_auc:3f}')\n\n # calculate FPR & TPRs\n s_fpr, s_tpr, s_thresh = roc_curve(l_test, s_probs)\n tree_fpr, tree_tpr, tree_thresh = roc_curve(l_test, tree_probs)\n reg_fpr, reg_tpr, reg_thresh = roc_curve(l_test, reg_probs)\n\n # plot the curves\n plt.plot(s_fpr, s_tpr, linestyle='--', label='Random Prediction')\n plt.plot(tree_fpr, tree_tpr, linestyle='solid', label='Decision Tree AUC')\n plt.plot(reg_fpr, reg_tpr, linestyle='dotted', label='Regression AUC')\n\n plt.title('ROC Plot')\n plt.xlabel('FPR')\n plt.ylabel('TPR')\n plt.legend()\n plt.savefig('Baseball_AUC.png')","def plot_curve(self, true_values, predictions, ax=None, title='ROC', label='ROC', lw=1, add_auc=True, **kwargs):\n fpr, tpr, _ = roc_curve(true_values, predictions)\n roc_auc = auc(fpr, tpr)\n label_auc = label + ': {:.3f} AUC'.format(roc_auc)\n logging.info('ROC result: %s', label_auc)\n ax.plot(fpr, tpr, lw=lw, label=label_auc if add_auc else label, **kwargs)\n ax.set_title(title)\n ax.set_xlabel('FPR')\n ax.set_ylabel('TPR')\n ax.legend(loc='lower right', frameon=False)\n return ax","def roc(proba, ts, classifier_name):\n fpr, tpr, _ = roc_curve(ts, proba[:,1])\n roc_auc = auc(fpr, tpr)\n print(\"Area under the ROC curve for %s : %f\") % (classifier_name, roc_auc)\n\n l = 'ROC curve for %s (area = %0.2f)' % (classifier_name, roc_auc)\n pl.clf()\n pl.plot(fpr, tpr, label=l)\n pl.plot([0, 1], [0, 1], 'k--')\n pl.xlim([0.0, 1.0])\n pl.ylim([0.0, 1.0])\n pl.xlabel('False Positive Rate')\n pl.ylabel('True Positive Rate')\n pl.title('Receiver operating characteristic for %s' % classifier_name)\n pl.legend(loc=\"lower right\")\n pl.show()","def plot_roc(preds, labels, title=\"Receiver operating characteristic\"):\n\n # Compute values for curve\n fpr, tpr, _ = roc_curve(labels, preds)\n\n # Compute FPR (95% TPR)\n tpr95 = fpr_at_95_tpr(preds, labels)\n\n # Compute AUROC\n roc_auc = auroc(preds, labels)\n\n # Draw the plot\n plt.figure()\n lw = 2\n plt.plot(fpr, tpr, color='darkorange',\n lw=lw, label='AUROC = %0.2f' % roc_auc)\n plt.plot([0, 1], [0.95, 0.95], color='black', lw=lw, linestyle=':', label='FPR (95%% TPR) = %0.2f' % tpr95)\n plt.plot([tpr95, tpr95], [0, 1], color='black', lw=lw, linestyle=':')\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--', label='Random detector ROC')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title(title)\n plt.legend(loc=\"lower right\")\n plt.show()","def roc2(fpr, tpr, roc_auc):\n plt.figure()\n plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\n plt.plot([0, 1], [0, 1], color='navy', lw=1, linestyle='--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Receiver operating characteristic')\n plt.legend(loc=\"lower right\")\n plt.show()","def verif_valid(model, X_val, y_val, cut=0.5):\n if type(model) == Sequential:\n X_val = np.array(X_val)\n reality = y_val\n \n if ((type(model) == svm.classes.OneClassSVM) | (type(model) == lgb.basic.Booster) | (type(model) == svm.classes.LinearSVC) | (type(model) == Sequential)):\n pred_score = model.predict(X_val)\n if (type(model) == svm.classes.OneClassSVM):\n pred_score = np.where(pred_score == -1, 1, 0)\n else:\n pred_score = model.predict_proba(X_val)[:,1]\n \n plt.hist(pred_score)\n plt.title('Distribution of the prediction score')\n plt.show()\n #if (type(model) == Sequential):\n # predictions = np.where(pred_score > 0.5, 1, 0)\n #else:\n predictions = np.where(pred_score > cut, 1, 0)\n \n print('Matrice de confusion :')\n conf_mat = confusion_matrix(reality, predictions)\n print(pd.DataFrame(conf_mat))\n print('Associated metrics :')\n print(classification_report(reality, predictions))\n fpr, tpr, _ = roc_curve(y_val, pred_score)\n \n roc_auc = auc(fpr, tpr)\n plt.plot(fpr, tpr, 'r-', lw=4)\n actual_fpr = conf_mat[1, 0] / (conf_mat[1, 0] + conf_mat[0, 0])\n actual_tpr = conf_mat[1, 1] / (conf_mat[1, 1] + conf_mat[0, 1])\n plt.plot(actual_fpr, actual_tpr, 'bo', lw=10)\n plt.xlabel('False-Positive Rate')\n plt.ylabel('True-Positive Rate')\n plt.title('ROC curve (with AUC = ' + str(round(roc_auc, 6)) + ')')\n plt.plot([0, 1], [0, 1], 'k-')\n plt.show()\n print('Score AUC : ' + str(roc_auc))\n print('Accuracy : ' + str(metrics.accuracy_score(y_val, predictions)))","def plot_roc(y_true, y_probas, classes = None, title='ROC Curves', average_plot = True,\n ax=None, figsize=None, cmap='nipy_spectral',\n title_fontsize=\"large\", text_fontsize=\"medium\"):\n if ax is None:\n fig, ax = plt.subplots(1, 1, figsize=figsize)\n ax.set_title(title, fontsize=title_fontsize)\n n_fold_roc_auc = []\n for i in range(len(y_true)):\n fpr, tpr, _ = roc_curve(y_true[i], y_probas[i])\n roc_auc = auc(fpr, tpr)\n color = plt.cm.get_cmap(cmap)(float(i) / len(y_true))\n \n if classes is None:\n s = 'fold'\n else:\n s = classes[i]\n ax.plot(fpr, tpr, lw=2, color=color,\n label='ROC curve of {0} {1} (area = {2:0.2f})'\n ''.format(s, i, roc_auc))\n n_fold_roc_auc.append(roc_auc)\n\n average_roc_auc = 0\n if classes is None:\n if average_plot:\n all_y_true = np.concatenate(y_true)\n all_probas = np.concatenate(y_probas)\n fpr_all, tpr_all, _ = roc_curve(all_y_true, all_probas)\n average_roc_auc = auc(fpr_all, tpr_all)\n ax.plot(fpr_all, tpr_all,\n label='average ROC curve '\n '(area = {0:0.2f})'.format(average_roc_auc),\n color='blue', linestyle=':', linewidth=4)\n\n ax.plot([0, 1], [0, 1], 'k--', lw=2)\n ax.set_xlim([0.0, 1.0])\n ax.set_ylim([0.0, 1.05])\n ax.set_xlabel('False Positive Rate', fontsize=text_fontsize)\n ax.set_ylabel('True Positive Rate', fontsize=text_fontsize)\n ax.tick_params(labelsize=text_fontsize)\n ax.legend(loc='lower right', fontsize=text_fontsize)\n return ax, n_fold_roc_auc, average_roc_auc","def plot_roc_curve(y: np.ndarray, \n y_pred_positive: np.ndarray, \n label: str) -> None:\n fpr, tpr, thresholds = metrics.roc_curve(y, y_pred_positive)\n plt.figure(figsize=(8, 8))\n plt.plot(fpr, tpr, \"b:\", linewidth=2, label=label)\n plt.fill_between(fpr, tpr, color='blue', alpha=0.3)\n plt.plot([0, 1], [0, 1], 'k--')\n plt.axis([0, 1, 0, 1])\n plt.xlabel('Odsetek fałszywie pozytywnych (FPR)', fontsize=16)\n plt.ylabel('Odsetek prawdziwie pozytywnych (TPR)', fontsize=16)\n plt.legend(loc=\"lower right\", fontsize=16)\n plt.title('Krzywa ROC, AUC={0:.3f}'.format(metrics.roc_auc_score(y, y_pred_positive)), fontsize=18)\n plt.show()","def plot_roc(self, ax, prob, y, label='ROC'):\n self.df = self.calculate_threshold_values(prob, y)\n ax.plot([1] + list(self.df.fpr), [1] + list(self.df.tpr), label=label)\n x = [1] + list(self.df.fpr)\n y1 = [1] + list(self.df.tpr)\n y2 = x\n ax.fill_between(x, y1, y2, alpha=0.2)\n ax.set_xlabel('fpr')\n ax.set_ylabel('tpr')\n ax.set_title('ROC Curve')\n ax.legend()","def saveit(func_predict, X, y, X_kin, VARS_kin, pt_edges, eta_edges, label):\n fig, ax, met = plots.binned_AUC(func_predict = func_predict, X = X, y = y, X_kin = X_kin, \\\n VARS_kin = VARS_kin, pt_edges = pt_edges, eta_edges = eta_edges, label = label)\n \n global roc_mstats\n global roc_labels\n roc_mstats.append(met)\n roc_labels.append(label)\n\n global targetdir\n filename = targetdir + '/' + label + '_AUC.pdf'\n plt.savefig(filename, bbox_inches='tight')","def draw_roc(signal, background, output_dir=\".\", output_name=\"roc.pdf\"):\n\n x, y = get_roc(signal, background)\n auc = metrics.auc(x, y, reorder=True)\n\n fig = plt.figure(1, figsize=(6, 6), dpi=300)\n fig.clear()\n\n # Create an axes instance\n ax = fig.add_subplot(111)\n\n ax.plot(x, y, '-', color='#B64926', lw=2, label=\"AUC: %.4f\" % auc)\n ax.plot([0, 1], [0, 1], ':', color='black', lw=2, label=\"Random cut\")\n ax.margins(0.05)\n\n ax.set_xlabel(\"Background efficiency\")\n ax.set_ylabel(\"Signal efficiency\")\n \n fig.set_tight_layout(True)\n\n ax.legend(loc='lower right', numpoints=1, frameon=False)\n\n print(\"AUC: %.4f\" % auc)\n\n fig.savefig(os.path.join(output_dir, output_name))\n\n plt.close()\n\n def get_index(y, value):\n \"\"\"\n Find the last index of the element in y\n satistying y[index] <= value\n \"\"\"\n\n for i in range(len(y)):\n if y[i] <= value:\n continue\n\n return i\n\n print(\"Background efficiency for signal efficiency of 0.70: %f\" % x[get_index(y, 0.70)])\n print(\"Background efficiency for signal efficiency of 0.80: %f\" % x[get_index(y, 0.80)])\n print(\"Background efficiency for signal efficiency of 0.90: %f\" % x[get_index(y, 0.90)])","def rocs(test_set_y_org,test_set_y_pred_prob,methods,linestyles,classes_unique,plot_curve=False,filename=\"./fig_roc.pdf\",colors=None,positive_class_for_two_classes=None,figwidth=5,figheight=5):\n from sklearn.metrics import roc_curve\n #from sklearn.metrics import auc\n from sklearn.metrics import roc_auc_score\n from scipy import interp\n import matplotlib as mpl\n mpl.use(\"pdf\")\n import matplotlib.pyplot as plt\n \n n_classes=len(classes_unique)\n test_set_Y_org,test_set_y_org_unique=membership_vector_to_indicator_matrix(test_set_y_org)\n\n num_methods=len(methods)\n roc_aucs=[0]*num_methods\n names=[None]*num_methods\n for m in range(num_methods):\n fpr = dict()\n tpr = dict()\n roc_auc = dict()\n for c in range(n_classes):\n fpr[c], tpr[c], _ = roc_curve(test_set_Y_org[:, c], test_set_y_pred_prob[m][:, c])\n roc_auc[c] = roc_auc_score(test_set_Y_org[:, c], test_set_y_pred_prob[m][:, c])\n\n # Compute macro-average ROC curve and AUROC area\n # First aggregate all false positive rates\n all_fpr = np.unique(np.concatenate([fpr[c] for c in range(n_classes)]))\n # Then interpolate all ROC curves at this points\n mean_tpr = np.zeros_like(all_fpr)\n for c in range(n_classes):\n mean_tpr += interp(all_fpr, fpr[c], tpr[c])\n # Finally average it and compute AUC\n mean_tpr /= n_classes\n fpr[\"macro\"] = all_fpr\n tpr[\"macro\"] = mean_tpr\n #roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])\n\n # Compute micro-average PRC curve and PRC areas\n fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(test_set_Y_org.ravel(), test_set_y_pred_prob[m].ravel())\n roc_auc[\"macro\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob[m], average=\"macro\") # micro macro, weighted, or samples\n roc_auc[\"micro\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob[m],average=\"micro\") # micro macro, weighted, or samples\n roc_auc[\"weighted\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob[m], average=\"weighted\") # micro macro, weighted, or samples\n roc_auc[\"samples\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob[m], average=\"samples\") # micro macro, weighted, or samples\n\n if plot_curve:\n if m==0:\n fig=plt.figure(num=1,figsize=(figwidth,figheight))\n ax=fig.add_subplot(1,1,1)\n ax.plot([0, 1], [0, 1], 'k--')\n if n_classes>2 or positive_class_for_two_classes is None:\n ax.plot(fpr[\"macro\"], tpr[\"macro\"], linestyle=linestyles[m],linewidth=1,color=colors[n_classes],label='{0}: macro-avg ROC (area={1:0.4f})'.format(methods[m], roc_auc[\"macro\"]))\n\n for c in range(n_classes):\n if positive_class_for_two_classes is None or (n_classes==2 and positive_class_for_two_classes==c):\n ax.plot(fpr[c], tpr[c],linestyle=linestyles[m],linewidth=1,color=colors[c],label='{0}: ROC of {1} (area={2:0.4f})'.format(methods[m], classes_unique[c], roc_auc[c]))\n\n # add some text for labels, title and axes ticks\n if m==num_methods-1:\n ax.set_ylim(0.0,1.0)\n ax.set_xlim(0.0,1.0)\n ax.set_ylabel(\"True Positive Rate\",fontsize=12)\n ax.set_xlabel(\"False Positive Rate\",fontsize=12) \n #ax.set_title(\"\",fontsize=15)\n ax.legend(loc=\"lower right\",fontsize=8)\n #plt.subplots_adjust(bottom=0.12) # may this is not working because of the following setting\n fig.savefig(filename,bbox_inches='tight')\n plt.close(fig)\n\n roc_auc_list=[roc_auc[c] for c in range(n_classes)]\n roc_auc_list.extend([roc_auc[\"macro\"],roc_auc[\"micro\"],roc_auc[\"weighted\"],roc_auc[\"samples\"]])\n roc_auc=np.array(roc_auc_list)\n name=[methods[m]+\"_AUROC_\" + c for c in classes_unique]\n name.extend([\"macro\",\"micro\",\"weighted\",\"samples\"])\n name=np.array(name)\n\n roc_aucs[m]=roc_auc\n names[m]=name\n \n return roc_aucs,names","def crowd_auc_plot(self, auto_open=False):\n def get_name(nofeat, cond):\n plural = nofeat > 1\n return \"{} features (condition {})\".format(nofeat, cond) if plural else \"{} feature (condition {})\".format(nofeat, cond)\n\n def get_trace(values, nofeat, cond):\n name = get_name(nofeat, cond)\n return go.Histogram(\n name=name,\n x=values,\n histnorm='probability',\n autobinx=False,\n xbins=dict(\n start=0.5,\n end=1,\n size=0.025,\n ),\n marker=dict(\n color=self.colours[cond]\n ),)\n\n aucs = pd.read_pickle(self.path_final_evaluation_aucs)\n nofeatures = sorted(set([nofeat for nofeat in aucs[1]]))\n conditions = [1, 2, 3, 4, 5]\n subplot_titles = [get_name(no_feat, c) for no_feat in nofeatures for c in conditions]\n fig = plotly.tools.make_subplots(rows=len(nofeatures), cols=len(conditions), subplot_titles=subplot_titles)\n row_index=1\n for no_feat in nofeatures:\n for i in range(len(conditions)):\n trace = get_trace(aucs[conditions[i]][no_feat], no_feat, conditions[i])\n fig.append_trace(trace, row_index, i+1)\n row_index += 1\n fig['layout'].update(showlegend=False, height=2500, width=1200, title='AUC Histograms for {} ({})'.format(self.dataset_name, self.experiment_name),)\n\n plotly.offline.plot(fig, auto_open=auto_open, filename=self.path_auc_plots)\n from IPython.display import Image\n Image('a-simple-plot.png')","def ROC_plot(metrics, labels, title = '', filename = 'ROC') :\n\n for k in [0,1]: # linear & log\n\n fig,ax = plt.subplots()\n xx = np.logspace(-5, 0, 100)\n plt.plot(xx, xx, linestyle='--', color='black', linewidth=1) # ROC diagonal\n\n for i in range(len(metrics)) :\n plt.plot(metrics[i].fpr, metrics[i].tpr, label = '{}: AUC = {:.3f}'.format(labels[i], metrics[i].auc))\n\n plt.legend(loc=4)\n ax.set_xlabel('False Positive (background) rate $\\\\alpha$')\n ax.set_ylabel('True Positive (signal) rate $1-\\\\beta$')\n ax.set_title(title)\n\n if k == 0:\n plt.ylim(0.0, 1.0)\n plt.xlim(0.0, 1.0)\n ax.set_aspect(1.0/ax.get_data_ratio() * 1.0)\n plt.savefig(filename + '.pdf', bbox_inches='tight')\n\n if k == 1:\n plt.ylim(0.0, 1.0)\n plt.xlim(1e-4, 1.0)\n plt.gca().set_xscale('log')\n ax.set_aspect(1.0/ax.get_data_ratio() * 0.75)\n plt.savefig(filename + '_log.pdf', bbox_inches='tight')\n\n plt.close()","def plot_roc_curve(y_true, y_pred_prob, show_threshold=False, **params):\n\n figure = plt.figure(figsize=params.get('figsize', (17, 10)))\n fpr, tpr, thresholds = roc_curve(y_true, y_pred_prob)\n roc_auc = auc(fpr, tpr)\n plt.plot(fpr, tpr, label='ROC curve (area = %0.5f)' % roc_auc)\n plt.plot([0, 1], [0, 1], 'k--')\n plt.xlim([-0.05, 1.05])\n plt.ylim([-0.05, 1.05])\n plt.xticks(np.arange(0.0, 1.1, step=0.1))\n plt.yticks(np.arange(0.0, 1.1, step=0.1))\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('ROC curve')\n plt.legend(loc=\"lower right\")\n if show_threshold:\n ax2 = plt.gca().twinx()\n ax2.plot(fpr, thresholds, markeredgecolor='r',\n linestyle='dashed', color='r')\n ax2.set_ylabel('Threshold', color='r')\n ax2.set_ylim([0.0, 1.0])\n ax2.set_xlim([0.0, 1.0])\n\n plt.show()\n\n return figure, roc_auc","def plot_ROC_curve(y_true, y_pred, labels, roc_path):\n n_classes = len(labels)\n # Compute ROC curve and ROC area for each class\n fpr = dict()\n tpr = dict()\n roc_auc = dict()\n for y, pred, label in zip(y_true.transpose(), y_pred.transpose(), labels):\n fpr[label], tpr[label], _ = roc_curve(y, pred)\n roc_auc[label] = auc(fpr[label], tpr[label])\n\n # First aggregate all false positive rates\n all_fpr = np.unique(np.concatenate([fpr[label] for label in labels]))\n\n # Then interpolate all ROC curves at this points\n mean_tpr = np.zeros_like(all_fpr)\n for label in labels:\n mean_tpr += interp(all_fpr, fpr[label], tpr[label])\n\n # Finally average it and compute AUC\n mean_tpr /= n_classes\n\n # Compute micro-average ROC curve and ROC area\n fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(y_true.ravel(), y_pred.ravel())\n roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n\n fpr[\"macro\"] = all_fpr\n tpr[\"macro\"] = mean_tpr\n roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])\n\n # Plot all ROC curves\n plt.figure()\n lw = 2\n plt.plot(fpr[\"micro\"], tpr[\"micro\"],\n label='micro-average ROC curve (area = {0:0.3f})'\n ''.format(roc_auc[\"micro\"]),\n color='deeppink', linestyle=':', linewidth=2)\n\n plt.plot(fpr[\"macro\"], tpr[\"macro\"],\n label='macro-average ROC curve (area = {0:0.3f})'\n ''.format(roc_auc[\"macro\"]),\n color='navy', linestyle=':', linewidth=2)\n\n if len(labels) == 4:\n colors = ['green', 'cornflowerblue', 'darkorange', 'darkred']\n else:\n colors = ['green', 'cornflowerblue', 'darkred']\n for label, color in zip(labels, cycle(colors)):\n plt.plot(fpr[label], tpr[label], color=color, lw=lw,\n label='ROC curve of {0} (area = {1:0.3f})'\n ''.format(label, roc_auc[label]))\n\n plt.plot([0, 1], [0, 1], 'k--', lw=lw)\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('ROC curve')\n plt.legend(loc=\"lower right\")\n matplotlib.rcParams.update({'font.size': 14})\n plt.savefig('%s.png' % roc_path, pad_inches = 0, bbox_inches='tight')","def plot_roc_distributions(self, model_str, resampling_number, roc_curve_steps, roc_plot_path):\n sampling_types = ['Normal', 'Oversampling', 'Undersampling']\n\n PLOT_MARGIN = 0.05\n plt.rcParams[\"figure.figsize\"] = (16, 9)\n plt.subplots_adjust(wspace=0.2, hspace=0.4)\n sub_plot_index = 1\n\n for sampling_type in sampling_types:\n mean_fpr, mean_tpr, mean_threshold, mean_auc, std_auc = self._compute_mean_auc_data(sampling_type, model_str, resampling_number, roc_curve_steps)\n\n plt.subplot(int('22' + str(sub_plot_index)))\n\n sub_plot_index += 1\n\n plt.plot(mean_fpr, mean_tpr, color='g', label='AUC:{0}, STD:{1}'.format(round(mean_auc, 2), round(std_auc, 2)))\n plt.plot(mean_fpr, mean_threshold, linestyle='--', lw=2, color='b', label='Thresholds')\n plt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r', label='Chance')\n\n plt.xlim([0 - PLOT_MARGIN, 1 + PLOT_MARGIN])\n plt.ylim([0 - PLOT_MARGIN, 1 + PLOT_MARGIN])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title(sampling_type + ' ROC Distribution')\n plt.legend(loc=\"lower right\")\n\n plt.savefig(roc_plot_path)\n plt.clf()","def _roc_plot(metrics, dummy_metrics, save_name):\n plt.figure()\n plt.plot([0, 1], [0, 1], \"k--\")\n if dummy_metrics is None or len(dummy_metrics) == 0:\n do_dummy = False\n else:\n do_dummy = True\n\n # Compute average ROC\n base_fpr = np.linspace(0, 1, 1000)\n # base_fpr = np.logspace(-4, 0, 1000)\n all_tpr = np.zeros((len(metrics), len(base_fpr)), float)\n for i, metric_set in enumerate(metrics):\n all_tpr[i, :] = np.interp(base_fpr, metric_set[\"fpr\"], metric_set[\"tpr\"])\n\n if do_dummy:\n all_tpr_dummy = np.zeros((len(dummy_metrics), len(base_fpr)), float)\n for i, metric_set in enumerate(dummy_metrics):\n all_tpr_dummy[i, :] = np.interp(\n base_fpr, metric_set[\"fpr\"], metric_set[\"tpr\"]\n )\n\n for _, metric_set in enumerate(dummy_metrics):\n plt.plot(\n metric_set[\"fpr\"],\n metric_set[\"tpr\"],\n color=\"lightsteelblue\",\n linewidth=0.5,\n alpha=0.5,\n )\n\n for _, metric_set in enumerate(metrics):\n plt.plot(\n metric_set[\"fpr\"], metric_set[\"tpr\"], color=\"lightsalmon\", linewidth=0.5\n )\n\n tpr_mu = all_tpr.mean(axis=0)\n plt.plot(base_fpr, tpr_mu, \"r\")\n\n if do_dummy:\n dummy_mu = all_tpr_dummy.mean(axis=0)\n plt.plot(base_fpr, dummy_mu, \"b\")\n\n plt.xscale(\"log\")\n plt.yscale(\"log\")\n plt.xlabel(\"False Positive Rate\")\n plt.ylabel(\"True Positive Rate\")\n plt.tight_layout()\n plt.grid()\n plt.savefig(save_name)","def metrics(labels, preds_proba, print_metrics=True, plot=False, threshold=0.5, rounded=4):\n \n\n test_fpr, test_tpr, test_thresholds = roc_curve(labels, preds_proba)\n roc_auc = auc(test_fpr, test_tpr)\n preds = preds_proba_to_preds_class(preds_proba,threshold)\n precision = precision_score(labels, preds)\n recall = recall_score(labels, preds)\n accuracy = accuracy_score(labels, preds)\n f1 = f1_score(labels, preds)\n if plot:\n sns.set_style('darkgrid', {'axes.facecolor': '0.9'})\n plt.figure(figsize=(10, 8))\n lw = 2\n plt.plot(test_fpr, test_tpr, color='darkorange',\n lw=lw, label='ROC curve')\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.yticks([i/20.0 for i in range(21)])\n plt.xticks([i/20.0 for i in range(21)])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Receiver operating characteristic (ROC) Curve')\n plt.legend(loc='lower right')\n plt.show()\n if print_metrics:\n print(f\"ROC AUC Score: {roc_auc}\\n\")\n print(f\"------- Metrics for threshold {threshold} -------\")\n print(f\"- Precision Score: {precision}\")\n print(f\"- Recall Score: {recall}\")\n print(f\"- Accuracy Score: {accuracy}\")\n print(f\"- F1 Score: {f1}\\n\")\n else:\n return {\"roc_auc\":roc_auc, \"precision\":precision, \"recall\":recall, \"accuracy\":accuracy, \"f1\":f1}","def _create_roc_curve(forecast_probabilities, observed_labels, output_dir_name):\n\n pofd_by_threshold, pod_by_threshold = model_eval.get_points_in_roc_curve(\n forecast_probabilities=forecast_probabilities,\n observed_labels=observed_labels,\n threshold_arg=model_eval.THRESHOLD_ARG_FOR_UNIQUE_FORECASTS,\n unique_forecast_precision=FORECAST_PRECISION_FOR_THRESHOLDS)\n\n auc = model_eval.get_area_under_roc_curve(\n pofd_by_threshold=pofd_by_threshold,\n pod_by_threshold=pod_by_threshold)\n scikit_learn_auc = roc_auc_score(\n y_true=observed_labels, y_score=forecast_probabilities)\n\n title_string = 'AUC = {0:.4f} ... scikit-learn AUC = {1:.4f}'.format(\n auc, scikit_learn_auc)\n print title_string\n\n figure_file_name = '{0:s}/roc_curve.jpg'.format(output_dir_name)\n print 'Saving ROC curve to: \"{0:s}\"...\\n'.format(figure_file_name)\n\n _, axes_object = pyplot.subplots(\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES))\n model_eval_plotting.plot_roc_curve(\n axes_object=axes_object, pod_by_threshold=pod_by_threshold,\n pofd_by_threshold=pofd_by_threshold)\n\n pyplot.title(title_string)\n pyplot.savefig(figure_file_name, dpi=DOTS_PER_INCH)\n pyplot.close()\n\n return auc, scikit_learn_auc","def plot_roc_curve(tprs, aucs, tag=''):\n fig, ax = plt.subplots()\n ax.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r',\n label='Chance', alpha=.8)\n\n mean_tpr = np.mean(tprs, axis=0)\n mean_tpr[-1] = 1.0\n mean_fpr = np.linspace(0, 1, 100)\n\n mean_auc = auc(mean_fpr, mean_tpr)\n std_auc = np.std(aucs)\n ax.plot(mean_fpr, mean_tpr, color='b',\n label=r'Mean ROC (AUC = %0.2f $\\pm$ %0.2f)' % (mean_auc, std_auc),\n lw=2, alpha=.8)\n\n std_tpr = np.std(tprs, axis=0)\n tprs_upper = np.minimum(mean_tpr + std_tpr, 1)\n tprs_lower = np.maximum(mean_tpr - std_tpr, 0)\n ax.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.2,\n label=r'$\\pm$ 1 std. dev.')\n\n ax.set(xlim=[-0.05, 1.05], ylim=[-0.05, 1.05],\n title=\"Receiver operating characteristic example\")\n ax.legend(loc=\"lower right\")\n plt.tight_layout()\n plt.savefig(f'roc_{tag}.png')\n plt.show()","def accuracy_stats(self, y_true_label, y_pred_prob, threshold = 0.50, accuracy = True, confusion_mat = True, ROC = True):\n # Reshape \n y_true_label = np.squeeze(y_true_label)\n y_pred_prob = np.squeeze(y_pred_prob)\n \n y_pred_label = (y_pred_prob >= threshold) + 0\n acc = np.mean(1 - abs(y_true_label - y_pred_label))\n \n #print(\"\\n --------PRINTING ACCURACY STATISTICS-------- \\n\")\n \n if accuracy:\n print(f\"accuracy: {acc * 100}%\\n\")\n \n if confusion_mat:\n print(\"confusion matrix:\\n\" + str(confusion_matrix(y_true_label, y_pred_label)) + \"\\n\")\n \n if ROC:\n fpr, tpr, thresholds = roc_curve(y_true_label, y_pred_label)\n roc_auc = roc_auc_score(y_true_label, y_pred_label)\n \n plt.figure()\n lw = 2\n plt.plot(fpr, tpr, color='darkorange',\n lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Receiver operating characteristic')\n plt.legend(loc=\"lower right\")\n plt.show()\n print(\"ROC AUC:\\n\" + str(roc_auc) + \"\\n\")","def plot_mean_roc_curve_of_classifiers(classifier_roc_list, data_set_description):\n if const.RECORD_RESULTS is True:\n fig = plt.figure(figsize=(8, 6.66))\n monochrome = (cycler(\"color\", [\"k\"]) * cycler(\"marker\", [\"\"]) *\n cycler(\"linestyle\", [\"-\", \"--\", \"-.\"]))\n color_arr = [\"#64B3DE\", \"#1f78b4\", \"#6ABF20\", \"#FBAC44\", \"#bc1659\", \"#B9B914\", \"#33a02c\", \"#ff7f00\", \"#6a3d9a\", \"black\", \"#b15928\", \"#e31a1c\"]\n plt.rc(\"axes\", prop_cycle=monochrome)\n line_style_index = 0\n color_index = 0\n\n for (test_run_roc_list, classifier_description) in classifier_roc_list:\n if not (None, None) in test_run_roc_list[0]:\n mean_tpr = 0.0\n mean_fpr = np.linspace(0, 1, 100)\n count = 0\n for roc_list in test_run_roc_list:\n for (tpr, fpr) in roc_list:\n mean_tpr += interp(mean_fpr, fpr, tpr)\n mean_tpr[0] = 0.0\n count += 1\n\n mean_tpr /= float(count)\n mean_tpr[-1] = 1.0\n mean_auc = auc(mean_fpr, mean_tpr)\n line_width = 0.5\n if line_style_index == 1:\n line_width = 0.8\n elif line_style_index == 2:\n line_width = 1.5\n\n plt.plot(mean_fpr, mean_tpr, c=color_arr[color_index], lw=line_width, alpha=1, label=\"{0} ({1:.3f})\".format(classifier_description, mean_auc))\n line_style_index = (line_style_index + 1) % 3\n color_index += 1\n\n plt.locator_params(axis='x', nbins=10)\n plt.locator_params(axis='y', nbins=10)\n plt.plot([0, 1], [0, 1], \"k--\", label=\"Random classification\", lw=0.8)\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.0])\n plt.xlabel(\"False Positive Rate\")\n plt.ylabel(\"True Positive Rate\")\n plt.title(\"ROC curve for each classifier\")\n plt.legend(loc=\"lower right\", fancybox=True, frameon=True)\n current_time = datetime.now().strftime(\"%Y-%m-%d_%H-%M-%S\")\n plt.savefig(os.path.dirname(os.path.realpath(__file__)) + \"/../results/{0}_roc_classifier_plot_{1}.png\".format(data_set_description, current_time), bbox_inches=\"tight\")\n plt.close(fig)","def plot_multi_roc_curve(y_trues, y_pred_probs, labels, **params):\n\n figure = plt.figure(figsize=params.get('figsize', (17, 10)))\n roc_aucs = []\n for y_true, y_pred_prob, label in zip(y_trues, y_pred_probs, labels):\n fpr, tpr, thresholds = roc_curve(y_true, y_pred_prob)\n roc_auc = auc(fpr, tpr)\n roc_aucs.append(roc_auc)\n plt.plot(fpr, tpr, label=f'{label} ROC curve (area = %0.5f)' % roc_auc)\n\n plt.plot([0, 1], [0, 1], 'k--')\n plt.xlim([-0.05, 1.05])\n plt.ylim([-0.05, 1.05])\n plt.xticks(np.arange(0.0, 1.1, step=0.1))\n plt.yticks(np.arange(0.0, 1.1, step=0.1))\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('ROC curve')\n plt.legend(loc=\"lower right\")\n\n plt.show()\n\n return figure, roc_aucs","def _plot_twoclass(out, fontsize=12, title='', label='', color='darkorange', ax=None, figsize=(12,8)):\n fpr = out['fpr']\n tpr = out['tpr']\n roc_auc = out.get('auc',None)\n \n if color is None:\n color='darkorange'\n\n if ax is None:\n fig,ax= plt.subplots(figsize=figsize)\n\n label = ('ROC curve (area = %.2f) ' %(roc_auc)) + label\n linewidth = 1.5\n ax.plot(fpr, tpr, color=color, lw=linewidth, label=label)\n ax.plot([0, 1], [0, 1], color='navy', lw=linewidth, linestyle='--')\n ax.set_xlim([0.0, 1.0])\n ax.set_ylim([0.0, 1.05])\n ax.set_xlabel('False Positive Rate', fontsize=fontsize)\n ax.set_ylabel('True Positive Rate', fontsize=fontsize)\n ax.set_title('[%s] Receiver operating characteristic. AUC:%.3f' %(title, roc_auc), fontsize=fontsize)\n ax.legend(loc=\"lower right\", fontsize=fontsize)\n ax.grid(True)\n return ax","def analyze(results: str):\n # Initialize plot\n co.nb.matplotlib_inline()\n plt.figure(figsize=(5, 4), linewidth=1)\n\n for model in os.listdir(results):\n # For each model, read in the results DataFrame\n df = pd.read_csv(os.path.join(results, model))\n\n # Compute statistics\n auc = roc_auc_score(df.true, df.pred)\n fpr, tpr, _ = roc_curve(df.true, df.proba)\n\n # Plot the stats\n plt.plot(fpr, tpr, label=f'{model} Score: ' + str(round(auc, 5)))\n\n # Finish up the plot and print it\n plt.plot([0, 1], [0, 1], 'k--', label='Random: 0.5')\n plt.xlabel('False positive rate')\n plt.ylabel('True positive rate')\n plt.title('ROC Curve')\n plt.legend(loc='best')\n plt.show()","def roc_curve(model, X_train, y_train, X_test, y_test, train=True):\n from sklearn.metrics import roc_curve\n if train==True:\n ypredTrain = model.predict(X_train)\n fpr, tpr, thresholds = roc_curve(y_train, ypredTrain)\n plt.plot(fpr, tpr, linewidth=3, label=None, color='r', linestyle='-')\n plt.rc('xtick', labelsize=10) \n plt.rc('ytick', labelsize=10) \n plt.xlabel('False Positive Rate', size=12)\n plt.ylabel('True Positive Rate', size=12)\n plt.grid()\n plt.rcParams['figure.facecolor'] = '#F2F3F4' \n plt.rcParams['axes.facecolor'] = '#F2F3F4' \n plt.title(\"ROC Curve: Sensitivity/Specificity Trade-off\\n\\n(Train)\\n\", size=14)\n plt.show()\n elif train==False:\n ypredTest = model.predict(X_test)\n fpr, tpr, thresholds = roc_curve(y_test, ypredTest)\n plt.plot(fpr, tpr, linewidth=3, label=None, color='b', linestyle='-')\n plt.rc('xtick', labelsize=10) \n plt.rc('ytick', labelsize=10) \n plt.xlabel('False Positive Rate', size=12)\n plt.ylabel('True Positive Rate', size=12)\n plt.grid()\n plt.rcParams['figure.facecolor'] = '#F2F3F4' \n plt.rcParams['axes.facecolor'] = '#F2F3F4'\n plt.title('ROC Curve: Sensitivity/Specificity Trade-off\\n\\n(Test)\\n', size=14)\n plt.show()","def plot_roc(self, X, y):\n plot_roc(self.clf, X, y)","def validate_and_plot_one_class(normal,outliers):\n print \"running a validation\"\n \n #classifier\n \n train_data = genfromtxt(normal, delimiter='\\t',skip_header=0)\n test_data = genfromtxt(outliers, delimiter='\\t',skip_header=0)\n\n outliers_proportion = float(test_data.shape[0])/(float(train_data.shape[0])+float(test_data.shape[0]))\n outliers_proportion=0.01\n\n clf = OneClassSVMClassifier(normal,outliers_proportion,0.95,0.05)\n #processing data without targets\n X_train = clf.scale(train_data)\n X_test = clf.scale(test_data)\n\n y_pred_train = clf.predict(X_train)\n y_pred_test = clf.predict(X_test)\n n_error_train = y_pred_train[y_pred_train == 1].size\n n_error_test = y_pred_test[y_pred_test == -1].size\n \n X=np.vstack((X_train,X_test))\n y_score = clf.predict(X)\n\n Y1=np.ones((X_train.shape[0],))\n Y2=(np.ones((X_test.shape[0],))*-1)\n y_true=np.concatenate((Y1,Y2))\n \n # Compute ROC curve and area the curve\n fpr, tpr, thresholds = metrics.roc_curve(y_true,y_score)\n roc_auc = metrics.auc(fpr, tpr)\n print \"Area under the ROC curve : %f\" % roc_auc\n \n # Plot ROC curve\n\n fig = matplotlib.pyplot.gcf()\n fig.set_size_inches(6.5,6.5)\n #font = {'family' : 'sans-serif',\n # 'weight' : 'normal',\n # 'size' : 18}\n\n #matplotlib.rc('font', **font)\n pl.clf()\n #modify plot area\n #modify tick label font size\n ax = pl.gca() # get the current axes\n for l in ax.get_xticklabels() + ax.get_yticklabels():\n l.set_fontsize('x-large')\n\n #color from html code table, linewidth x2.0\n pl.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc,color=\"#00CC66\",linewidth=3.0)\n# pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\"#009900\",linewidth=3.0)\n# pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\n# pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\n# pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\n #for more lines with different kernels\n #default_kernel=\"sigmoid\";clf = hermes.OneClassSVMClassifier(train,0.00,0.0,0.0595,default_kernel);y_score_sigmoid = clf.predict(X);fpr_sigmoid, tpr_sigmoid, thresholds_sigmoid = metrics.roc_curve(y_true,y_score_sigmoid);roc_auc_sigmoid = metrics.auc(fpr_sigmoid, tpr_sigmoid);fpr_sigmoid;tpr_sigmoid;roc_auc_sigmoid\n #pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\"#00CC66\",linewidth=2.0)\n #pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\n #pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\n #pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\n pl.plot([0, 1], [0, 1], 'k--')\n #modify base font size\n pl.xlim([0.0, 1.0])\n pl.ylim([0.0, 1.0])\n pl.xlabel('False positive rate',fontsize='xx-large')\n pl.ylabel('True positive rate',fontsize='xx-large')\n #pl.title('Receiver operating characteristic example')\n pl.legend(loc=\"lower right\",prop={'size':18})\n pl.show()\n sys.exit(0)\n ##the code here below was used to create the ROC curve for europar 13","def plot_roc_curve(y_true, y_pred_proba, threshold=0.5):\n\n y_pred = predict_with_threshold(y_pred_proba, threshold)\n roc_auc = roc_auc_score(y_true, y_pred)\n fpr, tpr, thresholds = roc_curve(y_true, y_pred_proba)\n\n plt.plot( # roc auc line\n fpr, tpr,\n label='AUC={:.3f}'.format(roc_auc),\n linewidth=3, alpha=0.7)\n plt.plot( # base line\n [0, 1], [0, 1], 'r--',\n label='baseline=0.5',\n linewidth=3, alpha=0.3)\n\n plt.xlim(0, 1)\n plt.ylim(0, 1)\n plt.title('ROC curve')\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.legend(loc=\"lower right\")","def plot_roc_curve(x_data, labels, net, plotfile,\n title=''):\n\n # Have the net predict, then split the scores by ground truth\n scores = net.predict(x_data)\n\n distfile = PLOTDIR / plotfile.replace('roc', 'dist')\n\n fig, ax = plt.subplots(1, 1, figsize=(12, 12))\n\n df = pd.DataFrame({'Condition': ['Positive' if int(i) == 1 else 'Negative'\n for i in labels[0, :]],\n 'Score': scores[0, :]})\n sns.violinplot(x='Condition', y='Score', data=df, ax=ax)\n ax.set_title('{} Dist for Rap1 Identification'.format(title))\n\n fig.savefig(str(distfile))\n\n plt.close()\n\n fp_rate, tp_rate = calc_roc(scores[labels], scores[~labels])\n\n # Make the plot\n plotfile = PLOTDIR / plotfile\n\n fig, ax = plt.subplots(1, 1, figsize=(12, 12))\n\n ax.plot(fp_rate, tp_rate, '-o', linewidth=3)\n\n # Plot the line for perfect confusion\n ax.plot([0, 1], [0, 1], '--', linewidth=3)\n\n ax.set_title('{} ROC for Rap1 Identification'.format(title))\n ax.set_xlabel('False Positive Rate')\n ax.set_ylabel('True Positive Rate')\n ax.set_xlim([-0.01, 1.01])\n ax.set_ylim([-0.01, 1.01])\n\n fig.savefig(str(plotfile))\n plt.close()","def prc(test_set_y_org,test_set_y_pred_prob,classes_unique,plot_curve=False,filename=\"./fig_prc.pdf\",colors=None,positive_class_for_two_classes=None,figwidth=5,figheight=5):\n from sklearn.metrics import precision_recall_curve\n from sklearn.metrics import average_precision_score\n #from scipy import interp\n import matplotlib as mpl\n mpl.use(\"pdf\")\n import matplotlib.pyplot as plt\n \n precision = dict()\n recall = dict()\n average_precision = dict()\n n_classes=len(classes_unique)\n test_set_Y_org,test_set_y_org_unique=membership_vector_to_indicator_matrix(test_set_y_org)\n \n for c in range(n_classes):\n precision[c], recall[c], _ = precision_recall_curve(test_set_Y_org[:, c], test_set_y_pred_prob[:, c])\n average_precision[c] = average_precision_score(test_set_Y_org[:, c], test_set_y_pred_prob[:, c])\n \n # Compute macro-average ROC curve and AUROC area\n # First aggregate all recalls\n all_recall = np.unique(np.concatenate([recall[c] for c in range(n_classes)]))\n #all_recall = np.sort(np.concatenate([recall[c] for c in range(n_classes)]))\n # Then interpolate all PRC curves at this points\n mean_precision = np.zeros_like(all_recall)\n for c in range(n_classes):\n mean_precision = mean_precision + np.interp(all_recall, recall[c][::-1], precision[c][::-1]) # xp in interp() must be in increasing order\n # Finally average it and compute AUPRC\n mean_precision = mean_precision/n_classes\n recall[\"macro\"] = all_recall\n precision[\"macro\"] = mean_precision\n #roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])\n # Compute micro-average ROC curve and ROC area\n precision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(test_set_Y_org.ravel(), test_set_y_pred_prob.ravel())\n average_precision[\"macro\"] = average_precision_score(test_set_Y_org, test_set_y_pred_prob, average=\"macro\") # micro macro, weighted, or samples\n average_precision[\"micro\"] = average_precision_score(test_set_Y_org, test_set_y_pred_prob, average=\"micro\") # micro macro, weighted, or samples\n average_precision[\"weighted\"] = average_precision_score(test_set_Y_org, test_set_y_pred_prob, average=\"weighted\") # micro macro, weighted, or samples\n average_precision[\"samples\"] = average_precision_score(test_set_Y_org, test_set_y_pred_prob, average=\"samples\") # micro macro, weighted, or samples\n\n if plot_curve:\n fig=plt.figure(num=1,figsize=(figwidth,figheight))\n ax=fig.add_subplot(1,1,1)\n if n_classes>2 or positive_class_for_two_classes is None:\n ax.plot(recall[\"macro\"], precision[\"macro\"], linewidth=1,color=colors[n_classes],label='macro-avg PRC (area={0:0.4f})'.format(average_precision[\"macro\"]))\n \n for c in range(n_classes):\n if positive_class_for_two_classes==None or (n_classes==2 and positive_class_for_two_classes==c):\n ax.plot(recall[c], precision[c],linewidth=1,color=colors[c],label='PRC of {0} (area={1:0.4f})'.format(classes_unique[c], average_precision[c]))\n \n # add some text for labels, title and axes ticks\n ax.set_ylim(0.0,1.0)\n ax.set_xlim(0.0,1.0)\n ax.set_ylabel(\"Precision\",fontsize=12)\n ax.set_xlabel(\"Recall\",fontsize=12) \n #ax.set_title(\"\",fontsize=15)\n ax.legend(loc=\"lower left\",fontsize=8)\n #plt.subplots_adjust(bottom=0.12) # may this is not working because of the following setting\n fig.savefig(filename,bbox_inches='tight')\n plt.close(fig)\n\n average_precision_list=[average_precision[c] for c in range(n_classes)]\n average_precision_list.extend([average_precision[\"macro\"],average_precision[\"micro\"],average_precision[\"weighted\"],average_precision[\"samples\"]])\n average_precision=np.array(average_precision_list)\n names=[\"AUPRC_\" + c for c in classes_unique]\n names.extend([\"macro\",\"micro\",\"weighted\",\"samples\"])\n names=np.array(names)\n \n return average_precision,names","def single_roc_plot(y_true, y_probas, text=None, title='ROC Curves', figsize=None, title_fontsize=\"large\", text_fontsize=\"medium\"):\n fig, ax = plt.subplots(1, 1, figsize=figsize)\n ax.set_title(title, fontsize=title_fontsize)\n fpr, tpr, _ = roc_curve(y_true, y_probas, pos_label=1)\n roc_auc = auc(fpr, tpr)\n ax.plot(fpr, tpr, label='ROC curve '\n '(area = {0:0.2f})'.format(roc_auc),\n color='blue', linewidth=2)\n ax.plot([0, 1], [0, 1], 'k--', lw=2)\n ax.set_xlim([0.0, 1.0])\n ax.set_ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n ax.set_ylabel('True Positive Rate', fontsize=text_fontsize)\n ax.tick_params(labelsize=text_fontsize)\n ax.legend(loc='lower right', fontsize=text_fontsize)\n return fig","def verif_valid_from_bag(list_models, X_val, reality, cut=0.5):\n bag_scores = []\n for model in list_models:\n pred_score = model.predict_proba(X_val)[:,1]\n bag_scores.append(pred_score.tolist())\n bag_scores = pd.DataFrame(bag_scores).transpose()\n #bag_scores = np.asmatrix(bag_scores)[:,0:5]\n pred_score = bag_scores.mean(axis=1)\n predictions = np.where(pred_score > cut, 1, 0)\n print('Confusion Matrix :')\n conf_mat = confusion_matrix(reality, predictions)\n print(pd.DataFrame(conf_mat))\n print('Associated metrics :')\n print(classification_report(reality, predictions))\n fpr, tpr, _ = roc_curve(reality, pred_score)\n roc_auc = auc(fpr, tpr)\n print('Avg False-Pos rate = ' + str(round(np.mean(fpr), 4)) +\n ' | Avg True-Pos rate : ' + str(round(np.mean(tpr), 4)))\n plt.plot(fpr, tpr, 'r-', lw=4)\n actual_fpr = conf_mat[1, 0] / (conf_mat[1, 0] + conf_mat[0, 0])\n actual_tpr = conf_mat[1, 1] / (conf_mat[1, 1] + conf_mat[0, 1])\n plt.plot(actual_fpr, actual_tpr, 'bo', lw=10)\n plt.xlabel('False-Positive Rate')\n plt.ylabel('True-Positive Rate')\n plt.title('ROC curve (with AUC = ' + str(round(roc_auc, 6)) + ')')\n plt.plot([0, 1], [0, 1], 'k-')\n plt.show()\n print('Score AUC : ' + str(roc_auc))\n print('Accuracy : ' + str(metrics.accuracy_score(reality, predictions)))","def examine(stocks, init_param, C_in, gamma_in, verbose):\r\n from sklearn.svm import SVC\r\n from sklearn import metrics\r\n import matplotlib.pyplot as plt\r\n# import pandas as pd\r\n \r\n training_data, test_data = form_data(stocks, init_param)\r\n std_scale = preprocessing.StandardScaler().fit(training_data.X)\r\n training_data.X = std_scale.transform(training_data.X)\r\n test_data.X = std_scale.transform(test_data.X)\r\n \r\n svm = SVC(kernel='rbf', random_state=0, gamma = gamma_in, C=C_in, probability=True)\r\n svm.fit(training_data.X, training_data.y)\r\n preds = svm.predict_proba(test_data.X)[:,1]\r\n fpr, tpr, _ = metrics.roc_curve(test_data.y, preds)\r\n\r\n# df = pd.DataFrame(dict(fpr=fpr, tpr=tpr))\r\n roc_auc = metrics.auc(fpr,tpr)\r\n \r\n if verbose:\r\n plt.figure()\r\n lw = 2\r\n plt.plot(fpr, tpr, color='darkorange',\r\n lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)\r\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\r\n plt.xlim([0.0, 1.0])\r\n plt.ylim([0.0, 1.05])\r\n plt.xlabel('False Positive Rate')\r\n plt.ylabel('True Positive Rate')\r\n plt.title('Receiver operating characteristic example')\r\n plt.legend(loc=\"lower right\")\r\n plt.show()\r\n \r\n return roc_auc","def plot_results(\n predictor_names, validation_auc_values, is_forward_test,\n axes_object=None, num_predictors_to_plot=None):\n\n if num_predictors_to_plot is None:\n num_predictors_to_plot = len(predictor_names)\n\n num_predictors_to_plot = max([num_predictors_to_plot, 2])\n num_predictors_to_plot = min([\n num_predictors_to_plot, len(predictor_names)\n ])\n\n y_coords = numpy.linspace(\n 0, num_predictors_to_plot - 1, num=num_predictors_to_plot, dtype=float\n )[::-1]\n\n if axes_object is None:\n _, axes_object = pyplot.subplots(\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\n )\n\n axes_object.barh(\n y_coords, validation_auc_values[:num_predictors_to_plot],\n color=BAR_FACE_COLOUR, edgecolor=BAR_EDGE_COLOUR,\n linewidth=BAR_EDGE_WIDTH\n )\n\n axes_object.set_yticks([], [])\n axes_object.set_xlabel('Validation AUC')\n\n if is_forward_test:\n axes_object.set_ylabel('Predictor added')\n else:\n axes_object.set_ylabel('Predictor removed')\n\n axes_object.set_ylim(\n numpy.min(y_coords) - 0.75, numpy.max(y_coords) + 0.75\n )\n axes_object.set_xlim(\n 0, numpy.max(validation_auc_values[:num_predictors_to_plot])\n )\n\n for j in range(num_predictors_to_plot):\n axes_object.text(\n 0., y_coords[j], ' ' + predictor_names[j],\n color=BAR_TEXT_COLOUR, fontsize=BAR_FONT_SIZE,\n horizontalalignment='left', verticalalignment='center'\n )\n\n return axes_object","def plot_acc(acc_v, acc_t, save_plots_path):\n\n plt.figure()\n plt.plot(acc_v, label='Validation acc')\n plt.plot(acc_t, label='Training acc')\n plt.legend()\n title = 'Accuracy per epoch'\n plt.title(title)\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Accuracy\")\n plt.savefig(save_plots_path + \"swag_accuracy_plot.png\")","def performancePlot(plot=\"ROC\"):\n fig, ax = plt.subplots()\n colors = {\"ML\": \"red\", \"Null YFP\": \"gold\", \"Null DAPI\": \"blue\"}\n mapp = pickle.load(open(\"pickles/mapp_fold_-1.pk\", \"rb\"))\n null_mapp = pickle.load(open(\"pickles/null_YFP_mapp_fold_-1.pk\", \"rb\"))\n null_DAPI_mapp = pickle.load(open(\"pickles/null_DAPI_mapp_fold_-1.pk\", \"rb\"))\n \n i = 0\n for m in [mapp, null_mapp, null_DAPI_mapp]:\n coordinates = [] #list of tuples (thresh, x point, y point) to plot\n for key in m: ##for each threshold\n TPs = sum([x[0] for x in m[key]])\n FPs = sum([x[1] for x in m[key]])\n TNs = sum([x[2] for x in m[key]])\n FNs = sum([x[3] for x in m[key]])\n if plot == \"PRC\":\n x = TPs / float(TPs + FNs) #recall (TPR)\n y = TPs / float(TPs + FPs) #precision\n if plot == \"ROC\":\n x = FPs / float(FPs + TNs) #FPR \n y = TPs / float(TPs + FNs) #recall (TPR)\n if not (np.isnan(x) or np.isnan(y)): \n coordinates.append((key, x, y))\n coordinates = sorted(coordinates, key=lambda x: x[0]) ##sort by threshold\n x = [t[1] for t in coordinates][::-1]\n y = [t[2] for t in coordinates][::-1]\n # print(i, coordinates)\n # thresholds = [entry[0] for entry in coordinates]\n # for j, txt in enumerate(thresholds):\n # ax.annotate(txt, (x[j], y[j]), fontsize=5)\n auc = np.trapz(y,x)\n if i == 0:\n label = \"ML\"\n if i == 1:\n label = \"Null YFP\"\n if i == 2:\n label = \"Null DAPI\" \n ax.plot(x, y, linewidth=2.0, color=colors[label], label=\"{} Model, AUC = {}\".format(label, str(round(auc, 2)))) \n i += 1\n plt.title(\"{} Curves\".format(plot), fontname=\"Times New Roman\", fontsize=12)\n ax.set_xlim((0,1))\n ax.set_ylim((0,1))\n plt.rc('font',family='Times New Roman')\n plt.xticks(fontname=\"Times New Roman\", fontsize=12)\n plt.yticks(fontname=\"Times New Roman\", fontsize=12)\n if plot == \"ROC\":\n ax.set_xlabel(\"False Positive Rate\", fontname=\"Times New Roman\", fontsize=12)\n ax.set_ylabel(\"True Positive Rate\",fontname=\"Times New Roman\", fontsize=12)\n ax.plot([0, .5, 1], [0,.5, 1], linestyle=\"--\", linewidth=1.0, color=\"black\")\n ax.legend(loc='lower right',prop={\"family\":\"Times New Roman\", \"size\":10})\n plt.savefig(\"matplotlib_figures/ROC.png\", dpi=300)\n if plot == \"PRC\":\n positives = TPs + FNs ##doesn't matter which map we use, positive prevalence independent of map \n total = TPs + FPs + TNs + FNs \n positive_prevalence = positives / float(total)\n ax.hlines(y=positive_prevalence, xmin=0, xmax=1, linestyle=\"--\", linewidth=1.0, color=\"black\")\n ax.set_xlabel(\"Recall\", fontname=\"Times New Roman\", fontsize=12)\n ax.set_ylabel(\"Precision\",fontname=\"Times New Roman\", fontsize=12)\n ax.set_xlim((0,1))\n ax.set_ylim((0,1))\n ax.legend(loc='upper right',prop={\"family\":\"Times New Roman\", \"size\":10})\n plt.savefig(\"matplotlib_figures/PRC.png\", dpi=300)","def ROC_curve_binary(actual_labels, basic_cnn_pred_score, pos_label = \"malaria\"):\n fpr, tpr, thresholds = metrics.roc_curve(actual_labels, basic_cnn_pred_score, pos_label=pos_label)\n\n roc_auc = auc(fpr, tpr)\n\n plt.figure()\n lw = 2\n # colors = ['aqua', 'darkorange', 'cornflowerblue', 'navy', 'deeppink', 'aqua', 'darkorange', 'cornflowerblue']\n plt.plot(fpr, tpr, color='darkorange',\n lw=lw, label='ROC curve (area = %0.4f)' % roc_auc)\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Receiver operating characteristic')\n plt.legend(loc=\"lower right\")\n plt.show()","def do_prc(scores, true_labels, file_name='', directory='', plot=True):\n\n # precision_0, recall_0, _ = precision_recall_curve(true_labels, scores[0])\n # prc_auc_0 = auc(recall_0, precision_0)\n # precision_1, recall_1, _ = precision_recall_curve(true_labels, scores[1])\n # prc_auc_1 = auc(recall_1, precision_1)\n # precision_2, recall_2, _ = precision_recall_curve(true_labels, scores[2])\n # prc_auc_2 = auc(recall_2, precision_2)\n # precision_3, recall_3, _ = precision_recall_curve(true_labels, scores[3])\n # prc_auc_3 = auc(recall_3, precision_3)\n # precision_4, recall_4, _ = precision_recall_curve(true_labels, scores[4])\n # prc_auc_4 = auc(recall_4, precision_4)\n precision, recall, _ = precision_recall_curve(true_labels, scores)\n prc_auc = auc(recall, precision)\n\n plt.figure(figsize=(10,10))\n plt.rcParams.update({'font.size': 50})\n plt.plot(recall, precision, color='lightblue',label='area = %0.3f' % (prc_auc))\n # plt.plot(recall_1, precision_1, color='wheat', label='VAE PRC curve (area = %0.3f)' % (prc_auc_1))\n # plt.plot(recall_2, precision_2, color='lightblue', label='CNNAE PRC curve (area = %0.3f)' % (prc_auc_2))\n # plt.plot(recall_3, precision_3, color='lightskyblue', label='CNNVAE PRC curve (area = %0.3f)' % (prc_auc_3))\n # plt.plot(recall_4, precision_4, color='plum', label='ALAD PRC curve (area = %0.3f)' % (prc_auc_4))\n # plt.plot(recall_4, precision_4, color='brown', label='Ensemble PRC curve (area = %0.3f)' % (prc_auc_5))\n\n\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('Recall')\n plt.ylabel('Precision')\n plt.legend(loc=\"lower right\")\n plt.savefig(directory + file_name + 'prc.eps', bbox_inches='tight', format='eps')\n plt.close()\n\n # return prc_auc","def plot_histogram_assess(assess_input, figure_output):\n\n sns.set_style(\"white\")\n raw_auc = pd.read_table(assess_input, index_col=\"Motif\")\n raw_auc = raw_auc.drop_duplicates()\n # df = df.T.drop_duplicates().T\n raw_auc = raw_auc.sort(columns=\"MNCP\", axis=0, ascending=False)\n labels = raw_auc.index\n x = 10\n if len(labels) > 50:\n x = 15\n elif len(labels) < 10:\n x = 5\n f, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1, figsize=(x, 10), sharex=True)\n a = sns.barplot(x=labels, y=raw_auc[\"AUC\"],\n palette='colorblind', x_order=labels, ax=ax1)\n b = sns.barplot(x=labels, y=raw_auc[\"MNCP\"],\n palette=\"colorblind\", x_order=labels, ax=ax2)\n c = sns.barplot(x=labels, y=raw_auc[\"Spearman\"],\n palette=\"colorblind\", x_order=labels, ax=ax3)\n d = sns.barplot(x=labels, y=raw_auc[\"Pearson\"],\n palette=\"colorblind\", x_order=labels, ax=ax4)\n d.set_xticklabels(labels, rotation=90)\n\n sns.despine()\n f.savefig(figure_output + \".eps\", bbox_inches='tight')\n f.savefig(figure_output + \".png\", bbox_inches='tight')","def check_fit(truth, prob):\n fpr, tpr, _ = roc_curve(truth, prob) # drop_intermediate:(default=True)\n roc_auc = auc(fpr, tpr) # calculate the AUC\n plt.figure()\n plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\n plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n plt.xlim([-0.1, 1.05])\n plt.ylim([-0.1, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Receiver operating characteristic example')\n plt.legend(loc=\"lower right\")\n plt.show()\n print('results are RMSE, accuracy, ROC, loss function')\n print(sqrt(mean_squared_error(truth, prob)), accuracy_score(truth, prob), roc_auc, zero_one_loss(truth, prob))","def plot_all(pred_tuple, filename='roc.png'):\n plt.clf()\n colors = [\"red\",\"blue\",\"green\",\"orange\",\"yellow\"]\n for (label, y, proba), color in zip(pred_tuple, colors):\n true_pos, false_pos, thresh = metrics.roc_curve(y, proba)\n plt.plot(false_pos, true_pos, label=label, linewidth=2,\n color=color)\n plt.plot([0,1],[0,1], linestyle=\"dashed\", color=\"grey\", label=\"random\")\n plt.xlim([0,1])\n plt.ylim([0,1])\n plt.xlabel(\"False Positive Rate\")\n plt.ylabel(\"True Positive Rate\")\n plt.title(\"Receiver Operating Characteristic\")\n plt.legend(loc=\"lower right\")\n\n plt.show()\n plt.savefig(_plots_path + filename)","def make_plot(folder, community, axarr=None, pos=None, n_points=20, show_legend=False, auc_file_writer=None):\n if axarr == None:\n fig = plt.figure(figsize=fig_dim)\n ax = fig.add_subplot(pos[0], pos[1], 1, zorder=1)\n else:\n ax = axarr[pos[0], pos[1]]\n # ax.set_ylim(bottom=0)\n if pos[0] == len(axarr) - 1:\n ax.set_xlabel('additions as % of |C|', fontsize=10)\n # ax.set_xlabel(r'$\\# \\textup{inclusions}/ | C^{\\textup{true}} |$', fontsize = 16)\n if pos[1] == 0:\n ax.set_ylabel('recall', fontsize=10)\n\n area_under_curve = []\n for idx, method in enumerate(METHODS):\n index, mean, std_error = read_recall(folder, community, method)\n area_under_curve.append(auc(index, mean))\n plot_indices = uniform_sample(n_points, len(\n index)) # don't want to plot all of the indices as the error bars look cluttered\n ax.errorbar(np.insert(index[plot_indices], 0, 0), np.insert(mean[plot_indices], 0, 0),\n np.insert(std_error[plot_indices], 0, 0), color=COLOURS[idx], label=method,\n alpha=0.5)\n # ax.set_title(folder.rsplit('/', 1)[-1], fontsize=10)\n ax.set_title(community, fontsize=8, y=0.95)\n auc_file_writer.writerow([community] + area_under_curve)\n if show_legend:\n legend = ax.legend(loc='upper center')\n for label in legend.get_texts():\n label.set_fontsize(6)\n\n if axarr == None:\n fig.tight_layout(pad=0.1)\n tag = folder.rsplit('/', 2)[-2]\n plt.savefig(\"local_results/recall_figs/recall_vs_range_{}.pdf\".format(tag))\n plt.close()\n\n return index, mean, std_error","def plot_ROC_curves(fig, ax, y_all, perf, title=None):\n curves = {'IMPRESS_all': 'royalblue',\n 'IMPRESS_HE_only': 'plum',\n 'IMPRESS_IHC_only': 'pink',\n 'pathologists_eval': 'tomato'}\n \n type_convert = {'IMPRESS_all': 'IMPRESS',\n 'IMPRESS_HE_only': 'IMPRESS (H&E only)',\n 'IMPRESS_IHC_only': 'IMPRESS (IHC only)',\n 'pathologists_eval': 'Pathologists'}\n \n for fgroup in curves.keys():\n tprs = []\n aucs = []\n mean_fpr = np.linspace(0, 1, 100)\n ax.set_aspect('equal')\n for seed in range(int(y_all[fgroup].shape[1]/3)):\n y_true = y_all[fgroup].loc[:,'y_true'].iloc[:,seed]\n y_pred_proba = y_all[fgroup].loc[:,'y_pred_proba'].iloc[:,seed]\n tpr, fpr, treshold = roc_curve(y_true, 1-y_pred_proba)\n tprs.append(np.interp(mean_fpr, fpr, tpr))\n roc_auc = auc(fpr, tpr)\n aucs.append(roc_auc)\n ax.plot(fpr, tpr, color=curves[fgroup], linewidth=2, alpha=0.10, label=None)\n \n mean_tpr = np.mean(tprs, axis=0)\n mean_tpr[-1] = 1.0\n \n ax.plot(mean_fpr, mean_tpr, color=curves[fgroup],\n label=r'%s (AUC = %0.4f $\\pm$ %0.2f)' % \\\n (type_convert[fgroup], perf[fgroup].loc['AUC','mean'], perf[fgroup].loc['AUC','std']),\n linewidth=3.0, alpha=0.80)\n \n std_tpr = np.std(tprs, axis=0)\n tprs_upper = np.minimum(mean_tpr + std_tpr, 1)\n tprs_lower = np.maximum(mean_tpr - std_tpr, 0)\n \n if fgroup == 'IMPRESS_all':\n ax.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=0.1,\n label=r'$\\pm$ 1 standard deviation')\n else:\n ax.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=0.1,\n label=None)\n \n ax.set_xlabel('False positive rate')\n ax.set_ylabel('True positive rate')\n x = [0.0, 1.0]\n plt.plot(x, x, linestyle='dashed', color='red', linewidth=2.0, label='Random')\n plt.legend(fontsize=10, loc='best')\n \n if title is not None:\n fig.suptitle(t=title, fontsize=12)\n return fig","def generate_roc_curve(clf, X, y, survived_weight=1, plot=False, n_classes=5):\n fpr = dict()\n tpr = dict()\n roc_auc = dict()\n aucs = []\n for i in range(5):\n # shuffle and split training and test sets\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.25)\n #weights = np.array([survived_weight if s == 1 else 1 for s in y_train])\n #clf.fit(X_train, y_train, sample_weight=weights)\n clf.fit(X_train, y_train)\n\n fpr[i], tpr[i], _ = roc_curve(y_test, clf.predict_proba(X_test)[:,1])\n roc_auc[i] = auc(fpr[i], tpr[i])\n aucs.append(roc_auc[i])\n print('ROC AUC: {:.2%}'.format(roc_auc[i]))\n\n auc_mean = \"{:.3%}\".format(np.mean(aucs))\n auc_std = \"{:.3%}\".format(np.std(aucs))\n auc_lower = \"{:.3%}\".format(np.mean(aucs)-np.std(aucs))\n print(\"ROC - Area under curve: {} and stddev: {}\".format(auc_mean, auc_std))\n\n if plot:\n # Plot of a ROC curve for a specific class\n plt.figure()\n for i in range(5):\n plt.plot(fpr[i], tpr[i], label='ROC curve (area = %0.2f)' % roc_auc[i])\n\n plt.plot([0, 1], [0, 1], 'k--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('ROC Curve')\n plt.legend(loc=\"lower right\")\n plt.show()","def single_auc_loging(history,title,path_to_save):\n f, (ax1, ax2) = plt.subplots(1, 2,figsize=(12,12))\n\n if 'loss' in history.keys():\n loss_key = 'loss' # for simple NN\n elif 'class_out_loss' in history.keys():\n loss_key = 'class_out_loss' # for DAL NN\n else:\n raise ValueError('Not found correct key for loss information in history')\n\n ax1.plot(history[loss_key],label='cl train loss')\n ax1.plot(history['val_%s' %loss_key],label='cl val loss')\n ax1.legend()\n min_loss_index,max_loss_value = min(enumerate(history['val_loss']), key=operator.itemgetter(1))\n ax1.set_title('min_loss_%.3f_epoch%d' % (max_loss_value, min_loss_index))\n ax2.plot(history['val_auc'])\n max_auc_index, max_auc_value = max(enumerate(history['val_auc']), key=operator.itemgetter(1))\n ax2.set_title('max_auc_%.3f_epoch%d' % (max_auc_value, max_auc_index))\n f.suptitle('%s' % (title))\n plt.savefig('%s/%s.png' % (path_to_save,title), figure=f)\n plt.close()\n with open('%s/%s.pkl' % (path_to_save,title), 'wb') as output:\n pickle.dump(history,output,pickle.HIGHEST_PROTOCOL)","def pr_writer(clf, y_true, y_prob, eval_folder, i=''):\n # make sure y_true, y_prob is iterable\n if type(y_true[0]) is not np.ndarray: y_true = [y_true]\n if type(y_prob[0]) is not np.ndarray: y_prob = [y_prob]\n\n img_dir = eval_folder+'/images/'\n if not os.path.exists(img_dir):\n os.makedirs(img_dir)\n\n clf_name = str(clf)[:str(clf).index('(')]+str(i)\n\n enum_list = range(0, len(y_true))\n pr_auc = []\n\n # plot pr each fold's PR curve\n for i in enum_list:\n prec, rec, _ = metrics.precision_recall_curve(y_true[i], y_prob[i])\n pr_auc.append(metrics.average_precision_score(y_true[i], y_prob[i]))\n plt.plot(rec, prec)\n\n # make plot, only show mean, SE for AUCs\n plt.title('Precision-Recall')\n plt.plot(rec, prec, linestyle='none', label='Mean AUC = %0.2f\\nSE AUC = %0.3f'% (np.mean(pr_auc), np.std(pr_auc)))\n plt.legend(loc='upper right')\n plt.xlabel('Recall')\n plt.ylabel('Precision')\n plt.ylim([0.0, 1.05])\n plt.xlim([0.0, 1.0])\n\n\n plt.savefig(img_dir+'PR_Curve_'+clf_name+'.png')","def gen_plot(fpr, tpr):\n plt.figure()\n plt.xlabel(\"FPR\", fontsize=14)\n plt.ylabel(\"TPR\", fontsize=14)\n plt.title(\"ROC Curve\", fontsize=14)\n plot = plt.plot(fpr, tpr, linewidth=2)\n buf = io.BytesIO()\n plt.savefig(buf, format='jpeg')\n buf.seek(0)\n plt.close()\n # plt.show()\n return buf","def plot_roc_curve(y, y_pred, threshold_step=0.001):\r\n # define the thresholds that will be used to compute the ROC curve\r\n thresholds = np.arange(threshold_step, 1.0, threshold_step)\r\n\r\n # define the list with the values of (sensitivity and 1 - specificity)\r\n recalls = []\r\n fall_outs = []\r\n\r\n # compute the metrics for every threshold\r\n for threshold in thresholds:\r\n\r\n # get the roc metrics\r\n recall, fall_out = roc_metrics(y_pred, y, threshold=threshold)\r\n\r\n # append to the corresponding lists\r\n recalls.append(recall)\r\n fall_outs.append(fall_out)\r\n\r\n # configure the size of the ROC curve plots\r\n plt.rcParams[\"figure.figsize\"] = [15, 10]\r\n plt.rcParams[\"xtick.labelsize\"] = 14\r\n plt.rcParams[\"ytick.labelsize\"] = 14\r\n\r\n # plot the ROC curve\r\n plt.plot(fall_outs, recalls, color=\"darkcyan\", label=\"RNN Classifier\")\r\n\r\n # plot y = x for comparison\r\n x = np.arange(0, 1.01, 0.1)\r\n plt.plot(x, x, color=\"brown\", linestyle=\"--\", label=r\"$y\\;=\\;x$\")\r\n\r\n # add legend, labels and title\r\n plt.xlabel(\"\\n1 - Specificity\", fontsize=20)\r\n plt.ylabel(\"Sensitivity\\n\", fontsize=20)\r\n plt.title(\"ROC curve\\n\", fontsize=25)\r\n plt.legend()\r\n plt.grid()\r\n plt.show()","def get_evaluation_metrics(inference_model_name,\n partition_option,\n data_split_type,\n plot_roc_curve=True,\n plot_confusion_matrix=True):\n inference_file_name = get_inference_file_name(inference_model_name,\n partition_option,\n data_split_type)\n inference_dir = os.path.join(args.output_data_dir, 'inference')\n inference_df = pd.read_pickle(os.path.join(inference_dir,\n inference_file_name))\n\n # Evaluate within the tissue region\n filter_mask = (inference_df['is_roi'] == 1) & \\\n (inference_df['non_gray_ratio'] > NON_GRAY_RATIO_THRESHOLD)\n inference_df = inference_df[filter_mask].copy()\n\n y_truth = inference_df['label'].astype(int).values\n y_pred_prob = inference_df['y_pred_prob'].values\n y_pred = (y_pred_prob > 0.5).astype(int)\n\n accuracy = accuracy_score(y_truth, y_pred)\n precision = precision_score(y_truth, y_pred)\n recall = recall_score(y_truth, y_pred)\n\n loss = log_loss(y_truth, y_pred_prob, eps=1e-6)\n fpr, tpr, threshold = roc_curve(y_truth, y_pred_prob)\n roc_auc = auc(fpr, tpr)\n\n # accuracy if we predict everything as negative\n dummy_accuracy = 1 - y_truth.mean()\n\n output = {\n 'model_name': inference_model_name,\n 'loss': loss,\n 'accuracy': accuracy,\n 'precision': precision,\n 'recall': recall,\n 'auc': roc_auc,\n 'dummy_accuracy': dummy_accuracy,\n }\n\n if plot_roc_curve:\n plt.figure()\n\n lw = 2\n plt.plot(fpr, tpr, color='orange',\n lw=lw,\n label='{} (area = {:.3f})'.format(\n inference_model_name, roc_auc))\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('ROC Curve')\n plt.legend(loc='lower right')\n\n if plot_confusion_matrix:\n cm = confusion_matrix(y_truth, y_pred)\n fig, ax = plt.subplots()\n sns.heatmap(cm, annot=True, ax=ax, fmt='g')\n\n # labels, title and ticks\n ax.set_xlabel('Predicted labels')\n ax.set_ylabel('True labels')\n ax.set_title('Confusion Matrix')\n ax.xaxis.set_ticklabels([0, 1])\n ax.yaxis.set_ticklabels([0, 1])\n\n return output","def finetune_n_estimators(savefigure=False):\n res = np.array(np.load('npy-data/result_n_estimators_tuning_acc_auc_crossval_train.npy'))\n acc, auc = res[:int(len(res)/2)], res[int(len(res)/2):]\n plt.plot([j*10 for j in range(1,31)],acc,[j*10 for j in range(1,31)],auc)\n plt.xlabel('Number of trees')\n plt.ylabel('Accuracy/AUC score')\n plt.legend([\"Accuracy\",\"ROC AUC\"])\n if savefigure:\n plt.savefig('img/accuracy_n_estimators_tuning_acc_auc_crossval.pdf', bbox_inches='tight')\n plt.show()","def evaluate_model(clf_, X_tr, X_te, y_tr, y_te, cls_rpt_tr=False, show=True, cls_labels=None, binary=False):\n \n import sklearn.metrics as metrics\n import matplotlib.pyplot as plt\n from yellowbrick.classifier import ROCAUC\n \n ## Fit and predict \n y_hat_trn, y_hat_tes = fit_n_pred(clf_, X_tr, X_te, y_tr)\n \n if show:\n ## Classification Report / Scores\n if cls_rpt_tr:\n print('Classification Report Train')\n print(metrics.classification_report(y_tr,y_hat_trn))\n else:\n print('Classification Report Test')\n print(metrics.classification_report(y_te,y_hat_tes))\n\n ## Confusion Matrix\n fig, ax = plt.subplots(figsize=(10,5), ncols=2)\n \n metrics.plot_confusion_matrix(clf_,X_te,y_te,cmap=\"YlOrRd\",\n normalize='true',ax=ax[0])\n ax[0].set(title='Confusion Matrix Test Data')\n ax[0].grid(False) \n\n roc = ROCAUC(clf_, classes=cls_labels, ax=ax[1])\n roc.fit(X_tr, y_tr)\n roc.score(X_te, y_te)\n roc.finalize()\n \n plt.tight_layout()\n plt.show()\n \n if binary:\n try:\n imps = plot_importance(clf_, X_tr)\n except:\n imps = None\n \n else:\n return y_hat_trn, y_hat_tes","def plot_loss_acc(history, aucs, model_path=None):\n # summarize history for accuracy\n plt.plot(history.history['acc'])\n plt.plot(history.history['val_acc'])\n plt.title('model accuracy')\n plt.ylabel('accuracy')\n plt.xlabel('epoch')\n plt.legend(['train', 'test'], loc='upper left')\n plt.savefig(path.join(model_path, 'accuracy.png'))\n plt.gcf().clear()\n # summarize history for loss\n plt.plot(history.history['loss'])\n plt.plot(history.history['val_loss'])\n plt.plot(aucs)\n plt.title('model loss, ROC AUC')\n plt.ylabel('loss, ROC AUC')\n plt.xlabel('epoch')\n plt.legend(['train', 'test', 'ROC AUC'], loc='upper left')\n plt.savefig(path.join(model_path, 'loss.png'))","def roc_auc(y_true, y_score, pos_label=..., ascending_score=...):\n ...","def gen_plot(fpr, tpr):\n plt.figure()\n plt.xlabel(\"FPR\", fontsize=14)\n plt.ylabel(\"TPR\", fontsize=14)\n plt.title(\"ROC Curve\", fontsize=14)\n plot = plt.plot(fpr, tpr, linewidth=2)\n buf = io.BytesIO()\n plt.savefig(buf, format='jpeg')\n buf.seek(0)\n plt.close()\n return buf","def draw_roc_curve(fpr, tpr, labels=None, size_inch=(5, 5), dpi=160, show=False, block=False):\n if not isinstance(fpr, np.ndarray) or not isinstance(tpr, np.ndarray):\n raise AssertionError(\"invalid inputs\")\n if fpr.shape != tpr.shape:\n raise AssertionError(\"mismatched input sizes\")\n if fpr.ndim == 1:\n fpr = np.expand_dims(fpr, 0)\n if tpr.ndim == 1:\n tpr = np.expand_dims(tpr, 0)\n if labels is not None:\n if isinstance(labels, str):\n labels = [labels]\n if len(labels) != fpr.shape[0]:\n raise AssertionError(\"should have one label per curve\")\n else:\n labels = [None] * fpr.shape[0]\n fig = plt.figure(num=\"roc\", figsize=size_inch, dpi=dpi, facecolor=\"w\", edgecolor=\"k\")\n fig.clf()\n ax = fig.add_subplot(1, 1, 1)\n import sklearn.metrics\n for idx, label in enumerate(labels):\n auc = sklearn.metrics.auc(fpr[idx, ...], tpr[idx, ...])\n if label is not None:\n ax.plot(fpr[idx, ...], tpr[idx, ...], \"b\", label=(\"%s [auc = %0.3f]\" % (label, auc)))\n else:\n ax.plot(fpr[idx, ...], tpr[idx, ...], \"b\", label=(\"auc = %0.3f\" % auc))\n ax.legend(loc=\"lower right\")\n ax.plot([0, 1], [0, 1], 'r--')\n ax.set_xlim(0, 1)\n ax.set_ylim(0, 1)\n ax.set_ylabel(\"True Positive Rate\")\n ax.set_xlabel(\"False Positive Rate\")\n fig.set_tight_layout(True)\n if show:\n fig.show()\n if block:\n plt.show(block=block)\n return fig\n plt.pause(0.5)\n return fig, ax","def gen_plot(fpr, tpr):\n plt.figure()\n plt.xlabel(\"FPR\", fontsize = 14)\n plt.ylabel(\"TPR\", fontsize = 14)\n plt.title(\"ROC Curve\", fontsize = 14)\n plot = plt.plot(fpr, tpr, linewidth = 2)\n buf = io.BytesIO()\n plt.savefig(buf, format = 'jpeg')\n buf.seek(0)\n plt.close()\n\n return buf","def gen_plot(fpr, tpr):\n plt.figure()\n plt.xlabel(\"FPR\", fontsize = 14)\n plt.ylabel(\"TPR\", fontsize = 14)\n plt.title(\"ROC Curve\", fontsize = 14)\n plot = plt.plot(fpr, tpr, linewidth = 2)\n buf = io.BytesIO()\n plt.savefig(buf, format = 'jpeg')\n buf.seek(0)\n plt.close()\n\n return buf","def calculate_roc_auc_score(model, evaluation_data, train_data, opt_data):\n return __calculate_classification_metrics(model, \"roc-auc\", evaluation_data, train_data, opt_data)","def roc(output, target):\r\n with torch.no_grad():\r\n\r\n scores = output[:,0]\r\n labels = target[:,0]\r\n fpr, tpr, _ = roc_curve(labels, scores)\r\n roc_auc = auc(fpr, tpr)\r\n\r\n return fpr, tpr, roc_auc","def get_ROC_AUC(data_input, label_input, pred, sess, labels, samples):\n\n # FUNCTION DOES NOT WORK PROPERLY, ROC AUC IS NOW ALWAYS 50%\n #TODO: fix ROC AUC\n\n # Get the predicted and the real labels\n pred, labels = sess.run([pred, label_input], feed_dict={data_input: samples, label_input: labels})\n\n # ROC AUC can not handle negative values, so they should be converted\n # The softmax function is used to get only positive values\n #TODO: this is where the bug is coming from\n sum_exp_pred = np.sum(np.exp(pred))\n pred = (np.exp(pred)) / sum_exp_pred\n\n # Get the ROC scores\n _, roc = tf.metrics.auc(labels=labels, predictions=pred)\n\n # Run the local variables to get the ROC AUC accuracy\n sess.run(tf.local_variables_initializer())\n\n # Run the session to obtain the accuracy\n roc_auc = sess.run(roc*100)\n\n return roc_auc","def plot_data(losses, accuracies, name):\n # convert accuracies to percentages\n accuracies['Train'] = [acc * 100 for acc in accuracies['Train']]\n accuracies['Valid'] = [acc * 100 for acc in accuracies['Valid']]\n # set fontsize\n plt.rcParams.update({'font.size': 13})\n fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(8,5))\n ax1.set_xlabel('Number of Epochs')\n ax1.set_ylabel('Cross Entropy Loss')\n ax1.set_ylim(0,2)\n ax1.plot(losses['Train'], label='Training')\n ax1.plot(losses['Valid'], label='Validation')\n ax1.legend(loc='upper right')\n\n ax2.set_xlabel('Number of Epochs')\n ax2.set_ylabel('Accuracy (%)')\n ax2.set_ylim(0,100)\n ax2.plot(accuracies['Train'], label='Training')\n ax2.plot(accuracies['Valid'], label='Validation')\n ax2.legend(loc='upper left')\n\n fig.tight_layout()\n fig.savefig('../outputs/' + name)","def plotPRC(yscore, true, datasets, title, outfile):\n \n fig = plt.figure()\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.0])\n plt.xlabel('Recall')\n plt.ylabel('Precision')\n plt.title(title)\n \n for i in range(len(datasets)):\n precision, recall, _ = precision_recall_curve(true[i], yscore[i][:,1])\n prc_auc = average_precision_score(true[i], yscore[i][:,1])\n plt.plot(recall, precision, label=datasets[i]+' (area = %0.2f)' % (prc_auc),linewidth=1)\n \n plt.legend(loc=\"lower right\")\n \n pdfplot = PdfPages(outfile);\n pdfplot.savefig(fig)\n pdfplot.close()","def eval(self):\n target_truth_labels = self.get_target_labels()\n for key in self.id_uncertainty_measures.keys():\n # deep copy needed as we mutate confidence values later on\n decision_fn_value = np.concatenate((copy.deepcopy(self.id_uncertainty_measures[key]),\n copy.deepcopy(self.ood_uncertainty_measures[key])),\n axis=0)\n # negation needed for confidence, as confidence is indicator of label=0 samples\n # i.e for correct classified samples.\n # But we need scores for label=1 samples i.e misclassified samples\n # to be higher, so we negate.\n if key == UncertaintyMeasuresEnum.CONFIDENCE or key == UncertaintyMeasuresEnum.PRECISION:\n decision_fn_value *= -1.0\n\n aupr, auroc = ClassifierPredictionEvaluator.compute_pr_roc_curves(\n decision_fn_value, target_truth_labels, self.result_dir, key._value_)\n\n with open(os.path.join(self.result_dir, 'results.txt'), 'a') as f:\n f.write('AUPR using ' + key._value_ + \": \" +\n str(np.round(aupr * 100.0, 1)) + '\\n')\n f.write('AUROC using ' + key._value_ + \": \" +\n str(np.round(auroc * 100.0, 1)) + '\\n')","def plot(self, ax=None, name=None, **kwargs):\n import matplotlib.pyplot as plt\n\n if ax is None:\n fig, ax = plt.subplots()\n\n name = self.estimator_name if name is None else name\n\n line_kwargs = {\n 'label': \"{} (AUC = {:0.2f})\".format(name, self.roc_auc), \n 'lw':0.25\n\n }\n line_kwargs.update(**kwargs)\n\n self.line_ = ax.plot(self.fpr, self.tpr, **line_kwargs)[0]\n ax.set_xlabel(\"False Positive Rate\")\n ax.set_ylabel(\"True Positive Rate\")\n ax.legend(loc='lower right')\n\n self.ax_ = ax\n self.figure_ = ax.figure\n return self","def test_model(model_name, save_dir, postive_file, negative_file, measure=\"SPC\", measure_threshold=0.95):\n print model_name\n postive_scores = get_model_scores(postive_file)\n negative_scores = get_model_scores(negative_file)\n all_scores = postive_scores+negative_scores\n # print all_scores\n\n if len(negative_scores) == 0:\n return {\"roc_auc\":0, \"threshold\":min(postive_scores)}\n\n y_true = [1]*len(postive_scores) + [0]*len(negative_scores)\n y_score = np.array(all_scores)\n\n fpr, tpr, thresholds = roc_curve(y_true, y_score)\n roc_auc = auc(fpr, tpr)\n\n best_threshold, thresholds, values = calcualte_threshold(\n postive_scores, \n negative_scores, \n measure=measure,\n measure_threshold=measure_threshold, \n thresholds=reversed(thresholds))\n\n\n pp = PdfPages(os.path.join(save_dir, \"{}_model_evaluation.pdf\".format(model_name)))\n\n sns.set(style=\"darkgrid\")\n f, axes = plt.subplots(3)\n trans = f.transFigure.inverted()\n colors = sns.color_palette(\"Set2\", 7)\n\n sns.kdeplot(np.array(postive_scores), shade=True, color=sns.xkcd_rgb[\"denim blue\"], label=\"Scores for postive examples\", ax=axes[0])\n sns.kdeplot(np.array(negative_scores), shade=True, color=sns.xkcd_rgb[\"pale red\"], label=\"Scores for negative examples\", ax=axes[0])\n axes[0].set_xlabel(\"Bit score\")\n axes[0].set_ylabel(\"Density\")\n axes[0].legend(loc=\"upper left\")\n #axes[0].set_title(\"Kernel Density of Scores\")\n axes[1].set_xlim([0, 1.0])\n axes[1].set_ylim([0.0, 1.05])\n\n \n axes[1].plot(fpr,tpr, color=colors[0], lw=3., label=\"ROC (AUC: {})\".format(roc_auc))\n axes[1].set_xlabel(\"False Positive Rate\")\n axes[1].set_ylabel(\"True Positive Rate\")\n axes[1].legend(loc=\"lower right\")\n axes[1].set_xlim([-0.05, 1.0])\n axes[1].set_ylim([0.0, 1.05])\n #axes[1].set_title(\"ROC\")\n \n for i, (measure, values) in enumerate(values.iteritems()):\n label = \"SPC: (>={})\".format(best_threshold) if measure==\"SPC\" else measure\n axes[2].plot(list(thresholds), values, label=label, linewidth=2, color=colors[i])\n axes[2].axvline(best_threshold)\n\n axes[2].legend()\n #axes[2].set_title(\"Coosing Cutoff\")\n axes[2].set_ylabel(\"Rate\")\n axes[2].set_xlabel(\"Threshold\")\n\n f.suptitle(\"{} Model Evaluation\".format(model_name), fontsize=20)\n\n pp.savefig()\n pp.close()\n\n return {\"roc_auc\":roc_auc, \"threshold\":best_threshold}","def plot_calibration_curve(classifier_name, pred_csv_file, fig_index):\n\n from sklearn.metrics import brier_score_loss, precision_score, recall_score, f1_score\n from sklearn.calibration import CalibratedClassifierCV, calibration_curve\n import matplotlib\n matplotlib.use('Agg')\n import matplotlib.pyplot as plt\n from sklearn.isotonic import isotonic_regression\n from sklearn.metrics import roc_auc_score, roc_curve, auc\n\n # # Calibrated with isotonic calibration\n # isotonic = CalibratedClassifierCV(base_estimator=None, cv=\"prefit\", method='isotonic')\n\n # # Calibrated with sigmoid calibration\n # sigmoid = CalibratedClassifierCV(base_estimator=None, cv=\"prefit\", method='sigmoid')\n\n # # Logistic regression with no calibration as baseline\n # lr = LogisticRegression(C=1., solver='lbfgs')\n\n fig = plt.figure(fig_index, figsize=(10, 10))\n ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2)\n ax2 = plt.subplot2grid((3, 1), (2, 0))\n\n ax1.plot([0, 1], [0, 1], \"k:\", label=\"Perfectly calibrated\")\n\n # for name in [classifier_name, classifier_name + ' + Isotonic', classifier_name + ' + Sigmoid']:\n for name in [classifier_name, classifier_name + ' + Sigmoid']:\n # for name in [classifier_name]:\n\n y_test, prob_pos, y_pred, _, _ = read_pred_csv_file_to_arrays(pred_csv_file)\n\n if name == classifier_name + ' + Sigmoid':\n a, b = sigmoid_calibration(prob_pos, y_test, sample_weight=None)\n prob_pos = predict_sigmoid(a, b, prob_pos)\n print a, b\n y_pred = binary_predict(prob_pos, threshold = 0.5)\n\n\n if name == classifier_name + ' + Isotonic' :\n prob_pos = isotonic_regression(prob_pos, sample_weight=None, y_min=None, y_max=None,\n increasing=True)\n y_pred = binary_predict(prob_pos, threshold = 0.5)\n\n\n # print prob_pos[:20]\n # # plot roc curve for test: class 1 only\n # fpr, tpr, _ = roc_curve(y_test, prob_pos)\n # lw = 2\n # plt.plot(fpr, tpr, color='darkorange',\n # lw=lw, label='ROC curve (area = %0.2f)' %(roc_auc_score(y_test, prob_pos, average='macro')))\n # plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n # plt.xlim([0.0, 1.0])\n # plt.ylim([0.0, 1.05])\n # plt.xlabel('False Positive Rate')\n # plt.ylabel('True Positive Rate')\n # plt.title('Receiver operating characteristic example')\n # plt.legend(loc=\"lower right\")\n # plt.savefig('plots/roc_%s.png'%(name))\n # plt.clf()\n\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=1)\n print(\"%s:\" % name)\n print(\"\\tBrier: %1.3f\" % (clf_score))\n print(\"\\tPrecision: %1.3f\" % precision_score(y_test, y_pred))\n print(\"\\tRecall: %1.3f\" % recall_score(y_test, y_pred))\n print(\"\\tF1: %1.3f\" % f1_score(y_test, y_pred))\n print(\"\\tROC: %1.3f\\n\" % roc_auc_score(y_test, prob_pos, average='macro'))\n\n fraction_of_positives, mean_predicted_value = \\\n calibration_curve(y_test, prob_pos, n_bins=10)\n\n ax1.plot(mean_predicted_value, fraction_of_positives, \"s-\",\n label=\"%s (%1.3f)\" % (name, clf_score))\n\n ax2.hist(prob_pos, range=(0, 1), bins=10, label=name,\n histtype=\"step\", lw=2)\n\n ax1.set_ylabel(\"Fraction of positives\")\n ax1.set_ylim([-0.05, 1.05])\n ax1.legend(loc=\"lower right\")\n ax1.set_title('Calibration plots (reliability curve)')\n\n ax2.set_xlabel(\"Mean predicted value\")\n ax2.set_ylabel(\"Count\")\n ax2.legend(loc=\"upper center\", ncol=2)\n\n plt.tight_layout()\n plt.savefig('plots/calibration.png')\n plt.clf()","def finetune_learningrate(savefigure=False):\n res = np.array(np.load('npy-data/result_learningrate_tuning_acc_auc_crossval_train.npy'))\n acc, auc = res[:int(len(res)/2)], res[int(len(res)/2):]\n plt.plot([j*0.005 for j in range(1,31)],acc,[j*0.005 for j in range(1,31)],auc)\n plt.xlabel('Learning rate')\n plt.ylabel('Accuracy/AUC score')\n plt.legend([\"Accuracy\",\"ROC AUC\"])\n if savefigure:\n plt.savefig('img/xgb_accuracy_learningrate_tuning_acc_auc_crossval.pdf', bbox_inches='tight')\n plt.show()","def auto_evaluation(model,x_train,y_train,x_test,y_test):\n\n y_train_prediction=model.predict(x_train)\n y_test_prediction=model.predict(x_test)\n\n plt.scatter(y_train,y_train_prediction,c=\"b\",s=1,alpha=0.5)\n plt.scatter(y_test,y_test_prediction,c=\"r\",s=2,alpha=0.5)\n plt.xlabel(\"actual\")\n plt.ylabel(\"predicted\")\n\n print(\"tr R2: {:.2f}\".format(r2_score(y_train_prediction,y_train)))\n print(\"te R2: {:.2f}\".format(r2_score(y_test_prediction,y_test))) \n \n return y_train_prediction,y_test_prediction","def plot_roc_curve(ht, scores, tp_label='tp', fp_label='fp', colors=None, title='ROC Curve', hover_mode='mouse'):\n if colors is None:\n # Get a palette automatically\n from bokeh.palettes import d3\n palette = d3['Category10'][max(3, len(scores))]\n colors = {score: palette[i] for i, score in enumerate(scores)}\n\n if isinstance(scores, str):\n scores = [scores]\n total_tp, total_fp = ht.aggregate((hl.agg.count_where(ht[tp_label]), hl.agg.count_where(ht[fp_label])))\n\n p = figure(title=title, x_axis_label='FPR', y_axis_label='TPR', tools=\"hover,save,pan,box_zoom,reset,wheel_zoom\")\n p.add_layout(Title(text=f'Based on {total_tp} TPs and {total_fp} FPs'), 'above')\n\n aucs = []\n for score in scores:\n ordered_ht = ht.key_by(_score=-ht[score])\n ordered_ht = ordered_ht.select(\n score_name=score, score=ordered_ht[score],\n tpr=hl.scan.count_where(ordered_ht[tp_label]) / total_tp,\n fpr=hl.scan.count_where(ordered_ht[fp_label]) / total_fp,\n ).key_by().drop('_score')\n last_row = hl.utils.range_table(1).key_by().select(score_name=score, score=hl.float64(float('-inf')), tpr=hl.float64(1.0), fpr=hl.float64(1.0))\n ordered_ht = ordered_ht.union(last_row)\n ordered_ht = ordered_ht.annotate(\n auc_contrib=hl.or_else((ordered_ht.fpr - hl.scan.max(ordered_ht.fpr)) * ordered_ht.tpr, 0.0)\n )\n auc = ordered_ht.aggregate(hl.agg.sum(ordered_ht.auc_contrib))\n aucs.append(auc)\n df = ordered_ht.annotate(score_name=ordered_ht.score_name + f' (AUC = {auc:.4f})').to_pandas()\n p.line(x='fpr', y='tpr', legend_field='score_name', source=ColumnDataSource(df), color=colors[score], line_width=3)\n\n p.legend.location = 'bottom_right'\n p.legend.click_policy = 'hide'\n p.select_one(HoverTool).tooltips = [(x, f\"@{x}\") for x in ('score_name', 'score', 'tpr', 'fpr')]\n p.select_one(HoverTool).mode = hover_mode\n return p, aucs","def write_result(self, file_path):\n f = open(file_path, \"a\")\n f.write(\"{}\\t{}\\n\".format(*[self.name, str(self.ROC_AUC_value)]))\n f.close()","def plot_acc(model_dir):\n ## extract loss from csv\n file_dir = os.path.join(model_dir, 'acc.csv')\n data = pd.read_csv(file_dir)\n epochs = data['epoch'].ravel()\n acc_train = data['acc_train'].ravel()\n acc_test = data['acc_test'].ravel()\n # epoch,acc_train,acc_test\n\n ## Theoretical Loss\n fig, ax = plt.subplots(1, 1, figsize=(7, 5), sharey=True, sharex=True, dpi=400)\n ax.plot(epochs, acc_train, label='train', color='green', alpha=0.8)\n ax.plot(epochs, acc_test, label='test', color='red', alpha=0.8)\n ax.set_ylabel('Accuracy', fontsize=10)\n ax.set_xlabel('Epoch', fontsize=10)\n ax.legend(loc='lower right', prop={\"size\": 15}, ncol=3, framealpha=0.5)\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n plt.tight_layout()\n\n ## create saving directory\n acc_dir = os.path.join(model_dir, 'figures', 'acc')\n os.makedirs(acc_dir, exist_ok=True)\n file_name = os.path.join(acc_dir, 'accuracy.png')\n plt.savefig(file_name, dpi=400)\n print(\"Plot saved to: {}\".format(file_name))\n file_name = os.path.join(acc_dir, 'accuracy.pdf')\n plt.savefig(file_name, dpi=400)\n plt.close()\n print(\"Plot saved to: {}\".format(file_name))","def auc(self,predictions,labels):\n\n # sort the array by predictions in descending order in case it has not been done\n order = np.flipud(predictions.argsort())\n labels = labels[order]\n\n # clean labels, calculate the number of positive labels\n labeled_true = (np.asarray(labels,dtype=bool) == True)\n num_positives = np.sum(labeled_true)\n num_predictions = len(labeled_true)\n\n # If no positive result return nan\n if num_positives == 0:\n return float('nan')\n\n # slide from top to the bottom;\n # each time slide the threshold so as to predict one more label as positive\n roc_curve = np.array([0.0,0.0])\n TP_above_threshold = 0\n for predict_as_positive in range(num_predictions):\n if labeled_true[predict_as_positive] == True:\n TP_above_threshold +=1\n # calculate True Positives Rate\n # TPR = TP / num_real_positives\n TPR = TP_above_threshold / float(num_positives)\n \n # FPR = FP / num_real_negatives\n FPR = (predict_as_positive +1 - TP_above_threshold) / (num_predictions - float(num_positives))\n \n roc_curve = np.vstack((roc_curve,[FPR,TPR]))\n\n roc_curve = np.vstack((roc_curve,[1.0,1.0]))\n\n \n # reduce into TP and FP rate, integrate with trapezoid to calculate AUC\n auc = np.trapz(roc_curve[:,1], x=roc_curve[:,0])\n\n\n return auc","def cross_validation_visualization_accuracy(epochs, accs, save=False, filename=\"cross_validation_acc\"):\n plt.plot(epochs, accs, marker=\".\", color='r', label='accuracy')\n plt.xlabel(\"epoch\")\n plt.ylabel(\"accuracy\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n if (save):\n plt.savefig(filename)","def reg_auroc(y_true, y_pred, th=0.5):\n y_true = np.where(y_true < th, 1, 0)\n y_score = np.where(y_pred < th, 1, 0)\n reg_auroc_score = sklearn.metrics.roc_auc_score(y_true, y_score)\n return reg_auroc_score"],"string":"[\n \"def plot_roc(X,y,test_preds,fname=\\\"res/roc.png\\\"):\\n\\t#Retrieve multiple fpr and tpr values for different thresholds\\n\\tfpr, tpr, thresholds = roc_curve(y,test_preds)\\n\\tplt.plot(fpr, tpr)\\n\\tplt.title(auc(fpr, tpr))\\n\\tplt.savefig(fname, bbox_inches='tight')\\n\\tplt.close()\",\n \"def plot_roc_acc(self,x_test,y_test):\\n if self.validated:\\n preds = self.model_cv.predict_proba(x_test[self.feats])\\n fpr, tpr, thresholds = metrics.roc_curve(y_test, preds[:,1])\\n auc = metrics.roc_auc_score(y_test, preds[:,1])\\n\\n # get accuracy of class0 and class1 predictions at different thresholds\\n acc_0 = []\\n acc_1 = []\\n for ind,th in enumerate(thresholds):\\n binary_preds = pred_from_prob(preds,th)\\n acc_1.append(accuracy_score(y_test[np.where(y_test==1)],binary_preds[np.where(y_test==1)]))\\n acc_0.append(accuracy_score(y_test[np.where(y_test==0)],binary_preds[np.where(y_test==0)]))\\n\\n # set up plotting parameters\\n sns.set()\\n mpl.rcParams['figure.figsize']=[15.0,5.0]\\n mpl.rcParams['lines.linewidth']=2.0\\n mpl.rcParams['xtick.labelsize']=13\\n mpl.rcParams['ytick.labelsize']=13\\n mpl.rcParams['axes.labelsize']=15\\n mpl.rcParams['axes.labelweight']='heavy'\\n mpl.rcParams['axes.titlesize']=18\\n mpl.rcParams['axes.titleweight']='heavy'\\n mpl.rcParams['legend.fontsize']=12\\n\\n # build the plots- ROC in subplot 1, accuracy in subplot 2\\n plt.subplot(1,2,1)\\n plt.plot(fpr,tpr,'r*', label='roc auc={:.4f}'.format(auc))\\n plt.plot(np.linspace(0,1,20),np.linspace(0,1,20),'k--')\\n plt.xlabel('FPR')\\n plt.ylabel('TPR')\\n plt.title('ROC')\\n plt.legend(frameon=False)\\n plt.xlim([0.0,1.0])\\n plt.ylim([0.0,1.0])\\n\\n plt.subplot(1,2,2)\\n plt.plot(thresholds,acc_0,'go--',label='cases: 0',alpha=0.3)\\n plt.plot(thresholds,acc_1,'yo--',label='cases: 1')\\n plt.plot(thresholds[::5],fpr[::5],'c*',alpha=0.2,label='fpr')\\n\\n plt.xlim([0,1])\\n plt.xlim([0,1])\\n\\n plt.xlabel('threshold')\\n plt.ylabel('accuracy')\\n plt.title('accuracy')\\n\\n plt.legend(frameon=False)\\n\\n plt.show()\\n return None\\n else:\\n raise err.NotYetFittedModelError('You should train the model with method train_CV first \\\\n')\",\n \"def plot_final_roc(prediction_matrix, model_names, y_test, PATH = None):\\n plt.figure(figsize=(10, 8))\\n for i, model in enumerate(model_names): \\n predictions = prediction_matrix[:,i]\\n fpr, tpr, threshholds = roc_curve(y_test, predictions)\\n sns.set_style('darkgrid', {'axes.facecolor': '0.9'})\\n lw = 2\\n plt.plot(fpr, tpr,\\n lw=lw, label=f'{model_names[i]} AUC: {round(auc(fpr, tpr), 3)}')\\n plt.plot([0, 1], [0, 1], lw=lw, linestyle='--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.yticks([i/20.0 for i in range(21)], size = 14)\\n plt.xticks([i/20.0 for i in range(21)], rotation = 45, size = 14)\\n plt.xlabel('False Positive Rate', size =16)\\n plt.ylabel('True Positive Rate', size =16)\\n plt.title('ROC Curve', size = 20)\\n plt.legend(loc='lower right', prop = {\\\"size\\\" : 20})\\n if PATH:\\n plt.savefig(PATH, bbox_inches='tight', transparent = True)\\n plt.show()\",\n \"def Classification_ROC_Report(X,Y,model): \\n \\n # Plot Classification report, Confustion Matrix, ROC\\n labels = {0: 'CNV', 1: 'DME', 2: 'DRUSEN', 3: 'NORMAL'}\\n\\n # get predictions on the test set\\n y_hat = model.predict(X)\\n #\\n Y_pred_classes = np.argmax(y_hat,axis = 1) \\n Y_true = np.argmax(Y,axis = 1)\\n\\n # Classification report\\n ax=plt.figure(figsize=(15,5))\\n ax = plt.subplot(1,3,1)\\n rpt = sklearn.metrics.classification_report(np.argmax(Y, axis=1), np.argmax(y_hat, axis=1), target_names=list(labels.values()))\\n ax.axis('off')\\n ax.annotate(rpt, \\n xy = (1.0,0.5), \\n xytext = (0, 0), \\n xycoords='axes fraction', textcoords='offset points',\\n fontsize=13, ha='right', va='center') \\n\\n # Plot confusion matrix\\n cm_df = Confusion_Matrix(Y,y_hat,labels,normalization=True)\\n ax = plt.subplot(1,3,2)\\n sns.heatmap(cm_df, annot=True)\\n score = model.evaluate(X, Y, verbose=1)\\n ax.set_title('Confusion Matrix\\\\nresult: {0:.2f} - loss: {0:.2f}'.format(score[1], score[0]))\\n ax.set_ylabel('True label')\\n ax.set_xlabel('Predicted label')\\n\\n # Plot ROC\\n lw=2\\n n_classes = 4\\n fpr, tpr, roc_auc = ROC(Y,y_hat,n_classes)\\n\\n # Plot all ROC curves\\n ax = plt.subplot(1,3,3)\\n ax.plot(fpr[\\\"micro\\\"], tpr[\\\"micro\\\"],\\n label='micro-average ROC curve (area = {0:0.2f})'\\n ''.format(roc_auc[\\\"micro\\\"]),\\n color='deeppink', linestyle=':', linewidth=4)\\n\\n ax.plot(fpr[\\\"macro\\\"], tpr[\\\"macro\\\"],\\n label='macro-average ROC curve (area = {0:0.2f})'\\n ''.format(roc_auc[\\\"macro\\\"]),\\n color='navy', linestyle=':', linewidth=4)\\n\\n colors = cycle(['aqua', 'darkorange', 'cornflowerblue', '#4DBD33'])\\n for i, color in zip(range(n_classes), colors):\\n ax.plot(fpr[i], tpr[i], color=color, lw=lw,\\n label='ROC curve of class {0} (area = {1:0.2f})'\\n ''.format(labels[i], roc_auc[i]))\\n\\n ax.plot([0, 1], [0, 1], 'k--', lw=lw)\\n ax.set_xlim([0.0, 1.0])\\n ax.set_ylim([0.0, 1.05])\\n ax.set_xlabel('False Positive Rate')\\n ax.set_ylabel('True Positive Rate')\\n ax.set_title('ROC')\\n ax.legend(loc=\\\"lower right\\\")\\n\\n plt.tight_layout()\\n plt.show()\\n\\n return\",\n \"def plot_roc(self, out_tag):\\n roc_fig = self.plotter.plot_roc(self.y_train, self.y_pred_train, self.train_weights, \\n self.y_test, self.y_pred_test, self.test_weights, out_tag=out_tag\\n )\\n\\n Utils.check_dir('{}/plotting/plots/{}'.format(os.getcwd(), out_tag))\\n roc_fig.savefig('{0}/plotting/plots/{1}/{1}_ROC_curve.pdf'.format(os.getcwd(),out_tag))\\n print('saving: {0}/plotting/plots/{1}/{1}_ROC_curve.pdf'.format(os.getcwd(),out_tag))\\n plt.close()\\n\\n #for MVA ROC comparisons later on\\n np.savez(\\\"{}/models/{}_ROC_comp_arrays\\\".format(os.getcwd(), out_tag), self.y_pred_test, self.y_pred_test, self.test_weights)\",\n \"def roc_plot(label, fpr, tpr, roc_auc):\\n plt.figure()\\n for i in range(len(label)):\\n plt.plot(fpr[i], tpr[i], label=label[i] + ' AUC = %0.2f' % roc_auc[i], alpha=0.75)\\n plt.plot([0, 1], [0, 1], 'r--')\\n plt.xlim([-0.01, 1.01])\\n plt.ylim([-0.01, 1.01])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('ROC Curve')\\n plt.legend(loc='lower right')\\n plt.show()\",\n \"def plot_ROC(y, prediction_prob, cnames, dataset_name, fname):\\r\\n plt.figure(figsize=(20, 10))\\r\\n for i in range(len(cnames)):\\r\\n fpr, tpr, _ = roc_curve(y, prediction_prob[i][:,1])\\r\\n auc = roc_auc_score(y, prediction_prob[i][:,1])\\r\\n plt.plot(fpr, tpr, label='%s (AUC = %.2f)'%(cnames[i], auc))\\r\\n plt.plot([0, 1], [0, 1], 'k--', lw=2)\\r\\n plt.xlim([0.0, 1.0])\\r\\n plt.ylim([0.0, 1.05])\\r\\n plt.xlabel('False Positive Rate')\\r\\n plt.ylabel('True Positive Rate')\\r\\n plt.title('ROC Curve - Binary Classification - %s'%(dataset_name))\\r\\n plt.legend(loc=\\\"lower right\\\")\\r\\n plt.savefig(fname, bbox_inches='tight')\\r\\n plt.close()\",\n \"def plot_ROC():\\r\\n fpr = dict()\\r\\n tpr = dict()\\r\\n roc_auc = dict()\\r\\n threshold = dict()\\r\\n \\r\\n for i in range(n_classes):\\r\\n \\r\\n fpr[i], tpr[i], threshold[i] = roc_curve(y_test[:, i], y_pred[:, i])\\r\\n \\r\\n roc_auc[i] = auc(fpr[i], tpr[i])\\r\\n\\r\\n fig = plt.figure()\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n ax.set_aspect('equal')\\r\\n colors = cycle(['aqua', 'red', 'purple', 'royalblue', 'black'])\\r\\n \\r\\n for i, color in zip(range(n_classes), colors):\\r\\n \\r\\n plt.plot(\\r\\n fpr[i],\\r\\n tpr[i],\\r\\n color=color,\\r\\n linewidth=3,\\r\\n #label='Class {0} (AUC {1:0.3f})'\\r\\n label='AUC {1:0.2f}' \\r\\n ''.format(i+1, roc_auc[i])\\r\\n )\\r\\n\\r\\n #plt.plot([0, 1], [0, 1], 'k--', linewidth=3)\\r\\n plt.xlim([-0.03, 1])\\r\\n plt.ylim([0, 1.03])\\r\\n ax.axhline(y=0, color='k', linewidth=4)\\r\\n ax.axhline(y=1.03, color='k', linewidth=4)\\r\\n ax.axvline(x=-0.03, color='k', linewidth=4)\\r\\n ax.axvline(x=1, color='k', linewidth=4) \\r\\n plt.xticks([0, 0.2, 0.4, 0.6, 0.8, 1.0], fontsize=16, fontweight='bold')\\r\\n plt.yticks([0, 0.2, 0.4, 0.6, 0.8, 1.0], fontsize=16, fontweight='bold')\\r\\n #plt.xlabel('False Positive Rate', fontweight='bold', fontsize=16)\\r\\n #plt.ylabel('True Positive Rate', fontweight='bold', fontsize=16)\\r\\n plt.legend(loc='lower right', prop={'size': 14, 'weight': 'bold'}) \\r\\n plt.grid(True)\\r\\n\\r\\n ROC_filename = 'ROC' + '_' + \\\\\\r\\n str(DNN_Model) + '_' + \\\\\\r\\n strftime(\\\"%d-%b-%Y-%H-%M-%S\\\", gmtime()) + '.png'\\r\\n \\r\\n plt.savefig(\\r\\n os.path.join(result_dir, ROC_filename),\\r\\n format='png',\\r\\n dpi=600\\r\\n )\\r\\n\\r\\n plt.show()\\r\\n plt.close()\",\n \"def plot_roc(model, X_test, Y_test, verbose=False):\\n\\n y_true, y_pred = Y_test, model.predict(X_test)\\n if verbose:\\n print(\\\"CLASSIFICATION REPORT\\\")\\n print(classification_report(y_true, y_pred))\\n\\n y_pred_prob = model.predict_proba(X_test)[:,1]\\n\\n fpr, tpr, _ = roc_curve(Y_test, y_pred_prob)\\n\\n if verbose:\\n print(\\\"TESTING PROBABILITIES:\\\")\\n for a,b in zip(Y_test,y_pred_prob):\\n print(a,b)\\n \\n if verbose:\\n print(\\\"ROC RAW DATA:\\\")\\n for a,b in zip(fpr, tpr):\\n print(a,b)\",\n \"def plot_ROC_curve(model, X_train, X_test, y_train, y_test):\\n \\n # Model Metrics\\n print model\\n print \\\"*************************** Model Metrics *********************************\\\"\\n print 'Accuracy: %s' % cross_val_score(model, X_train, y_train, scoring = 'accuracy', cv = 5).mean()\\n print 'Precision: %s' % cross_val_score(model, X_train, y_train, scoring = 'precision', cv = 5).mean()\\n print 'Recall: %s' % cross_val_score(model, X_train, y_train, scoring = 'recall_weighted', cv = 5).mean()\\n print 'F1: %s' % cross_val_score(model, X_train, y_train, scoring = 'f1', cv = 5).mean()\\n\\n fitted = model.fit(X_train, y_train)\\n try:\\n y_score = fitted.predict_proba(X_test)[:,1]\\n except:\\n y_score = fitted.decision_function(X_test)\\n \\n # Confusion matrix\\n print \\\"********************* Normalized Confusion Matrix *************************\\\"\\n cm = confusion_matrix(y_test, fitted.predict(X_test))\\n cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\\n \\n print('Normalized confusion matrix')\\n print(cm_normalized)\\n plt.matshow(cm, cmap=plt.cm.Blues)\\n plt.colorbar()\\n plt.xlabel('Predicted Values')\\n plt.ylabel('Actual Values')\\n \\n # Classification Report\\n print \\\"********************* Classification Report********************************\\\" \\n print classification_report(y_test, fitted.predict(X_test))\\n \\n print \\\"********************* ROC Curve *******************************************\\\"\\n \\n # ROC Curve\\n fpr, tpr, _ = roc_curve(y_test, y_score)\\n roc_auc = auc(fpr, tpr)\\n \\n plt.figure()\\n plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc)\\n plt.plot([0, 1], [0, 1], 'k--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('Receiver operating characteristic')\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\",\n \"def AUC_ROC(true_vessel_arr, pred_vessel_arr):\\n fpr, tpr, _ = roc_curve(true_vessel_arr.flatten(), pred_vessel_arr.flatten())\\n \\n AUC_ROC=roc_auc_score(true_vessel_arr.flatten(), pred_vessel_arr.flatten())\\n print(\\\"AUC_ROC:\\\",AUC_ROC)\\n\\n plt.title('Receiver Operating Characteristic')\\n plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' )\\n plt.legend(loc = 'lower right')\\n plt.plot([0, 1], [0, 1],'b--')\\n plt.xlim([0, 1])\\n plt.ylim([0, 1])\\n plt.ylabel('True Positive Rate')\\n plt.xlabel('False Positive Rate')\\n plt.show()\",\n \"def plotROC(attr, target, pred, save_as=None):\\n fig, ax = plt.subplots()\\n auc = metrics.roc_auc_score(target, pred)\\n acc = metrics.accuracy_score(target, (pred >= 0.5).astype(int))\\n fpr, tpr, _ = metrics.roc_curve(target, pred)\\n plt.plot(fpr, tpr, lw = 2, label = attr.title())\\n plt.legend(loc = 4, fontsize = 15)\\n plt.title(('ROC Curve for {attr} (Accuracy = {acc:.3f}, AUC = {auc:.3f})'\\n .format(attr = attr.title(), acc= acc, auc = auc)),\\n fontsize = 15)\\n plt.xlabel('False Positive Rate', fontsize = 15)\\n plt.ylabel('True Positive Rate', fontsize = 15)\\n if not save_as is None:\\n plt.savefig(save_as)\\n else:\\n plt.show()\",\n \"def do_roc(scores, true_labels, file_name='', directory='', plot=True):\\n\\n # fpr_0, tpr_0, _ = roc_curve(true_labels, scores[0])\\n # roc_auc_0 = auc(fpr_0, tpr_0)\\n # fpr_1, tpr_1, _ = roc_curve(true_labels, scores[1])\\n # roc_auc_1 = auc(fpr_1, tpr_1)\\n # fpr_2, tpr_2, _ = roc_curve(true_labels, scores[2])\\n # roc_auc_2 = auc(fpr_2, tpr_2)\\n # fpr_3, tpr_3, _ = roc_curve(true_labels, scores[3])\\n # roc_auc_3 = auc(fpr_3, tpr_3)\\n # fpr_4, tpr_4, _ = roc_curve(true_labels, scores[4])\\n # roc_auc_4 = auc(fpr_4, tpr_4)\\n # fpr_5, tpr_5, _ = roc_curve(true_labels, scores[5])\\n # roc_auc_5 = auc(fpr_5, tpr_5)\\n\\n fpr, tpr, _ = roc_curve(true_labels, scores)\\n roc_auc = auc(fpr, tpr) # compute area under the curve\\n\\n plt.figure(figsize=(10,10))\\n plt.rcParams.update({'font.size': 50})\\n # plt.plot(fpr_0, tpr_0, label='ROC curve (area = %0.3f)' % (roc_auc_0))\\n # plt.plot(fpr_1, tpr_1, label='ROC curve (area = %0.3f)' % (roc_auc_1))\\n # plt.plot(fpr_2, tpr_2, label='ROC curve (area = %0.3f)' % (roc_auc_2))\\n # plt.plot(fpr_3, tpr_3, label='ROC curve (area = %0.3f)' % (roc_auc_3))\\n # plt.plot(fpr_4, tpr_4, label='ROC curve (area = %0.3f)' % (roc_auc_4))\\n plt.plot(fpr, tpr, color='lightblue',label='area = %0.3f' % (roc_auc))\\n\\n plt.plot([0, 1], [0, 1], 'k--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n# plt.title('Receiver operating characteristic')\\n plt.legend(loc=\\\"lower right\\\")\\n\\n plt.savefig(directory + file_name + 'roc.eps', bbox_inches='tight', format='eps')\\n plt.close()\\n\\n # return roc_auc\",\n \"def plotROC(yscore, true, predtrue, datasets, title, outfile):\\n fig = plt.figure()\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.0])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title(title)\\n \\n for i in range(len(datasets)):\\n acc = accuracy_score(true[i], predtrue[i])\\n fpr, tpr, _ = roc_curve(true[i], yscore[i][:,1])\\n roc_auc = auc(fpr, tpr)\\n plt.plot(fpr, tpr, label=datasets[i]+' (area = %0.2f, acc = %0.2f)' % (roc_auc,acc),linewidth=2)\\n \\n plt.legend(loc=\\\"lower right\\\")\\n \\n pdfplot = PdfPages(outfile);\\n pdfplot.savefig(fig)\\n pdfplot.close()\",\n \"def auroc_helper(labels, preds):\\r\\n fpr, tpr, threshold = metrics.roc_curve(labels, preds)\\r\\n df = pd.DataFrame({'fpr': fpr,\\r\\n 'tpr': tpr,\\r\\n 'threshold': threshold})\\r\\n # uncomment for the best model to save\\r\\n # df.to_csv('/home/delvinso/nephro/output/all_custom_thresholds.csv', index = False)\\r\\n epoch_auc = metrics.auc(fpr, tpr)\\r\\n print('AUC: {}'.format(epoch_auc))\\r\\n\\r\\n # https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html\\r\\n f = plt.figure()\\r\\n lw = 2\\r\\n plt.plot(fpr, tpr, color='darkred',\\r\\n lw=lw, label='ROC curve (area = %0.3f)' % epoch_auc)\\r\\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\\r\\n plt.xlim([0.0, 1.0])\\r\\n plt.ylim([0.0, 1.05])\\r\\n plt.xlabel('1 - Specificity (FPR)')\\r\\n plt.ylabel('Sensitivity (TPR)')\\r\\n plt.title('ROC - Bladder vs Other')\\r\\n plt.legend(loc=\\\"lower right\\\")\\r\\n return f\",\n \"def roc_writer(clf, y_true, y_prob, eval_folder, i=''):\\n # make sure that y_true, y_prob are iterable\\n if type(y_true[0]) is not np.ndarray: y_true = [y_true]\\n if type(y_prob[0]) is not np.ndarray: y_prob = [y_prob]\\n\\n # make an image folder if you have to\\n img_dir = eval_folder+'/images/'\\n if not os.path.exists(img_dir):\\n os.makedirs(img_dir)\\n\\n # get the classifier family name i.e., LogisticRegression\\n clf_name = str(clf)[:str(clf).index('(')]+str(i)\\n\\n enum_list = range(0, len(y_true))\\n roc_auc = []\\n\\n mean_tpr = 0.0\\n mean_fpr = np.linspace(0,1,1000)\\n\\n # plot each fold's ROC curve, calculate mean ROC curve\\n for i in enum_list:\\n fpr, tpr, _ = metrics.roc_curve(y_true[i], y_prob[i])\\n mean_tpr += interp(mean_fpr, fpr, tpr) \\n mean_tpr[0] = 0.0\\n roc_auc.append(metrics.roc_auc_score(y_true[i], y_prob[i]))\\n plt.plot(fpr, tpr)\\n\\n mean_tpr /= len(y_true)\\n mean_tpr[-1] = 1.0\\n\\n # make plot, plot mean ROC curve\\n plt.title('Receiver Operating Characteristic')\\n plt.plot(mean_fpr, mean_tpr, 'k--', label='Mean AUC = %0.2f\\\\nSE AUC = %0.3f'% (np.mean(roc_auc), np.std(roc_auc)))\\n plt.legend(loc='lower right')\\n plt.plot([0,1],[0,1],'r--')\\n plt.xlim([0,1.0])\\n plt.ylim([0,1.0])\\n plt.ylabel('True Positive Rate')\\n plt.xlabel('False Positive Rate')\\n\\n plt.savefig(img_dir+'ROC_Curve_'+clf_name+'.png')\",\n \"def draw_roc(signal, background, output_dir=\\\".\\\", output_name=\\\"roc\\\", form=\\\".pdf\\\"):\\n\\n x, y = get_roc(signal, background)\\n file_path = output_dir + \\\"/\\\"+ output_name + \\\"_X.cvs\\\"\\n numpy.savetxt(file_path, x, delimiter=\\\",\\\")\\n file_path = output_dir + \\\"/\\\"+ output_name + \\\"_Y.cvs\\\"\\n numpy.savetxt(file_path, y, delimiter=\\\",\\\")\\n output_name = output_name + form\\n\\n auc = metrics.auc(x, y, reorder=True)\\n\\n fig = plt.figure(1, figsize=(7, 7), dpi=300)\\n fig.clear()\\n\\n # Create an axes instance\\n ax = fig.add_subplot(111)\\n\\n ax.plot(x, y, '-', color='#B64926', lw=2, label=\\\"AUC: %.4f\\\" % auc)\\n ax.margins(0.05)\\n\\n ax.set_xlabel(\\\"Background efficiency\\\")\\n ax.set_ylabel(\\\"Signal efficiency\\\")\\n \\n fig.set_tight_layout(True)\\n\\n ax.legend(loc='lower right', numpoints=1, frameon=False)\\n\\n print(\\\"AUC: %.4f\\\" % auc)\\n\\n fig.savefig(os.path.join(output_dir, output_name))\\n\\n plt.close()\\n\\n def get_index(y, value):\\n \\\"\\\"\\\"\\n Find the last index of the element in y\\n satistying y[index] <= value\\n \\\"\\\"\\\"\\n\\n for i in range(len(y)):\\n if y[i] <= value:\\n continue\\n\\n return i\\n\\n print(\\\"Background efficiency for signal efficiency of 0.70: %f\\\" % x[get_index(y, 0.70)])\\n print(\\\"Background efficiency for signal efficiency of 0.80: %f\\\" % x[get_index(y, 0.80)])\\n print(\\\"Background efficiency for signal efficiency of 0.90: %f\\\" % x[get_index(y, 0.90)])\",\n \"def compute_and_plot_ic_AUCROC(y_true, y_score, ic_name,\\n filename, title='AUC/ROC Curve'):\\n print(' Computing {} AUC score / ROC curve...'.format(ic_name))\\n start = time()\\n\\n # calculate AUC\\n auc = roc_auc_score(y_true, y_score)\\n print(' AUC: %.3f' % auc)\\n # calculate roc curve\\n fpr, tpr, _ = roc_curve(y_true, y_score)\\n print(' ROC curve size: {}'.format(len(fpr)))\\n if len(fpr) > 10000: # Sample when curve has *a lot* of data-points\\n # Take every other 50th data-point. Reduce size by factor 50.0\\n fpr = fpr[0:len(fpr):50]\\n tpr = tpr[0:len(tpr):50]\\n\\n print(' → sampled roc curve to {} data-points'.format(len(fpr)))\\n\\n end = time()\\n print(' Computed in {}'.format(timedelta(seconds=end - start)))\\n\\n # plot no skill\\n plt.plot([0, 1], [0, 1], linestyle='--')\\n # plot the roc curve for the model\\n plt.plot(fpr, tpr, marker='.')\\n plt.title(title)\\n plt.xlabel('AUC score: {:.3f}'.format(auc))\\n\\n # Save\\n plt.savefig(join(VISUALS_FOLDERPATH, '{}-aucroc.svg'\\n .format(filename)))\\n plt.clf()\",\n \"def roc(test_set_y_org,test_set_y_pred_prob,classes_unique,plot_curve=False,filename=\\\"./fig_roc.pdf\\\",colors=None,positive_class_for_two_classes=None,figwidth=5,figheight=5):\\n from sklearn.metrics import roc_curve\\n #from sklearn.metrics import auc\\n from sklearn.metrics import roc_auc_score\\n from scipy import interp\\n import matplotlib as mpl\\n mpl.use(\\\"pdf\\\")\\n import matplotlib.pyplot as plt\\n \\n fpr = dict()\\n tpr = dict()\\n roc_auc = dict()\\n n_classes=len(classes_unique)\\n test_set_Y_org,test_set_y_org_unique=membership_vector_to_indicator_matrix(test_set_y_org)\\n \\n for c in range(n_classes):\\n fpr[c], tpr[c], _ = roc_curve(test_set_Y_org[:, c], test_set_y_pred_prob[:, c])\\n roc_auc[c] = roc_auc_score(test_set_Y_org[:, c], test_set_y_pred_prob[:, c])\\n \\n # Compute macro-average ROC curve and AUROC area\\n # First aggregate all false positive rates\\n all_fpr = np.unique(np.concatenate([fpr[c] for c in range(n_classes)]))\\n # Then interpolate all ROC curves at this points\\n mean_tpr = np.zeros_like(all_fpr)\\n for c in range(n_classes):\\n mean_tpr += interp(all_fpr, fpr[c], tpr[c])\\n # Finally average it and compute AUC\\n mean_tpr /= n_classes\\n fpr[\\\"macro\\\"] = all_fpr\\n tpr[\\\"macro\\\"] = mean_tpr\\n #roc_auc[\\\"macro\\\"] = auc(fpr[\\\"macro\\\"], tpr[\\\"macro\\\"])\\n \\n # Compute micro-average PRC curve and PRC areas\\n fpr[\\\"micro\\\"], tpr[\\\"micro\\\"], _ = roc_curve(test_set_Y_org.ravel(), test_set_y_pred_prob.ravel())\\n roc_auc[\\\"macro\\\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob, average=\\\"macro\\\") # micro macro, weighted, or samples\\n roc_auc[\\\"micro\\\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob,average=\\\"micro\\\") # micro macro, weighted, or samples\\n roc_auc[\\\"weighted\\\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob, average=\\\"weighted\\\") # micro macro, weighted, or samples\\n roc_auc[\\\"samples\\\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob, average=\\\"samples\\\") # micro macro, weighted, or samples\\n\\n if plot_curve:\\n fig=plt.figure(num=1,figsize=(figwidth,figheight))\\n ax=fig.add_subplot(1,1,1)\\n ax.plot([0, 1], [0, 1], 'k--')\\n if n_classes>2 or positive_class_for_two_classes is None:\\n ax.plot(fpr[\\\"macro\\\"], tpr[\\\"macro\\\"], linewidth=1,color=colors[n_classes],label='macro-avg ROC (area={0:0.4f})'.format(roc_auc[\\\"macro\\\"]))\\n \\n for c in range(n_classes):\\n if positive_class_for_two_classes is None or (n_classes==2 and positive_class_for_two_classes==c):\\n ax.plot(fpr[c], tpr[c],linewidth=1,color=colors[c],label='ROC of {0} (area={1:0.4f})'.format(classes_unique[c], roc_auc[c]))\\n \\n # add some text for labels, title and axes ticks\\n ax.set_ylim(0.0,1.0)\\n ax.set_xlim(0.0,1.0)\\n ax.set_ylabel(\\\"True Positive Rate\\\",fontsize=12)\\n ax.set_xlabel(\\\"False Positive Rate\\\",fontsize=12) \\n #ax.set_title(\\\"\\\",fontsize=15)\\n ax.legend(loc=\\\"lower right\\\",fontsize=8)\\n #plt.subplots_adjust(bottom=0.12) # may this is not working because of the following setting\\n fig.savefig(filename,bbox_inches='tight')\\n plt.close(fig)\\n\\n roc_auc_list=[roc_auc[c] for c in range(n_classes)]\\n roc_auc_list.extend([roc_auc[\\\"macro\\\"],roc_auc[\\\"micro\\\"],roc_auc[\\\"weighted\\\"],roc_auc[\\\"samples\\\"]])\\n roc_auc=np.array(roc_auc_list)\\n names=[\\\"AUROC_\\\" + c for c in classes_unique]\\n names.extend([\\\"macro\\\",\\\"micro\\\",\\\"weighted\\\",\\\"samples\\\"])\\n names=np.array(names)\\n return roc_auc,names\",\n \"def roc(y_true, y_prob, ARGS):\\n roc_auc = roc_auc_score(y_true, y_prob)\\n if ARGS.graphs:\\n fpr, tpr, _ = roc_curve(y_true, y_prob)\\n plt.plot(fpr, tpr, color='darkorange', lw=2,\\n label='ROC curve (Area = %0.3f)'% roc_auc)\\n plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate (1 - Specifity)')\\n plt.ylabel('True Positive Rate (Sensitivity)')\\n plt.title('Receiver Operating Characteristic')\\n plt.legend(loc=\\\"lower right\\\")\\n print(f'ROC Curve saved to {ARGS.out_directory}/roc.png')\\n plt.savefig(f'{ARGS.out_directory}/roc.png')\\n else:\\n print('ROC-AUC %0.3f' % roc_auc)\",\n \"def plot_ROC(self, canvas):\\n\\t\\tfpr = self.fpr_\\n\\t\\ttpr = self.tpr_\\n\\t\\tauc = self.class_auroc_\\n\\t\\tclasses = self.classes_\\n\\t\\tnum_classes = self.num_classes_\\n\\n\\t\\trcParams.update({'font.size': 7})\\n\\t\\tcanvas.figure.clear()\\n\\t\\tax = canvas.figure.subplots()\\n\\n\\t\\tax.plot(fpr['avg'], tpr['avg'], label='avg (area={0})'.format(self.avg_auroc_), \\\\\\n\\t\\t\\tcolor = 'black', linewidth=2, linestyle='--')\\n\\n\\t\\tcolors = cycle(['blue', 'orange', 'green', 'red', 'yellow', 'purple', 'cyan'])\\n\\t\\tfor i, color in zip(range(0, num_classes), colors):\\n\\t\\t\\tax.plot(fpr[i], tpr[i], label='{0} (area={1})'.format(classes[i], auc[classes[i]]), \\\\\\n\\t\\t\\t\\tcolor=color, linewidth=1)\\n\\n\\t\\tax.plot([0 ,1], [0, 1], color='lightgray', linewidth=1, linestyle='--')\\n\\t\\tax.set_xlim([0.0, 1.0])\\n\\t\\tax.set_ylim([0.0, 1.05])\\n\\t\\tax.set_xlabel('FPR')\\n\\t\\tax.set_ylabel('TPR')\\n\\t\\tax.legend(loc='lower right')\\n\\n\\t\\tcanvas.figure.tight_layout()\\n\\t\\tcanvas.draw()\",\n \"def do_roc(scores, true_labels, file_name='', directory='', plot=True):\\n fpr, tpr, _ = roc_curve(true_labels, scores)\\n roc_auc = auc(fpr, tpr) # compute area under the curve\\n if plot: \\n plt.figure()\\n plt.plot(fpr, tpr, label='ROC curve (area = %0.3f)' % (roc_auc))\\n plt.plot([0, 1], [0, 1], 'k--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('Receiver operating characteristic')\\n plt.legend(loc=\\\"lower right\\\")\\n\\n plt.savefig(directory + file_name + 'roc.png')\\n plt.close()\\n\\n return roc_auc\",\n \"def _roc_plot_single(metrics, save_name):\\n plt.figure()\\n plt.plot([0, 1], [0, 1], \\\"k--\\\")\\n plt.plot(metrics[\\\"fpr\\\"], metrics[\\\"tpr\\\"], \\\"r\\\", linewidth=2)\\n plt.xscale(\\\"log\\\")\\n plt.yscale(\\\"log\\\")\\n plt.grid()\\n plt.xlabel(\\\"True Positive Rate\\\")\\n plt.ylabel(\\\"False Positive Rate\\\")\\n plt.tight_layout()\\n plt.savefig(save_name)\",\n \"def _th_plot(self, y_true, y_pred_proba, pos_label, pos_label_ind,\\n best_th_, q, tpr, fpr, th_, th_range, index, roc_auc_kwargs):\\n fig, axs = plt.subplots(nrows=2, ncols=1)\\n fig.set_size_inches(10, 10)\\n # Roc score.\\n y_type = sklearn.utils.multiclass.type_of_target(y_true)\\n if y_type == \\\"binary\\\":\\n roc_auc = sklearn.metrics.roc_auc_score(\\n y_true, y_pred_proba[:, pos_label_ind], **roc_auc_kwargs)\\n elif y_type == \\\"multiclass\\\":\\n roc_auc = sklearn.metrics.roc_auc_score(\\n y_true, y_pred_proba, **roc_auc_kwargs)\\n else:\\n assert False, f\\\"Unhandled y_type {y_type}\\\"\\n # Roc curve.\\n axs[0].plot(fpr, tpr, 'darkorange',\\n label=f\\\"ROC curve (AUC = {roc_auc:.3f}).\\\")\\n axs[0].scatter(fpr[index], tpr[index], c='b', marker=\\\"o\\\")\\n axs[0].plot([0, 1], [0, 1], color='navy', linestyle='--')\\n axs[0].set_xlabel('False Positive Rate')\\n axs[0].set_ylabel('True Positive Rate')\\n axs[0].set_title(f\\\"Receiver operating characteristic \\\"\\n f\\\"(label '{pos_label}')\\\")\\n axs[0].legend(loc=\\\"lower right\\\")\\n # Metric q.\\n axs[1].plot(th_, q, 'green')\\n axs[1].vlines(best_th_, np.min(q), np.max(q))\\n axs[1].vlines(th_range, np.min(q), np.max(q), colors='b',\\n linestyles=':')\\n axs[1].set_xlim([0.0, 1.0])\\n axs[1].set_xlabel('Threshold')\\n axs[1].set_ylabel('TPR/(TPR+FPR)')\\n axs[1].set_title('Selected th values objective maximum')\\n # plt.plot(th_, fpr, 'red')\\n plt.show()\",\n \"def plot_roc_auc(tree, reg, f_test, l_test):\\n\\n # Calculate probabilites for each model\\n s_probs = [0 for _ in range(len(l_test))]\\n tree_probs = tree.predict_proba(f_test)\\n reg_probs = reg.predict_proba(f_test)\\n\\n # Only keep postive outcomes\\n tree_probs = tree_probs[:, 1]\\n reg_probs = reg_probs[:, 1]\\n\\n # Calculate AUC value for each model and 0.5\\n s_auc = roc_auc_score(l_test, s_probs)\\n tree_auc = roc_auc_score(l_test, tree_probs)\\n reg_auc = roc_auc_score(l_test, reg_probs)\\n\\n print(f'Random prediction AUC: {s_auc:.3f}')\\n print(f'Decision Tree AUC: {tree_auc:.3f}')\\n print(f'Logistic Regression AUC: {reg_auc:3f}')\\n\\n # calculate FPR & TPRs\\n s_fpr, s_tpr, s_thresh = roc_curve(l_test, s_probs)\\n tree_fpr, tree_tpr, tree_thresh = roc_curve(l_test, tree_probs)\\n reg_fpr, reg_tpr, reg_thresh = roc_curve(l_test, reg_probs)\\n\\n # plot the curves\\n plt.plot(s_fpr, s_tpr, linestyle='--', label='Random Prediction')\\n plt.plot(tree_fpr, tree_tpr, linestyle='solid', label='Decision Tree AUC')\\n plt.plot(reg_fpr, reg_tpr, linestyle='dotted', label='Regression AUC')\\n\\n plt.title('ROC Plot')\\n plt.xlabel('FPR')\\n plt.ylabel('TPR')\\n plt.legend()\\n plt.savefig('Baseball_AUC.png')\",\n \"def plot_curve(self, true_values, predictions, ax=None, title='ROC', label='ROC', lw=1, add_auc=True, **kwargs):\\n fpr, tpr, _ = roc_curve(true_values, predictions)\\n roc_auc = auc(fpr, tpr)\\n label_auc = label + ': {:.3f} AUC'.format(roc_auc)\\n logging.info('ROC result: %s', label_auc)\\n ax.plot(fpr, tpr, lw=lw, label=label_auc if add_auc else label, **kwargs)\\n ax.set_title(title)\\n ax.set_xlabel('FPR')\\n ax.set_ylabel('TPR')\\n ax.legend(loc='lower right', frameon=False)\\n return ax\",\n \"def roc(proba, ts, classifier_name):\\n fpr, tpr, _ = roc_curve(ts, proba[:,1])\\n roc_auc = auc(fpr, tpr)\\n print(\\\"Area under the ROC curve for %s : %f\\\") % (classifier_name, roc_auc)\\n\\n l = 'ROC curve for %s (area = %0.2f)' % (classifier_name, roc_auc)\\n pl.clf()\\n pl.plot(fpr, tpr, label=l)\\n pl.plot([0, 1], [0, 1], 'k--')\\n pl.xlim([0.0, 1.0])\\n pl.ylim([0.0, 1.0])\\n pl.xlabel('False Positive Rate')\\n pl.ylabel('True Positive Rate')\\n pl.title('Receiver operating characteristic for %s' % classifier_name)\\n pl.legend(loc=\\\"lower right\\\")\\n pl.show()\",\n \"def plot_roc(preds, labels, title=\\\"Receiver operating characteristic\\\"):\\n\\n # Compute values for curve\\n fpr, tpr, _ = roc_curve(labels, preds)\\n\\n # Compute FPR (95% TPR)\\n tpr95 = fpr_at_95_tpr(preds, labels)\\n\\n # Compute AUROC\\n roc_auc = auroc(preds, labels)\\n\\n # Draw the plot\\n plt.figure()\\n lw = 2\\n plt.plot(fpr, tpr, color='darkorange',\\n lw=lw, label='AUROC = %0.2f' % roc_auc)\\n plt.plot([0, 1], [0.95, 0.95], color='black', lw=lw, linestyle=':', label='FPR (95%% TPR) = %0.2f' % tpr95)\\n plt.plot([tpr95, tpr95], [0, 1], color='black', lw=lw, linestyle=':')\\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--', label='Random detector ROC')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title(title)\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\",\n \"def roc2(fpr, tpr, roc_auc):\\n plt.figure()\\n plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\\n plt.plot([0, 1], [0, 1], color='navy', lw=1, linestyle='--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('Receiver operating characteristic')\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\",\n \"def verif_valid(model, X_val, y_val, cut=0.5):\\n if type(model) == Sequential:\\n X_val = np.array(X_val)\\n reality = y_val\\n \\n if ((type(model) == svm.classes.OneClassSVM) | (type(model) == lgb.basic.Booster) | (type(model) == svm.classes.LinearSVC) | (type(model) == Sequential)):\\n pred_score = model.predict(X_val)\\n if (type(model) == svm.classes.OneClassSVM):\\n pred_score = np.where(pred_score == -1, 1, 0)\\n else:\\n pred_score = model.predict_proba(X_val)[:,1]\\n \\n plt.hist(pred_score)\\n plt.title('Distribution of the prediction score')\\n plt.show()\\n #if (type(model) == Sequential):\\n # predictions = np.where(pred_score > 0.5, 1, 0)\\n #else:\\n predictions = np.where(pred_score > cut, 1, 0)\\n \\n print('Matrice de confusion :')\\n conf_mat = confusion_matrix(reality, predictions)\\n print(pd.DataFrame(conf_mat))\\n print('Associated metrics :')\\n print(classification_report(reality, predictions))\\n fpr, tpr, _ = roc_curve(y_val, pred_score)\\n \\n roc_auc = auc(fpr, tpr)\\n plt.plot(fpr, tpr, 'r-', lw=4)\\n actual_fpr = conf_mat[1, 0] / (conf_mat[1, 0] + conf_mat[0, 0])\\n actual_tpr = conf_mat[1, 1] / (conf_mat[1, 1] + conf_mat[0, 1])\\n plt.plot(actual_fpr, actual_tpr, 'bo', lw=10)\\n plt.xlabel('False-Positive Rate')\\n plt.ylabel('True-Positive Rate')\\n plt.title('ROC curve (with AUC = ' + str(round(roc_auc, 6)) + ')')\\n plt.plot([0, 1], [0, 1], 'k-')\\n plt.show()\\n print('Score AUC : ' + str(roc_auc))\\n print('Accuracy : ' + str(metrics.accuracy_score(y_val, predictions)))\",\n \"def plot_roc(y_true, y_probas, classes = None, title='ROC Curves', average_plot = True,\\n ax=None, figsize=None, cmap='nipy_spectral',\\n title_fontsize=\\\"large\\\", text_fontsize=\\\"medium\\\"):\\n if ax is None:\\n fig, ax = plt.subplots(1, 1, figsize=figsize)\\n ax.set_title(title, fontsize=title_fontsize)\\n n_fold_roc_auc = []\\n for i in range(len(y_true)):\\n fpr, tpr, _ = roc_curve(y_true[i], y_probas[i])\\n roc_auc = auc(fpr, tpr)\\n color = plt.cm.get_cmap(cmap)(float(i) / len(y_true))\\n \\n if classes is None:\\n s = 'fold'\\n else:\\n s = classes[i]\\n ax.plot(fpr, tpr, lw=2, color=color,\\n label='ROC curve of {0} {1} (area = {2:0.2f})'\\n ''.format(s, i, roc_auc))\\n n_fold_roc_auc.append(roc_auc)\\n\\n average_roc_auc = 0\\n if classes is None:\\n if average_plot:\\n all_y_true = np.concatenate(y_true)\\n all_probas = np.concatenate(y_probas)\\n fpr_all, tpr_all, _ = roc_curve(all_y_true, all_probas)\\n average_roc_auc = auc(fpr_all, tpr_all)\\n ax.plot(fpr_all, tpr_all,\\n label='average ROC curve '\\n '(area = {0:0.2f})'.format(average_roc_auc),\\n color='blue', linestyle=':', linewidth=4)\\n\\n ax.plot([0, 1], [0, 1], 'k--', lw=2)\\n ax.set_xlim([0.0, 1.0])\\n ax.set_ylim([0.0, 1.05])\\n ax.set_xlabel('False Positive Rate', fontsize=text_fontsize)\\n ax.set_ylabel('True Positive Rate', fontsize=text_fontsize)\\n ax.tick_params(labelsize=text_fontsize)\\n ax.legend(loc='lower right', fontsize=text_fontsize)\\n return ax, n_fold_roc_auc, average_roc_auc\",\n \"def plot_roc_curve(y: np.ndarray, \\n y_pred_positive: np.ndarray, \\n label: str) -> None:\\n fpr, tpr, thresholds = metrics.roc_curve(y, y_pred_positive)\\n plt.figure(figsize=(8, 8))\\n plt.plot(fpr, tpr, \\\"b:\\\", linewidth=2, label=label)\\n plt.fill_between(fpr, tpr, color='blue', alpha=0.3)\\n plt.plot([0, 1], [0, 1], 'k--')\\n plt.axis([0, 1, 0, 1])\\n plt.xlabel('Odsetek fałszywie pozytywnych (FPR)', fontsize=16)\\n plt.ylabel('Odsetek prawdziwie pozytywnych (TPR)', fontsize=16)\\n plt.legend(loc=\\\"lower right\\\", fontsize=16)\\n plt.title('Krzywa ROC, AUC={0:.3f}'.format(metrics.roc_auc_score(y, y_pred_positive)), fontsize=18)\\n plt.show()\",\n \"def plot_roc(self, ax, prob, y, label='ROC'):\\n self.df = self.calculate_threshold_values(prob, y)\\n ax.plot([1] + list(self.df.fpr), [1] + list(self.df.tpr), label=label)\\n x = [1] + list(self.df.fpr)\\n y1 = [1] + list(self.df.tpr)\\n y2 = x\\n ax.fill_between(x, y1, y2, alpha=0.2)\\n ax.set_xlabel('fpr')\\n ax.set_ylabel('tpr')\\n ax.set_title('ROC Curve')\\n ax.legend()\",\n \"def saveit(func_predict, X, y, X_kin, VARS_kin, pt_edges, eta_edges, label):\\n fig, ax, met = plots.binned_AUC(func_predict = func_predict, X = X, y = y, X_kin = X_kin, \\\\\\n VARS_kin = VARS_kin, pt_edges = pt_edges, eta_edges = eta_edges, label = label)\\n \\n global roc_mstats\\n global roc_labels\\n roc_mstats.append(met)\\n roc_labels.append(label)\\n\\n global targetdir\\n filename = targetdir + '/' + label + '_AUC.pdf'\\n plt.savefig(filename, bbox_inches='tight')\",\n \"def draw_roc(signal, background, output_dir=\\\".\\\", output_name=\\\"roc.pdf\\\"):\\n\\n x, y = get_roc(signal, background)\\n auc = metrics.auc(x, y, reorder=True)\\n\\n fig = plt.figure(1, figsize=(6, 6), dpi=300)\\n fig.clear()\\n\\n # Create an axes instance\\n ax = fig.add_subplot(111)\\n\\n ax.plot(x, y, '-', color='#B64926', lw=2, label=\\\"AUC: %.4f\\\" % auc)\\n ax.plot([0, 1], [0, 1], ':', color='black', lw=2, label=\\\"Random cut\\\")\\n ax.margins(0.05)\\n\\n ax.set_xlabel(\\\"Background efficiency\\\")\\n ax.set_ylabel(\\\"Signal efficiency\\\")\\n \\n fig.set_tight_layout(True)\\n\\n ax.legend(loc='lower right', numpoints=1, frameon=False)\\n\\n print(\\\"AUC: %.4f\\\" % auc)\\n\\n fig.savefig(os.path.join(output_dir, output_name))\\n\\n plt.close()\\n\\n def get_index(y, value):\\n \\\"\\\"\\\"\\n Find the last index of the element in y\\n satistying y[index] <= value\\n \\\"\\\"\\\"\\n\\n for i in range(len(y)):\\n if y[i] <= value:\\n continue\\n\\n return i\\n\\n print(\\\"Background efficiency for signal efficiency of 0.70: %f\\\" % x[get_index(y, 0.70)])\\n print(\\\"Background efficiency for signal efficiency of 0.80: %f\\\" % x[get_index(y, 0.80)])\\n print(\\\"Background efficiency for signal efficiency of 0.90: %f\\\" % x[get_index(y, 0.90)])\",\n \"def rocs(test_set_y_org,test_set_y_pred_prob,methods,linestyles,classes_unique,plot_curve=False,filename=\\\"./fig_roc.pdf\\\",colors=None,positive_class_for_two_classes=None,figwidth=5,figheight=5):\\n from sklearn.metrics import roc_curve\\n #from sklearn.metrics import auc\\n from sklearn.metrics import roc_auc_score\\n from scipy import interp\\n import matplotlib as mpl\\n mpl.use(\\\"pdf\\\")\\n import matplotlib.pyplot as plt\\n \\n n_classes=len(classes_unique)\\n test_set_Y_org,test_set_y_org_unique=membership_vector_to_indicator_matrix(test_set_y_org)\\n\\n num_methods=len(methods)\\n roc_aucs=[0]*num_methods\\n names=[None]*num_methods\\n for m in range(num_methods):\\n fpr = dict()\\n tpr = dict()\\n roc_auc = dict()\\n for c in range(n_classes):\\n fpr[c], tpr[c], _ = roc_curve(test_set_Y_org[:, c], test_set_y_pred_prob[m][:, c])\\n roc_auc[c] = roc_auc_score(test_set_Y_org[:, c], test_set_y_pred_prob[m][:, c])\\n\\n # Compute macro-average ROC curve and AUROC area\\n # First aggregate all false positive rates\\n all_fpr = np.unique(np.concatenate([fpr[c] for c in range(n_classes)]))\\n # Then interpolate all ROC curves at this points\\n mean_tpr = np.zeros_like(all_fpr)\\n for c in range(n_classes):\\n mean_tpr += interp(all_fpr, fpr[c], tpr[c])\\n # Finally average it and compute AUC\\n mean_tpr /= n_classes\\n fpr[\\\"macro\\\"] = all_fpr\\n tpr[\\\"macro\\\"] = mean_tpr\\n #roc_auc[\\\"macro\\\"] = auc(fpr[\\\"macro\\\"], tpr[\\\"macro\\\"])\\n\\n # Compute micro-average PRC curve and PRC areas\\n fpr[\\\"micro\\\"], tpr[\\\"micro\\\"], _ = roc_curve(test_set_Y_org.ravel(), test_set_y_pred_prob[m].ravel())\\n roc_auc[\\\"macro\\\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob[m], average=\\\"macro\\\") # micro macro, weighted, or samples\\n roc_auc[\\\"micro\\\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob[m],average=\\\"micro\\\") # micro macro, weighted, or samples\\n roc_auc[\\\"weighted\\\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob[m], average=\\\"weighted\\\") # micro macro, weighted, or samples\\n roc_auc[\\\"samples\\\"] = roc_auc_score(test_set_Y_org, test_set_y_pred_prob[m], average=\\\"samples\\\") # micro macro, weighted, or samples\\n\\n if plot_curve:\\n if m==0:\\n fig=plt.figure(num=1,figsize=(figwidth,figheight))\\n ax=fig.add_subplot(1,1,1)\\n ax.plot([0, 1], [0, 1], 'k--')\\n if n_classes>2 or positive_class_for_two_classes is None:\\n ax.plot(fpr[\\\"macro\\\"], tpr[\\\"macro\\\"], linestyle=linestyles[m],linewidth=1,color=colors[n_classes],label='{0}: macro-avg ROC (area={1:0.4f})'.format(methods[m], roc_auc[\\\"macro\\\"]))\\n\\n for c in range(n_classes):\\n if positive_class_for_two_classes is None or (n_classes==2 and positive_class_for_two_classes==c):\\n ax.plot(fpr[c], tpr[c],linestyle=linestyles[m],linewidth=1,color=colors[c],label='{0}: ROC of {1} (area={2:0.4f})'.format(methods[m], classes_unique[c], roc_auc[c]))\\n\\n # add some text for labels, title and axes ticks\\n if m==num_methods-1:\\n ax.set_ylim(0.0,1.0)\\n ax.set_xlim(0.0,1.0)\\n ax.set_ylabel(\\\"True Positive Rate\\\",fontsize=12)\\n ax.set_xlabel(\\\"False Positive Rate\\\",fontsize=12) \\n #ax.set_title(\\\"\\\",fontsize=15)\\n ax.legend(loc=\\\"lower right\\\",fontsize=8)\\n #plt.subplots_adjust(bottom=0.12) # may this is not working because of the following setting\\n fig.savefig(filename,bbox_inches='tight')\\n plt.close(fig)\\n\\n roc_auc_list=[roc_auc[c] for c in range(n_classes)]\\n roc_auc_list.extend([roc_auc[\\\"macro\\\"],roc_auc[\\\"micro\\\"],roc_auc[\\\"weighted\\\"],roc_auc[\\\"samples\\\"]])\\n roc_auc=np.array(roc_auc_list)\\n name=[methods[m]+\\\"_AUROC_\\\" + c for c in classes_unique]\\n name.extend([\\\"macro\\\",\\\"micro\\\",\\\"weighted\\\",\\\"samples\\\"])\\n name=np.array(name)\\n\\n roc_aucs[m]=roc_auc\\n names[m]=name\\n \\n return roc_aucs,names\",\n \"def crowd_auc_plot(self, auto_open=False):\\n def get_name(nofeat, cond):\\n plural = nofeat > 1\\n return \\\"{} features (condition {})\\\".format(nofeat, cond) if plural else \\\"{} feature (condition {})\\\".format(nofeat, cond)\\n\\n def get_trace(values, nofeat, cond):\\n name = get_name(nofeat, cond)\\n return go.Histogram(\\n name=name,\\n x=values,\\n histnorm='probability',\\n autobinx=False,\\n xbins=dict(\\n start=0.5,\\n end=1,\\n size=0.025,\\n ),\\n marker=dict(\\n color=self.colours[cond]\\n ),)\\n\\n aucs = pd.read_pickle(self.path_final_evaluation_aucs)\\n nofeatures = sorted(set([nofeat for nofeat in aucs[1]]))\\n conditions = [1, 2, 3, 4, 5]\\n subplot_titles = [get_name(no_feat, c) for no_feat in nofeatures for c in conditions]\\n fig = plotly.tools.make_subplots(rows=len(nofeatures), cols=len(conditions), subplot_titles=subplot_titles)\\n row_index=1\\n for no_feat in nofeatures:\\n for i in range(len(conditions)):\\n trace = get_trace(aucs[conditions[i]][no_feat], no_feat, conditions[i])\\n fig.append_trace(trace, row_index, i+1)\\n row_index += 1\\n fig['layout'].update(showlegend=False, height=2500, width=1200, title='AUC Histograms for {} ({})'.format(self.dataset_name, self.experiment_name),)\\n\\n plotly.offline.plot(fig, auto_open=auto_open, filename=self.path_auc_plots)\\n from IPython.display import Image\\n Image('a-simple-plot.png')\",\n \"def ROC_plot(metrics, labels, title = '', filename = 'ROC') :\\n\\n for k in [0,1]: # linear & log\\n\\n fig,ax = plt.subplots()\\n xx = np.logspace(-5, 0, 100)\\n plt.plot(xx, xx, linestyle='--', color='black', linewidth=1) # ROC diagonal\\n\\n for i in range(len(metrics)) :\\n plt.plot(metrics[i].fpr, metrics[i].tpr, label = '{}: AUC = {:.3f}'.format(labels[i], metrics[i].auc))\\n\\n plt.legend(loc=4)\\n ax.set_xlabel('False Positive (background) rate $\\\\\\\\alpha$')\\n ax.set_ylabel('True Positive (signal) rate $1-\\\\\\\\beta$')\\n ax.set_title(title)\\n\\n if k == 0:\\n plt.ylim(0.0, 1.0)\\n plt.xlim(0.0, 1.0)\\n ax.set_aspect(1.0/ax.get_data_ratio() * 1.0)\\n plt.savefig(filename + '.pdf', bbox_inches='tight')\\n\\n if k == 1:\\n plt.ylim(0.0, 1.0)\\n plt.xlim(1e-4, 1.0)\\n plt.gca().set_xscale('log')\\n ax.set_aspect(1.0/ax.get_data_ratio() * 0.75)\\n plt.savefig(filename + '_log.pdf', bbox_inches='tight')\\n\\n plt.close()\",\n \"def plot_roc_curve(y_true, y_pred_prob, show_threshold=False, **params):\\n\\n figure = plt.figure(figsize=params.get('figsize', (17, 10)))\\n fpr, tpr, thresholds = roc_curve(y_true, y_pred_prob)\\n roc_auc = auc(fpr, tpr)\\n plt.plot(fpr, tpr, label='ROC curve (area = %0.5f)' % roc_auc)\\n plt.plot([0, 1], [0, 1], 'k--')\\n plt.xlim([-0.05, 1.05])\\n plt.ylim([-0.05, 1.05])\\n plt.xticks(np.arange(0.0, 1.1, step=0.1))\\n plt.yticks(np.arange(0.0, 1.1, step=0.1))\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('ROC curve')\\n plt.legend(loc=\\\"lower right\\\")\\n if show_threshold:\\n ax2 = plt.gca().twinx()\\n ax2.plot(fpr, thresholds, markeredgecolor='r',\\n linestyle='dashed', color='r')\\n ax2.set_ylabel('Threshold', color='r')\\n ax2.set_ylim([0.0, 1.0])\\n ax2.set_xlim([0.0, 1.0])\\n\\n plt.show()\\n\\n return figure, roc_auc\",\n \"def plot_ROC_curve(y_true, y_pred, labels, roc_path):\\n n_classes = len(labels)\\n # Compute ROC curve and ROC area for each class\\n fpr = dict()\\n tpr = dict()\\n roc_auc = dict()\\n for y, pred, label in zip(y_true.transpose(), y_pred.transpose(), labels):\\n fpr[label], tpr[label], _ = roc_curve(y, pred)\\n roc_auc[label] = auc(fpr[label], tpr[label])\\n\\n # First aggregate all false positive rates\\n all_fpr = np.unique(np.concatenate([fpr[label] for label in labels]))\\n\\n # Then interpolate all ROC curves at this points\\n mean_tpr = np.zeros_like(all_fpr)\\n for label in labels:\\n mean_tpr += interp(all_fpr, fpr[label], tpr[label])\\n\\n # Finally average it and compute AUC\\n mean_tpr /= n_classes\\n\\n # Compute micro-average ROC curve and ROC area\\n fpr[\\\"micro\\\"], tpr[\\\"micro\\\"], _ = roc_curve(y_true.ravel(), y_pred.ravel())\\n roc_auc[\\\"micro\\\"] = auc(fpr[\\\"micro\\\"], tpr[\\\"micro\\\"])\\n\\n fpr[\\\"macro\\\"] = all_fpr\\n tpr[\\\"macro\\\"] = mean_tpr\\n roc_auc[\\\"macro\\\"] = auc(fpr[\\\"macro\\\"], tpr[\\\"macro\\\"])\\n\\n # Plot all ROC curves\\n plt.figure()\\n lw = 2\\n plt.plot(fpr[\\\"micro\\\"], tpr[\\\"micro\\\"],\\n label='micro-average ROC curve (area = {0:0.3f})'\\n ''.format(roc_auc[\\\"micro\\\"]),\\n color='deeppink', linestyle=':', linewidth=2)\\n\\n plt.plot(fpr[\\\"macro\\\"], tpr[\\\"macro\\\"],\\n label='macro-average ROC curve (area = {0:0.3f})'\\n ''.format(roc_auc[\\\"macro\\\"]),\\n color='navy', linestyle=':', linewidth=2)\\n\\n if len(labels) == 4:\\n colors = ['green', 'cornflowerblue', 'darkorange', 'darkred']\\n else:\\n colors = ['green', 'cornflowerblue', 'darkred']\\n for label, color in zip(labels, cycle(colors)):\\n plt.plot(fpr[label], tpr[label], color=color, lw=lw,\\n label='ROC curve of {0} (area = {1:0.3f})'\\n ''.format(label, roc_auc[label]))\\n\\n plt.plot([0, 1], [0, 1], 'k--', lw=lw)\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('ROC curve')\\n plt.legend(loc=\\\"lower right\\\")\\n matplotlib.rcParams.update({'font.size': 14})\\n plt.savefig('%s.png' % roc_path, pad_inches = 0, bbox_inches='tight')\",\n \"def plot_roc_distributions(self, model_str, resampling_number, roc_curve_steps, roc_plot_path):\\n sampling_types = ['Normal', 'Oversampling', 'Undersampling']\\n\\n PLOT_MARGIN = 0.05\\n plt.rcParams[\\\"figure.figsize\\\"] = (16, 9)\\n plt.subplots_adjust(wspace=0.2, hspace=0.4)\\n sub_plot_index = 1\\n\\n for sampling_type in sampling_types:\\n mean_fpr, mean_tpr, mean_threshold, mean_auc, std_auc = self._compute_mean_auc_data(sampling_type, model_str, resampling_number, roc_curve_steps)\\n\\n plt.subplot(int('22' + str(sub_plot_index)))\\n\\n sub_plot_index += 1\\n\\n plt.plot(mean_fpr, mean_tpr, color='g', label='AUC:{0}, STD:{1}'.format(round(mean_auc, 2), round(std_auc, 2)))\\n plt.plot(mean_fpr, mean_threshold, linestyle='--', lw=2, color='b', label='Thresholds')\\n plt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r', label='Chance')\\n\\n plt.xlim([0 - PLOT_MARGIN, 1 + PLOT_MARGIN])\\n plt.ylim([0 - PLOT_MARGIN, 1 + PLOT_MARGIN])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title(sampling_type + ' ROC Distribution')\\n plt.legend(loc=\\\"lower right\\\")\\n\\n plt.savefig(roc_plot_path)\\n plt.clf()\",\n \"def _roc_plot(metrics, dummy_metrics, save_name):\\n plt.figure()\\n plt.plot([0, 1], [0, 1], \\\"k--\\\")\\n if dummy_metrics is None or len(dummy_metrics) == 0:\\n do_dummy = False\\n else:\\n do_dummy = True\\n\\n # Compute average ROC\\n base_fpr = np.linspace(0, 1, 1000)\\n # base_fpr = np.logspace(-4, 0, 1000)\\n all_tpr = np.zeros((len(metrics), len(base_fpr)), float)\\n for i, metric_set in enumerate(metrics):\\n all_tpr[i, :] = np.interp(base_fpr, metric_set[\\\"fpr\\\"], metric_set[\\\"tpr\\\"])\\n\\n if do_dummy:\\n all_tpr_dummy = np.zeros((len(dummy_metrics), len(base_fpr)), float)\\n for i, metric_set in enumerate(dummy_metrics):\\n all_tpr_dummy[i, :] = np.interp(\\n base_fpr, metric_set[\\\"fpr\\\"], metric_set[\\\"tpr\\\"]\\n )\\n\\n for _, metric_set in enumerate(dummy_metrics):\\n plt.plot(\\n metric_set[\\\"fpr\\\"],\\n metric_set[\\\"tpr\\\"],\\n color=\\\"lightsteelblue\\\",\\n linewidth=0.5,\\n alpha=0.5,\\n )\\n\\n for _, metric_set in enumerate(metrics):\\n plt.plot(\\n metric_set[\\\"fpr\\\"], metric_set[\\\"tpr\\\"], color=\\\"lightsalmon\\\", linewidth=0.5\\n )\\n\\n tpr_mu = all_tpr.mean(axis=0)\\n plt.plot(base_fpr, tpr_mu, \\\"r\\\")\\n\\n if do_dummy:\\n dummy_mu = all_tpr_dummy.mean(axis=0)\\n plt.plot(base_fpr, dummy_mu, \\\"b\\\")\\n\\n plt.xscale(\\\"log\\\")\\n plt.yscale(\\\"log\\\")\\n plt.xlabel(\\\"False Positive Rate\\\")\\n plt.ylabel(\\\"True Positive Rate\\\")\\n plt.tight_layout()\\n plt.grid()\\n plt.savefig(save_name)\",\n \"def metrics(labels, preds_proba, print_metrics=True, plot=False, threshold=0.5, rounded=4):\\n \\n\\n test_fpr, test_tpr, test_thresholds = roc_curve(labels, preds_proba)\\n roc_auc = auc(test_fpr, test_tpr)\\n preds = preds_proba_to_preds_class(preds_proba,threshold)\\n precision = precision_score(labels, preds)\\n recall = recall_score(labels, preds)\\n accuracy = accuracy_score(labels, preds)\\n f1 = f1_score(labels, preds)\\n if plot:\\n sns.set_style('darkgrid', {'axes.facecolor': '0.9'})\\n plt.figure(figsize=(10, 8))\\n lw = 2\\n plt.plot(test_fpr, test_tpr, color='darkorange',\\n lw=lw, label='ROC curve')\\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.yticks([i/20.0 for i in range(21)])\\n plt.xticks([i/20.0 for i in range(21)])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('Receiver operating characteristic (ROC) Curve')\\n plt.legend(loc='lower right')\\n plt.show()\\n if print_metrics:\\n print(f\\\"ROC AUC Score: {roc_auc}\\\\n\\\")\\n print(f\\\"------- Metrics for threshold {threshold} -------\\\")\\n print(f\\\"- Precision Score: {precision}\\\")\\n print(f\\\"- Recall Score: {recall}\\\")\\n print(f\\\"- Accuracy Score: {accuracy}\\\")\\n print(f\\\"- F1 Score: {f1}\\\\n\\\")\\n else:\\n return {\\\"roc_auc\\\":roc_auc, \\\"precision\\\":precision, \\\"recall\\\":recall, \\\"accuracy\\\":accuracy, \\\"f1\\\":f1}\",\n \"def _create_roc_curve(forecast_probabilities, observed_labels, output_dir_name):\\n\\n pofd_by_threshold, pod_by_threshold = model_eval.get_points_in_roc_curve(\\n forecast_probabilities=forecast_probabilities,\\n observed_labels=observed_labels,\\n threshold_arg=model_eval.THRESHOLD_ARG_FOR_UNIQUE_FORECASTS,\\n unique_forecast_precision=FORECAST_PRECISION_FOR_THRESHOLDS)\\n\\n auc = model_eval.get_area_under_roc_curve(\\n pofd_by_threshold=pofd_by_threshold,\\n pod_by_threshold=pod_by_threshold)\\n scikit_learn_auc = roc_auc_score(\\n y_true=observed_labels, y_score=forecast_probabilities)\\n\\n title_string = 'AUC = {0:.4f} ... scikit-learn AUC = {1:.4f}'.format(\\n auc, scikit_learn_auc)\\n print title_string\\n\\n figure_file_name = '{0:s}/roc_curve.jpg'.format(output_dir_name)\\n print 'Saving ROC curve to: \\\"{0:s}\\\"...\\\\n'.format(figure_file_name)\\n\\n _, axes_object = pyplot.subplots(\\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES))\\n model_eval_plotting.plot_roc_curve(\\n axes_object=axes_object, pod_by_threshold=pod_by_threshold,\\n pofd_by_threshold=pofd_by_threshold)\\n\\n pyplot.title(title_string)\\n pyplot.savefig(figure_file_name, dpi=DOTS_PER_INCH)\\n pyplot.close()\\n\\n return auc, scikit_learn_auc\",\n \"def plot_roc_curve(tprs, aucs, tag=''):\\n fig, ax = plt.subplots()\\n ax.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r',\\n label='Chance', alpha=.8)\\n\\n mean_tpr = np.mean(tprs, axis=0)\\n mean_tpr[-1] = 1.0\\n mean_fpr = np.linspace(0, 1, 100)\\n\\n mean_auc = auc(mean_fpr, mean_tpr)\\n std_auc = np.std(aucs)\\n ax.plot(mean_fpr, mean_tpr, color='b',\\n label=r'Mean ROC (AUC = %0.2f $\\\\pm$ %0.2f)' % (mean_auc, std_auc),\\n lw=2, alpha=.8)\\n\\n std_tpr = np.std(tprs, axis=0)\\n tprs_upper = np.minimum(mean_tpr + std_tpr, 1)\\n tprs_lower = np.maximum(mean_tpr - std_tpr, 0)\\n ax.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.2,\\n label=r'$\\\\pm$ 1 std. dev.')\\n\\n ax.set(xlim=[-0.05, 1.05], ylim=[-0.05, 1.05],\\n title=\\\"Receiver operating characteristic example\\\")\\n ax.legend(loc=\\\"lower right\\\")\\n plt.tight_layout()\\n plt.savefig(f'roc_{tag}.png')\\n plt.show()\",\n \"def accuracy_stats(self, y_true_label, y_pred_prob, threshold = 0.50, accuracy = True, confusion_mat = True, ROC = True):\\n # Reshape \\n y_true_label = np.squeeze(y_true_label)\\n y_pred_prob = np.squeeze(y_pred_prob)\\n \\n y_pred_label = (y_pred_prob >= threshold) + 0\\n acc = np.mean(1 - abs(y_true_label - y_pred_label))\\n \\n #print(\\\"\\\\n --------PRINTING ACCURACY STATISTICS-------- \\\\n\\\")\\n \\n if accuracy:\\n print(f\\\"accuracy: {acc * 100}%\\\\n\\\")\\n \\n if confusion_mat:\\n print(\\\"confusion matrix:\\\\n\\\" + str(confusion_matrix(y_true_label, y_pred_label)) + \\\"\\\\n\\\")\\n \\n if ROC:\\n fpr, tpr, thresholds = roc_curve(y_true_label, y_pred_label)\\n roc_auc = roc_auc_score(y_true_label, y_pred_label)\\n \\n plt.figure()\\n lw = 2\\n plt.plot(fpr, tpr, color='darkorange',\\n lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)\\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('Receiver operating characteristic')\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\\n print(\\\"ROC AUC:\\\\n\\\" + str(roc_auc) + \\\"\\\\n\\\")\",\n \"def plot_mean_roc_curve_of_classifiers(classifier_roc_list, data_set_description):\\n if const.RECORD_RESULTS is True:\\n fig = plt.figure(figsize=(8, 6.66))\\n monochrome = (cycler(\\\"color\\\", [\\\"k\\\"]) * cycler(\\\"marker\\\", [\\\"\\\"]) *\\n cycler(\\\"linestyle\\\", [\\\"-\\\", \\\"--\\\", \\\"-.\\\"]))\\n color_arr = [\\\"#64B3DE\\\", \\\"#1f78b4\\\", \\\"#6ABF20\\\", \\\"#FBAC44\\\", \\\"#bc1659\\\", \\\"#B9B914\\\", \\\"#33a02c\\\", \\\"#ff7f00\\\", \\\"#6a3d9a\\\", \\\"black\\\", \\\"#b15928\\\", \\\"#e31a1c\\\"]\\n plt.rc(\\\"axes\\\", prop_cycle=monochrome)\\n line_style_index = 0\\n color_index = 0\\n\\n for (test_run_roc_list, classifier_description) in classifier_roc_list:\\n if not (None, None) in test_run_roc_list[0]:\\n mean_tpr = 0.0\\n mean_fpr = np.linspace(0, 1, 100)\\n count = 0\\n for roc_list in test_run_roc_list:\\n for (tpr, fpr) in roc_list:\\n mean_tpr += interp(mean_fpr, fpr, tpr)\\n mean_tpr[0] = 0.0\\n count += 1\\n\\n mean_tpr /= float(count)\\n mean_tpr[-1] = 1.0\\n mean_auc = auc(mean_fpr, mean_tpr)\\n line_width = 0.5\\n if line_style_index == 1:\\n line_width = 0.8\\n elif line_style_index == 2:\\n line_width = 1.5\\n\\n plt.plot(mean_fpr, mean_tpr, c=color_arr[color_index], lw=line_width, alpha=1, label=\\\"{0} ({1:.3f})\\\".format(classifier_description, mean_auc))\\n line_style_index = (line_style_index + 1) % 3\\n color_index += 1\\n\\n plt.locator_params(axis='x', nbins=10)\\n plt.locator_params(axis='y', nbins=10)\\n plt.plot([0, 1], [0, 1], \\\"k--\\\", label=\\\"Random classification\\\", lw=0.8)\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.0])\\n plt.xlabel(\\\"False Positive Rate\\\")\\n plt.ylabel(\\\"True Positive Rate\\\")\\n plt.title(\\\"ROC curve for each classifier\\\")\\n plt.legend(loc=\\\"lower right\\\", fancybox=True, frameon=True)\\n current_time = datetime.now().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")\\n plt.savefig(os.path.dirname(os.path.realpath(__file__)) + \\\"/../results/{0}_roc_classifier_plot_{1}.png\\\".format(data_set_description, current_time), bbox_inches=\\\"tight\\\")\\n plt.close(fig)\",\n \"def plot_multi_roc_curve(y_trues, y_pred_probs, labels, **params):\\n\\n figure = plt.figure(figsize=params.get('figsize', (17, 10)))\\n roc_aucs = []\\n for y_true, y_pred_prob, label in zip(y_trues, y_pred_probs, labels):\\n fpr, tpr, thresholds = roc_curve(y_true, y_pred_prob)\\n roc_auc = auc(fpr, tpr)\\n roc_aucs.append(roc_auc)\\n plt.plot(fpr, tpr, label=f'{label} ROC curve (area = %0.5f)' % roc_auc)\\n\\n plt.plot([0, 1], [0, 1], 'k--')\\n plt.xlim([-0.05, 1.05])\\n plt.ylim([-0.05, 1.05])\\n plt.xticks(np.arange(0.0, 1.1, step=0.1))\\n plt.yticks(np.arange(0.0, 1.1, step=0.1))\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('ROC curve')\\n plt.legend(loc=\\\"lower right\\\")\\n\\n plt.show()\\n\\n return figure, roc_aucs\",\n \"def _plot_twoclass(out, fontsize=12, title='', label='', color='darkorange', ax=None, figsize=(12,8)):\\n fpr = out['fpr']\\n tpr = out['tpr']\\n roc_auc = out.get('auc',None)\\n \\n if color is None:\\n color='darkorange'\\n\\n if ax is None:\\n fig,ax= plt.subplots(figsize=figsize)\\n\\n label = ('ROC curve (area = %.2f) ' %(roc_auc)) + label\\n linewidth = 1.5\\n ax.plot(fpr, tpr, color=color, lw=linewidth, label=label)\\n ax.plot([0, 1], [0, 1], color='navy', lw=linewidth, linestyle='--')\\n ax.set_xlim([0.0, 1.0])\\n ax.set_ylim([0.0, 1.05])\\n ax.set_xlabel('False Positive Rate', fontsize=fontsize)\\n ax.set_ylabel('True Positive Rate', fontsize=fontsize)\\n ax.set_title('[%s] Receiver operating characteristic. AUC:%.3f' %(title, roc_auc), fontsize=fontsize)\\n ax.legend(loc=\\\"lower right\\\", fontsize=fontsize)\\n ax.grid(True)\\n return ax\",\n \"def analyze(results: str):\\n # Initialize plot\\n co.nb.matplotlib_inline()\\n plt.figure(figsize=(5, 4), linewidth=1)\\n\\n for model in os.listdir(results):\\n # For each model, read in the results DataFrame\\n df = pd.read_csv(os.path.join(results, model))\\n\\n # Compute statistics\\n auc = roc_auc_score(df.true, df.pred)\\n fpr, tpr, _ = roc_curve(df.true, df.proba)\\n\\n # Plot the stats\\n plt.plot(fpr, tpr, label=f'{model} Score: ' + str(round(auc, 5)))\\n\\n # Finish up the plot and print it\\n plt.plot([0, 1], [0, 1], 'k--', label='Random: 0.5')\\n plt.xlabel('False positive rate')\\n plt.ylabel('True positive rate')\\n plt.title('ROC Curve')\\n plt.legend(loc='best')\\n plt.show()\",\n \"def roc_curve(model, X_train, y_train, X_test, y_test, train=True):\\n from sklearn.metrics import roc_curve\\n if train==True:\\n ypredTrain = model.predict(X_train)\\n fpr, tpr, thresholds = roc_curve(y_train, ypredTrain)\\n plt.plot(fpr, tpr, linewidth=3, label=None, color='r', linestyle='-')\\n plt.rc('xtick', labelsize=10) \\n plt.rc('ytick', labelsize=10) \\n plt.xlabel('False Positive Rate', size=12)\\n plt.ylabel('True Positive Rate', size=12)\\n plt.grid()\\n plt.rcParams['figure.facecolor'] = '#F2F3F4' \\n plt.rcParams['axes.facecolor'] = '#F2F3F4' \\n plt.title(\\\"ROC Curve: Sensitivity/Specificity Trade-off\\\\n\\\\n(Train)\\\\n\\\", size=14)\\n plt.show()\\n elif train==False:\\n ypredTest = model.predict(X_test)\\n fpr, tpr, thresholds = roc_curve(y_test, ypredTest)\\n plt.plot(fpr, tpr, linewidth=3, label=None, color='b', linestyle='-')\\n plt.rc('xtick', labelsize=10) \\n plt.rc('ytick', labelsize=10) \\n plt.xlabel('False Positive Rate', size=12)\\n plt.ylabel('True Positive Rate', size=12)\\n plt.grid()\\n plt.rcParams['figure.facecolor'] = '#F2F3F4' \\n plt.rcParams['axes.facecolor'] = '#F2F3F4'\\n plt.title('ROC Curve: Sensitivity/Specificity Trade-off\\\\n\\\\n(Test)\\\\n', size=14)\\n plt.show()\",\n \"def plot_roc(self, X, y):\\n plot_roc(self.clf, X, y)\",\n \"def validate_and_plot_one_class(normal,outliers):\\n print \\\"running a validation\\\"\\n \\n #classifier\\n \\n train_data = genfromtxt(normal, delimiter='\\\\t',skip_header=0)\\n test_data = genfromtxt(outliers, delimiter='\\\\t',skip_header=0)\\n\\n outliers_proportion = float(test_data.shape[0])/(float(train_data.shape[0])+float(test_data.shape[0]))\\n outliers_proportion=0.01\\n\\n clf = OneClassSVMClassifier(normal,outliers_proportion,0.95,0.05)\\n #processing data without targets\\n X_train = clf.scale(train_data)\\n X_test = clf.scale(test_data)\\n\\n y_pred_train = clf.predict(X_train)\\n y_pred_test = clf.predict(X_test)\\n n_error_train = y_pred_train[y_pred_train == 1].size\\n n_error_test = y_pred_test[y_pred_test == -1].size\\n \\n X=np.vstack((X_train,X_test))\\n y_score = clf.predict(X)\\n\\n Y1=np.ones((X_train.shape[0],))\\n Y2=(np.ones((X_test.shape[0],))*-1)\\n y_true=np.concatenate((Y1,Y2))\\n \\n # Compute ROC curve and area the curve\\n fpr, tpr, thresholds = metrics.roc_curve(y_true,y_score)\\n roc_auc = metrics.auc(fpr, tpr)\\n print \\\"Area under the ROC curve : %f\\\" % roc_auc\\n \\n # Plot ROC curve\\n\\n fig = matplotlib.pyplot.gcf()\\n fig.set_size_inches(6.5,6.5)\\n #font = {'family' : 'sans-serif',\\n # 'weight' : 'normal',\\n # 'size' : 18}\\n\\n #matplotlib.rc('font', **font)\\n pl.clf()\\n #modify plot area\\n #modify tick label font size\\n ax = pl.gca() # get the current axes\\n for l in ax.get_xticklabels() + ax.get_yticklabels():\\n l.set_fontsize('x-large')\\n\\n #color from html code table, linewidth x2.0\\n pl.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc,color=\\\"#00CC66\\\",linewidth=3.0)\\n# pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\\\"#009900\\\",linewidth=3.0)\\n# pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\\n# pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\\n# pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\\n #for more lines with different kernels\\n #default_kernel=\\\"sigmoid\\\";clf = hermes.OneClassSVMClassifier(train,0.00,0.0,0.0595,default_kernel);y_score_sigmoid = clf.predict(X);fpr_sigmoid, tpr_sigmoid, thresholds_sigmoid = metrics.roc_curve(y_true,y_score_sigmoid);roc_auc_sigmoid = metrics.auc(fpr_sigmoid, tpr_sigmoid);fpr_sigmoid;tpr_sigmoid;roc_auc_sigmoid\\n #pl.plot(fpr_rbf, tpr_rbf, label='RBF: ROC curve (area = %0.2f)' % roc_auc_rbf,color=\\\"#00CC66\\\",linewidth=2.0)\\n #pl.plot(fpr_sigmoid, tpr_sigmoid, label='Sigmoid: ROC curve (area = %0.2f)' % roc_auc_sigmoid,color='0.55',linewidth=2.0)\\n #pl.plot(fpr_linear, tpr_linear, label='Linear: ROC curve (area = %0.2f)' % roc_auc_linear,color='0.70',linewidth=2.0)\\n #pl.plot(fpr_poly, tpr_poly, label='Poly: ROC curve (area = %0.2f)' % roc_auc_poly,color='0.85',linewidth=2.0)\\n pl.plot([0, 1], [0, 1], 'k--')\\n #modify base font size\\n pl.xlim([0.0, 1.0])\\n pl.ylim([0.0, 1.0])\\n pl.xlabel('False positive rate',fontsize='xx-large')\\n pl.ylabel('True positive rate',fontsize='xx-large')\\n #pl.title('Receiver operating characteristic example')\\n pl.legend(loc=\\\"lower right\\\",prop={'size':18})\\n pl.show()\\n sys.exit(0)\\n ##the code here below was used to create the ROC curve for europar 13\",\n \"def plot_roc_curve(y_true, y_pred_proba, threshold=0.5):\\n\\n y_pred = predict_with_threshold(y_pred_proba, threshold)\\n roc_auc = roc_auc_score(y_true, y_pred)\\n fpr, tpr, thresholds = roc_curve(y_true, y_pred_proba)\\n\\n plt.plot( # roc auc line\\n fpr, tpr,\\n label='AUC={:.3f}'.format(roc_auc),\\n linewidth=3, alpha=0.7)\\n plt.plot( # base line\\n [0, 1], [0, 1], 'r--',\\n label='baseline=0.5',\\n linewidth=3, alpha=0.3)\\n\\n plt.xlim(0, 1)\\n plt.ylim(0, 1)\\n plt.title('ROC curve')\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.legend(loc=\\\"lower right\\\")\",\n \"def plot_roc_curve(x_data, labels, net, plotfile,\\n title=''):\\n\\n # Have the net predict, then split the scores by ground truth\\n scores = net.predict(x_data)\\n\\n distfile = PLOTDIR / plotfile.replace('roc', 'dist')\\n\\n fig, ax = plt.subplots(1, 1, figsize=(12, 12))\\n\\n df = pd.DataFrame({'Condition': ['Positive' if int(i) == 1 else 'Negative'\\n for i in labels[0, :]],\\n 'Score': scores[0, :]})\\n sns.violinplot(x='Condition', y='Score', data=df, ax=ax)\\n ax.set_title('{} Dist for Rap1 Identification'.format(title))\\n\\n fig.savefig(str(distfile))\\n\\n plt.close()\\n\\n fp_rate, tp_rate = calc_roc(scores[labels], scores[~labels])\\n\\n # Make the plot\\n plotfile = PLOTDIR / plotfile\\n\\n fig, ax = plt.subplots(1, 1, figsize=(12, 12))\\n\\n ax.plot(fp_rate, tp_rate, '-o', linewidth=3)\\n\\n # Plot the line for perfect confusion\\n ax.plot([0, 1], [0, 1], '--', linewidth=3)\\n\\n ax.set_title('{} ROC for Rap1 Identification'.format(title))\\n ax.set_xlabel('False Positive Rate')\\n ax.set_ylabel('True Positive Rate')\\n ax.set_xlim([-0.01, 1.01])\\n ax.set_ylim([-0.01, 1.01])\\n\\n fig.savefig(str(plotfile))\\n plt.close()\",\n \"def prc(test_set_y_org,test_set_y_pred_prob,classes_unique,plot_curve=False,filename=\\\"./fig_prc.pdf\\\",colors=None,positive_class_for_two_classes=None,figwidth=5,figheight=5):\\n from sklearn.metrics import precision_recall_curve\\n from sklearn.metrics import average_precision_score\\n #from scipy import interp\\n import matplotlib as mpl\\n mpl.use(\\\"pdf\\\")\\n import matplotlib.pyplot as plt\\n \\n precision = dict()\\n recall = dict()\\n average_precision = dict()\\n n_classes=len(classes_unique)\\n test_set_Y_org,test_set_y_org_unique=membership_vector_to_indicator_matrix(test_set_y_org)\\n \\n for c in range(n_classes):\\n precision[c], recall[c], _ = precision_recall_curve(test_set_Y_org[:, c], test_set_y_pred_prob[:, c])\\n average_precision[c] = average_precision_score(test_set_Y_org[:, c], test_set_y_pred_prob[:, c])\\n \\n # Compute macro-average ROC curve and AUROC area\\n # First aggregate all recalls\\n all_recall = np.unique(np.concatenate([recall[c] for c in range(n_classes)]))\\n #all_recall = np.sort(np.concatenate([recall[c] for c in range(n_classes)]))\\n # Then interpolate all PRC curves at this points\\n mean_precision = np.zeros_like(all_recall)\\n for c in range(n_classes):\\n mean_precision = mean_precision + np.interp(all_recall, recall[c][::-1], precision[c][::-1]) # xp in interp() must be in increasing order\\n # Finally average it and compute AUPRC\\n mean_precision = mean_precision/n_classes\\n recall[\\\"macro\\\"] = all_recall\\n precision[\\\"macro\\\"] = mean_precision\\n #roc_auc[\\\"macro\\\"] = auc(fpr[\\\"macro\\\"], tpr[\\\"macro\\\"])\\n # Compute micro-average ROC curve and ROC area\\n precision[\\\"micro\\\"], recall[\\\"micro\\\"], _ = precision_recall_curve(test_set_Y_org.ravel(), test_set_y_pred_prob.ravel())\\n average_precision[\\\"macro\\\"] = average_precision_score(test_set_Y_org, test_set_y_pred_prob, average=\\\"macro\\\") # micro macro, weighted, or samples\\n average_precision[\\\"micro\\\"] = average_precision_score(test_set_Y_org, test_set_y_pred_prob, average=\\\"micro\\\") # micro macro, weighted, or samples\\n average_precision[\\\"weighted\\\"] = average_precision_score(test_set_Y_org, test_set_y_pred_prob, average=\\\"weighted\\\") # micro macro, weighted, or samples\\n average_precision[\\\"samples\\\"] = average_precision_score(test_set_Y_org, test_set_y_pred_prob, average=\\\"samples\\\") # micro macro, weighted, or samples\\n\\n if plot_curve:\\n fig=plt.figure(num=1,figsize=(figwidth,figheight))\\n ax=fig.add_subplot(1,1,1)\\n if n_classes>2 or positive_class_for_two_classes is None:\\n ax.plot(recall[\\\"macro\\\"], precision[\\\"macro\\\"], linewidth=1,color=colors[n_classes],label='macro-avg PRC (area={0:0.4f})'.format(average_precision[\\\"macro\\\"]))\\n \\n for c in range(n_classes):\\n if positive_class_for_two_classes==None or (n_classes==2 and positive_class_for_two_classes==c):\\n ax.plot(recall[c], precision[c],linewidth=1,color=colors[c],label='PRC of {0} (area={1:0.4f})'.format(classes_unique[c], average_precision[c]))\\n \\n # add some text for labels, title and axes ticks\\n ax.set_ylim(0.0,1.0)\\n ax.set_xlim(0.0,1.0)\\n ax.set_ylabel(\\\"Precision\\\",fontsize=12)\\n ax.set_xlabel(\\\"Recall\\\",fontsize=12) \\n #ax.set_title(\\\"\\\",fontsize=15)\\n ax.legend(loc=\\\"lower left\\\",fontsize=8)\\n #plt.subplots_adjust(bottom=0.12) # may this is not working because of the following setting\\n fig.savefig(filename,bbox_inches='tight')\\n plt.close(fig)\\n\\n average_precision_list=[average_precision[c] for c in range(n_classes)]\\n average_precision_list.extend([average_precision[\\\"macro\\\"],average_precision[\\\"micro\\\"],average_precision[\\\"weighted\\\"],average_precision[\\\"samples\\\"]])\\n average_precision=np.array(average_precision_list)\\n names=[\\\"AUPRC_\\\" + c for c in classes_unique]\\n names.extend([\\\"macro\\\",\\\"micro\\\",\\\"weighted\\\",\\\"samples\\\"])\\n names=np.array(names)\\n \\n return average_precision,names\",\n \"def single_roc_plot(y_true, y_probas, text=None, title='ROC Curves', figsize=None, title_fontsize=\\\"large\\\", text_fontsize=\\\"medium\\\"):\\n fig, ax = plt.subplots(1, 1, figsize=figsize)\\n ax.set_title(title, fontsize=title_fontsize)\\n fpr, tpr, _ = roc_curve(y_true, y_probas, pos_label=1)\\n roc_auc = auc(fpr, tpr)\\n ax.plot(fpr, tpr, label='ROC curve '\\n '(area = {0:0.2f})'.format(roc_auc),\\n color='blue', linewidth=2)\\n ax.plot([0, 1], [0, 1], 'k--', lw=2)\\n ax.set_xlim([0.0, 1.0])\\n ax.set_ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n ax.set_ylabel('True Positive Rate', fontsize=text_fontsize)\\n ax.tick_params(labelsize=text_fontsize)\\n ax.legend(loc='lower right', fontsize=text_fontsize)\\n return fig\",\n \"def verif_valid_from_bag(list_models, X_val, reality, cut=0.5):\\n bag_scores = []\\n for model in list_models:\\n pred_score = model.predict_proba(X_val)[:,1]\\n bag_scores.append(pred_score.tolist())\\n bag_scores = pd.DataFrame(bag_scores).transpose()\\n #bag_scores = np.asmatrix(bag_scores)[:,0:5]\\n pred_score = bag_scores.mean(axis=1)\\n predictions = np.where(pred_score > cut, 1, 0)\\n print('Confusion Matrix :')\\n conf_mat = confusion_matrix(reality, predictions)\\n print(pd.DataFrame(conf_mat))\\n print('Associated metrics :')\\n print(classification_report(reality, predictions))\\n fpr, tpr, _ = roc_curve(reality, pred_score)\\n roc_auc = auc(fpr, tpr)\\n print('Avg False-Pos rate = ' + str(round(np.mean(fpr), 4)) +\\n ' | Avg True-Pos rate : ' + str(round(np.mean(tpr), 4)))\\n plt.plot(fpr, tpr, 'r-', lw=4)\\n actual_fpr = conf_mat[1, 0] / (conf_mat[1, 0] + conf_mat[0, 0])\\n actual_tpr = conf_mat[1, 1] / (conf_mat[1, 1] + conf_mat[0, 1])\\n plt.plot(actual_fpr, actual_tpr, 'bo', lw=10)\\n plt.xlabel('False-Positive Rate')\\n plt.ylabel('True-Positive Rate')\\n plt.title('ROC curve (with AUC = ' + str(round(roc_auc, 6)) + ')')\\n plt.plot([0, 1], [0, 1], 'k-')\\n plt.show()\\n print('Score AUC : ' + str(roc_auc))\\n print('Accuracy : ' + str(metrics.accuracy_score(reality, predictions)))\",\n \"def examine(stocks, init_param, C_in, gamma_in, verbose):\\r\\n from sklearn.svm import SVC\\r\\n from sklearn import metrics\\r\\n import matplotlib.pyplot as plt\\r\\n# import pandas as pd\\r\\n \\r\\n training_data, test_data = form_data(stocks, init_param)\\r\\n std_scale = preprocessing.StandardScaler().fit(training_data.X)\\r\\n training_data.X = std_scale.transform(training_data.X)\\r\\n test_data.X = std_scale.transform(test_data.X)\\r\\n \\r\\n svm = SVC(kernel='rbf', random_state=0, gamma = gamma_in, C=C_in, probability=True)\\r\\n svm.fit(training_data.X, training_data.y)\\r\\n preds = svm.predict_proba(test_data.X)[:,1]\\r\\n fpr, tpr, _ = metrics.roc_curve(test_data.y, preds)\\r\\n\\r\\n# df = pd.DataFrame(dict(fpr=fpr, tpr=tpr))\\r\\n roc_auc = metrics.auc(fpr,tpr)\\r\\n \\r\\n if verbose:\\r\\n plt.figure()\\r\\n lw = 2\\r\\n plt.plot(fpr, tpr, color='darkorange',\\r\\n lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)\\r\\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\\r\\n plt.xlim([0.0, 1.0])\\r\\n plt.ylim([0.0, 1.05])\\r\\n plt.xlabel('False Positive Rate')\\r\\n plt.ylabel('True Positive Rate')\\r\\n plt.title('Receiver operating characteristic example')\\r\\n plt.legend(loc=\\\"lower right\\\")\\r\\n plt.show()\\r\\n \\r\\n return roc_auc\",\n \"def plot_results(\\n predictor_names, validation_auc_values, is_forward_test,\\n axes_object=None, num_predictors_to_plot=None):\\n\\n if num_predictors_to_plot is None:\\n num_predictors_to_plot = len(predictor_names)\\n\\n num_predictors_to_plot = max([num_predictors_to_plot, 2])\\n num_predictors_to_plot = min([\\n num_predictors_to_plot, len(predictor_names)\\n ])\\n\\n y_coords = numpy.linspace(\\n 0, num_predictors_to_plot - 1, num=num_predictors_to_plot, dtype=float\\n )[::-1]\\n\\n if axes_object is None:\\n _, axes_object = pyplot.subplots(\\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\\n )\\n\\n axes_object.barh(\\n y_coords, validation_auc_values[:num_predictors_to_plot],\\n color=BAR_FACE_COLOUR, edgecolor=BAR_EDGE_COLOUR,\\n linewidth=BAR_EDGE_WIDTH\\n )\\n\\n axes_object.set_yticks([], [])\\n axes_object.set_xlabel('Validation AUC')\\n\\n if is_forward_test:\\n axes_object.set_ylabel('Predictor added')\\n else:\\n axes_object.set_ylabel('Predictor removed')\\n\\n axes_object.set_ylim(\\n numpy.min(y_coords) - 0.75, numpy.max(y_coords) + 0.75\\n )\\n axes_object.set_xlim(\\n 0, numpy.max(validation_auc_values[:num_predictors_to_plot])\\n )\\n\\n for j in range(num_predictors_to_plot):\\n axes_object.text(\\n 0., y_coords[j], ' ' + predictor_names[j],\\n color=BAR_TEXT_COLOUR, fontsize=BAR_FONT_SIZE,\\n horizontalalignment='left', verticalalignment='center'\\n )\\n\\n return axes_object\",\n \"def plot_acc(acc_v, acc_t, save_plots_path):\\n\\n plt.figure()\\n plt.plot(acc_v, label='Validation acc')\\n plt.plot(acc_t, label='Training acc')\\n plt.legend()\\n title = 'Accuracy per epoch'\\n plt.title(title)\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Accuracy\\\")\\n plt.savefig(save_plots_path + \\\"swag_accuracy_plot.png\\\")\",\n \"def performancePlot(plot=\\\"ROC\\\"):\\n fig, ax = plt.subplots()\\n colors = {\\\"ML\\\": \\\"red\\\", \\\"Null YFP\\\": \\\"gold\\\", \\\"Null DAPI\\\": \\\"blue\\\"}\\n mapp = pickle.load(open(\\\"pickles/mapp_fold_-1.pk\\\", \\\"rb\\\"))\\n null_mapp = pickle.load(open(\\\"pickles/null_YFP_mapp_fold_-1.pk\\\", \\\"rb\\\"))\\n null_DAPI_mapp = pickle.load(open(\\\"pickles/null_DAPI_mapp_fold_-1.pk\\\", \\\"rb\\\"))\\n \\n i = 0\\n for m in [mapp, null_mapp, null_DAPI_mapp]:\\n coordinates = [] #list of tuples (thresh, x point, y point) to plot\\n for key in m: ##for each threshold\\n TPs = sum([x[0] for x in m[key]])\\n FPs = sum([x[1] for x in m[key]])\\n TNs = sum([x[2] for x in m[key]])\\n FNs = sum([x[3] for x in m[key]])\\n if plot == \\\"PRC\\\":\\n x = TPs / float(TPs + FNs) #recall (TPR)\\n y = TPs / float(TPs + FPs) #precision\\n if plot == \\\"ROC\\\":\\n x = FPs / float(FPs + TNs) #FPR \\n y = TPs / float(TPs + FNs) #recall (TPR)\\n if not (np.isnan(x) or np.isnan(y)): \\n coordinates.append((key, x, y))\\n coordinates = sorted(coordinates, key=lambda x: x[0]) ##sort by threshold\\n x = [t[1] for t in coordinates][::-1]\\n y = [t[2] for t in coordinates][::-1]\\n # print(i, coordinates)\\n # thresholds = [entry[0] for entry in coordinates]\\n # for j, txt in enumerate(thresholds):\\n # ax.annotate(txt, (x[j], y[j]), fontsize=5)\\n auc = np.trapz(y,x)\\n if i == 0:\\n label = \\\"ML\\\"\\n if i == 1:\\n label = \\\"Null YFP\\\"\\n if i == 2:\\n label = \\\"Null DAPI\\\" \\n ax.plot(x, y, linewidth=2.0, color=colors[label], label=\\\"{} Model, AUC = {}\\\".format(label, str(round(auc, 2)))) \\n i += 1\\n plt.title(\\\"{} Curves\\\".format(plot), fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_xlim((0,1))\\n ax.set_ylim((0,1))\\n plt.rc('font',family='Times New Roman')\\n plt.xticks(fontname=\\\"Times New Roman\\\", fontsize=12)\\n plt.yticks(fontname=\\\"Times New Roman\\\", fontsize=12)\\n if plot == \\\"ROC\\\":\\n ax.set_xlabel(\\\"False Positive Rate\\\", fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_ylabel(\\\"True Positive Rate\\\",fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.plot([0, .5, 1], [0,.5, 1], linestyle=\\\"--\\\", linewidth=1.0, color=\\\"black\\\")\\n ax.legend(loc='lower right',prop={\\\"family\\\":\\\"Times New Roman\\\", \\\"size\\\":10})\\n plt.savefig(\\\"matplotlib_figures/ROC.png\\\", dpi=300)\\n if plot == \\\"PRC\\\":\\n positives = TPs + FNs ##doesn't matter which map we use, positive prevalence independent of map \\n total = TPs + FPs + TNs + FNs \\n positive_prevalence = positives / float(total)\\n ax.hlines(y=positive_prevalence, xmin=0, xmax=1, linestyle=\\\"--\\\", linewidth=1.0, color=\\\"black\\\")\\n ax.set_xlabel(\\\"Recall\\\", fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_ylabel(\\\"Precision\\\",fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_xlim((0,1))\\n ax.set_ylim((0,1))\\n ax.legend(loc='upper right',prop={\\\"family\\\":\\\"Times New Roman\\\", \\\"size\\\":10})\\n plt.savefig(\\\"matplotlib_figures/PRC.png\\\", dpi=300)\",\n \"def ROC_curve_binary(actual_labels, basic_cnn_pred_score, pos_label = \\\"malaria\\\"):\\n fpr, tpr, thresholds = metrics.roc_curve(actual_labels, basic_cnn_pred_score, pos_label=pos_label)\\n\\n roc_auc = auc(fpr, tpr)\\n\\n plt.figure()\\n lw = 2\\n # colors = ['aqua', 'darkorange', 'cornflowerblue', 'navy', 'deeppink', 'aqua', 'darkorange', 'cornflowerblue']\\n plt.plot(fpr, tpr, color='darkorange',\\n lw=lw, label='ROC curve (area = %0.4f)' % roc_auc)\\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('Receiver operating characteristic')\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\",\n \"def do_prc(scores, true_labels, file_name='', directory='', plot=True):\\n\\n # precision_0, recall_0, _ = precision_recall_curve(true_labels, scores[0])\\n # prc_auc_0 = auc(recall_0, precision_0)\\n # precision_1, recall_1, _ = precision_recall_curve(true_labels, scores[1])\\n # prc_auc_1 = auc(recall_1, precision_1)\\n # precision_2, recall_2, _ = precision_recall_curve(true_labels, scores[2])\\n # prc_auc_2 = auc(recall_2, precision_2)\\n # precision_3, recall_3, _ = precision_recall_curve(true_labels, scores[3])\\n # prc_auc_3 = auc(recall_3, precision_3)\\n # precision_4, recall_4, _ = precision_recall_curve(true_labels, scores[4])\\n # prc_auc_4 = auc(recall_4, precision_4)\\n precision, recall, _ = precision_recall_curve(true_labels, scores)\\n prc_auc = auc(recall, precision)\\n\\n plt.figure(figsize=(10,10))\\n plt.rcParams.update({'font.size': 50})\\n plt.plot(recall, precision, color='lightblue',label='area = %0.3f' % (prc_auc))\\n # plt.plot(recall_1, precision_1, color='wheat', label='VAE PRC curve (area = %0.3f)' % (prc_auc_1))\\n # plt.plot(recall_2, precision_2, color='lightblue', label='CNNAE PRC curve (area = %0.3f)' % (prc_auc_2))\\n # plt.plot(recall_3, precision_3, color='lightskyblue', label='CNNVAE PRC curve (area = %0.3f)' % (prc_auc_3))\\n # plt.plot(recall_4, precision_4, color='plum', label='ALAD PRC curve (area = %0.3f)' % (prc_auc_4))\\n # plt.plot(recall_4, precision_4, color='brown', label='Ensemble PRC curve (area = %0.3f)' % (prc_auc_5))\\n\\n\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('Recall')\\n plt.ylabel('Precision')\\n plt.legend(loc=\\\"lower right\\\")\\n plt.savefig(directory + file_name + 'prc.eps', bbox_inches='tight', format='eps')\\n plt.close()\\n\\n # return prc_auc\",\n \"def plot_histogram_assess(assess_input, figure_output):\\n\\n sns.set_style(\\\"white\\\")\\n raw_auc = pd.read_table(assess_input, index_col=\\\"Motif\\\")\\n raw_auc = raw_auc.drop_duplicates()\\n # df = df.T.drop_duplicates().T\\n raw_auc = raw_auc.sort(columns=\\\"MNCP\\\", axis=0, ascending=False)\\n labels = raw_auc.index\\n x = 10\\n if len(labels) > 50:\\n x = 15\\n elif len(labels) < 10:\\n x = 5\\n f, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1, figsize=(x, 10), sharex=True)\\n a = sns.barplot(x=labels, y=raw_auc[\\\"AUC\\\"],\\n palette='colorblind', x_order=labels, ax=ax1)\\n b = sns.barplot(x=labels, y=raw_auc[\\\"MNCP\\\"],\\n palette=\\\"colorblind\\\", x_order=labels, ax=ax2)\\n c = sns.barplot(x=labels, y=raw_auc[\\\"Spearman\\\"],\\n palette=\\\"colorblind\\\", x_order=labels, ax=ax3)\\n d = sns.barplot(x=labels, y=raw_auc[\\\"Pearson\\\"],\\n palette=\\\"colorblind\\\", x_order=labels, ax=ax4)\\n d.set_xticklabels(labels, rotation=90)\\n\\n sns.despine()\\n f.savefig(figure_output + \\\".eps\\\", bbox_inches='tight')\\n f.savefig(figure_output + \\\".png\\\", bbox_inches='tight')\",\n \"def check_fit(truth, prob):\\n fpr, tpr, _ = roc_curve(truth, prob) # drop_intermediate:(default=True)\\n roc_auc = auc(fpr, tpr) # calculate the AUC\\n plt.figure()\\n plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\\n plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\\n plt.xlim([-0.1, 1.05])\\n plt.ylim([-0.1, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('Receiver operating characteristic example')\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\\n print('results are RMSE, accuracy, ROC, loss function')\\n print(sqrt(mean_squared_error(truth, prob)), accuracy_score(truth, prob), roc_auc, zero_one_loss(truth, prob))\",\n \"def plot_all(pred_tuple, filename='roc.png'):\\n plt.clf()\\n colors = [\\\"red\\\",\\\"blue\\\",\\\"green\\\",\\\"orange\\\",\\\"yellow\\\"]\\n for (label, y, proba), color in zip(pred_tuple, colors):\\n true_pos, false_pos, thresh = metrics.roc_curve(y, proba)\\n plt.plot(false_pos, true_pos, label=label, linewidth=2,\\n color=color)\\n plt.plot([0,1],[0,1], linestyle=\\\"dashed\\\", color=\\\"grey\\\", label=\\\"random\\\")\\n plt.xlim([0,1])\\n plt.ylim([0,1])\\n plt.xlabel(\\\"False Positive Rate\\\")\\n plt.ylabel(\\\"True Positive Rate\\\")\\n plt.title(\\\"Receiver Operating Characteristic\\\")\\n plt.legend(loc=\\\"lower right\\\")\\n\\n plt.show()\\n plt.savefig(_plots_path + filename)\",\n \"def make_plot(folder, community, axarr=None, pos=None, n_points=20, show_legend=False, auc_file_writer=None):\\n if axarr == None:\\n fig = plt.figure(figsize=fig_dim)\\n ax = fig.add_subplot(pos[0], pos[1], 1, zorder=1)\\n else:\\n ax = axarr[pos[0], pos[1]]\\n # ax.set_ylim(bottom=0)\\n if pos[0] == len(axarr) - 1:\\n ax.set_xlabel('additions as % of |C|', fontsize=10)\\n # ax.set_xlabel(r'$\\\\# \\\\textup{inclusions}/ | C^{\\\\textup{true}} |$', fontsize = 16)\\n if pos[1] == 0:\\n ax.set_ylabel('recall', fontsize=10)\\n\\n area_under_curve = []\\n for idx, method in enumerate(METHODS):\\n index, mean, std_error = read_recall(folder, community, method)\\n area_under_curve.append(auc(index, mean))\\n plot_indices = uniform_sample(n_points, len(\\n index)) # don't want to plot all of the indices as the error bars look cluttered\\n ax.errorbar(np.insert(index[plot_indices], 0, 0), np.insert(mean[plot_indices], 0, 0),\\n np.insert(std_error[plot_indices], 0, 0), color=COLOURS[idx], label=method,\\n alpha=0.5)\\n # ax.set_title(folder.rsplit('/', 1)[-1], fontsize=10)\\n ax.set_title(community, fontsize=8, y=0.95)\\n auc_file_writer.writerow([community] + area_under_curve)\\n if show_legend:\\n legend = ax.legend(loc='upper center')\\n for label in legend.get_texts():\\n label.set_fontsize(6)\\n\\n if axarr == None:\\n fig.tight_layout(pad=0.1)\\n tag = folder.rsplit('/', 2)[-2]\\n plt.savefig(\\\"local_results/recall_figs/recall_vs_range_{}.pdf\\\".format(tag))\\n plt.close()\\n\\n return index, mean, std_error\",\n \"def plot_ROC_curves(fig, ax, y_all, perf, title=None):\\n curves = {'IMPRESS_all': 'royalblue',\\n 'IMPRESS_HE_only': 'plum',\\n 'IMPRESS_IHC_only': 'pink',\\n 'pathologists_eval': 'tomato'}\\n \\n type_convert = {'IMPRESS_all': 'IMPRESS',\\n 'IMPRESS_HE_only': 'IMPRESS (H&E only)',\\n 'IMPRESS_IHC_only': 'IMPRESS (IHC only)',\\n 'pathologists_eval': 'Pathologists'}\\n \\n for fgroup in curves.keys():\\n tprs = []\\n aucs = []\\n mean_fpr = np.linspace(0, 1, 100)\\n ax.set_aspect('equal')\\n for seed in range(int(y_all[fgroup].shape[1]/3)):\\n y_true = y_all[fgroup].loc[:,'y_true'].iloc[:,seed]\\n y_pred_proba = y_all[fgroup].loc[:,'y_pred_proba'].iloc[:,seed]\\n tpr, fpr, treshold = roc_curve(y_true, 1-y_pred_proba)\\n tprs.append(np.interp(mean_fpr, fpr, tpr))\\n roc_auc = auc(fpr, tpr)\\n aucs.append(roc_auc)\\n ax.plot(fpr, tpr, color=curves[fgroup], linewidth=2, alpha=0.10, label=None)\\n \\n mean_tpr = np.mean(tprs, axis=0)\\n mean_tpr[-1] = 1.0\\n \\n ax.plot(mean_fpr, mean_tpr, color=curves[fgroup],\\n label=r'%s (AUC = %0.4f $\\\\pm$ %0.2f)' % \\\\\\n (type_convert[fgroup], perf[fgroup].loc['AUC','mean'], perf[fgroup].loc['AUC','std']),\\n linewidth=3.0, alpha=0.80)\\n \\n std_tpr = np.std(tprs, axis=0)\\n tprs_upper = np.minimum(mean_tpr + std_tpr, 1)\\n tprs_lower = np.maximum(mean_tpr - std_tpr, 0)\\n \\n if fgroup == 'IMPRESS_all':\\n ax.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=0.1,\\n label=r'$\\\\pm$ 1 standard deviation')\\n else:\\n ax.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=0.1,\\n label=None)\\n \\n ax.set_xlabel('False positive rate')\\n ax.set_ylabel('True positive rate')\\n x = [0.0, 1.0]\\n plt.plot(x, x, linestyle='dashed', color='red', linewidth=2.0, label='Random')\\n plt.legend(fontsize=10, loc='best')\\n \\n if title is not None:\\n fig.suptitle(t=title, fontsize=12)\\n return fig\",\n \"def generate_roc_curve(clf, X, y, survived_weight=1, plot=False, n_classes=5):\\n fpr = dict()\\n tpr = dict()\\n roc_auc = dict()\\n aucs = []\\n for i in range(5):\\n # shuffle and split training and test sets\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.25)\\n #weights = np.array([survived_weight if s == 1 else 1 for s in y_train])\\n #clf.fit(X_train, y_train, sample_weight=weights)\\n clf.fit(X_train, y_train)\\n\\n fpr[i], tpr[i], _ = roc_curve(y_test, clf.predict_proba(X_test)[:,1])\\n roc_auc[i] = auc(fpr[i], tpr[i])\\n aucs.append(roc_auc[i])\\n print('ROC AUC: {:.2%}'.format(roc_auc[i]))\\n\\n auc_mean = \\\"{:.3%}\\\".format(np.mean(aucs))\\n auc_std = \\\"{:.3%}\\\".format(np.std(aucs))\\n auc_lower = \\\"{:.3%}\\\".format(np.mean(aucs)-np.std(aucs))\\n print(\\\"ROC - Area under curve: {} and stddev: {}\\\".format(auc_mean, auc_std))\\n\\n if plot:\\n # Plot of a ROC curve for a specific class\\n plt.figure()\\n for i in range(5):\\n plt.plot(fpr[i], tpr[i], label='ROC curve (area = %0.2f)' % roc_auc[i])\\n\\n plt.plot([0, 1], [0, 1], 'k--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('ROC Curve')\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\",\n \"def single_auc_loging(history,title,path_to_save):\\n f, (ax1, ax2) = plt.subplots(1, 2,figsize=(12,12))\\n\\n if 'loss' in history.keys():\\n loss_key = 'loss' # for simple NN\\n elif 'class_out_loss' in history.keys():\\n loss_key = 'class_out_loss' # for DAL NN\\n else:\\n raise ValueError('Not found correct key for loss information in history')\\n\\n ax1.plot(history[loss_key],label='cl train loss')\\n ax1.plot(history['val_%s' %loss_key],label='cl val loss')\\n ax1.legend()\\n min_loss_index,max_loss_value = min(enumerate(history['val_loss']), key=operator.itemgetter(1))\\n ax1.set_title('min_loss_%.3f_epoch%d' % (max_loss_value, min_loss_index))\\n ax2.plot(history['val_auc'])\\n max_auc_index, max_auc_value = max(enumerate(history['val_auc']), key=operator.itemgetter(1))\\n ax2.set_title('max_auc_%.3f_epoch%d' % (max_auc_value, max_auc_index))\\n f.suptitle('%s' % (title))\\n plt.savefig('%s/%s.png' % (path_to_save,title), figure=f)\\n plt.close()\\n with open('%s/%s.pkl' % (path_to_save,title), 'wb') as output:\\n pickle.dump(history,output,pickle.HIGHEST_PROTOCOL)\",\n \"def pr_writer(clf, y_true, y_prob, eval_folder, i=''):\\n # make sure y_true, y_prob is iterable\\n if type(y_true[0]) is not np.ndarray: y_true = [y_true]\\n if type(y_prob[0]) is not np.ndarray: y_prob = [y_prob]\\n\\n img_dir = eval_folder+'/images/'\\n if not os.path.exists(img_dir):\\n os.makedirs(img_dir)\\n\\n clf_name = str(clf)[:str(clf).index('(')]+str(i)\\n\\n enum_list = range(0, len(y_true))\\n pr_auc = []\\n\\n # plot pr each fold's PR curve\\n for i in enum_list:\\n prec, rec, _ = metrics.precision_recall_curve(y_true[i], y_prob[i])\\n pr_auc.append(metrics.average_precision_score(y_true[i], y_prob[i]))\\n plt.plot(rec, prec)\\n\\n # make plot, only show mean, SE for AUCs\\n plt.title('Precision-Recall')\\n plt.plot(rec, prec, linestyle='none', label='Mean AUC = %0.2f\\\\nSE AUC = %0.3f'% (np.mean(pr_auc), np.std(pr_auc)))\\n plt.legend(loc='upper right')\\n plt.xlabel('Recall')\\n plt.ylabel('Precision')\\n plt.ylim([0.0, 1.05])\\n plt.xlim([0.0, 1.0])\\n\\n\\n plt.savefig(img_dir+'PR_Curve_'+clf_name+'.png')\",\n \"def gen_plot(fpr, tpr):\\n plt.figure()\\n plt.xlabel(\\\"FPR\\\", fontsize=14)\\n plt.ylabel(\\\"TPR\\\", fontsize=14)\\n plt.title(\\\"ROC Curve\\\", fontsize=14)\\n plot = plt.plot(fpr, tpr, linewidth=2)\\n buf = io.BytesIO()\\n plt.savefig(buf, format='jpeg')\\n buf.seek(0)\\n plt.close()\\n # plt.show()\\n return buf\",\n \"def plot_roc_curve(y, y_pred, threshold_step=0.001):\\r\\n # define the thresholds that will be used to compute the ROC curve\\r\\n thresholds = np.arange(threshold_step, 1.0, threshold_step)\\r\\n\\r\\n # define the list with the values of (sensitivity and 1 - specificity)\\r\\n recalls = []\\r\\n fall_outs = []\\r\\n\\r\\n # compute the metrics for every threshold\\r\\n for threshold in thresholds:\\r\\n\\r\\n # get the roc metrics\\r\\n recall, fall_out = roc_metrics(y_pred, y, threshold=threshold)\\r\\n\\r\\n # append to the corresponding lists\\r\\n recalls.append(recall)\\r\\n fall_outs.append(fall_out)\\r\\n\\r\\n # configure the size of the ROC curve plots\\r\\n plt.rcParams[\\\"figure.figsize\\\"] = [15, 10]\\r\\n plt.rcParams[\\\"xtick.labelsize\\\"] = 14\\r\\n plt.rcParams[\\\"ytick.labelsize\\\"] = 14\\r\\n\\r\\n # plot the ROC curve\\r\\n plt.plot(fall_outs, recalls, color=\\\"darkcyan\\\", label=\\\"RNN Classifier\\\")\\r\\n\\r\\n # plot y = x for comparison\\r\\n x = np.arange(0, 1.01, 0.1)\\r\\n plt.plot(x, x, color=\\\"brown\\\", linestyle=\\\"--\\\", label=r\\\"$y\\\\;=\\\\;x$\\\")\\r\\n\\r\\n # add legend, labels and title\\r\\n plt.xlabel(\\\"\\\\n1 - Specificity\\\", fontsize=20)\\r\\n plt.ylabel(\\\"Sensitivity\\\\n\\\", fontsize=20)\\r\\n plt.title(\\\"ROC curve\\\\n\\\", fontsize=25)\\r\\n plt.legend()\\r\\n plt.grid()\\r\\n plt.show()\",\n \"def get_evaluation_metrics(inference_model_name,\\n partition_option,\\n data_split_type,\\n plot_roc_curve=True,\\n plot_confusion_matrix=True):\\n inference_file_name = get_inference_file_name(inference_model_name,\\n partition_option,\\n data_split_type)\\n inference_dir = os.path.join(args.output_data_dir, 'inference')\\n inference_df = pd.read_pickle(os.path.join(inference_dir,\\n inference_file_name))\\n\\n # Evaluate within the tissue region\\n filter_mask = (inference_df['is_roi'] == 1) & \\\\\\n (inference_df['non_gray_ratio'] > NON_GRAY_RATIO_THRESHOLD)\\n inference_df = inference_df[filter_mask].copy()\\n\\n y_truth = inference_df['label'].astype(int).values\\n y_pred_prob = inference_df['y_pred_prob'].values\\n y_pred = (y_pred_prob > 0.5).astype(int)\\n\\n accuracy = accuracy_score(y_truth, y_pred)\\n precision = precision_score(y_truth, y_pred)\\n recall = recall_score(y_truth, y_pred)\\n\\n loss = log_loss(y_truth, y_pred_prob, eps=1e-6)\\n fpr, tpr, threshold = roc_curve(y_truth, y_pred_prob)\\n roc_auc = auc(fpr, tpr)\\n\\n # accuracy if we predict everything as negative\\n dummy_accuracy = 1 - y_truth.mean()\\n\\n output = {\\n 'model_name': inference_model_name,\\n 'loss': loss,\\n 'accuracy': accuracy,\\n 'precision': precision,\\n 'recall': recall,\\n 'auc': roc_auc,\\n 'dummy_accuracy': dummy_accuracy,\\n }\\n\\n if plot_roc_curve:\\n plt.figure()\\n\\n lw = 2\\n plt.plot(fpr, tpr, color='orange',\\n lw=lw,\\n label='{} (area = {:.3f})'.format(\\n inference_model_name, roc_auc))\\n plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('ROC Curve')\\n plt.legend(loc='lower right')\\n\\n if plot_confusion_matrix:\\n cm = confusion_matrix(y_truth, y_pred)\\n fig, ax = plt.subplots()\\n sns.heatmap(cm, annot=True, ax=ax, fmt='g')\\n\\n # labels, title and ticks\\n ax.set_xlabel('Predicted labels')\\n ax.set_ylabel('True labels')\\n ax.set_title('Confusion Matrix')\\n ax.xaxis.set_ticklabels([0, 1])\\n ax.yaxis.set_ticklabels([0, 1])\\n\\n return output\",\n \"def finetune_n_estimators(savefigure=False):\\n res = np.array(np.load('npy-data/result_n_estimators_tuning_acc_auc_crossval_train.npy'))\\n acc, auc = res[:int(len(res)/2)], res[int(len(res)/2):]\\n plt.plot([j*10 for j in range(1,31)],acc,[j*10 for j in range(1,31)],auc)\\n plt.xlabel('Number of trees')\\n plt.ylabel('Accuracy/AUC score')\\n plt.legend([\\\"Accuracy\\\",\\\"ROC AUC\\\"])\\n if savefigure:\\n plt.savefig('img/accuracy_n_estimators_tuning_acc_auc_crossval.pdf', bbox_inches='tight')\\n plt.show()\",\n \"def evaluate_model(clf_, X_tr, X_te, y_tr, y_te, cls_rpt_tr=False, show=True, cls_labels=None, binary=False):\\n \\n import sklearn.metrics as metrics\\n import matplotlib.pyplot as plt\\n from yellowbrick.classifier import ROCAUC\\n \\n ## Fit and predict \\n y_hat_trn, y_hat_tes = fit_n_pred(clf_, X_tr, X_te, y_tr)\\n \\n if show:\\n ## Classification Report / Scores\\n if cls_rpt_tr:\\n print('Classification Report Train')\\n print(metrics.classification_report(y_tr,y_hat_trn))\\n else:\\n print('Classification Report Test')\\n print(metrics.classification_report(y_te,y_hat_tes))\\n\\n ## Confusion Matrix\\n fig, ax = plt.subplots(figsize=(10,5), ncols=2)\\n \\n metrics.plot_confusion_matrix(clf_,X_te,y_te,cmap=\\\"YlOrRd\\\",\\n normalize='true',ax=ax[0])\\n ax[0].set(title='Confusion Matrix Test Data')\\n ax[0].grid(False) \\n\\n roc = ROCAUC(clf_, classes=cls_labels, ax=ax[1])\\n roc.fit(X_tr, y_tr)\\n roc.score(X_te, y_te)\\n roc.finalize()\\n \\n plt.tight_layout()\\n plt.show()\\n \\n if binary:\\n try:\\n imps = plot_importance(clf_, X_tr)\\n except:\\n imps = None\\n \\n else:\\n return y_hat_trn, y_hat_tes\",\n \"def plot_loss_acc(history, aucs, model_path=None):\\n # summarize history for accuracy\\n plt.plot(history.history['acc'])\\n plt.plot(history.history['val_acc'])\\n plt.title('model accuracy')\\n plt.ylabel('accuracy')\\n plt.xlabel('epoch')\\n plt.legend(['train', 'test'], loc='upper left')\\n plt.savefig(path.join(model_path, 'accuracy.png'))\\n plt.gcf().clear()\\n # summarize history for loss\\n plt.plot(history.history['loss'])\\n plt.plot(history.history['val_loss'])\\n plt.plot(aucs)\\n plt.title('model loss, ROC AUC')\\n plt.ylabel('loss, ROC AUC')\\n plt.xlabel('epoch')\\n plt.legend(['train', 'test', 'ROC AUC'], loc='upper left')\\n plt.savefig(path.join(model_path, 'loss.png'))\",\n \"def roc_auc(y_true, y_score, pos_label=..., ascending_score=...):\\n ...\",\n \"def gen_plot(fpr, tpr):\\n plt.figure()\\n plt.xlabel(\\\"FPR\\\", fontsize=14)\\n plt.ylabel(\\\"TPR\\\", fontsize=14)\\n plt.title(\\\"ROC Curve\\\", fontsize=14)\\n plot = plt.plot(fpr, tpr, linewidth=2)\\n buf = io.BytesIO()\\n plt.savefig(buf, format='jpeg')\\n buf.seek(0)\\n plt.close()\\n return buf\",\n \"def draw_roc_curve(fpr, tpr, labels=None, size_inch=(5, 5), dpi=160, show=False, block=False):\\n if not isinstance(fpr, np.ndarray) or not isinstance(tpr, np.ndarray):\\n raise AssertionError(\\\"invalid inputs\\\")\\n if fpr.shape != tpr.shape:\\n raise AssertionError(\\\"mismatched input sizes\\\")\\n if fpr.ndim == 1:\\n fpr = np.expand_dims(fpr, 0)\\n if tpr.ndim == 1:\\n tpr = np.expand_dims(tpr, 0)\\n if labels is not None:\\n if isinstance(labels, str):\\n labels = [labels]\\n if len(labels) != fpr.shape[0]:\\n raise AssertionError(\\\"should have one label per curve\\\")\\n else:\\n labels = [None] * fpr.shape[0]\\n fig = plt.figure(num=\\\"roc\\\", figsize=size_inch, dpi=dpi, facecolor=\\\"w\\\", edgecolor=\\\"k\\\")\\n fig.clf()\\n ax = fig.add_subplot(1, 1, 1)\\n import sklearn.metrics\\n for idx, label in enumerate(labels):\\n auc = sklearn.metrics.auc(fpr[idx, ...], tpr[idx, ...])\\n if label is not None:\\n ax.plot(fpr[idx, ...], tpr[idx, ...], \\\"b\\\", label=(\\\"%s [auc = %0.3f]\\\" % (label, auc)))\\n else:\\n ax.plot(fpr[idx, ...], tpr[idx, ...], \\\"b\\\", label=(\\\"auc = %0.3f\\\" % auc))\\n ax.legend(loc=\\\"lower right\\\")\\n ax.plot([0, 1], [0, 1], 'r--')\\n ax.set_xlim(0, 1)\\n ax.set_ylim(0, 1)\\n ax.set_ylabel(\\\"True Positive Rate\\\")\\n ax.set_xlabel(\\\"False Positive Rate\\\")\\n fig.set_tight_layout(True)\\n if show:\\n fig.show()\\n if block:\\n plt.show(block=block)\\n return fig\\n plt.pause(0.5)\\n return fig, ax\",\n \"def gen_plot(fpr, tpr):\\n plt.figure()\\n plt.xlabel(\\\"FPR\\\", fontsize = 14)\\n plt.ylabel(\\\"TPR\\\", fontsize = 14)\\n plt.title(\\\"ROC Curve\\\", fontsize = 14)\\n plot = plt.plot(fpr, tpr, linewidth = 2)\\n buf = io.BytesIO()\\n plt.savefig(buf, format = 'jpeg')\\n buf.seek(0)\\n plt.close()\\n\\n return buf\",\n \"def gen_plot(fpr, tpr):\\n plt.figure()\\n plt.xlabel(\\\"FPR\\\", fontsize = 14)\\n plt.ylabel(\\\"TPR\\\", fontsize = 14)\\n plt.title(\\\"ROC Curve\\\", fontsize = 14)\\n plot = plt.plot(fpr, tpr, linewidth = 2)\\n buf = io.BytesIO()\\n plt.savefig(buf, format = 'jpeg')\\n buf.seek(0)\\n plt.close()\\n\\n return buf\",\n \"def calculate_roc_auc_score(model, evaluation_data, train_data, opt_data):\\n return __calculate_classification_metrics(model, \\\"roc-auc\\\", evaluation_data, train_data, opt_data)\",\n \"def roc(output, target):\\r\\n with torch.no_grad():\\r\\n\\r\\n scores = output[:,0]\\r\\n labels = target[:,0]\\r\\n fpr, tpr, _ = roc_curve(labels, scores)\\r\\n roc_auc = auc(fpr, tpr)\\r\\n\\r\\n return fpr, tpr, roc_auc\",\n \"def get_ROC_AUC(data_input, label_input, pred, sess, labels, samples):\\n\\n # FUNCTION DOES NOT WORK PROPERLY, ROC AUC IS NOW ALWAYS 50%\\n #TODO: fix ROC AUC\\n\\n # Get the predicted and the real labels\\n pred, labels = sess.run([pred, label_input], feed_dict={data_input: samples, label_input: labels})\\n\\n # ROC AUC can not handle negative values, so they should be converted\\n # The softmax function is used to get only positive values\\n #TODO: this is where the bug is coming from\\n sum_exp_pred = np.sum(np.exp(pred))\\n pred = (np.exp(pred)) / sum_exp_pred\\n\\n # Get the ROC scores\\n _, roc = tf.metrics.auc(labels=labels, predictions=pred)\\n\\n # Run the local variables to get the ROC AUC accuracy\\n sess.run(tf.local_variables_initializer())\\n\\n # Run the session to obtain the accuracy\\n roc_auc = sess.run(roc*100)\\n\\n return roc_auc\",\n \"def plot_data(losses, accuracies, name):\\n # convert accuracies to percentages\\n accuracies['Train'] = [acc * 100 for acc in accuracies['Train']]\\n accuracies['Valid'] = [acc * 100 for acc in accuracies['Valid']]\\n # set fontsize\\n plt.rcParams.update({'font.size': 13})\\n fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(8,5))\\n ax1.set_xlabel('Number of Epochs')\\n ax1.set_ylabel('Cross Entropy Loss')\\n ax1.set_ylim(0,2)\\n ax1.plot(losses['Train'], label='Training')\\n ax1.plot(losses['Valid'], label='Validation')\\n ax1.legend(loc='upper right')\\n\\n ax2.set_xlabel('Number of Epochs')\\n ax2.set_ylabel('Accuracy (%)')\\n ax2.set_ylim(0,100)\\n ax2.plot(accuracies['Train'], label='Training')\\n ax2.plot(accuracies['Valid'], label='Validation')\\n ax2.legend(loc='upper left')\\n\\n fig.tight_layout()\\n fig.savefig('../outputs/' + name)\",\n \"def plotPRC(yscore, true, datasets, title, outfile):\\n \\n fig = plt.figure()\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.0])\\n plt.xlabel('Recall')\\n plt.ylabel('Precision')\\n plt.title(title)\\n \\n for i in range(len(datasets)):\\n precision, recall, _ = precision_recall_curve(true[i], yscore[i][:,1])\\n prc_auc = average_precision_score(true[i], yscore[i][:,1])\\n plt.plot(recall, precision, label=datasets[i]+' (area = %0.2f)' % (prc_auc),linewidth=1)\\n \\n plt.legend(loc=\\\"lower right\\\")\\n \\n pdfplot = PdfPages(outfile);\\n pdfplot.savefig(fig)\\n pdfplot.close()\",\n \"def eval(self):\\n target_truth_labels = self.get_target_labels()\\n for key in self.id_uncertainty_measures.keys():\\n # deep copy needed as we mutate confidence values later on\\n decision_fn_value = np.concatenate((copy.deepcopy(self.id_uncertainty_measures[key]),\\n copy.deepcopy(self.ood_uncertainty_measures[key])),\\n axis=0)\\n # negation needed for confidence, as confidence is indicator of label=0 samples\\n # i.e for correct classified samples.\\n # But we need scores for label=1 samples i.e misclassified samples\\n # to be higher, so we negate.\\n if key == UncertaintyMeasuresEnum.CONFIDENCE or key == UncertaintyMeasuresEnum.PRECISION:\\n decision_fn_value *= -1.0\\n\\n aupr, auroc = ClassifierPredictionEvaluator.compute_pr_roc_curves(\\n decision_fn_value, target_truth_labels, self.result_dir, key._value_)\\n\\n with open(os.path.join(self.result_dir, 'results.txt'), 'a') as f:\\n f.write('AUPR using ' + key._value_ + \\\": \\\" +\\n str(np.round(aupr * 100.0, 1)) + '\\\\n')\\n f.write('AUROC using ' + key._value_ + \\\": \\\" +\\n str(np.round(auroc * 100.0, 1)) + '\\\\n')\",\n \"def plot(self, ax=None, name=None, **kwargs):\\n import matplotlib.pyplot as plt\\n\\n if ax is None:\\n fig, ax = plt.subplots()\\n\\n name = self.estimator_name if name is None else name\\n\\n line_kwargs = {\\n 'label': \\\"{} (AUC = {:0.2f})\\\".format(name, self.roc_auc), \\n 'lw':0.25\\n\\n }\\n line_kwargs.update(**kwargs)\\n\\n self.line_ = ax.plot(self.fpr, self.tpr, **line_kwargs)[0]\\n ax.set_xlabel(\\\"False Positive Rate\\\")\\n ax.set_ylabel(\\\"True Positive Rate\\\")\\n ax.legend(loc='lower right')\\n\\n self.ax_ = ax\\n self.figure_ = ax.figure\\n return self\",\n \"def test_model(model_name, save_dir, postive_file, negative_file, measure=\\\"SPC\\\", measure_threshold=0.95):\\n print model_name\\n postive_scores = get_model_scores(postive_file)\\n negative_scores = get_model_scores(negative_file)\\n all_scores = postive_scores+negative_scores\\n # print all_scores\\n\\n if len(negative_scores) == 0:\\n return {\\\"roc_auc\\\":0, \\\"threshold\\\":min(postive_scores)}\\n\\n y_true = [1]*len(postive_scores) + [0]*len(negative_scores)\\n y_score = np.array(all_scores)\\n\\n fpr, tpr, thresholds = roc_curve(y_true, y_score)\\n roc_auc = auc(fpr, tpr)\\n\\n best_threshold, thresholds, values = calcualte_threshold(\\n postive_scores, \\n negative_scores, \\n measure=measure,\\n measure_threshold=measure_threshold, \\n thresholds=reversed(thresholds))\\n\\n\\n pp = PdfPages(os.path.join(save_dir, \\\"{}_model_evaluation.pdf\\\".format(model_name)))\\n\\n sns.set(style=\\\"darkgrid\\\")\\n f, axes = plt.subplots(3)\\n trans = f.transFigure.inverted()\\n colors = sns.color_palette(\\\"Set2\\\", 7)\\n\\n sns.kdeplot(np.array(postive_scores), shade=True, color=sns.xkcd_rgb[\\\"denim blue\\\"], label=\\\"Scores for postive examples\\\", ax=axes[0])\\n sns.kdeplot(np.array(negative_scores), shade=True, color=sns.xkcd_rgb[\\\"pale red\\\"], label=\\\"Scores for negative examples\\\", ax=axes[0])\\n axes[0].set_xlabel(\\\"Bit score\\\")\\n axes[0].set_ylabel(\\\"Density\\\")\\n axes[0].legend(loc=\\\"upper left\\\")\\n #axes[0].set_title(\\\"Kernel Density of Scores\\\")\\n axes[1].set_xlim([0, 1.0])\\n axes[1].set_ylim([0.0, 1.05])\\n\\n \\n axes[1].plot(fpr,tpr, color=colors[0], lw=3., label=\\\"ROC (AUC: {})\\\".format(roc_auc))\\n axes[1].set_xlabel(\\\"False Positive Rate\\\")\\n axes[1].set_ylabel(\\\"True Positive Rate\\\")\\n axes[1].legend(loc=\\\"lower right\\\")\\n axes[1].set_xlim([-0.05, 1.0])\\n axes[1].set_ylim([0.0, 1.05])\\n #axes[1].set_title(\\\"ROC\\\")\\n \\n for i, (measure, values) in enumerate(values.iteritems()):\\n label = \\\"SPC: (>={})\\\".format(best_threshold) if measure==\\\"SPC\\\" else measure\\n axes[2].plot(list(thresholds), values, label=label, linewidth=2, color=colors[i])\\n axes[2].axvline(best_threshold)\\n\\n axes[2].legend()\\n #axes[2].set_title(\\\"Coosing Cutoff\\\")\\n axes[2].set_ylabel(\\\"Rate\\\")\\n axes[2].set_xlabel(\\\"Threshold\\\")\\n\\n f.suptitle(\\\"{} Model Evaluation\\\".format(model_name), fontsize=20)\\n\\n pp.savefig()\\n pp.close()\\n\\n return {\\\"roc_auc\\\":roc_auc, \\\"threshold\\\":best_threshold}\",\n \"def plot_calibration_curve(classifier_name, pred_csv_file, fig_index):\\n\\n from sklearn.metrics import brier_score_loss, precision_score, recall_score, f1_score\\n from sklearn.calibration import CalibratedClassifierCV, calibration_curve\\n import matplotlib\\n matplotlib.use('Agg')\\n import matplotlib.pyplot as plt\\n from sklearn.isotonic import isotonic_regression\\n from sklearn.metrics import roc_auc_score, roc_curve, auc\\n\\n # # Calibrated with isotonic calibration\\n # isotonic = CalibratedClassifierCV(base_estimator=None, cv=\\\"prefit\\\", method='isotonic')\\n\\n # # Calibrated with sigmoid calibration\\n # sigmoid = CalibratedClassifierCV(base_estimator=None, cv=\\\"prefit\\\", method='sigmoid')\\n\\n # # Logistic regression with no calibration as baseline\\n # lr = LogisticRegression(C=1., solver='lbfgs')\\n\\n fig = plt.figure(fig_index, figsize=(10, 10))\\n ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2)\\n ax2 = plt.subplot2grid((3, 1), (2, 0))\\n\\n ax1.plot([0, 1], [0, 1], \\\"k:\\\", label=\\\"Perfectly calibrated\\\")\\n\\n # for name in [classifier_name, classifier_name + ' + Isotonic', classifier_name + ' + Sigmoid']:\\n for name in [classifier_name, classifier_name + ' + Sigmoid']:\\n # for name in [classifier_name]:\\n\\n y_test, prob_pos, y_pred, _, _ = read_pred_csv_file_to_arrays(pred_csv_file)\\n\\n if name == classifier_name + ' + Sigmoid':\\n a, b = sigmoid_calibration(prob_pos, y_test, sample_weight=None)\\n prob_pos = predict_sigmoid(a, b, prob_pos)\\n print a, b\\n y_pred = binary_predict(prob_pos, threshold = 0.5)\\n\\n\\n if name == classifier_name + ' + Isotonic' :\\n prob_pos = isotonic_regression(prob_pos, sample_weight=None, y_min=None, y_max=None,\\n increasing=True)\\n y_pred = binary_predict(prob_pos, threshold = 0.5)\\n\\n\\n # print prob_pos[:20]\\n # # plot roc curve for test: class 1 only\\n # fpr, tpr, _ = roc_curve(y_test, prob_pos)\\n # lw = 2\\n # plt.plot(fpr, tpr, color='darkorange',\\n # lw=lw, label='ROC curve (area = %0.2f)' %(roc_auc_score(y_test, prob_pos, average='macro')))\\n # plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\\n # plt.xlim([0.0, 1.0])\\n # plt.ylim([0.0, 1.05])\\n # plt.xlabel('False Positive Rate')\\n # plt.ylabel('True Positive Rate')\\n # plt.title('Receiver operating characteristic example')\\n # plt.legend(loc=\\\"lower right\\\")\\n # plt.savefig('plots/roc_%s.png'%(name))\\n # plt.clf()\\n\\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=1)\\n print(\\\"%s:\\\" % name)\\n print(\\\"\\\\tBrier: %1.3f\\\" % (clf_score))\\n print(\\\"\\\\tPrecision: %1.3f\\\" % precision_score(y_test, y_pred))\\n print(\\\"\\\\tRecall: %1.3f\\\" % recall_score(y_test, y_pred))\\n print(\\\"\\\\tF1: %1.3f\\\" % f1_score(y_test, y_pred))\\n print(\\\"\\\\tROC: %1.3f\\\\n\\\" % roc_auc_score(y_test, prob_pos, average='macro'))\\n\\n fraction_of_positives, mean_predicted_value = \\\\\\n calibration_curve(y_test, prob_pos, n_bins=10)\\n\\n ax1.plot(mean_predicted_value, fraction_of_positives, \\\"s-\\\",\\n label=\\\"%s (%1.3f)\\\" % (name, clf_score))\\n\\n ax2.hist(prob_pos, range=(0, 1), bins=10, label=name,\\n histtype=\\\"step\\\", lw=2)\\n\\n ax1.set_ylabel(\\\"Fraction of positives\\\")\\n ax1.set_ylim([-0.05, 1.05])\\n ax1.legend(loc=\\\"lower right\\\")\\n ax1.set_title('Calibration plots (reliability curve)')\\n\\n ax2.set_xlabel(\\\"Mean predicted value\\\")\\n ax2.set_ylabel(\\\"Count\\\")\\n ax2.legend(loc=\\\"upper center\\\", ncol=2)\\n\\n plt.tight_layout()\\n plt.savefig('plots/calibration.png')\\n plt.clf()\",\n \"def finetune_learningrate(savefigure=False):\\n res = np.array(np.load('npy-data/result_learningrate_tuning_acc_auc_crossval_train.npy'))\\n acc, auc = res[:int(len(res)/2)], res[int(len(res)/2):]\\n plt.plot([j*0.005 for j in range(1,31)],acc,[j*0.005 for j in range(1,31)],auc)\\n plt.xlabel('Learning rate')\\n plt.ylabel('Accuracy/AUC score')\\n plt.legend([\\\"Accuracy\\\",\\\"ROC AUC\\\"])\\n if savefigure:\\n plt.savefig('img/xgb_accuracy_learningrate_tuning_acc_auc_crossval.pdf', bbox_inches='tight')\\n plt.show()\",\n \"def auto_evaluation(model,x_train,y_train,x_test,y_test):\\n\\n y_train_prediction=model.predict(x_train)\\n y_test_prediction=model.predict(x_test)\\n\\n plt.scatter(y_train,y_train_prediction,c=\\\"b\\\",s=1,alpha=0.5)\\n plt.scatter(y_test,y_test_prediction,c=\\\"r\\\",s=2,alpha=0.5)\\n plt.xlabel(\\\"actual\\\")\\n plt.ylabel(\\\"predicted\\\")\\n\\n print(\\\"tr R2: {:.2f}\\\".format(r2_score(y_train_prediction,y_train)))\\n print(\\\"te R2: {:.2f}\\\".format(r2_score(y_test_prediction,y_test))) \\n \\n return y_train_prediction,y_test_prediction\",\n \"def plot_roc_curve(ht, scores, tp_label='tp', fp_label='fp', colors=None, title='ROC Curve', hover_mode='mouse'):\\n if colors is None:\\n # Get a palette automatically\\n from bokeh.palettes import d3\\n palette = d3['Category10'][max(3, len(scores))]\\n colors = {score: palette[i] for i, score in enumerate(scores)}\\n\\n if isinstance(scores, str):\\n scores = [scores]\\n total_tp, total_fp = ht.aggregate((hl.agg.count_where(ht[tp_label]), hl.agg.count_where(ht[fp_label])))\\n\\n p = figure(title=title, x_axis_label='FPR', y_axis_label='TPR', tools=\\\"hover,save,pan,box_zoom,reset,wheel_zoom\\\")\\n p.add_layout(Title(text=f'Based on {total_tp} TPs and {total_fp} FPs'), 'above')\\n\\n aucs = []\\n for score in scores:\\n ordered_ht = ht.key_by(_score=-ht[score])\\n ordered_ht = ordered_ht.select(\\n score_name=score, score=ordered_ht[score],\\n tpr=hl.scan.count_where(ordered_ht[tp_label]) / total_tp,\\n fpr=hl.scan.count_where(ordered_ht[fp_label]) / total_fp,\\n ).key_by().drop('_score')\\n last_row = hl.utils.range_table(1).key_by().select(score_name=score, score=hl.float64(float('-inf')), tpr=hl.float64(1.0), fpr=hl.float64(1.0))\\n ordered_ht = ordered_ht.union(last_row)\\n ordered_ht = ordered_ht.annotate(\\n auc_contrib=hl.or_else((ordered_ht.fpr - hl.scan.max(ordered_ht.fpr)) * ordered_ht.tpr, 0.0)\\n )\\n auc = ordered_ht.aggregate(hl.agg.sum(ordered_ht.auc_contrib))\\n aucs.append(auc)\\n df = ordered_ht.annotate(score_name=ordered_ht.score_name + f' (AUC = {auc:.4f})').to_pandas()\\n p.line(x='fpr', y='tpr', legend_field='score_name', source=ColumnDataSource(df), color=colors[score], line_width=3)\\n\\n p.legend.location = 'bottom_right'\\n p.legend.click_policy = 'hide'\\n p.select_one(HoverTool).tooltips = [(x, f\\\"@{x}\\\") for x in ('score_name', 'score', 'tpr', 'fpr')]\\n p.select_one(HoverTool).mode = hover_mode\\n return p, aucs\",\n \"def write_result(self, file_path):\\n f = open(file_path, \\\"a\\\")\\n f.write(\\\"{}\\\\t{}\\\\n\\\".format(*[self.name, str(self.ROC_AUC_value)]))\\n f.close()\",\n \"def plot_acc(model_dir):\\n ## extract loss from csv\\n file_dir = os.path.join(model_dir, 'acc.csv')\\n data = pd.read_csv(file_dir)\\n epochs = data['epoch'].ravel()\\n acc_train = data['acc_train'].ravel()\\n acc_test = data['acc_test'].ravel()\\n # epoch,acc_train,acc_test\\n\\n ## Theoretical Loss\\n fig, ax = plt.subplots(1, 1, figsize=(7, 5), sharey=True, sharex=True, dpi=400)\\n ax.plot(epochs, acc_train, label='train', color='green', alpha=0.8)\\n ax.plot(epochs, acc_test, label='test', color='red', alpha=0.8)\\n ax.set_ylabel('Accuracy', fontsize=10)\\n ax.set_xlabel('Epoch', fontsize=10)\\n ax.legend(loc='lower right', prop={\\\"size\\\": 15}, ncol=3, framealpha=0.5)\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n plt.tight_layout()\\n\\n ## create saving directory\\n acc_dir = os.path.join(model_dir, 'figures', 'acc')\\n os.makedirs(acc_dir, exist_ok=True)\\n file_name = os.path.join(acc_dir, 'accuracy.png')\\n plt.savefig(file_name, dpi=400)\\n print(\\\"Plot saved to: {}\\\".format(file_name))\\n file_name = os.path.join(acc_dir, 'accuracy.pdf')\\n plt.savefig(file_name, dpi=400)\\n plt.close()\\n print(\\\"Plot saved to: {}\\\".format(file_name))\",\n \"def auc(self,predictions,labels):\\n\\n # sort the array by predictions in descending order in case it has not been done\\n order = np.flipud(predictions.argsort())\\n labels = labels[order]\\n\\n # clean labels, calculate the number of positive labels\\n labeled_true = (np.asarray(labels,dtype=bool) == True)\\n num_positives = np.sum(labeled_true)\\n num_predictions = len(labeled_true)\\n\\n # If no positive result return nan\\n if num_positives == 0:\\n return float('nan')\\n\\n # slide from top to the bottom;\\n # each time slide the threshold so as to predict one more label as positive\\n roc_curve = np.array([0.0,0.0])\\n TP_above_threshold = 0\\n for predict_as_positive in range(num_predictions):\\n if labeled_true[predict_as_positive] == True:\\n TP_above_threshold +=1\\n # calculate True Positives Rate\\n # TPR = TP / num_real_positives\\n TPR = TP_above_threshold / float(num_positives)\\n \\n # FPR = FP / num_real_negatives\\n FPR = (predict_as_positive +1 - TP_above_threshold) / (num_predictions - float(num_positives))\\n \\n roc_curve = np.vstack((roc_curve,[FPR,TPR]))\\n\\n roc_curve = np.vstack((roc_curve,[1.0,1.0]))\\n\\n \\n # reduce into TP and FP rate, integrate with trapezoid to calculate AUC\\n auc = np.trapz(roc_curve[:,1], x=roc_curve[:,0])\\n\\n\\n return auc\",\n \"def cross_validation_visualization_accuracy(epochs, accs, save=False, filename=\\\"cross_validation_acc\\\"):\\n plt.plot(epochs, accs, marker=\\\".\\\", color='r', label='accuracy')\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"accuracy\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n if (save):\\n plt.savefig(filename)\",\n \"def reg_auroc(y_true, y_pred, th=0.5):\\n y_true = np.where(y_true < th, 1, 0)\\n y_score = np.where(y_pred < th, 1, 0)\\n reg_auroc_score = sklearn.metrics.roc_auc_score(y_true, y_score)\\n return reg_auroc_score\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7867306","0.7626776","0.732372","0.7319301","0.73173314","0.7298921","0.7294701","0.7286847","0.71924317","0.71809953","0.71744895","0.7162829","0.71388173","0.712525","0.70957816","0.7076601","0.70679814","0.70641404","0.706279","0.69863737","0.69803417","0.6926248","0.68958706","0.689518","0.68821436","0.6874888","0.68213457","0.68192786","0.6805078","0.6800101","0.67795473","0.6727196","0.66916543","0.66884196","0.66745543","0.6658217","0.66572833","0.66490144","0.66118914","0.6581351","0.6574311","0.6571955","0.6563241","0.65334976","0.65304446","0.649824","0.6487844","0.64696825","0.64495265","0.6437658","0.6437383","0.6433645","0.63964623","0.6382842","0.6348217","0.6344462","0.6330384","0.63195527","0.63036054","0.62961054","0.6288615","0.628182","0.6278585","0.62541926","0.6247603","0.6243724","0.6205587","0.619353","0.6177377","0.6150191","0.61417294","0.6127748","0.61266","0.612597","0.6098891","0.60865235","0.6075715","0.6072096","0.6033959","0.6012416","0.60096484","0.60079503","0.60079503","0.60007834","0.5982301","0.5965519","0.5957871","0.59529495","0.594073","0.59398997","0.59388226","0.5921384","0.5907841","0.58981675","0.58625734","0.58574975","0.5857457","0.584869","0.58416396","0.58281404"],"string":"[\n \"0.7867306\",\n \"0.7626776\",\n \"0.732372\",\n \"0.7319301\",\n \"0.73173314\",\n \"0.7298921\",\n \"0.7294701\",\n \"0.7286847\",\n \"0.71924317\",\n \"0.71809953\",\n \"0.71744895\",\n \"0.7162829\",\n \"0.71388173\",\n \"0.712525\",\n \"0.70957816\",\n \"0.7076601\",\n \"0.70679814\",\n \"0.70641404\",\n \"0.706279\",\n \"0.69863737\",\n \"0.69803417\",\n \"0.6926248\",\n \"0.68958706\",\n \"0.689518\",\n \"0.68821436\",\n \"0.6874888\",\n \"0.68213457\",\n \"0.68192786\",\n \"0.6805078\",\n \"0.6800101\",\n \"0.67795473\",\n \"0.6727196\",\n \"0.66916543\",\n \"0.66884196\",\n \"0.66745543\",\n \"0.6658217\",\n \"0.66572833\",\n \"0.66490144\",\n \"0.66118914\",\n \"0.6581351\",\n \"0.6574311\",\n \"0.6571955\",\n \"0.6563241\",\n \"0.65334976\",\n \"0.65304446\",\n \"0.649824\",\n \"0.6487844\",\n \"0.64696825\",\n \"0.64495265\",\n \"0.6437658\",\n \"0.6437383\",\n \"0.6433645\",\n \"0.63964623\",\n \"0.6382842\",\n \"0.6348217\",\n \"0.6344462\",\n \"0.6330384\",\n \"0.63195527\",\n \"0.63036054\",\n \"0.62961054\",\n \"0.6288615\",\n \"0.628182\",\n \"0.6278585\",\n \"0.62541926\",\n \"0.6247603\",\n \"0.6243724\",\n \"0.6205587\",\n \"0.619353\",\n \"0.6177377\",\n \"0.6150191\",\n \"0.61417294\",\n \"0.6127748\",\n \"0.61266\",\n \"0.612597\",\n \"0.6098891\",\n \"0.60865235\",\n \"0.6075715\",\n \"0.6072096\",\n \"0.6033959\",\n \"0.6012416\",\n \"0.60096484\",\n \"0.60079503\",\n \"0.60079503\",\n \"0.60007834\",\n \"0.5982301\",\n \"0.5965519\",\n \"0.5957871\",\n \"0.59529495\",\n \"0.594073\",\n \"0.59398997\",\n \"0.59388226\",\n \"0.5921384\",\n \"0.5907841\",\n \"0.58981675\",\n \"0.58625734\",\n \"0.58574975\",\n \"0.5857457\",\n \"0.584869\",\n \"0.58416396\",\n \"0.58281404\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78781956"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21490,"cells":{"query":{"kind":"string","value":"Calculate the TPR, TNR, FPR, FNR and F1 score. Arguments"},"document":{"kind":"string","value":"def metrics(x, y, save_folder, threshold, ds_name):\n predicted = model.predict(x)\n predicted[predicted > threshold] = 1\n predicted[predicted <= threshold] = 0\n actual = y\n TP = np.sum(np.logical_and(predicted == 1, actual == 1))\n FN = np.sum(np.logical_and(predicted == 0, actual == 1))\n TN = np.sum(np.logical_and(predicted == 0, actual == 0))\n FP = np.sum(np.logical_and(predicted == 1, actual == 0))\n TPR = TP / (TP + FN + 1e-8)\n TNR = TN / (TN + FP + 1e-8)\n FPR = FP / (FP + TN + 1e-8)\n FNR = FN / (FN + TP + 1e-8)\n precision = TP / (TP + FP + 1e-8)\n recall = TPR\n F1 = 2 * precision * recall / (precision + recall + 1e-8)\n metrics_dict = {'TPR': np.round(TPR, 3),\n 'TNR': np.round(TNR, 3),\n 'FPR' : np.round(FPR, 3),\n 'FNR' : np.round(FNR, 3),\n 'F1 Score' : np.round(F1, 3)\n }\n with open(save_folder + '/' + ds_name + '_metrics.txt', 'w') as f:\n f.write(str(metrics_dict))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def computeFScores(self, targetLabels, actualLabels):\r\n if self.prMeasures is None:\r\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\r\n if self.prMeasures[0] == 0:\r\n return 0\r\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\r\n return self.f1score","def calculate_scores(self):\n # Prediction based scores\n #self.report = classification_report(self.y_test, self.y_pred)\n self.accuracy = accuracy_score(self.y_real, self.y_pred)\n self.precision = precision_score(self.y_real, self.y_pred)\n self.recall = recall_score(self.y_real, self.y_pred)\n self.f1 = f1_score(self.y_real, self.y_pred)\n \n # Probability based scores\n self.fpr, self.tpr, _ = roc_curve(self.y_real, self.y_proba)\n self.average_precision = average_precision_score(self.y_real, self.y_proba)\n self.brier_loss = brier_score_loss(self.y_real, self.y_proba)\n self.roc_auc = roc_auc_score(self.y_real, self.y_proba)\n self.prec_cur, self.recall_cur, _ = precision_recall_curve(self.y_real, self.y_proba)","def f1_score(self):\n self.overall_f1_score = f1_score(\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\n self.classes_f1_score = f1_score(\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)","def calculate_f1_score(y_test, y_pred):\n print('# Running precision, recall and F1-score')\n print('# F1-Score:\\t\\t%.2f' % (f1_score(y_test, y_pred, average=\"macro\") * 100))\n print('# Precision:\\t\\t%.2f' % (precision_score(y_test, y_pred, average=\"macro\") * 100))\n print('# Recall:\\t\\t%.2f' % (recall_score(y_test, y_pred, average=\"macro\") * 100))","def performance(stats):\n\n def fbeta_score(precision, recall, beta=1.0):\n beta_square = beta * beta\n if (precision != 0.0) and (recall != 0.0):\n res = ((1 + beta_square) * precision * recall / (beta_square * precision + recall))\n else:\n res = 0.0\n return res\n\n def prf1(tp_, fp_, fn_, tn_):\n # 单类的\n tp_ = np.sum(tp_, axis=0) #batch*=》\n fp_ = np.sum(fp_, axis=0)\n fn_ = np.sum(fn_, axis=0)\n tn_ = np.sum(tn_, axis=0)\n # 总体的\n atp = np.sum(tp_)\n afp = np.sum(fp_)\n afn = np.sum(fn_)\n atn = np.sum(tn_)\n\n micro_p = (1.0 * atp) / (atp + afp) if (atp + afp != 0) else 0.0\n micro_r = (1.0 * atp) / (atp + afn) if (atp + afn != 0) else 0.0\n micro_f = fbeta_score(micro_p, micro_r)\n\n pp = [0]\n rr = [0]\n ff = [0]\n macro_p = np.mean(pp)\n macro_r = np.mean(rr)\n macro_f = np.mean(ff)\n\n acc = (atp + atn) / (atp + atn + afp + afn) if (atp + atn + afp + afn) else 0.0\n acc_NA = atn / (atn + afp) if (atn + afp) else 0.0\n acc_not_NA = atp / (atp + afn) if (atp + afn) else 0.0\n return {'acc': acc, 'NA_acc': acc_NA, 'not_NA_acc': acc_not_NA,\n 'micro_p': micro_p, 'micro_r': micro_r, 'micro_f': micro_f,\n 'macro_p': macro_p, 'macro_r': macro_r, 'macro_f': macro_f,\n 'tp': atp, 'true': atp + afn, 'pred': atp + afp, 'total': (atp + atn + afp + afn)}\n\n fin_loss = sum(stats['loss']) / len(stats['loss'])\n scores = prf1(stats['tp'], stats['fp'], stats['fn'], stats['tn'])\n return fin_loss, scores","def prf_analysis(y_true: list, y_pred: list) -> None:\n print('Precision: {:,.2f}'.format(precision_score(y_true, y_pred)))\n print('Recall : {:,.2f}'.format(recall_score(y_true, y_pred)))\n print('F1 : {:,.2f}'.format(f1_score(y_true, y_pred)))\n print('Accuracy : {:,.2f}'.format(accuracy_score(y_true, y_pred)))\n return None","def compute_prf(self, counts_dict):\n precision = counts_dict[\"correct\"] / counts_dict[\"predicted\"] if counts_dict[\"predicted\"] else 0.0\n recall = counts_dict[\"correct\"] / counts_dict[\"gold\"] if counts_dict[\"gold\"] else 0.0\n fscore = 2 * precision * recall / (precision + recall) if precision + recall else 0.0\n\n return {\"precision\": precision, \"recall\": recall, \"fscore\": fscore}","def F1_score(y_t, y_p, weights):\n\n P = Precision()\n R = Recall() #label per label evaluation\n F1_score_per_label = [] #store per label\n P_per_label = []\n R_per_label = []\n F1_tot = 0 #weighted sum\n\n for i in range(8):\n P.update_state( y_t[:,i], y_p[:,i] )\n R.update_state( y_t[:,i], y_p[:,i] )\n p = P.result().numpy()\n r = R.result().numpy()\n P.reset_states()\n R.reset_states()\n if p+r == 0:\n f1 = 0\n else:\n f1 = 2*p*r/ (p+r)\n F1_score_per_label.append(f1)\n P_per_label.append(p)\n R_per_label.append(r)\n\n F1_tot += f1*weights[i]\n\n return F1_score_per_label, P_per_label, R_per_label, F1_tot","def custom_scoring(y_te, y_pred):\n #weights computed with training data set\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\n \n ## F1 SCORES\n #evaluate F1 score, precision and recall for each label, \n #along with custom proportionally weighted F1 score\n #and built in weighted and macro F1 scores\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\n f = F1Score(8, threshold = 0.5, average = 'weighted')\n f.update_state(y_te, y_pred)\n wf1 = f.result().numpy() #weighted f1 score\n f.reset_states()\n f = F1Score(8, threshold = 0.5, average = 'macro')\n f.update_state(y_te, y_pred)\n mf1 = f.result().numpy() #macro f1 score\n f.reset_states()\n\n ##EDIT DISTANCE\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\n\n ##ACCURACY\n #evaluate accuracy per label\n acc_tab = Acc(y_te, y_pred)\n\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab","def prf(stats):\n if stats['pred'] == 0:\n return 0, 0, 0\n p = stats['corr']/stats['pred']\n r = stats['corr']/stats['gold']\n if p > 0 and r > 0:\n f = 2*p*r/(p+r)\n else:\n f = 0\n return p, r, f","def f1_score(self):","def calculate_metrics(self):\n sensitivity = TP + FN\n sensitivity = TP / sensitivity\n\n specificity = TN + FP\n specificity = TN / specificity\n\n accuracy = TP + FP + TN + FN\n divisor = TP + TN\n accuracy = divisor / accuracy\n\n positive_predictive = TP + FP\n positive_predictive = TP / positive_predictive\n\n negative_predictive = TN + FN\n negative_predictive = TN / negative_predictive\n\n # This is for format decimal in metrics\n sensitivity = float(\"{0:.4f}\".format(sensitivity))\n specificity = float(\"{0:.4f}\".format(specificity))\n accuracy = float(\"{0:.4f}\".format(accuracy))\n positive_predictive = float(\"{0:.4f}\".format(positive_predictive))\n negative_predictive = float(\"{0:.4f}\".format(negative_predictive))\n\n average = (sensitivity + specificity + accuracy + positive_predictive + negative_predictive) / 5\n\n average = float(\"{0:.4f}\".format(average))\n\n metrics = [sensitivity, specificity, accuracy,positive_predictive,negative_predictive, average]\n\n return metrics","def get_f1_score(y_true, y_pred):\n cf_m = confusion_matrix(y_true, y_pred)\n print(\"tn:\",cf_m[0,0])\n print(\"fp:\",cf_m[0,1])\n print(\"fn:\",cf_m[1,0])\n print(\"tp:\",cf_m[1,1])\n precision = cf_m[1,1] / (cf_m[1,1] + cf_m[0,1])\n recall = cf_m[1,1] / (cf_m[1,1] + cf_m[1,0])\n f1 = 2 * (precision * recall) / (precision + recall)\n\n\n return precision, recall, f1","def calculate_recall(num_tp, num_fp, num_fn):\n if (num_tp + num_fn) == 0:\n return 0\n else:\n return num_tp / (num_tp + num_fn)","def _metric(self, fpr, tpr, th_):\n def np_divide(a, b):\n \"\"\"Numpy array division.\n\n ignore / 0, div( [-1, 0, 1], 0 ) -> [0, 0, 0]\n \"\"\"\n with np.errstate(divide='ignore', invalid='ignore'):\n c = np.true_divide(a, b)\n c[~np.isfinite(c)] = 0 # -inf inf NaN\n return c\n\n # q = tpr/(fpr+tpr) go through max.\n q = np_divide(tpr, fpr + tpr)\n best_ind = np.argmax(q)\n best_th_ = th_[best_ind]\n return best_th_, best_ind, q","def f1_score(model_id, test_set_id, rubric_id):\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\n # right answers\n answers = db.get_rubric_answers(test_set_id, rubric_id)\n # rubrication results\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\n\n for key in rubrication_result:\n if rubrication_result[key] == answers[key]:\n if rubrication_result[key] == 1:\n result['true_positive'] += 1\n else:\n result['true_negative'] += 1\n else:\n if rubrication_result[key] == 1:\n result['false_positive'] += 1\n else:\n result['false_negative'] += 1\n if (result['true_positive'] + result['false_positive']) > 0:\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\n else:\n result['precision'] = 0\n if (result['true_positive'] + result['false_negative']) > 0:\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\n else:\n result['recall'] = 0\n if (result['precision'] + result['recall']) > 0:\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\n else:\n result['f1'] = 0\n return result","def calf_f1(annotated_Y, predicted_Y):\n\n POSITIVE = ADR_MENTION_CLASS_LABEL\n NEGATIVE = NON_ADR_MENTION_CLASS_LABEL\n\n tp = 0\n fp = 0\n fn = 0\n tn = 0\n\n total_actual_positives = 0\n total_actual_negatives = 0\n\n for index, actual in enumerate(annotated_Y):\n predicted = predicted_Y[index]\n\n if actual == POSITIVE:\n total_actual_positives += 1\n\n if predicted == POSITIVE:\n tp += 1\n elif predicted == NEGATIVE:\n fn += 1\n\n elif actual == NEGATIVE:\n total_actual_negatives += 1\n\n if predicted == POSITIVE:\n fp += 1\n elif predicted == NEGATIVE:\n tn += 1\n\n if (tp+fp) == 0:\n precision = 0\n else:\n precision = tp/(tp+fp)\n\n if (tp+fn) == 0:\n recall = 0\n else:\n recall = tp/(tp+fn)\n\n if (precision+recall) == 0:\n f1 = 0\n else:\n f1 = 2*precision*recall/(precision+recall)\n\n # print(\"Total labels: {}, total actual positives: {}, total_actual_negatives: {}\".format(len(predicted_Y), total_actual_positives, total_actual_negatives))\n # print(\"tp: {}, tn: {}, fp: {}, fn: {}\".format(tp, tn, fp, fn))\n # print(\" Accuracy: {}\".format((tp+tn)/(len(test_Y))))\n print(\" Precision: {}\".format(precision))\n print(\" Recall: {}\".format(recall))\n print(\" F1: {}\".format(f1))","def evaluate(self, test_data):\n test_results = [(self.decide(self.feedforward(x)), y)\n for (x, y) in test_data]\n\n # Check for and keep track of TP's FP's and FN's\n # Write FP's and FN's to a special directories\n TP = FP = FN = count = 0\n TN = 0\n # what you got = x, what should be = y\n for ((x, y), (image, gt)) in zip(test_results, test_data):\n count += 1\n if x == 1 and y == 1:\n TP += 1\n elif x == 1 and y == 0:\n FP += 1\n if not self.validating: self.save_Image(FP_PATH, count, image)\n elif x == 0 and y == 1:\n FN += 1\n if not self.validating: self.save_Image(FN_PATH, count, image)\n \n if (TP + FP ) == 0:\n return TP, FP, FN, '---------', '---------','---------'\n else:\n false_rate = float(FP) / float(TP + FP)\n\n if (TP + FN ) == 0:\n return TP, FP, FN, '---------', '---------', false_rate\n else:\n detect_rate = float(TP) / float(TP + FN)\n\n if (TP + FP + FN ) == 0:\n return TP, FP, FN, '---------', detect_rate, false_rate\n else:\n quality_rate = float(TP) / float(TP+FP+FN)\n \n return TP, FP, FN, quality_rate, detect_rate, false_rate","def get_scores(self):\n hist = self.confusion_matrix\n # hist = [TN,FP;FN,TP]\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n # iou = iu.sum() / self.n_classes\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n cls_iou = dict(zip(range(self.n_classes), iu))\n\n ##############################################\n tn = hist[0, 0]\n tp = np.diag(hist).sum() - tn\n fp = np.triu(hist, 1).sum()\n fn = np.tril(hist, -1).sum()\n precision = tp / (tp + fp)\n recall = tp / (tp + fn)\n f1 = 2 * precision * recall / (precision + recall)\n\n # for medical img, img_seg \\in [0,1]\n dice = 2 * tp / (tp + tp + fn + fp)\n # dice = f1-score\n dsc = 2 * tp / (tp + fn + fp)\n # dsc = jaccard\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\n # voe = 1 - dsc\n\n k2 = {\n # \"Overall Acc: \\t\": acc,\n 'Mean Acc': float(judge_nan(acc_cls)),\n # \"FreqW Acc : \\t\": fwavacc,\n 'Mean IoU': float(judge_nan(mean_iou)),\n 'F1-score': float(judge_nan(f1)),\n 'DSC': float(judge_nan(dsc)),\n 'Precision': float(judge_nan(precision)),\n 'Recall': float(judge_nan(recall)),\n }\n\n return k2","def print_results(precision, recall, f1):\n print \"Precision:\", precision\n print \"Recall:\", recall\n print \"F1 score:\", f1","def TPR(self):\n return _div(self.TP, self.TP + self.FN)","def score(label_recall, label_precision, pred_recall, pred_precision):\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\n\n return 0.4*f11 + 0.6*f12","def get_evaluations(self, pred_Y, Y):\n \n tp, fp, tn, fn = self._get_evaluations(pred_Y, Y)\n\n # calculate F1\n try:\n precision = tp / (tp+fp)\n except ZeroDivisionError:\n precision = tp\n try:\n recall = tp / (tp+fn)\n except ZeroDivisionError:\n recall = tp\n try:\n f1 = 2.0 * ((precision*recall) / (precision+recall))\n except ZeroDivisionError:\n f1 = 0.0\n # calculate accuracy\n accuracy = (tp+tn) / (tp+fp+tn+fn)\n\n return accuracy, f1, precision, recall","def calcMetrics(TP, P, T, percent=True):\r\n precision = TP / P if P else 0\r\n recall = TP / T if T else 0\r\n FB1 = 2 * precision * recall / (precision + recall) if precision + recall else 0\r\n if percent:\r\n return 100 * precision, 100 * recall, 100 * FB1\r\n else:\r\n return precision, recall, FB1","def get_precision_recall_f1(gt, pred):\n tp, tn, fp, fn = calc_pred_stats(gt, pred)\n prec = precision(tp, fp)\n rec = recall(tp, fn)\n f1_score = f1(prec, rec)\n return prec, rec, f1_score","def get_perf(self) :\n self.train()\n\n prediction = self.clf.predict(self.df_test.drop(columns = 'up')[:-1])\n self.accuracy = accuracy_score(df_test['up'][length:].values, prediction)\n tn, fp, fn, tp = confusion_matrix(df_test['up'][length:].values, prediction).ravel()\n self.recall = tp/(tp+fn)\n self.specificity = tn / (tn+fp)\n\n\n self.df_true = self.df_true[self.length:]\n\n profit = 1\n mini = 1\n maxi = 1\n self.df_true['close'] = self.df_true['close'].map(lambda x : np.exp(x))\n for s in range(1,len(self.df_true)):\n if prediction[x-1] == 1 :\n result = ((self.df_true['close'].iloc[s] -self.df_true['close'].iloc[s-1]) / self.df_true['close'].iloc[s-1]) + 1\n profit = profit * result\n if result < mini :\n mini = result\n if maxi < result :\n maxi = result\n self.mini = mini\n self.maxi = maxi\n self.profit = profit","def compute(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n precisions = (self.TPs + METRIC_EPS) / (self.TPs + self.FPs + METRIC_EPS)\n recalls = self.TPs / (self.TPs + self.FNs + METRIC_EPS)\n\n return precisions, recalls, self.thresholds","def get_f1_score(actual_labels, preds_labels, binary_classifcation, pos_label=\"malaria\", confusion_matrix_title=\"\"):\n # demonstration of calculating metrics for a neural network model using sklearn\n if not binary_classifcation:\n # For multiclass classification.\n accuracy = accuracy_score(actual_labels, preds_labels)\n precision = precision_score(actual_labels, preds_labels, average=\"macro\")\n recall = recall_score(actual_labels, preds_labels, average=\"macro\")\n f1 = f1_score(actual_labels, preds_labels, average=\"macro\")\n print('Accuracy: %f' % accuracy)\n print('Precision: %f' % precision)\n print('Recall: %f' % recall)\n print('F1 score: %f' % f1)\n\n else:\n accuracy = accuracy_score(actual_labels, preds_labels)\n print('Accuracy: %f' % accuracy)\n # # precision tp / (tp + fp)\n precision = precision_score(actual_labels, preds_labels, pos_label=pos_label)\n print('Precision: %f' % precision)\n # recall: tp / (tp + fn)\n recall = recall_score(actual_labels, preds_labels, pos_label=pos_label)\n print('Recall: %f' % recall)\n # f1: 2 tp / (2 tp + fp + fn)\n f1 = f1_score(actual_labels, preds_labels, pos_label=pos_label)\n print('F1 score: %f' % f1)\n # ROC AUC\n # auc = roc_auc_score(test_labels, basic_cnn_preds_labels)\n # print('ROC AUC: %f' % auc)\n\n # confusion matrix\n disp = plot_confusion_matrix(y_true=actual_labels, y_pred=preds_labels,\n display_labels=list(np.unique(actual_labels)),\n cmap=plt.cm.Blues,\n normalize=None)\n disp.ax_.set_title(confusion_matrix_title)\n plt.show()\n matrix = confusion_matrix(actual_labels, preds_labels)\n print(matrix)\n # if plot_confusion_matrix:\n # show_confusion_matrix(matrix=matrix, labels=list(np.unique(actual_labels)))","def score( self ):\r\n result = 0.0\r\n for rr in self.ee.getRsrcs( ):\r\n value = self.scoreRsrc( rr )\r\n result += value\r\n print( \"INFO: Value for the schedule is %s \" % ( rr, result ) )\r\n return( result )","def evaluate(self, test_dir='data/dev', target='real'):\n test_data = {c: os.path.join(test_dir, c) for c in self.classes}\n if not target in test_data:\n print('Error: target class does not exist in test data.')\n return\n outcomes = {'TP': 0, 'TN': 0, 'FP': 0, 'FN': 0}\n # >>> YOUR ANSWER HERE\n data = []\n for c in test_data:\n docs = open(test_data[c]).readlines()\n for doc in docs:\n preprocess_doc = doc.strip()\n data.append((c, preprocess_doc))\n for item in data:\n predict_ans = self.predict(item[1])\n if item[0] == 'real':\n if predict_ans == 'real':\n outcomes['TP'] += 1\n else:\n outcomes['FN'] += 1\n else:\n if predict_ans == 'real':\n outcomes['FP'] += 1\n else:\n outcomes['TN'] += 1\n precision = outcomes['TP'] / (outcomes['TP'] + outcomes['FP']) # replace with equation for precision\n recall = outcomes['TP'] / (outcomes['TP'] + outcomes['FN']) # replace with equation for recall\n f1_score = 2 * ((precision * recall) / (precision + recall)) # replace with equation for f1\n # >>> END YOUR ANSWER\n return precision, recall, f1_score","def evaluate(labels, predictions):\n TP = 0\n actualP = 0\n TN = 0\n actualN = 0\n for label, prediction in zip(labels, predictions):\n if label ==1:\n actualP +=1\n if prediction == 1:\n TP +=1\n else:\n actualN +=1\n if prediction ==0:\n TN +=1\n \n sensitivity = float(TP/actualP)\n specificity = float(TN/actualN)\n return (sensitivity, specificity)","def get_f_score(self):\n return self.get_g_score() + self.get_h_score()","def __score_t(self, *args, **kwargs):\n pass","def f1(y_true, y_pred):\n p = precision(y_true, y_pred)\n r = recall(y_true, y_pred)\n score = 2 * p * r / (p + r)\n return score","def f1_score(precision, recall):\n if precision + recall == 0:\n return 0\n return 2 * precision * recall / (precision + recall)","def score_method(pairs_true, pairs_test):\n \n set_true = {tuple(e) for e in pairs_true}\n set_test = {tuple(e) for e in pairs_test}\n true_pos, false_pos, false_neg = confusion_stats(set_true, set_test)\n \n total = true_pos + false_pos + false_neg\n true_pos_rate = true_pos / total\n false_pos_rate = false_pos / total\n false_neg_rate = false_neg / total\n \n return true_pos_rate, false_pos_rate, false_neg_rate","def calc_acc_metrics(preds, teY):\n\n prec = precision_score(teY, preds)\n rec = recall_score(teY, preds)\n acc = accuracy_score(teY, preds)\n f1 = f1_score(teY, preds)\n\n conf_matrix = confusion_matrix(teY, preds)\n fpr = conf_matrix[0][1] / (conf_matrix[0][1] + conf_matrix[0][0])\n\n return prec, rec, acc, f1, fpr","def f1score(prediction,ytest):\n truepos = np.sum(ytest[prediction == 1])\n predpos = np.sum(prediction)\n actpos = np.sum(ytest)\n precision = truepos/predpos\n recall = truepos/actpos\n return 2*precision*recall/(precision + recall)","def calculate(self):\n\n specificity = self.confusion_matrix.tn / (self.confusion_matrix.tn + self.confusion_matrix.fp)\n\n false_positive_rate = 1 - specificity\n\n true_positive_rate = self.confusion_matrix.tp / (self.confusion_matrix.tp + self.confusion_matrix.fn)\n\n return (true_positive_rate - false_positive_rate + 1) / 2","def print_results(self, f1_score, precision_score, recall_score):\n print(\"Algorithm: %s\" % self.name)\n self.print_score(f1_score, \"F1 Score\")\n self.print_score(precision_score, \"Precision Score\")\n self.print_score(recall_score, \"Recall Score\")","def scoring(estimator, features_test, labels_test):\n pred = estimator.predict(features_test)\n p = metrics.precision_score(labels_test, pred, average='micro')\n r = metrics.recall_score(labels_test, pred, average='micro')\n if p > 0.3 and r > 0.3:\n return metrics.f1_score(labels_test, pred, average='macro')\n return 0","def fpr_at_98tpr(self):\r\n\r\n return self.fpr_at_confidence(self.confidence_at_tpr(0.98))","def calculate_many_precs_recall_stats(test_class=test_class,\n local_list=local_list,\n Q_stop='',\n no_files_in_label=no_files_in_label,\n no_of_images=no_of_images,\n verbose=verbose):\n if not Q_stop == '':\n Q = Q_stop\n else:\n Q = len(local_list)\n # does all points\n if Q > len(local_list):\n Q = len(local_list)\n if verbose:\n print('The number of points to check (Q) {} is more than the number of points above minx {}'.format(Q, len(local_list)))\n print('Setting Q to len(local_list), you may wish to change your settings')\n N_test = no_files_in_label[test_class] # no of items in class A\n N_not_test = no_of_images - N_test # i.e. set not-A\n # set up counters\n AP = 0 # average precision\n found_recall_precs_p95 = False\n recall_p95 = 0.0\n count_of_test_class = 0\n # loop backwards through the list, abs j is the position in a 1-indexed list\n recall_x = 0 # n.b. this is also sensitivity\n Ave_precs_x = 0\n specificity_x = 0\n count_of_false_positives = 0 # number of not-A on misidentified\n max_informedness = 0\n x_for_max_informedness = 0\n max_f1_stat = 0\n x_for_max_f1 = 0\n recall_for_max_informedness = 0\n specificity_for_max_informedness = 0\n for i in range(Q):\n j = -(i + 1) # 1 indexed\n recall_x_minus_1 = recall_x\n current_class = local_list[j][0]\n #j = j - 1 # really this is here so we can check j\n # break\n if count_of_test_class == N_test:\n # we've found them all\n if verbose:\n print('found all {} of {}, stopping...'.format(N_test, current_class))\n print('{}/{}'.format(count_of_test_class, abs(j)))\n break\n if (current_class == test_class):\n count_of_test_class = count_of_test_class + 1 # n A\n else:\n count_of_false_positives = count_of_false_positives + 1\n precs_x = count_of_test_class / (abs(j)) # N.b. this is the sum, we divide by j on the output\n recall_x = count_of_test_class / N_test\n false_pos_rate = count_of_false_positives / no_of_images\n specificity_x = 1-false_pos_rate\n if (precs_x <= .95) and (found_recall_precs_p95 is False):\n # thingy to grab the recall when precision drops below .95 (if ever)\n recall_p95 = recall_x\n found_recall_precs_p95 = True\n delta_recall_x = recall_x - recall_x_minus_1 # difference in recall between this point nd the next\n weight_precs_x = precs_x * delta_recall_x # weighted precsion at point x (we do average via weighted sum)\n Ave_precs_x = Ave_precs_x + weight_precs_x # average_precision evaluated at point x\n informedness_x = recall_x + specificity_x -1\n if informedness_x > max_informedness:\n max_informedness = informedness_x\n x_for_max_informedness = abs(j)\n recall_for_max_informedness = recall_x\n specificity_for_max_informedness = specificity_x\n if (precs_x > 0 and recall_x > 0):\n f1_x = 2*(precs_x*recall_x) / (precs_x + recall_x)\n else:\n f1_x = 0\n if f1_x > max_f1_stat:\n max_f1_stat = f1_x\n x_for_max_f1 = abs(j)\n if verbose:\n print('Class {}, evaluated at Q={}:, found {}'.format(test_class, Q, count_of_test_class))\n print('Average precision={}; precision={}; recall={}'.format(Ave_precs_x,precs_x,recall_x))\n print('Recall at precision .95 threashold is {}'.format(recall_p95))\n print('specificity = {}'.format(specificity_x))\n print('informedness = {}'.format(informedness_x))\n print('Max informedness was {}, seen at x {}'.format(max_informedness, x_for_max_informedness))\n print('F1 at x={} is {}'.format(abs(j),f1_x))\n print('Max F1 was {}, seen at x = {}'.format(max_f1_stat,x_for_max_f1))\n out = (Ave_precs_x, precs_x, recall_x, recall_p95,\n specificity_x, informedness_x, max_informedness, x_for_max_informedness,\n max_f1_stat, x_for_max_f1,\n recall_for_max_informedness, specificity_for_max_informedness,)\n return out","def calculate_risk_tol(*args):\n global total_score\n risk_tol_start = 0.0\n\n for risk_per_pg in risk_tol_per_qs.iterkeys():\n try:\n risk_tol_start = risk_tol_start + risk_tol_per_qs[risk_per_pg][-1] # this is the last item in the list of each information in the page\n except IndexError:\n pass\n total_score = risk_tol_start","def _compute_scores(y_pred, y_true):\n auc = accuracy_score(y_true = y_true, y_pred = y_pred)\n pre = precision_score(y_true, y_pred, average = \"macro\")\n rec = recall_score(y_true, y_pred, average = \"macro\")\n f1 = f1_score(y_true, y_pred, average = \"macro\")\n\n return pd.Series(data = [auc, pre, rec, f1], index = ['acc', 'pre', 'rec', 'f1'])","def cal_precision(preds, gts, tp_threshold=0.9, fp_threshold=0.1):\r\n TPs, tplabels = cal_TP(preds, gts)\r\n FPs, fplabels = cal_FP(preds, gts)\r\n \r\n correct_pred = set()\r\n correspond_pred = []\r\n # correspond_gt = []\r\n for i, (tp, label) in enumerate(zip(TPs, tplabels)):\r\n if ( fplabels[int(label)-1] == i+1\r\n and tp >= tp_threshold \r\n and label > 0 \r\n and FPs[int(label)-1] <= fp_threshold ):\r\n correct_pred.add(i+1)\r\n correspond_pred.append(label)\r\n else:\r\n correspond_pred.append(0.)\r\n # for _, (fp, label) in enumerate(zip(FPs, fplabels)):\r\n # if fp <= fp_threshold and label > 0 and TPs[int(label)-1] >= tp_threshold:\r\n # correct_pred.add(label)\r\n # correspond_gt.append(label)\r\n # else:\r\n # correspond_gt.append(0.)\r\n result = [[i, correspond_pred[i-1]] for i in correct_pred]\r\n\r\n return len(correct_pred) / len(TPs), result #list(correct_pred), list(correspond_pred)#, list(correspond_gt)\r","def get_f1score(conf_matrix1, conf_matrix2, conf_matrix3):\r\n p = get_precision(conf_matrix1, conf_matrix2, conf_matrix3)\r\n r = get_recall(conf_matrix1, conf_matrix2, conf_matrix3)\r\n\r\n if p + r > 0:\r\n return 2 * p * r / (p + r)\r\n else:\r\n return 0","def evaluate_ranks(articles, rank_tuples):\n rank_tp=defaultdict(int)\n rank_fn=defaultdict(int)\n rank_fp=defaultdict(int)\n \n for article in articles:\n for mention in article.entity_mentions:\n form=mention.mention\n meaning=mention.gold_link\n sys_meaning=mention.sys_link\n t_gold=(form, meaning)\n t_sys=(form, sys_meaning)\n for rank, r_tuples in rank_tuples.items():\n if t_gold in r_tuples and t_sys in r_tuples:\n rank_tp[rank]+=1\n break\n elif t_gold in r_tuples:\n rank_fn[rank]+=1\n elif t_sys in r_tuples:\n rank_fp[rank]+=1\n print('tp', rank_tp)\n print('fp', rank_fp)\n print('fn', rank_fn)\n \n rank_prec={}\n rank_recall={}\n rank_f1={}\n \n for rank in range(1,13):\n if rank_tp[rank]+rank_fp[rank]>0:\n rank_prec[rank]=rank_tp[rank]/(rank_tp[rank]+rank_fp[rank])\n else:\n rank_prec[rank]=0.0\n if rank_tp[rank]+rank_fn[rank]>0:\n rank_recall[rank]=rank_tp[rank]/(rank_tp[rank]+rank_fn[rank])\n else:\n rank_recall[rank]=0.0\n if rank_prec[rank]+rank_recall[rank]>0:\n rank_f1[rank]=2*rank_prec[rank]*rank_recall[rank]/(rank_prec[rank]+rank_recall[rank])\n else:\n rank_f1[rank]=0.0\n print('precision', rank_prec)\n print()\n print('recall', rank_recall)\n print()\n print('f1', rank_f1)\n print()\n return rank_prec, rank_recall, rank_f1","def _get_fpr(self, arg):","def fpr_at_99tpr(self):\r\n\r\n return self.fpr_at_confidence(self.confidence_at_tpr(0.99))","def evaluate(true_labels, predicted_labels):\n accuracy = np.round(metrics.accuracy_score(true_labels, predicted_labels), \n 2)\n precision = np.round(metrics.precision_score(true_labels, predicted_labels, \n average='weighted'), 2)\n recall = np.round(metrics.recall_score(true_labels, predicted_labels,\n average='weighted'), 2)\n f1 = np.round(metrics.f1_score(true_labels, predicted_labels, \n average='weighted'), 2)\n \n return accuracy, precision, recall, f1","def _compute_scores(self, triples):\n # compute scores as sum(s * p * o)\n scores = tf.reduce_sum(triples[0] * triples[1] * triples[2], 1)\n return scores","def calc_TP_FP(groundtruth, eval_boxes, matches_predicate, confidence_threshold=-9e999):\n TP = 0\n FP = 0\n FN = 0\n for image_key in groundtruth.keys() + eval_boxes.keys():\n gt_bboxes = set(groundtruth.get(image_key, []))\n other_bboxes = set(box\n for box in eval_boxes.get(image_key, [])\n if box.confidence >= confidence_threshold\n or box.confidence is None\n )\n for gt_bbox in gt_bboxes:\n # Do any of their boxes match?\n match = None\n for other_box in other_bboxes:\n if matches_predicate(gt_bbox, other_box):\n match = other_box\n if match:\n other_bboxes.remove(match)\n TP += 1\n else:\n FN += 1\n FP += len(other_bboxes)\n # if len(other_bboxes):\n # print \"False positive on\", image_key\n return {\"TP\": TP, \"FP\": FP, \"FN\": FN, \"TN\": 0}","def KendallTau_calc(TP, FP, FN, TN):\n try:\n n = TP + FP + FN + TN\n return (2 * (TP + TN - FP - FN)) / (n * (n - 1))\n except Exception:\n return \"None\"","def calc_pr_rc_F1(GTD, block_occ):\r\n true_pos = ((GTD + block_occ)==2).sum()\r\n false_pos = sum([1 if BI_val==1 and GTD[i]==0 else 0 for i, BI_val in enumerate(block_occ.values)])\r\n precision = float(true_pos/(true_pos+false_pos))\r\n recall = float(true_pos/(GTD.sum()))\r\n if precision == 0:\r\n F1 = 0\r\n else:\r\n F1 = float(2 * (precision * recall) / (precision + recall))\r\n \r\n return precision, recall, F1","def evaluate(pred_file, ref_file):\n ref_dict, pred_dict, query_dict, id_dict = build_pred_ref_dict(ref_file, pred_file, ref_file)\n total, acc, scores = res_eval_with_type_acc(query_dict, pred_dict, ref_dict, id_dict, save=False)\n em = calculate_exact_match(pred_dict, ref_dict)\n print('Comp Acc: {:.3f}%\\tBleu-4: {:.3f}\\tRouge-L: {:.3f}'.format(acc, scores['Bleu-4'], scores['Rouge-L']))\n print('EM: {:.3f}%'.format(em))\n # calculate_sketch_type_acc(ref_file, pred_file)\n # calculate_exact_match_for_each_q_type(ref_file, pred_file)\n return total, acc, scores, em","def completing_evalution(self, *args):\n self.calculate_risk_tol(*args)\n graham_picks = key_ratios(\"GrahamScore\", total_score)\n lynch_picks = key_ratios(\"LynchScore\", total_score)\n return (graham_picks, lynch_picks)","def KentFosterII_calc(TP, FP, FN, TN):\n try:\n part1 = ((TN + FP) * (TN + FN)) / (TN + FP + FN)\n return (TN - part1) / (TN - part1 + FP + FN)\n except Exception:\n return \"None\"","def stats(detections, faces):\n vp, fp, fn, vn = 0, 0, 0, 0\n max_label = np.max(faces[:, 0])\n for i in range(max_label + 1):\n detections_i = get_label_with_index(detections, i)\n faces_i = get_label_with_index(faces, i)\n local_vp = 0\n for face in faces_i:\n found = False\n for detection in detections_i:\n if intersection_ratio(face, detection) >= 0.5:\n found = True\n break\n if found:\n vp += 1\n local_vp += 1\n else:\n fn += 1\n fp += len(detections_i) - local_vp\n\n precision = vp / (vp + fp)\n rappel = vp / (vp + fn)\n f_score = 2 * ((precision * rappel) / (precision + rappel))\n\n return precision, rappel, f_score","def scoring(self):\n pass","def compute_scores(self):\n if self.num_classes == 2:\n score_1 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold=0.5,\n )[1]\n\n score_2 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold_ratio=0.5,\n )[1]\n\n score_3 = self.competition_metric(\n impact_threshold=0.5,\n )[1]\n else:\n score_1 = self.detection_metric(threshold=0.1)\n score_2 = self.detection_metric(threshold=0.25)\n score_3 = self.detection_metric(threshold=0.5)\n\n return score_1, score_2, score_3","def f1_score_model(self, model, X, y):\n\n prediction = model.predict_classes(X)\n f1_macro = f1_score(y, prediction, average='macro')\n f1_micro = f1_score(y, prediction, average='macro')\n print(\"f1_macro: \", f1_score(y, prediction, average='macro'))\n print(\"f1_micro: \", f1_score(y, prediction, average=\"micro\"))\n print(\"f1_weighted: \", f1_score(y, prediction, average=\"weighted\"))\n return f1_macro, f1_micro","def KentFosterI_calc(TP, FP, FN, TN):\n try:\n part1 = ((TP + FP) * (TP + FN)) / (TP + FP + FN)\n return (TP - part1) / (TP - part1 + FP + FN)\n except Exception:\n return \"None\"","def score(self, params):\n\n if self.use_sqrt:\n return self.score_sqrt(params)\n else:\n return self.score_full(params)","def score(self, x, y, verbose=False):\n y_pred = self.forward(x).T\n\n y_p = np.argmax(y_pred, axis=-1)\n y_t = np.argmax(y, axis=-1)\n fpr, tpr, thresholds = roc_curve(y_t, y_p, pos_label=2)\n\n metricas = {\n 'accuracy': accuracy_score(y_t, y_p),\n 'f1':f1_score(y_t, y_p, average='macro'),\n 'balanced accuracy': balanced_accuracy_score(y_t, y_p),\n 'auc': auc(fpr, tpr)\n }\n\n if verbose:\n print('Accuracy', metricas['accuracy'])\n print('F1-Macro', metricas['f1'])\n print('Balanced accuracy', metricas['balanced accuracy'])\n print('AUC', metricas['auc'])\n\n return metricas","def HarrisLahey_calc(TP, FP, FN, TN):\n try:\n n = TP + FP + FN + TN\n part1 = TP / (TP + FP + FN)\n part2 = (2 * TN + FP + FN) / (2 * n)\n part3 = TN / (TN + FP + FN)\n part4 = (2 * TP + FP + FN) / (2 * n)\n return part1 * part2 + part3 * part4\n except Exception:\n return \"None\"","def overall_performance_prf(articles, skip_nils=True, skip_nonnils=False):\n tp=0\n fn=0\n fp=0\n for article in articles:\n for entity in article.entity_mentions:\n if skip_nils and entity.gold_link=='--NME--':\n continue\n if skip_nonnils and entity.gold_link!='--NME--':\n continue\n if entity.gold_link==entity.sys_link:\n tp+=1\n else:\n if entity.sys_link!='--NME--':\n fp+=1\n if entity.gold_link!='--NME--':\n fn+=1\n print(tp, fp, fn)\n p=tp/(tp+fp) \n r=tp/(tp+fn) \n f1=2*p*r/(p+r)\n print(p,r,f1)\n return f1","def tpr(positive, negative, fpr):\n threshold = np.percentile(np.asarray(negative), 100 - fpr)\n total_true_positives = sum(positive > threshold)\n\n return total_true_positives / len(positive)","def analyze_confusion(confusion, true_labels):\n print(\"Confusion matrix:\")\n printer(\"Pre\\Tru\", true_labels)\n\n for line, label in zip(confusion, true_labels):\n printer(f\"{label}\", line)\n\n TP = confusion.diagonal()\n FN = np.sum(confusion, axis=0) - TP\n FP = np.sum(confusion, axis=1) - TP\n\n print()\n printer(\"TP\", TP)\n printer(\"FP\", FP)\n printer(\"FN\", FN)\n\n # https://stackoverflow.com/a/37977222\n # P = TP / ( TP + FP)\n # R = TP / ( TP + FN)\n dP = TP + FP\n P = np.divide(TP, dP, out=np.zeros_like(TP, dtype=float), where=dP != 0)\n dR = TP + FN\n R = np.divide(TP, dR, out=np.zeros_like(TP, dtype=float), where=dR != 0)\n\n print(\"\\nPrecision = TP / ( TP + FP)\\tRecall = TP / ( TP + FN)\")\n printer(\"Prec\", P, \":.4f\")\n printer(\"Recall\", R, \":.4f\")\n\n avgP = np.sum(P) / len(true_labels)\n avgR = np.sum(R) / len(true_labels)\n print(f\"Average P: {avgP:.4f}\\tR: {avgR:.4f}\")\n\n print(\"F-score = 2 (PxR) / (P+R)\")\n # F = 2 (PxR) / (P+R)\n PdR = 2 * P * R\n PpR = P + R\n F = np.divide(PdR, PpR, out=np.zeros_like(TP, dtype=float), where=PpR != 0)\n printer(\"F-score\", F, \":.4f\")\n\n avgF = np.sum(F) / len(true_labels)\n print(f\"Average F-score {avgF}\")\n\n return avgF","def find_TPR_threshold(y, scores, desired_TPR):\n for threshold in np.arange(1,0,-0.01):\n y_hat = (scores>=threshold).astype(int)\n confusion = confusion_matrix(y, y_hat)\n TN, FP, FN, TP = confusion.flat\n TPR = TP / (TP + FN)\n FPR = FP / (FP + TN)\n if TPR >= desired_TPR:\n return threshold, FPR","def f1_score(self, y_true=None, y_pred=None, labels=None, average=\"macro\", decimal=None, **kwargs):\n y_true, y_pred, binary, representor, decimal = self.get_processed_data(y_true, y_pred, decimal)\n matrix, imap, imap_count = cu.calculate_confusion_matrix(y_true, y_pred, labels, normalize=None)\n metrics = cu.calculate_single_label_metric(matrix, imap, imap_count)\n\n list_f1 = np.array([item[\"f1\"] for item in metrics.values()])\n list_weights = np.array([item[\"n_true\"] for item in metrics.values()])\n\n if average == \"micro\":\n tp_global = np.sum(np.diag(matrix))\n fp_global = fn_global = np.sum(matrix) - tp_global\n precision = tp_global / (tp_global + fp_global)\n recall = tp_global / (tp_global + fn_global)\n f1 = (2 * precision * recall) / (precision + recall)\n elif average == \"macro\":\n f1 = np.mean(list_f1)\n elif average == \"weighted\":\n f1 = np.dot(list_weights, list_f1) / np.sum(list_weights)\n else:\n f1 = dict([(label, np.round(item[\"f1\"], decimal)) for label, item in metrics.items()])\n return f1 if type(f1) == dict else np.round(f1, decimal)","def get_recall(TP, FN):\n recall = TP / (TP + FN)\n return recall","def calculate_f1_score(predictions, actuals):\n predictions = predictions > 0.5\n # fbeta_score throws a confusing error if inputs are not numpy arrays\n predictions, actuals, = np.array(predictions), np.array(actuals)\n # We need to use average='samples' here, any other average method will generate bogus results\n return fbeta_score(actuals, predictions, beta=1, average='samples')","def _f1_score_(prediction, ground_truth):\n prediction_tokens = _normalize_answer(prediction).split()\n ground_truth_tokens = _normalize_answer(ground_truth).split()\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(prediction_tokens)\n recall = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def _get_scores(target, predicted):\n recall = scoring(target, predicted, metric=\"recall\")\n precision = scoring(target, predicted, metric=\"precision\")\n accuracy = scoring(target, predicted, metric=\"accuracy\")\n f_score = scoring(target, predicted, metric=\"f1\")\n\n return [recall, precision, accuracy, f_score]","def compute(self) -> Tuple[float, float, float]:\n # @TODO: ddp hotfix, could be done better\n if self._is_ddp:\n for key in self.statistics:\n value: List[float] = all_gather(self.statistics[key])\n value: float = sum(value)\n self.statistics[key] = value\n\n precision_value, recall_value, f1_value = get_binary_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n zero_division=self.zero_division,\n )\n return precision_value, recall_value, f1_value","def BatageljBren_calc(TP, FP, FN, TN):\n try:\n return (FP * FN) / (TP * TN)\n except Exception:\n return \"None\"","def f1_score(confusion):\n p = precision(confusion)\n r = sensitivity(confusion)\n F1 = (2 * p * r) / (p + r)\n return F1","def get_score(snack_data, percentage_data, snack, snack_query, protein_query, carb_query, fat_query):\n\tstart_time = time.time()\n\n\t#Load necessary data\n\t\"\"\"\twith open ('../../../Data/percentagesDict.pickle', 'rb') as f:\n\t\tpercentage_data = pickle.load(f)\n\n\twith open ('../../../Data/FINAL_snacks_data.pickle', 'rb') as f:\n\t\tsnack_data = pickle.load(f)\"\"\"\n\n\t#Set constants\n\tLOW_FAT = .3\n\tHIGH_FAT = .6\n\tLOW_CARB = .1\n\tHIGH_CARB = .2\n\tLOW_PRO = .2\n\tHIGH_PRO = .4\n\n\t#Convert macro percentages to 'high', 'med', 'low' categories\n\tfat = percentage_data[snack]['fat']\n\tprotein = percentage_data[snack]['protein']\n\tcarb = percentage_data[snack]['carb']\n\n\tif fat > HIGH_FAT:\n\t\tfat_content = 'high'\n\telif fat < LOW_FAT:\n\t\tfat_content = 'low'\n\telse:\n\t\tfat_content = 'med'\n\n\tif protein > HIGH_PRO:\n\t\tprotein_content = 'high'\n\telif protein < LOW_PRO:\n\t\tprotein_content = 'low'\n\telse:\n\t\tprotein_content = 'med'\n\n\tif carb > HIGH_CARB:\n\t\tcarb_content = 'high'\n\telif carb < LOW_CARB:\n\t\tcarb_content = 'low'\n\telse:\n\t\tcarb_content = 'med'\n\n\t#Set x values\n\tx1 = fat_query == fat_content\n\tx2 = carb_query == carb_content\n\tx3 = protein_query == protein_content\n\tx4 = cooccur(snack_data, snack, snack_query) \n\tx5 = snack_data[snack]['rating']\n\n\tw1 = 1\n\tw2 = 1\n\tw3 = 1\n\tw4 = 1\n\tw5 = 1\n\t\n\t#print('x1: {}, x2: {}, x3: {}, x4: {}, x5: {}'.format(x1, x2, x3, x4, x5))\n\t#print(\"get_score() time: --- %s seconds ---\" % (time.time() - start_time))\n\n\n\treturn w1*x1 + w2*x2 + w3*x3 + w4*x4 + w5*x5","def get_f1(self,common_len,RTSummary,SystemSummary):\n recall = self.get_recall(common_len,RTSummary)\n precision = self.get_precision(common_len,SystemSummary)\n if precision<=0 or recall <=0:\n return 0.0\n else:\n return ((2 * recall * precision)/(recall + precision))","def compute_prf_on_selection(arts, forms_set):\n tp=0\n fn=0\n fp=0\n for article in arts:\n for entity in article.entity_mentions:\n if entity.mention in forms_set:\n if entity.gold_link==entity.sys_link:\n tp+=1\n else:\n if entity.sys_link!='--NME--':\n fp+=1\n if entity.gold_link!='--NME--':\n fn+=1\n print(tp, fp, fn)\n p=tp/(tp+fp)\n r=tp/(tp+fn)\n f1=2*p*r/(p+r)\n print(p,r,f1)\n return f1","def fpr_at_95tpr(self):\r\n\r\n return self.fpr_at_confidence(self.confidence_at_tpr(0.95))","def raw_score(self,X,Y):\n return self.rf.score(X,Y)","def prf_cal(y_pred,y_true,k):\r\n GT=np.sum(y_true[y_true==1.])\r\n instance_num=y_true.shape[0]\r\n prediction_num=instance_num*k\r\n\r\n sort_indices = np.argsort(y_pred)\r\n sort_indices=sort_indices[:,::-1]\r\n static_indices = np.indices(sort_indices.shape)\r\n sorted_annotation= y_true[static_indices[0],sort_indices]\r\n top_k_annotation=sorted_annotation[:,0:k]\r\n TP=np.sum(top_k_annotation[top_k_annotation==1.])\r\n recall=TP/GT\r\n precision=TP/prediction_num\r\n f1=2.*recall*precision/(recall+precision)\r\n return precision, recall, f1","def _prec_recall_f1_score(pred_items, gold_items):\n common = Counter(gold_items) & Counter(pred_items)\n num_same = sum(common.values())\n if num_same == 0:\n return 0, 0, 0\n precision = 1.0 * num_same / len(pred_items)\n recall = 1.0 * num_same / len(gold_items)\n f1 = (2 * precision * recall) / (precision + recall)\n return precision, recall, f1","def evaluate(train, train_labels, test, test_labels):\n \n # Use the same model for each training set for now\n model = RandomForestClassifier(n_estimators = 100, \n random_state = 50, n_jobs = -1)\n \n train = train.replace({np.inf: np.nan, -np.inf: np.nan})\n test = test.replace({np.inf: np.nan, -np.inf:np.nan})\n \n feature_names = list(train.columns)\n \n # Impute the missing values\n imputer = Imputer(strategy = 'median', axis = 1)\n train = imputer.fit_transform(train)\n test = imputer.transform(test)\n \n cv_score = 1 * cross_val_score(model, train, train_labels, \n scoring = \"f1\", \n cv = 5)\n \n # Fit on the training data and make predictions\n model.fit(train, train_labels)\n preds = model.predict(test)\n \n # Calculate the performance\n f1 = f1_score(test_labels, preds)\n print('5-fold CV F1: {:.2f} with std: {:.2f}'.format(cv_score.mean(),cv_score.std()))\n print('Test F1: {:.2f}.'.format(f1))\n \n feature_importances = pd.DataFrame({'feature': feature_names, \n 'importance': model.feature_importances_})\n \n return preds, feature_importances","def calculate(self):\n\n s_sum = 0\n class_num = len(self.scores)\n \n for i in range(class_num):\n s_sum += self.scores[i]\n\n av = float(s_sum)/class_num\n if av >= 90:\n return 'O'\n elif av >= 80:\n return 'E'\n elif av >= 70:\n return 'A'\n elif av >= 55:\n return 'P'\n elif av >= 40:\n return 'D'\n else:\n return 'T'","def set_score(self):\n if self.PotTax_intervention is None:\n if self.PotTax_reference is not None:\n self.score = (((self.PotTax_reference.sum().TFI - 29.33) /\n 1.4349) / 100)\n else:\n print(\"There is no Biosafe output to score\")\n return\n else:\n self.score = (((self.PotTax_intervention.sum().TFI - 29.33) /\n 1.4349) / 100)\n return","def fpr(positive, negative, tpr):\n threshold = np.percentile(np.asarray(positive), 100-tpr) # uses numpy percentile (ex 70th tpr is the 30th percentile)\n total_false_positives = sum(negative > threshold)\n\n return total_false_positives/len(negative)","def calc_metrics(metric_scores_list):\n\n N_split, N_miss, N_add, Q_P, Q_R, Q_F, N_gt, N_pred = [], [], [], [], [], [], [], []\n Q_rand, Q_jaccard, Q_aggregated_jaccard, Q_ctc, Q_piou = [], [], [], [], []\n tp, fp, fn = [], [], []\n\n for score in metric_scores_list:\n N_split.append(score['N_split']), N_miss.append(score['N_miss']), N_add.append(score['N_add'])\n Q_P.append(score['Q_P']), Q_R.append(score['Q_R']), Q_F.append(score['Q_F'])\n Q_rand.append(score['Q_rand']), Q_jaccard.append(score['Q_jaccard'])\n Q_aggregated_jaccard.append(score['Q_aggregated_jaccard'])\n if \"Q_ctc\" in score:\n Q_ctc.append(score['Q_ctc']), \n Q_piou.append(score['Q_piou'])\n N_gt.append(score['N_gt']), N_pred.append(score['N_pred'])\n tp.append(score['tp']), fp.append(score['fp']), fn.append(score['fn'])\n\n N_split, N_miss, N_add = np.array(N_split), np.array(N_miss), np.array(N_add)\n N_gt, N_pred = np.array(N_gt), np.array(N_pred)\n tp, fp, fn = np.array(tp), np.array(fp), np.array(fn)\n Q_P_macro, Q_R_macro, Q_F_macro = np.mean(np.array(Q_P)), np.mean(np.array(Q_R)), np.mean(np.array(Q_F))\n Q_P_micro = np.sum(tp) / (np.sum(tp) + np.sum(fp)) if (np.sum(tp) + np.sum(fp)) > 0 else 0\n Q_R_micro = np.sum(tp) / (np.sum(tp) + np.sum(fn)) if (np.sum(tp) + np.sum(fn)) > 0 else 0\n Q_rand_macro, Q_jaccard_macro = np.mean(np.array(Q_rand)), np.mean(np.array(Q_jaccard))\n Q_aggregated_jaccard_macro = np.mean(np.array(Q_aggregated_jaccard))\n Q_ctc_macro, Q_piou_macro = np.mean(np.array(Q_ctc)), np.mean(np.array(Q_piou))\n\n metrics = {\n 'Q_split_micro': float(np.sum(N_split) / np.sum(N_gt)),\n 'Q_split_macro': float(np.mean(N_split / N_gt)),\n 'Q_miss_micro': float(np.sum(N_miss) / np.sum(N_gt)),\n 'Q_miss_macro': float(np.mean(N_miss / N_gt)),\n 'Q_add_micro': float(np.sum(N_add) / np.sum(N_gt)),\n 'Q_add_macro': float(np.mean(N_add / N_gt)),\n 'N_gt': int(np.sum(N_gt)),\n 'N_pred': int(np.sum(N_pred)),\n 'Q_rand_macro': float(Q_rand_macro),\n 'Q_jaccard_macro': float(Q_jaccard_macro),\n 'Q_aggregated_jaccard_macro': float(Q_aggregated_jaccard_macro),\n 'Q_ctc_macro': float(Q_ctc_macro),\n 'Q_piou_macro': float(Q_piou_macro),\n 'Q_P_micro': float(Q_P_micro),\n 'Q_P_macro': float(Q_P_macro),\n 'Q_R_micro': float(Q_R_micro),\n 'Q_R_macro': float(Q_R_macro),\n 'Q_F_macro': float(Q_F_macro),\n 'Q_F_micro': float(2 * Q_P_micro * Q_R_micro / (Q_P_micro + Q_R_micro)) if (Q_P_micro + Q_R_micro) > 0 else 0\n }\n return metrics","def muc_scores(self):\n A_card, B_card = self.shape\n V_card = len(self)\n N = self.grand_total\n\n recall = _div(N - V_card, N - A_card)\n precision = _div(N - V_card, N - B_card)\n fscore = hmean(recall, precision)\n return precision, recall, fscore","def f1_score(y_true, y_pred):\n num = 2 * precision_score(y_true, y_pred) * recall_score(y_true, y_pred)\n deno = (precision_score(y_true, y_pred) + recall_score(y_true, y_pred))\n return num / deno","def ForbesI_calc(TP, FP, FN, TN):\n try:\n n = TP + FP + FN + TN\n part1 = (TP + FP) * (TP + FN)\n return (n * TP) / part1\n except Exception:\n return \"None\"","def f1_score(guess, answer):\n if guess is None or answer is None:\n return 0\n score = prec_recall_f1_score(normalize_answer(guess).split(), normalize_answer(answer).split())\n\n return score","def _get_evaluations(self, pred_Y, Y):\n\n tp = fp = tn = fn = 0\n for i in range(len(pred_Y)):\n if pred_Y[i] == 1 and Y[i] == 1:\n tp += 1\n elif pred_Y[i] == 0 and Y[i] == 0:\n tn += 1\n elif pred_Y[i] == 1 and Y[i] == 0:\n fp += 1\n else:\n fn += 1\n tp = float(tp)\n fp = float(fp)\n tn = float(tn)\n fn = float(fn)\n return tp, fp, tn, fn","def precision_recall_fscore(true, predicted, beta=1, labels=None, pos_label=None, average=None):\n\n # Build contingency table as ldict\n ldict = {}\n for l in labels:\n ldict[l] = {\"tp\": 0., \"fp\": 0., \"fn\": 0., \"support\": 0.}\n\n for t, p in zip(true, predicted):\n if t == p:\n ldict[t][\"tp\"] += 1\n else:\n ldict[t][\"fn\"] += 1\n ldict[p][\"fp\"] += 1\n ldict[t][\"support\"] += 1\n\n # Calculate precision, recall and F-beta score per class\n beta2 = beta ** 2\n for l, d in ldict.items():\n try:\n ldict[l][\"precision\"] = d[\"tp\"]/(d[\"tp\"] + d[\"fp\"])\n except ZeroDivisionError: ldict[l][\"precision\"] = 0.0\n try: ldict[l][\"recall\"] = d[\"tp\"]/(d[\"tp\"] + d[\"fn\"])\n except ZeroDivisionError: ldict[l][\"recall\"] = 0.0\n try: ldict[l][\"fscore\"] = (1 + beta2) * (ldict[l][\"precision\"] * ldict[l][\"recall\"]) / (beta2 * ldict[l][\"precision\"] + ldict[l][\"recall\"])\n except ZeroDivisionError: ldict[l][\"fscore\"] = 0.0\n\n # If there is only 1 label of interest, return the scores. No averaging needs to be done.\n if pos_label:\n d = ldict[pos_label]\n return (d[\"precision\"], d[\"recall\"], d[\"fscore\"])\n # If there are multiple labels of interest, macro-average scores.\n else:\n for label in ldict.keys():\n avg_precision = sum(l[\"precision\"] for l in ldict.values()) / len(ldict)\n avg_recall = sum(l[\"recall\"] for l in ldict.values()) / len(ldict)\n avg_fscore = sum(l[\"fscore\"] for l in ldict.values()) / len(ldict)\n return (avg_precision, avg_recall, avg_fscore)","def comp_recall_precision_f1(nr_correct, nr_predicted, nr_total):\n recall = comp_recall(nr_correct, nr_total)\n precision = comp_precision(nr_correct, nr_predicted)\n f1 = comp_f1(precision, recall)\n return recall, precision, f1","def calculate_precision(num_tp, num_fp, num_fn):\n if (num_tp + num_fp) == 0:\n return 1\n else:\n return num_tp / (num_tp + num_fp)","def pf_analysis():\r\n\r\n global params\r\n n = params['n']\r\n level = params['level']\r\n pfmin = params['pfmin']\r\n pfmax = params['pfmax']\r\n pfstep = params['pfstep']\r\n ns = params['ns']\r\n nt = params['nt']\r\n po = params['po']\r\n pe = params['pe']\r\n pf_dir = create_dir(TIMES_PATH + 'pf')\r\n filename = datetime.datetime.now().strftime(DATE_FORMAT) + '.csv'\r\n with open(pf_dir + filename, 'wb') as csvfile:\r\n fw = csv.writer(csvfile)\r\n fw.writerow(('lv', 'ns', 'nt', 'no', 'ne', 'pf', 'nf',\r\n 'method1', 'method2', 'method3_1', 'method3_2'))\r\n pf = pfmin\r\n while pf <= pfmax:\r\n no = max(int(round(po * nt)), 1)\r\n ne = max(int(round(pe * no)), 1)\r\n nf = max(int(round(pf * nt)), 1)\r\n times = [0] * 4\r\n for i in range(n):\r\n times = map(sum, zip(times, get_times(level, ns, nt, no, ne, nf)))\r\n show_progress('pf', pf, pfmin, pfmax, pfstep, i, n)\r\n times = map(lambda x: float(x) / n, times)\r\n fw.writerow((level, ns, nt, no, ne, pf, nf) + tuple(times))\r\n pf += pfstep\r\n csvfile.close()","def f1_score(y_true, y_pred, threshold, macro = False, eps = 1e-9):\n\n y_pred = torch.ge(y_pred.float(), threshold).float()\n\n y_true = y_true.float()\n\n tp_l = (y_pred * y_true).sum(0).float()\n\n fp_l = (y_pred * (1 - y_true)).sum(0).float()\n\n fn_l = ((1 - y_pred) * y_true).sum(0).float()\n\n precision_label = tp_l.div(tp_l + fp_l + eps)\n\n recall_label = tp_l.div(tp_l + fn_l + eps)\n\n if macro:\n\n f1_macro = torch.mean((precision_label * recall_label).div(precision_label + recall_label + eps) * 2)\n\n return f1_macro.item(), torch.mean(precision_label).item(), torch.mean(recall_label).item()\n\n else: \n\n tp = tp_l.sum()\n\n fp = fp_l.sum()\n\n fn = fn_l.sum()\n\n precision = tp / (tp + fp + eps)\n\n recall = tp / (tp + fn + eps)\n\n f1_micro = (precision * recall).div(precision + recall + eps) * 2\n\n return f1_micro.item(), precision.item(), recall.item()","def get_f1_scores(labels_true: np.ndarray, labels_pred: np.ndarray, return_precision_recall: bool = False) \\\n -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray, np.ndarray]]:\n confusion = get_confusion_matrix(labels_true, labels_pred)\n n_labels = confusion.shape[0]\n counts_correct = confusion.diagonal()\n counts_true = confusion.dot(np.ones(n_labels))\n counts_pred = confusion.T.dot(np.ones(n_labels))\n mask = counts_true > 0\n recalls = np.zeros(n_labels)\n recalls[mask] = counts_correct[mask] / counts_true[mask]\n precisions = np.zeros(n_labels)\n mask = counts_pred > 0\n precisions[mask] = counts_correct[mask] / counts_pred[mask]\n f1_scores = np.zeros(n_labels)\n mask = (counts_true > 0) & (counts_pred > 0)\n f1_scores[mask] = 2 / (1 / precisions[mask] + 1 / recalls[mask])\n if return_precision_recall:\n return f1_scores, precisions, recalls\n else:\n return f1_scores"],"string":"[\n \"def computeFScores(self, targetLabels, actualLabels):\\r\\n if self.prMeasures is None:\\r\\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\\r\\n if self.prMeasures[0] == 0:\\r\\n return 0\\r\\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\\r\\n return self.f1score\",\n \"def calculate_scores(self):\\n # Prediction based scores\\n #self.report = classification_report(self.y_test, self.y_pred)\\n self.accuracy = accuracy_score(self.y_real, self.y_pred)\\n self.precision = precision_score(self.y_real, self.y_pred)\\n self.recall = recall_score(self.y_real, self.y_pred)\\n self.f1 = f1_score(self.y_real, self.y_pred)\\n \\n # Probability based scores\\n self.fpr, self.tpr, _ = roc_curve(self.y_real, self.y_proba)\\n self.average_precision = average_precision_score(self.y_real, self.y_proba)\\n self.brier_loss = brier_score_loss(self.y_real, self.y_proba)\\n self.roc_auc = roc_auc_score(self.y_real, self.y_proba)\\n self.prec_cur, self.recall_cur, _ = precision_recall_curve(self.y_real, self.y_proba)\",\n \"def f1_score(self):\\n self.overall_f1_score = f1_score(\\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\\n self.classes_f1_score = f1_score(\\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)\",\n \"def calculate_f1_score(y_test, y_pred):\\n print('# Running precision, recall and F1-score')\\n print('# F1-Score:\\\\t\\\\t%.2f' % (f1_score(y_test, y_pred, average=\\\"macro\\\") * 100))\\n print('# Precision:\\\\t\\\\t%.2f' % (precision_score(y_test, y_pred, average=\\\"macro\\\") * 100))\\n print('# Recall:\\\\t\\\\t%.2f' % (recall_score(y_test, y_pred, average=\\\"macro\\\") * 100))\",\n \"def performance(stats):\\n\\n def fbeta_score(precision, recall, beta=1.0):\\n beta_square = beta * beta\\n if (precision != 0.0) and (recall != 0.0):\\n res = ((1 + beta_square) * precision * recall / (beta_square * precision + recall))\\n else:\\n res = 0.0\\n return res\\n\\n def prf1(tp_, fp_, fn_, tn_):\\n # 单类的\\n tp_ = np.sum(tp_, axis=0) #batch*=》\\n fp_ = np.sum(fp_, axis=0)\\n fn_ = np.sum(fn_, axis=0)\\n tn_ = np.sum(tn_, axis=0)\\n # 总体的\\n atp = np.sum(tp_)\\n afp = np.sum(fp_)\\n afn = np.sum(fn_)\\n atn = np.sum(tn_)\\n\\n micro_p = (1.0 * atp) / (atp + afp) if (atp + afp != 0) else 0.0\\n micro_r = (1.0 * atp) / (atp + afn) if (atp + afn != 0) else 0.0\\n micro_f = fbeta_score(micro_p, micro_r)\\n\\n pp = [0]\\n rr = [0]\\n ff = [0]\\n macro_p = np.mean(pp)\\n macro_r = np.mean(rr)\\n macro_f = np.mean(ff)\\n\\n acc = (atp + atn) / (atp + atn + afp + afn) if (atp + atn + afp + afn) else 0.0\\n acc_NA = atn / (atn + afp) if (atn + afp) else 0.0\\n acc_not_NA = atp / (atp + afn) if (atp + afn) else 0.0\\n return {'acc': acc, 'NA_acc': acc_NA, 'not_NA_acc': acc_not_NA,\\n 'micro_p': micro_p, 'micro_r': micro_r, 'micro_f': micro_f,\\n 'macro_p': macro_p, 'macro_r': macro_r, 'macro_f': macro_f,\\n 'tp': atp, 'true': atp + afn, 'pred': atp + afp, 'total': (atp + atn + afp + afn)}\\n\\n fin_loss = sum(stats['loss']) / len(stats['loss'])\\n scores = prf1(stats['tp'], stats['fp'], stats['fn'], stats['tn'])\\n return fin_loss, scores\",\n \"def prf_analysis(y_true: list, y_pred: list) -> None:\\n print('Precision: {:,.2f}'.format(precision_score(y_true, y_pred)))\\n print('Recall : {:,.2f}'.format(recall_score(y_true, y_pred)))\\n print('F1 : {:,.2f}'.format(f1_score(y_true, y_pred)))\\n print('Accuracy : {:,.2f}'.format(accuracy_score(y_true, y_pred)))\\n return None\",\n \"def compute_prf(self, counts_dict):\\n precision = counts_dict[\\\"correct\\\"] / counts_dict[\\\"predicted\\\"] if counts_dict[\\\"predicted\\\"] else 0.0\\n recall = counts_dict[\\\"correct\\\"] / counts_dict[\\\"gold\\\"] if counts_dict[\\\"gold\\\"] else 0.0\\n fscore = 2 * precision * recall / (precision + recall) if precision + recall else 0.0\\n\\n return {\\\"precision\\\": precision, \\\"recall\\\": recall, \\\"fscore\\\": fscore}\",\n \"def F1_score(y_t, y_p, weights):\\n\\n P = Precision()\\n R = Recall() #label per label evaluation\\n F1_score_per_label = [] #store per label\\n P_per_label = []\\n R_per_label = []\\n F1_tot = 0 #weighted sum\\n\\n for i in range(8):\\n P.update_state( y_t[:,i], y_p[:,i] )\\n R.update_state( y_t[:,i], y_p[:,i] )\\n p = P.result().numpy()\\n r = R.result().numpy()\\n P.reset_states()\\n R.reset_states()\\n if p+r == 0:\\n f1 = 0\\n else:\\n f1 = 2*p*r/ (p+r)\\n F1_score_per_label.append(f1)\\n P_per_label.append(p)\\n R_per_label.append(r)\\n\\n F1_tot += f1*weights[i]\\n\\n return F1_score_per_label, P_per_label, R_per_label, F1_tot\",\n \"def custom_scoring(y_te, y_pred):\\n #weights computed with training data set\\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\\n \\n ## F1 SCORES\\n #evaluate F1 score, precision and recall for each label, \\n #along with custom proportionally weighted F1 score\\n #and built in weighted and macro F1 scores\\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\\n f = F1Score(8, threshold = 0.5, average = 'weighted')\\n f.update_state(y_te, y_pred)\\n wf1 = f.result().numpy() #weighted f1 score\\n f.reset_states()\\n f = F1Score(8, threshold = 0.5, average = 'macro')\\n f.update_state(y_te, y_pred)\\n mf1 = f.result().numpy() #macro f1 score\\n f.reset_states()\\n\\n ##EDIT DISTANCE\\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\\n\\n ##ACCURACY\\n #evaluate accuracy per label\\n acc_tab = Acc(y_te, y_pred)\\n\\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab\",\n \"def prf(stats):\\n if stats['pred'] == 0:\\n return 0, 0, 0\\n p = stats['corr']/stats['pred']\\n r = stats['corr']/stats['gold']\\n if p > 0 and r > 0:\\n f = 2*p*r/(p+r)\\n else:\\n f = 0\\n return p, r, f\",\n \"def f1_score(self):\",\n \"def calculate_metrics(self):\\n sensitivity = TP + FN\\n sensitivity = TP / sensitivity\\n\\n specificity = TN + FP\\n specificity = TN / specificity\\n\\n accuracy = TP + FP + TN + FN\\n divisor = TP + TN\\n accuracy = divisor / accuracy\\n\\n positive_predictive = TP + FP\\n positive_predictive = TP / positive_predictive\\n\\n negative_predictive = TN + FN\\n negative_predictive = TN / negative_predictive\\n\\n # This is for format decimal in metrics\\n sensitivity = float(\\\"{0:.4f}\\\".format(sensitivity))\\n specificity = float(\\\"{0:.4f}\\\".format(specificity))\\n accuracy = float(\\\"{0:.4f}\\\".format(accuracy))\\n positive_predictive = float(\\\"{0:.4f}\\\".format(positive_predictive))\\n negative_predictive = float(\\\"{0:.4f}\\\".format(negative_predictive))\\n\\n average = (sensitivity + specificity + accuracy + positive_predictive + negative_predictive) / 5\\n\\n average = float(\\\"{0:.4f}\\\".format(average))\\n\\n metrics = [sensitivity, specificity, accuracy,positive_predictive,negative_predictive, average]\\n\\n return metrics\",\n \"def get_f1_score(y_true, y_pred):\\n cf_m = confusion_matrix(y_true, y_pred)\\n print(\\\"tn:\\\",cf_m[0,0])\\n print(\\\"fp:\\\",cf_m[0,1])\\n print(\\\"fn:\\\",cf_m[1,0])\\n print(\\\"tp:\\\",cf_m[1,1])\\n precision = cf_m[1,1] / (cf_m[1,1] + cf_m[0,1])\\n recall = cf_m[1,1] / (cf_m[1,1] + cf_m[1,0])\\n f1 = 2 * (precision * recall) / (precision + recall)\\n\\n\\n return precision, recall, f1\",\n \"def calculate_recall(num_tp, num_fp, num_fn):\\n if (num_tp + num_fn) == 0:\\n return 0\\n else:\\n return num_tp / (num_tp + num_fn)\",\n \"def _metric(self, fpr, tpr, th_):\\n def np_divide(a, b):\\n \\\"\\\"\\\"Numpy array division.\\n\\n ignore / 0, div( [-1, 0, 1], 0 ) -> [0, 0, 0]\\n \\\"\\\"\\\"\\n with np.errstate(divide='ignore', invalid='ignore'):\\n c = np.true_divide(a, b)\\n c[~np.isfinite(c)] = 0 # -inf inf NaN\\n return c\\n\\n # q = tpr/(fpr+tpr) go through max.\\n q = np_divide(tpr, fpr + tpr)\\n best_ind = np.argmax(q)\\n best_th_ = th_[best_ind]\\n return best_th_, best_ind, q\",\n \"def f1_score(model_id, test_set_id, rubric_id):\\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\\n # right answers\\n answers = db.get_rubric_answers(test_set_id, rubric_id)\\n # rubrication results\\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\\n\\n for key in rubrication_result:\\n if rubrication_result[key] == answers[key]:\\n if rubrication_result[key] == 1:\\n result['true_positive'] += 1\\n else:\\n result['true_negative'] += 1\\n else:\\n if rubrication_result[key] == 1:\\n result['false_positive'] += 1\\n else:\\n result['false_negative'] += 1\\n if (result['true_positive'] + result['false_positive']) > 0:\\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\\n else:\\n result['precision'] = 0\\n if (result['true_positive'] + result['false_negative']) > 0:\\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\\n else:\\n result['recall'] = 0\\n if (result['precision'] + result['recall']) > 0:\\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\\n else:\\n result['f1'] = 0\\n return result\",\n \"def calf_f1(annotated_Y, predicted_Y):\\n\\n POSITIVE = ADR_MENTION_CLASS_LABEL\\n NEGATIVE = NON_ADR_MENTION_CLASS_LABEL\\n\\n tp = 0\\n fp = 0\\n fn = 0\\n tn = 0\\n\\n total_actual_positives = 0\\n total_actual_negatives = 0\\n\\n for index, actual in enumerate(annotated_Y):\\n predicted = predicted_Y[index]\\n\\n if actual == POSITIVE:\\n total_actual_positives += 1\\n\\n if predicted == POSITIVE:\\n tp += 1\\n elif predicted == NEGATIVE:\\n fn += 1\\n\\n elif actual == NEGATIVE:\\n total_actual_negatives += 1\\n\\n if predicted == POSITIVE:\\n fp += 1\\n elif predicted == NEGATIVE:\\n tn += 1\\n\\n if (tp+fp) == 0:\\n precision = 0\\n else:\\n precision = tp/(tp+fp)\\n\\n if (tp+fn) == 0:\\n recall = 0\\n else:\\n recall = tp/(tp+fn)\\n\\n if (precision+recall) == 0:\\n f1 = 0\\n else:\\n f1 = 2*precision*recall/(precision+recall)\\n\\n # print(\\\"Total labels: {}, total actual positives: {}, total_actual_negatives: {}\\\".format(len(predicted_Y), total_actual_positives, total_actual_negatives))\\n # print(\\\"tp: {}, tn: {}, fp: {}, fn: {}\\\".format(tp, tn, fp, fn))\\n # print(\\\" Accuracy: {}\\\".format((tp+tn)/(len(test_Y))))\\n print(\\\" Precision: {}\\\".format(precision))\\n print(\\\" Recall: {}\\\".format(recall))\\n print(\\\" F1: {}\\\".format(f1))\",\n \"def evaluate(self, test_data):\\n test_results = [(self.decide(self.feedforward(x)), y)\\n for (x, y) in test_data]\\n\\n # Check for and keep track of TP's FP's and FN's\\n # Write FP's and FN's to a special directories\\n TP = FP = FN = count = 0\\n TN = 0\\n # what you got = x, what should be = y\\n for ((x, y), (image, gt)) in zip(test_results, test_data):\\n count += 1\\n if x == 1 and y == 1:\\n TP += 1\\n elif x == 1 and y == 0:\\n FP += 1\\n if not self.validating: self.save_Image(FP_PATH, count, image)\\n elif x == 0 and y == 1:\\n FN += 1\\n if not self.validating: self.save_Image(FN_PATH, count, image)\\n \\n if (TP + FP ) == 0:\\n return TP, FP, FN, '---------', '---------','---------'\\n else:\\n false_rate = float(FP) / float(TP + FP)\\n\\n if (TP + FN ) == 0:\\n return TP, FP, FN, '---------', '---------', false_rate\\n else:\\n detect_rate = float(TP) / float(TP + FN)\\n\\n if (TP + FP + FN ) == 0:\\n return TP, FP, FN, '---------', detect_rate, false_rate\\n else:\\n quality_rate = float(TP) / float(TP+FP+FN)\\n \\n return TP, FP, FN, quality_rate, detect_rate, false_rate\",\n \"def get_scores(self):\\n hist = self.confusion_matrix\\n # hist = [TN,FP;FN,TP]\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n # iou = iu.sum() / self.n_classes\\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n cls_iou = dict(zip(range(self.n_classes), iu))\\n\\n ##############################################\\n tn = hist[0, 0]\\n tp = np.diag(hist).sum() - tn\\n fp = np.triu(hist, 1).sum()\\n fn = np.tril(hist, -1).sum()\\n precision = tp / (tp + fp)\\n recall = tp / (tp + fn)\\n f1 = 2 * precision * recall / (precision + recall)\\n\\n # for medical img, img_seg \\\\in [0,1]\\n dice = 2 * tp / (tp + tp + fn + fp)\\n # dice = f1-score\\n dsc = 2 * tp / (tp + fn + fp)\\n # dsc = jaccard\\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\\n # voe = 1 - dsc\\n\\n k2 = {\\n # \\\"Overall Acc: \\\\t\\\": acc,\\n 'Mean Acc': float(judge_nan(acc_cls)),\\n # \\\"FreqW Acc : \\\\t\\\": fwavacc,\\n 'Mean IoU': float(judge_nan(mean_iou)),\\n 'F1-score': float(judge_nan(f1)),\\n 'DSC': float(judge_nan(dsc)),\\n 'Precision': float(judge_nan(precision)),\\n 'Recall': float(judge_nan(recall)),\\n }\\n\\n return k2\",\n \"def print_results(precision, recall, f1):\\n print \\\"Precision:\\\", precision\\n print \\\"Recall:\\\", recall\\n print \\\"F1 score:\\\", f1\",\n \"def TPR(self):\\n return _div(self.TP, self.TP + self.FN)\",\n \"def score(label_recall, label_precision, pred_recall, pred_precision):\\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\\n\\n return 0.4*f11 + 0.6*f12\",\n \"def get_evaluations(self, pred_Y, Y):\\n \\n tp, fp, tn, fn = self._get_evaluations(pred_Y, Y)\\n\\n # calculate F1\\n try:\\n precision = tp / (tp+fp)\\n except ZeroDivisionError:\\n precision = tp\\n try:\\n recall = tp / (tp+fn)\\n except ZeroDivisionError:\\n recall = tp\\n try:\\n f1 = 2.0 * ((precision*recall) / (precision+recall))\\n except ZeroDivisionError:\\n f1 = 0.0\\n # calculate accuracy\\n accuracy = (tp+tn) / (tp+fp+tn+fn)\\n\\n return accuracy, f1, precision, recall\",\n \"def calcMetrics(TP, P, T, percent=True):\\r\\n precision = TP / P if P else 0\\r\\n recall = TP / T if T else 0\\r\\n FB1 = 2 * precision * recall / (precision + recall) if precision + recall else 0\\r\\n if percent:\\r\\n return 100 * precision, 100 * recall, 100 * FB1\\r\\n else:\\r\\n return precision, recall, FB1\",\n \"def get_precision_recall_f1(gt, pred):\\n tp, tn, fp, fn = calc_pred_stats(gt, pred)\\n prec = precision(tp, fp)\\n rec = recall(tp, fn)\\n f1_score = f1(prec, rec)\\n return prec, rec, f1_score\",\n \"def get_perf(self) :\\n self.train()\\n\\n prediction = self.clf.predict(self.df_test.drop(columns = 'up')[:-1])\\n self.accuracy = accuracy_score(df_test['up'][length:].values, prediction)\\n tn, fp, fn, tp = confusion_matrix(df_test['up'][length:].values, prediction).ravel()\\n self.recall = tp/(tp+fn)\\n self.specificity = tn / (tn+fp)\\n\\n\\n self.df_true = self.df_true[self.length:]\\n\\n profit = 1\\n mini = 1\\n maxi = 1\\n self.df_true['close'] = self.df_true['close'].map(lambda x : np.exp(x))\\n for s in range(1,len(self.df_true)):\\n if prediction[x-1] == 1 :\\n result = ((self.df_true['close'].iloc[s] -self.df_true['close'].iloc[s-1]) / self.df_true['close'].iloc[s-1]) + 1\\n profit = profit * result\\n if result < mini :\\n mini = result\\n if maxi < result :\\n maxi = result\\n self.mini = mini\\n self.maxi = maxi\\n self.profit = profit\",\n \"def compute(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\\n precisions = (self.TPs + METRIC_EPS) / (self.TPs + self.FPs + METRIC_EPS)\\n recalls = self.TPs / (self.TPs + self.FNs + METRIC_EPS)\\n\\n return precisions, recalls, self.thresholds\",\n \"def get_f1_score(actual_labels, preds_labels, binary_classifcation, pos_label=\\\"malaria\\\", confusion_matrix_title=\\\"\\\"):\\n # demonstration of calculating metrics for a neural network model using sklearn\\n if not binary_classifcation:\\n # For multiclass classification.\\n accuracy = accuracy_score(actual_labels, preds_labels)\\n precision = precision_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n recall = recall_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n f1 = f1_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n print('Accuracy: %f' % accuracy)\\n print('Precision: %f' % precision)\\n print('Recall: %f' % recall)\\n print('F1 score: %f' % f1)\\n\\n else:\\n accuracy = accuracy_score(actual_labels, preds_labels)\\n print('Accuracy: %f' % accuracy)\\n # # precision tp / (tp + fp)\\n precision = precision_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('Precision: %f' % precision)\\n # recall: tp / (tp + fn)\\n recall = recall_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('Recall: %f' % recall)\\n # f1: 2 tp / (2 tp + fp + fn)\\n f1 = f1_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('F1 score: %f' % f1)\\n # ROC AUC\\n # auc = roc_auc_score(test_labels, basic_cnn_preds_labels)\\n # print('ROC AUC: %f' % auc)\\n\\n # confusion matrix\\n disp = plot_confusion_matrix(y_true=actual_labels, y_pred=preds_labels,\\n display_labels=list(np.unique(actual_labels)),\\n cmap=plt.cm.Blues,\\n normalize=None)\\n disp.ax_.set_title(confusion_matrix_title)\\n plt.show()\\n matrix = confusion_matrix(actual_labels, preds_labels)\\n print(matrix)\\n # if plot_confusion_matrix:\\n # show_confusion_matrix(matrix=matrix, labels=list(np.unique(actual_labels)))\",\n \"def score( self ):\\r\\n result = 0.0\\r\\n for rr in self.ee.getRsrcs( ):\\r\\n value = self.scoreRsrc( rr )\\r\\n result += value\\r\\n print( \\\"INFO: Value for the schedule is %s \\\" % ( rr, result ) )\\r\\n return( result )\",\n \"def evaluate(self, test_dir='data/dev', target='real'):\\n test_data = {c: os.path.join(test_dir, c) for c in self.classes}\\n if not target in test_data:\\n print('Error: target class does not exist in test data.')\\n return\\n outcomes = {'TP': 0, 'TN': 0, 'FP': 0, 'FN': 0}\\n # >>> YOUR ANSWER HERE\\n data = []\\n for c in test_data:\\n docs = open(test_data[c]).readlines()\\n for doc in docs:\\n preprocess_doc = doc.strip()\\n data.append((c, preprocess_doc))\\n for item in data:\\n predict_ans = self.predict(item[1])\\n if item[0] == 'real':\\n if predict_ans == 'real':\\n outcomes['TP'] += 1\\n else:\\n outcomes['FN'] += 1\\n else:\\n if predict_ans == 'real':\\n outcomes['FP'] += 1\\n else:\\n outcomes['TN'] += 1\\n precision = outcomes['TP'] / (outcomes['TP'] + outcomes['FP']) # replace with equation for precision\\n recall = outcomes['TP'] / (outcomes['TP'] + outcomes['FN']) # replace with equation for recall\\n f1_score = 2 * ((precision * recall) / (precision + recall)) # replace with equation for f1\\n # >>> END YOUR ANSWER\\n return precision, recall, f1_score\",\n \"def evaluate(labels, predictions):\\n TP = 0\\n actualP = 0\\n TN = 0\\n actualN = 0\\n for label, prediction in zip(labels, predictions):\\n if label ==1:\\n actualP +=1\\n if prediction == 1:\\n TP +=1\\n else:\\n actualN +=1\\n if prediction ==0:\\n TN +=1\\n \\n sensitivity = float(TP/actualP)\\n specificity = float(TN/actualN)\\n return (sensitivity, specificity)\",\n \"def get_f_score(self):\\n return self.get_g_score() + self.get_h_score()\",\n \"def __score_t(self, *args, **kwargs):\\n pass\",\n \"def f1(y_true, y_pred):\\n p = precision(y_true, y_pred)\\n r = recall(y_true, y_pred)\\n score = 2 * p * r / (p + r)\\n return score\",\n \"def f1_score(precision, recall):\\n if precision + recall == 0:\\n return 0\\n return 2 * precision * recall / (precision + recall)\",\n \"def score_method(pairs_true, pairs_test):\\n \\n set_true = {tuple(e) for e in pairs_true}\\n set_test = {tuple(e) for e in pairs_test}\\n true_pos, false_pos, false_neg = confusion_stats(set_true, set_test)\\n \\n total = true_pos + false_pos + false_neg\\n true_pos_rate = true_pos / total\\n false_pos_rate = false_pos / total\\n false_neg_rate = false_neg / total\\n \\n return true_pos_rate, false_pos_rate, false_neg_rate\",\n \"def calc_acc_metrics(preds, teY):\\n\\n prec = precision_score(teY, preds)\\n rec = recall_score(teY, preds)\\n acc = accuracy_score(teY, preds)\\n f1 = f1_score(teY, preds)\\n\\n conf_matrix = confusion_matrix(teY, preds)\\n fpr = conf_matrix[0][1] / (conf_matrix[0][1] + conf_matrix[0][0])\\n\\n return prec, rec, acc, f1, fpr\",\n \"def f1score(prediction,ytest):\\n truepos = np.sum(ytest[prediction == 1])\\n predpos = np.sum(prediction)\\n actpos = np.sum(ytest)\\n precision = truepos/predpos\\n recall = truepos/actpos\\n return 2*precision*recall/(precision + recall)\",\n \"def calculate(self):\\n\\n specificity = self.confusion_matrix.tn / (self.confusion_matrix.tn + self.confusion_matrix.fp)\\n\\n false_positive_rate = 1 - specificity\\n\\n true_positive_rate = self.confusion_matrix.tp / (self.confusion_matrix.tp + self.confusion_matrix.fn)\\n\\n return (true_positive_rate - false_positive_rate + 1) / 2\",\n \"def print_results(self, f1_score, precision_score, recall_score):\\n print(\\\"Algorithm: %s\\\" % self.name)\\n self.print_score(f1_score, \\\"F1 Score\\\")\\n self.print_score(precision_score, \\\"Precision Score\\\")\\n self.print_score(recall_score, \\\"Recall Score\\\")\",\n \"def scoring(estimator, features_test, labels_test):\\n pred = estimator.predict(features_test)\\n p = metrics.precision_score(labels_test, pred, average='micro')\\n r = metrics.recall_score(labels_test, pred, average='micro')\\n if p > 0.3 and r > 0.3:\\n return metrics.f1_score(labels_test, pred, average='macro')\\n return 0\",\n \"def fpr_at_98tpr(self):\\r\\n\\r\\n return self.fpr_at_confidence(self.confidence_at_tpr(0.98))\",\n \"def calculate_many_precs_recall_stats(test_class=test_class,\\n local_list=local_list,\\n Q_stop='',\\n no_files_in_label=no_files_in_label,\\n no_of_images=no_of_images,\\n verbose=verbose):\\n if not Q_stop == '':\\n Q = Q_stop\\n else:\\n Q = len(local_list)\\n # does all points\\n if Q > len(local_list):\\n Q = len(local_list)\\n if verbose:\\n print('The number of points to check (Q) {} is more than the number of points above minx {}'.format(Q, len(local_list)))\\n print('Setting Q to len(local_list), you may wish to change your settings')\\n N_test = no_files_in_label[test_class] # no of items in class A\\n N_not_test = no_of_images - N_test # i.e. set not-A\\n # set up counters\\n AP = 0 # average precision\\n found_recall_precs_p95 = False\\n recall_p95 = 0.0\\n count_of_test_class = 0\\n # loop backwards through the list, abs j is the position in a 1-indexed list\\n recall_x = 0 # n.b. this is also sensitivity\\n Ave_precs_x = 0\\n specificity_x = 0\\n count_of_false_positives = 0 # number of not-A on misidentified\\n max_informedness = 0\\n x_for_max_informedness = 0\\n max_f1_stat = 0\\n x_for_max_f1 = 0\\n recall_for_max_informedness = 0\\n specificity_for_max_informedness = 0\\n for i in range(Q):\\n j = -(i + 1) # 1 indexed\\n recall_x_minus_1 = recall_x\\n current_class = local_list[j][0]\\n #j = j - 1 # really this is here so we can check j\\n # break\\n if count_of_test_class == N_test:\\n # we've found them all\\n if verbose:\\n print('found all {} of {}, stopping...'.format(N_test, current_class))\\n print('{}/{}'.format(count_of_test_class, abs(j)))\\n break\\n if (current_class == test_class):\\n count_of_test_class = count_of_test_class + 1 # n A\\n else:\\n count_of_false_positives = count_of_false_positives + 1\\n precs_x = count_of_test_class / (abs(j)) # N.b. this is the sum, we divide by j on the output\\n recall_x = count_of_test_class / N_test\\n false_pos_rate = count_of_false_positives / no_of_images\\n specificity_x = 1-false_pos_rate\\n if (precs_x <= .95) and (found_recall_precs_p95 is False):\\n # thingy to grab the recall when precision drops below .95 (if ever)\\n recall_p95 = recall_x\\n found_recall_precs_p95 = True\\n delta_recall_x = recall_x - recall_x_minus_1 # difference in recall between this point nd the next\\n weight_precs_x = precs_x * delta_recall_x # weighted precsion at point x (we do average via weighted sum)\\n Ave_precs_x = Ave_precs_x + weight_precs_x # average_precision evaluated at point x\\n informedness_x = recall_x + specificity_x -1\\n if informedness_x > max_informedness:\\n max_informedness = informedness_x\\n x_for_max_informedness = abs(j)\\n recall_for_max_informedness = recall_x\\n specificity_for_max_informedness = specificity_x\\n if (precs_x > 0 and recall_x > 0):\\n f1_x = 2*(precs_x*recall_x) / (precs_x + recall_x)\\n else:\\n f1_x = 0\\n if f1_x > max_f1_stat:\\n max_f1_stat = f1_x\\n x_for_max_f1 = abs(j)\\n if verbose:\\n print('Class {}, evaluated at Q={}:, found {}'.format(test_class, Q, count_of_test_class))\\n print('Average precision={}; precision={}; recall={}'.format(Ave_precs_x,precs_x,recall_x))\\n print('Recall at precision .95 threashold is {}'.format(recall_p95))\\n print('specificity = {}'.format(specificity_x))\\n print('informedness = {}'.format(informedness_x))\\n print('Max informedness was {}, seen at x {}'.format(max_informedness, x_for_max_informedness))\\n print('F1 at x={} is {}'.format(abs(j),f1_x))\\n print('Max F1 was {}, seen at x = {}'.format(max_f1_stat,x_for_max_f1))\\n out = (Ave_precs_x, precs_x, recall_x, recall_p95,\\n specificity_x, informedness_x, max_informedness, x_for_max_informedness,\\n max_f1_stat, x_for_max_f1,\\n recall_for_max_informedness, specificity_for_max_informedness,)\\n return out\",\n \"def calculate_risk_tol(*args):\\n global total_score\\n risk_tol_start = 0.0\\n\\n for risk_per_pg in risk_tol_per_qs.iterkeys():\\n try:\\n risk_tol_start = risk_tol_start + risk_tol_per_qs[risk_per_pg][-1] # this is the last item in the list of each information in the page\\n except IndexError:\\n pass\\n total_score = risk_tol_start\",\n \"def _compute_scores(y_pred, y_true):\\n auc = accuracy_score(y_true = y_true, y_pred = y_pred)\\n pre = precision_score(y_true, y_pred, average = \\\"macro\\\")\\n rec = recall_score(y_true, y_pred, average = \\\"macro\\\")\\n f1 = f1_score(y_true, y_pred, average = \\\"macro\\\")\\n\\n return pd.Series(data = [auc, pre, rec, f1], index = ['acc', 'pre', 'rec', 'f1'])\",\n \"def cal_precision(preds, gts, tp_threshold=0.9, fp_threshold=0.1):\\r\\n TPs, tplabels = cal_TP(preds, gts)\\r\\n FPs, fplabels = cal_FP(preds, gts)\\r\\n \\r\\n correct_pred = set()\\r\\n correspond_pred = []\\r\\n # correspond_gt = []\\r\\n for i, (tp, label) in enumerate(zip(TPs, tplabels)):\\r\\n if ( fplabels[int(label)-1] == i+1\\r\\n and tp >= tp_threshold \\r\\n and label > 0 \\r\\n and FPs[int(label)-1] <= fp_threshold ):\\r\\n correct_pred.add(i+1)\\r\\n correspond_pred.append(label)\\r\\n else:\\r\\n correspond_pred.append(0.)\\r\\n # for _, (fp, label) in enumerate(zip(FPs, fplabels)):\\r\\n # if fp <= fp_threshold and label > 0 and TPs[int(label)-1] >= tp_threshold:\\r\\n # correct_pred.add(label)\\r\\n # correspond_gt.append(label)\\r\\n # else:\\r\\n # correspond_gt.append(0.)\\r\\n result = [[i, correspond_pred[i-1]] for i in correct_pred]\\r\\n\\r\\n return len(correct_pred) / len(TPs), result #list(correct_pred), list(correspond_pred)#, list(correspond_gt)\\r\",\n \"def get_f1score(conf_matrix1, conf_matrix2, conf_matrix3):\\r\\n p = get_precision(conf_matrix1, conf_matrix2, conf_matrix3)\\r\\n r = get_recall(conf_matrix1, conf_matrix2, conf_matrix3)\\r\\n\\r\\n if p + r > 0:\\r\\n return 2 * p * r / (p + r)\\r\\n else:\\r\\n return 0\",\n \"def evaluate_ranks(articles, rank_tuples):\\n rank_tp=defaultdict(int)\\n rank_fn=defaultdict(int)\\n rank_fp=defaultdict(int)\\n \\n for article in articles:\\n for mention in article.entity_mentions:\\n form=mention.mention\\n meaning=mention.gold_link\\n sys_meaning=mention.sys_link\\n t_gold=(form, meaning)\\n t_sys=(form, sys_meaning)\\n for rank, r_tuples in rank_tuples.items():\\n if t_gold in r_tuples and t_sys in r_tuples:\\n rank_tp[rank]+=1\\n break\\n elif t_gold in r_tuples:\\n rank_fn[rank]+=1\\n elif t_sys in r_tuples:\\n rank_fp[rank]+=1\\n print('tp', rank_tp)\\n print('fp', rank_fp)\\n print('fn', rank_fn)\\n \\n rank_prec={}\\n rank_recall={}\\n rank_f1={}\\n \\n for rank in range(1,13):\\n if rank_tp[rank]+rank_fp[rank]>0:\\n rank_prec[rank]=rank_tp[rank]/(rank_tp[rank]+rank_fp[rank])\\n else:\\n rank_prec[rank]=0.0\\n if rank_tp[rank]+rank_fn[rank]>0:\\n rank_recall[rank]=rank_tp[rank]/(rank_tp[rank]+rank_fn[rank])\\n else:\\n rank_recall[rank]=0.0\\n if rank_prec[rank]+rank_recall[rank]>0:\\n rank_f1[rank]=2*rank_prec[rank]*rank_recall[rank]/(rank_prec[rank]+rank_recall[rank])\\n else:\\n rank_f1[rank]=0.0\\n print('precision', rank_prec)\\n print()\\n print('recall', rank_recall)\\n print()\\n print('f1', rank_f1)\\n print()\\n return rank_prec, rank_recall, rank_f1\",\n \"def _get_fpr(self, arg):\",\n \"def fpr_at_99tpr(self):\\r\\n\\r\\n return self.fpr_at_confidence(self.confidence_at_tpr(0.99))\",\n \"def evaluate(true_labels, predicted_labels):\\n accuracy = np.round(metrics.accuracy_score(true_labels, predicted_labels), \\n 2)\\n precision = np.round(metrics.precision_score(true_labels, predicted_labels, \\n average='weighted'), 2)\\n recall = np.round(metrics.recall_score(true_labels, predicted_labels,\\n average='weighted'), 2)\\n f1 = np.round(metrics.f1_score(true_labels, predicted_labels, \\n average='weighted'), 2)\\n \\n return accuracy, precision, recall, f1\",\n \"def _compute_scores(self, triples):\\n # compute scores as sum(s * p * o)\\n scores = tf.reduce_sum(triples[0] * triples[1] * triples[2], 1)\\n return scores\",\n \"def calc_TP_FP(groundtruth, eval_boxes, matches_predicate, confidence_threshold=-9e999):\\n TP = 0\\n FP = 0\\n FN = 0\\n for image_key in groundtruth.keys() + eval_boxes.keys():\\n gt_bboxes = set(groundtruth.get(image_key, []))\\n other_bboxes = set(box\\n for box in eval_boxes.get(image_key, [])\\n if box.confidence >= confidence_threshold\\n or box.confidence is None\\n )\\n for gt_bbox in gt_bboxes:\\n # Do any of their boxes match?\\n match = None\\n for other_box in other_bboxes:\\n if matches_predicate(gt_bbox, other_box):\\n match = other_box\\n if match:\\n other_bboxes.remove(match)\\n TP += 1\\n else:\\n FN += 1\\n FP += len(other_bboxes)\\n # if len(other_bboxes):\\n # print \\\"False positive on\\\", image_key\\n return {\\\"TP\\\": TP, \\\"FP\\\": FP, \\\"FN\\\": FN, \\\"TN\\\": 0}\",\n \"def KendallTau_calc(TP, FP, FN, TN):\\n try:\\n n = TP + FP + FN + TN\\n return (2 * (TP + TN - FP - FN)) / (n * (n - 1))\\n except Exception:\\n return \\\"None\\\"\",\n \"def calc_pr_rc_F1(GTD, block_occ):\\r\\n true_pos = ((GTD + block_occ)==2).sum()\\r\\n false_pos = sum([1 if BI_val==1 and GTD[i]==0 else 0 for i, BI_val in enumerate(block_occ.values)])\\r\\n precision = float(true_pos/(true_pos+false_pos))\\r\\n recall = float(true_pos/(GTD.sum()))\\r\\n if precision == 0:\\r\\n F1 = 0\\r\\n else:\\r\\n F1 = float(2 * (precision * recall) / (precision + recall))\\r\\n \\r\\n return precision, recall, F1\",\n \"def evaluate(pred_file, ref_file):\\n ref_dict, pred_dict, query_dict, id_dict = build_pred_ref_dict(ref_file, pred_file, ref_file)\\n total, acc, scores = res_eval_with_type_acc(query_dict, pred_dict, ref_dict, id_dict, save=False)\\n em = calculate_exact_match(pred_dict, ref_dict)\\n print('Comp Acc: {:.3f}%\\\\tBleu-4: {:.3f}\\\\tRouge-L: {:.3f}'.format(acc, scores['Bleu-4'], scores['Rouge-L']))\\n print('EM: {:.3f}%'.format(em))\\n # calculate_sketch_type_acc(ref_file, pred_file)\\n # calculate_exact_match_for_each_q_type(ref_file, pred_file)\\n return total, acc, scores, em\",\n \"def completing_evalution(self, *args):\\n self.calculate_risk_tol(*args)\\n graham_picks = key_ratios(\\\"GrahamScore\\\", total_score)\\n lynch_picks = key_ratios(\\\"LynchScore\\\", total_score)\\n return (graham_picks, lynch_picks)\",\n \"def KentFosterII_calc(TP, FP, FN, TN):\\n try:\\n part1 = ((TN + FP) * (TN + FN)) / (TN + FP + FN)\\n return (TN - part1) / (TN - part1 + FP + FN)\\n except Exception:\\n return \\\"None\\\"\",\n \"def stats(detections, faces):\\n vp, fp, fn, vn = 0, 0, 0, 0\\n max_label = np.max(faces[:, 0])\\n for i in range(max_label + 1):\\n detections_i = get_label_with_index(detections, i)\\n faces_i = get_label_with_index(faces, i)\\n local_vp = 0\\n for face in faces_i:\\n found = False\\n for detection in detections_i:\\n if intersection_ratio(face, detection) >= 0.5:\\n found = True\\n break\\n if found:\\n vp += 1\\n local_vp += 1\\n else:\\n fn += 1\\n fp += len(detections_i) - local_vp\\n\\n precision = vp / (vp + fp)\\n rappel = vp / (vp + fn)\\n f_score = 2 * ((precision * rappel) / (precision + rappel))\\n\\n return precision, rappel, f_score\",\n \"def scoring(self):\\n pass\",\n \"def compute_scores(self):\\n if self.num_classes == 2:\\n score_1 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold=0.5,\\n )[1]\\n\\n score_2 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold_ratio=0.5,\\n )[1]\\n\\n score_3 = self.competition_metric(\\n impact_threshold=0.5,\\n )[1]\\n else:\\n score_1 = self.detection_metric(threshold=0.1)\\n score_2 = self.detection_metric(threshold=0.25)\\n score_3 = self.detection_metric(threshold=0.5)\\n\\n return score_1, score_2, score_3\",\n \"def f1_score_model(self, model, X, y):\\n\\n prediction = model.predict_classes(X)\\n f1_macro = f1_score(y, prediction, average='macro')\\n f1_micro = f1_score(y, prediction, average='macro')\\n print(\\\"f1_macro: \\\", f1_score(y, prediction, average='macro'))\\n print(\\\"f1_micro: \\\", f1_score(y, prediction, average=\\\"micro\\\"))\\n print(\\\"f1_weighted: \\\", f1_score(y, prediction, average=\\\"weighted\\\"))\\n return f1_macro, f1_micro\",\n \"def KentFosterI_calc(TP, FP, FN, TN):\\n try:\\n part1 = ((TP + FP) * (TP + FN)) / (TP + FP + FN)\\n return (TP - part1) / (TP - part1 + FP + FN)\\n except Exception:\\n return \\\"None\\\"\",\n \"def score(self, params):\\n\\n if self.use_sqrt:\\n return self.score_sqrt(params)\\n else:\\n return self.score_full(params)\",\n \"def score(self, x, y, verbose=False):\\n y_pred = self.forward(x).T\\n\\n y_p = np.argmax(y_pred, axis=-1)\\n y_t = np.argmax(y, axis=-1)\\n fpr, tpr, thresholds = roc_curve(y_t, y_p, pos_label=2)\\n\\n metricas = {\\n 'accuracy': accuracy_score(y_t, y_p),\\n 'f1':f1_score(y_t, y_p, average='macro'),\\n 'balanced accuracy': balanced_accuracy_score(y_t, y_p),\\n 'auc': auc(fpr, tpr)\\n }\\n\\n if verbose:\\n print('Accuracy', metricas['accuracy'])\\n print('F1-Macro', metricas['f1'])\\n print('Balanced accuracy', metricas['balanced accuracy'])\\n print('AUC', metricas['auc'])\\n\\n return metricas\",\n \"def HarrisLahey_calc(TP, FP, FN, TN):\\n try:\\n n = TP + FP + FN + TN\\n part1 = TP / (TP + FP + FN)\\n part2 = (2 * TN + FP + FN) / (2 * n)\\n part3 = TN / (TN + FP + FN)\\n part4 = (2 * TP + FP + FN) / (2 * n)\\n return part1 * part2 + part3 * part4\\n except Exception:\\n return \\\"None\\\"\",\n \"def overall_performance_prf(articles, skip_nils=True, skip_nonnils=False):\\n tp=0\\n fn=0\\n fp=0\\n for article in articles:\\n for entity in article.entity_mentions:\\n if skip_nils and entity.gold_link=='--NME--':\\n continue\\n if skip_nonnils and entity.gold_link!='--NME--':\\n continue\\n if entity.gold_link==entity.sys_link:\\n tp+=1\\n else:\\n if entity.sys_link!='--NME--':\\n fp+=1\\n if entity.gold_link!='--NME--':\\n fn+=1\\n print(tp, fp, fn)\\n p=tp/(tp+fp) \\n r=tp/(tp+fn) \\n f1=2*p*r/(p+r)\\n print(p,r,f1)\\n return f1\",\n \"def tpr(positive, negative, fpr):\\n threshold = np.percentile(np.asarray(negative), 100 - fpr)\\n total_true_positives = sum(positive > threshold)\\n\\n return total_true_positives / len(positive)\",\n \"def analyze_confusion(confusion, true_labels):\\n print(\\\"Confusion matrix:\\\")\\n printer(\\\"Pre\\\\Tru\\\", true_labels)\\n\\n for line, label in zip(confusion, true_labels):\\n printer(f\\\"{label}\\\", line)\\n\\n TP = confusion.diagonal()\\n FN = np.sum(confusion, axis=0) - TP\\n FP = np.sum(confusion, axis=1) - TP\\n\\n print()\\n printer(\\\"TP\\\", TP)\\n printer(\\\"FP\\\", FP)\\n printer(\\\"FN\\\", FN)\\n\\n # https://stackoverflow.com/a/37977222\\n # P = TP / ( TP + FP)\\n # R = TP / ( TP + FN)\\n dP = TP + FP\\n P = np.divide(TP, dP, out=np.zeros_like(TP, dtype=float), where=dP != 0)\\n dR = TP + FN\\n R = np.divide(TP, dR, out=np.zeros_like(TP, dtype=float), where=dR != 0)\\n\\n print(\\\"\\\\nPrecision = TP / ( TP + FP)\\\\tRecall = TP / ( TP + FN)\\\")\\n printer(\\\"Prec\\\", P, \\\":.4f\\\")\\n printer(\\\"Recall\\\", R, \\\":.4f\\\")\\n\\n avgP = np.sum(P) / len(true_labels)\\n avgR = np.sum(R) / len(true_labels)\\n print(f\\\"Average P: {avgP:.4f}\\\\tR: {avgR:.4f}\\\")\\n\\n print(\\\"F-score = 2 (PxR) / (P+R)\\\")\\n # F = 2 (PxR) / (P+R)\\n PdR = 2 * P * R\\n PpR = P + R\\n F = np.divide(PdR, PpR, out=np.zeros_like(TP, dtype=float), where=PpR != 0)\\n printer(\\\"F-score\\\", F, \\\":.4f\\\")\\n\\n avgF = np.sum(F) / len(true_labels)\\n print(f\\\"Average F-score {avgF}\\\")\\n\\n return avgF\",\n \"def find_TPR_threshold(y, scores, desired_TPR):\\n for threshold in np.arange(1,0,-0.01):\\n y_hat = (scores>=threshold).astype(int)\\n confusion = confusion_matrix(y, y_hat)\\n TN, FP, FN, TP = confusion.flat\\n TPR = TP / (TP + FN)\\n FPR = FP / (FP + TN)\\n if TPR >= desired_TPR:\\n return threshold, FPR\",\n \"def f1_score(self, y_true=None, y_pred=None, labels=None, average=\\\"macro\\\", decimal=None, **kwargs):\\n y_true, y_pred, binary, representor, decimal = self.get_processed_data(y_true, y_pred, decimal)\\n matrix, imap, imap_count = cu.calculate_confusion_matrix(y_true, y_pred, labels, normalize=None)\\n metrics = cu.calculate_single_label_metric(matrix, imap, imap_count)\\n\\n list_f1 = np.array([item[\\\"f1\\\"] for item in metrics.values()])\\n list_weights = np.array([item[\\\"n_true\\\"] for item in metrics.values()])\\n\\n if average == \\\"micro\\\":\\n tp_global = np.sum(np.diag(matrix))\\n fp_global = fn_global = np.sum(matrix) - tp_global\\n precision = tp_global / (tp_global + fp_global)\\n recall = tp_global / (tp_global + fn_global)\\n f1 = (2 * precision * recall) / (precision + recall)\\n elif average == \\\"macro\\\":\\n f1 = np.mean(list_f1)\\n elif average == \\\"weighted\\\":\\n f1 = np.dot(list_weights, list_f1) / np.sum(list_weights)\\n else:\\n f1 = dict([(label, np.round(item[\\\"f1\\\"], decimal)) for label, item in metrics.items()])\\n return f1 if type(f1) == dict else np.round(f1, decimal)\",\n \"def get_recall(TP, FN):\\n recall = TP / (TP + FN)\\n return recall\",\n \"def calculate_f1_score(predictions, actuals):\\n predictions = predictions > 0.5\\n # fbeta_score throws a confusing error if inputs are not numpy arrays\\n predictions, actuals, = np.array(predictions), np.array(actuals)\\n # We need to use average='samples' here, any other average method will generate bogus results\\n return fbeta_score(actuals, predictions, beta=1, average='samples')\",\n \"def _f1_score_(prediction, ground_truth):\\n prediction_tokens = _normalize_answer(prediction).split()\\n ground_truth_tokens = _normalize_answer(ground_truth).split()\\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(prediction_tokens)\\n recall = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def _get_scores(target, predicted):\\n recall = scoring(target, predicted, metric=\\\"recall\\\")\\n precision = scoring(target, predicted, metric=\\\"precision\\\")\\n accuracy = scoring(target, predicted, metric=\\\"accuracy\\\")\\n f_score = scoring(target, predicted, metric=\\\"f1\\\")\\n\\n return [recall, precision, accuracy, f_score]\",\n \"def compute(self) -> Tuple[float, float, float]:\\n # @TODO: ddp hotfix, could be done better\\n if self._is_ddp:\\n for key in self.statistics:\\n value: List[float] = all_gather(self.statistics[key])\\n value: float = sum(value)\\n self.statistics[key] = value\\n\\n precision_value, recall_value, f1_value = get_binary_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n zero_division=self.zero_division,\\n )\\n return precision_value, recall_value, f1_value\",\n \"def BatageljBren_calc(TP, FP, FN, TN):\\n try:\\n return (FP * FN) / (TP * TN)\\n except Exception:\\n return \\\"None\\\"\",\n \"def f1_score(confusion):\\n p = precision(confusion)\\n r = sensitivity(confusion)\\n F1 = (2 * p * r) / (p + r)\\n return F1\",\n \"def get_score(snack_data, percentage_data, snack, snack_query, protein_query, carb_query, fat_query):\\n\\tstart_time = time.time()\\n\\n\\t#Load necessary data\\n\\t\\\"\\\"\\\"\\twith open ('../../../Data/percentagesDict.pickle', 'rb') as f:\\n\\t\\tpercentage_data = pickle.load(f)\\n\\n\\twith open ('../../../Data/FINAL_snacks_data.pickle', 'rb') as f:\\n\\t\\tsnack_data = pickle.load(f)\\\"\\\"\\\"\\n\\n\\t#Set constants\\n\\tLOW_FAT = .3\\n\\tHIGH_FAT = .6\\n\\tLOW_CARB = .1\\n\\tHIGH_CARB = .2\\n\\tLOW_PRO = .2\\n\\tHIGH_PRO = .4\\n\\n\\t#Convert macro percentages to 'high', 'med', 'low' categories\\n\\tfat = percentage_data[snack]['fat']\\n\\tprotein = percentage_data[snack]['protein']\\n\\tcarb = percentage_data[snack]['carb']\\n\\n\\tif fat > HIGH_FAT:\\n\\t\\tfat_content = 'high'\\n\\telif fat < LOW_FAT:\\n\\t\\tfat_content = 'low'\\n\\telse:\\n\\t\\tfat_content = 'med'\\n\\n\\tif protein > HIGH_PRO:\\n\\t\\tprotein_content = 'high'\\n\\telif protein < LOW_PRO:\\n\\t\\tprotein_content = 'low'\\n\\telse:\\n\\t\\tprotein_content = 'med'\\n\\n\\tif carb > HIGH_CARB:\\n\\t\\tcarb_content = 'high'\\n\\telif carb < LOW_CARB:\\n\\t\\tcarb_content = 'low'\\n\\telse:\\n\\t\\tcarb_content = 'med'\\n\\n\\t#Set x values\\n\\tx1 = fat_query == fat_content\\n\\tx2 = carb_query == carb_content\\n\\tx3 = protein_query == protein_content\\n\\tx4 = cooccur(snack_data, snack, snack_query) \\n\\tx5 = snack_data[snack]['rating']\\n\\n\\tw1 = 1\\n\\tw2 = 1\\n\\tw3 = 1\\n\\tw4 = 1\\n\\tw5 = 1\\n\\t\\n\\t#print('x1: {}, x2: {}, x3: {}, x4: {}, x5: {}'.format(x1, x2, x3, x4, x5))\\n\\t#print(\\\"get_score() time: --- %s seconds ---\\\" % (time.time() - start_time))\\n\\n\\n\\treturn w1*x1 + w2*x2 + w3*x3 + w4*x4 + w5*x5\",\n \"def get_f1(self,common_len,RTSummary,SystemSummary):\\n recall = self.get_recall(common_len,RTSummary)\\n precision = self.get_precision(common_len,SystemSummary)\\n if precision<=0 or recall <=0:\\n return 0.0\\n else:\\n return ((2 * recall * precision)/(recall + precision))\",\n \"def compute_prf_on_selection(arts, forms_set):\\n tp=0\\n fn=0\\n fp=0\\n for article in arts:\\n for entity in article.entity_mentions:\\n if entity.mention in forms_set:\\n if entity.gold_link==entity.sys_link:\\n tp+=1\\n else:\\n if entity.sys_link!='--NME--':\\n fp+=1\\n if entity.gold_link!='--NME--':\\n fn+=1\\n print(tp, fp, fn)\\n p=tp/(tp+fp)\\n r=tp/(tp+fn)\\n f1=2*p*r/(p+r)\\n print(p,r,f1)\\n return f1\",\n \"def fpr_at_95tpr(self):\\r\\n\\r\\n return self.fpr_at_confidence(self.confidence_at_tpr(0.95))\",\n \"def raw_score(self,X,Y):\\n return self.rf.score(X,Y)\",\n \"def prf_cal(y_pred,y_true,k):\\r\\n GT=np.sum(y_true[y_true==1.])\\r\\n instance_num=y_true.shape[0]\\r\\n prediction_num=instance_num*k\\r\\n\\r\\n sort_indices = np.argsort(y_pred)\\r\\n sort_indices=sort_indices[:,::-1]\\r\\n static_indices = np.indices(sort_indices.shape)\\r\\n sorted_annotation= y_true[static_indices[0],sort_indices]\\r\\n top_k_annotation=sorted_annotation[:,0:k]\\r\\n TP=np.sum(top_k_annotation[top_k_annotation==1.])\\r\\n recall=TP/GT\\r\\n precision=TP/prediction_num\\r\\n f1=2.*recall*precision/(recall+precision)\\r\\n return precision, recall, f1\",\n \"def _prec_recall_f1_score(pred_items, gold_items):\\n common = Counter(gold_items) & Counter(pred_items)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0, 0, 0\\n precision = 1.0 * num_same / len(pred_items)\\n recall = 1.0 * num_same / len(gold_items)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return precision, recall, f1\",\n \"def evaluate(train, train_labels, test, test_labels):\\n \\n # Use the same model for each training set for now\\n model = RandomForestClassifier(n_estimators = 100, \\n random_state = 50, n_jobs = -1)\\n \\n train = train.replace({np.inf: np.nan, -np.inf: np.nan})\\n test = test.replace({np.inf: np.nan, -np.inf:np.nan})\\n \\n feature_names = list(train.columns)\\n \\n # Impute the missing values\\n imputer = Imputer(strategy = 'median', axis = 1)\\n train = imputer.fit_transform(train)\\n test = imputer.transform(test)\\n \\n cv_score = 1 * cross_val_score(model, train, train_labels, \\n scoring = \\\"f1\\\", \\n cv = 5)\\n \\n # Fit on the training data and make predictions\\n model.fit(train, train_labels)\\n preds = model.predict(test)\\n \\n # Calculate the performance\\n f1 = f1_score(test_labels, preds)\\n print('5-fold CV F1: {:.2f} with std: {:.2f}'.format(cv_score.mean(),cv_score.std()))\\n print('Test F1: {:.2f}.'.format(f1))\\n \\n feature_importances = pd.DataFrame({'feature': feature_names, \\n 'importance': model.feature_importances_})\\n \\n return preds, feature_importances\",\n \"def calculate(self):\\n\\n s_sum = 0\\n class_num = len(self.scores)\\n \\n for i in range(class_num):\\n s_sum += self.scores[i]\\n\\n av = float(s_sum)/class_num\\n if av >= 90:\\n return 'O'\\n elif av >= 80:\\n return 'E'\\n elif av >= 70:\\n return 'A'\\n elif av >= 55:\\n return 'P'\\n elif av >= 40:\\n return 'D'\\n else:\\n return 'T'\",\n \"def set_score(self):\\n if self.PotTax_intervention is None:\\n if self.PotTax_reference is not None:\\n self.score = (((self.PotTax_reference.sum().TFI - 29.33) /\\n 1.4349) / 100)\\n else:\\n print(\\\"There is no Biosafe output to score\\\")\\n return\\n else:\\n self.score = (((self.PotTax_intervention.sum().TFI - 29.33) /\\n 1.4349) / 100)\\n return\",\n \"def fpr(positive, negative, tpr):\\n threshold = np.percentile(np.asarray(positive), 100-tpr) # uses numpy percentile (ex 70th tpr is the 30th percentile)\\n total_false_positives = sum(negative > threshold)\\n\\n return total_false_positives/len(negative)\",\n \"def calc_metrics(metric_scores_list):\\n\\n N_split, N_miss, N_add, Q_P, Q_R, Q_F, N_gt, N_pred = [], [], [], [], [], [], [], []\\n Q_rand, Q_jaccard, Q_aggregated_jaccard, Q_ctc, Q_piou = [], [], [], [], []\\n tp, fp, fn = [], [], []\\n\\n for score in metric_scores_list:\\n N_split.append(score['N_split']), N_miss.append(score['N_miss']), N_add.append(score['N_add'])\\n Q_P.append(score['Q_P']), Q_R.append(score['Q_R']), Q_F.append(score['Q_F'])\\n Q_rand.append(score['Q_rand']), Q_jaccard.append(score['Q_jaccard'])\\n Q_aggregated_jaccard.append(score['Q_aggregated_jaccard'])\\n if \\\"Q_ctc\\\" in score:\\n Q_ctc.append(score['Q_ctc']), \\n Q_piou.append(score['Q_piou'])\\n N_gt.append(score['N_gt']), N_pred.append(score['N_pred'])\\n tp.append(score['tp']), fp.append(score['fp']), fn.append(score['fn'])\\n\\n N_split, N_miss, N_add = np.array(N_split), np.array(N_miss), np.array(N_add)\\n N_gt, N_pred = np.array(N_gt), np.array(N_pred)\\n tp, fp, fn = np.array(tp), np.array(fp), np.array(fn)\\n Q_P_macro, Q_R_macro, Q_F_macro = np.mean(np.array(Q_P)), np.mean(np.array(Q_R)), np.mean(np.array(Q_F))\\n Q_P_micro = np.sum(tp) / (np.sum(tp) + np.sum(fp)) if (np.sum(tp) + np.sum(fp)) > 0 else 0\\n Q_R_micro = np.sum(tp) / (np.sum(tp) + np.sum(fn)) if (np.sum(tp) + np.sum(fn)) > 0 else 0\\n Q_rand_macro, Q_jaccard_macro = np.mean(np.array(Q_rand)), np.mean(np.array(Q_jaccard))\\n Q_aggregated_jaccard_macro = np.mean(np.array(Q_aggregated_jaccard))\\n Q_ctc_macro, Q_piou_macro = np.mean(np.array(Q_ctc)), np.mean(np.array(Q_piou))\\n\\n metrics = {\\n 'Q_split_micro': float(np.sum(N_split) / np.sum(N_gt)),\\n 'Q_split_macro': float(np.mean(N_split / N_gt)),\\n 'Q_miss_micro': float(np.sum(N_miss) / np.sum(N_gt)),\\n 'Q_miss_macro': float(np.mean(N_miss / N_gt)),\\n 'Q_add_micro': float(np.sum(N_add) / np.sum(N_gt)),\\n 'Q_add_macro': float(np.mean(N_add / N_gt)),\\n 'N_gt': int(np.sum(N_gt)),\\n 'N_pred': int(np.sum(N_pred)),\\n 'Q_rand_macro': float(Q_rand_macro),\\n 'Q_jaccard_macro': float(Q_jaccard_macro),\\n 'Q_aggregated_jaccard_macro': float(Q_aggregated_jaccard_macro),\\n 'Q_ctc_macro': float(Q_ctc_macro),\\n 'Q_piou_macro': float(Q_piou_macro),\\n 'Q_P_micro': float(Q_P_micro),\\n 'Q_P_macro': float(Q_P_macro),\\n 'Q_R_micro': float(Q_R_micro),\\n 'Q_R_macro': float(Q_R_macro),\\n 'Q_F_macro': float(Q_F_macro),\\n 'Q_F_micro': float(2 * Q_P_micro * Q_R_micro / (Q_P_micro + Q_R_micro)) if (Q_P_micro + Q_R_micro) > 0 else 0\\n }\\n return metrics\",\n \"def muc_scores(self):\\n A_card, B_card = self.shape\\n V_card = len(self)\\n N = self.grand_total\\n\\n recall = _div(N - V_card, N - A_card)\\n precision = _div(N - V_card, N - B_card)\\n fscore = hmean(recall, precision)\\n return precision, recall, fscore\",\n \"def f1_score(y_true, y_pred):\\n num = 2 * precision_score(y_true, y_pred) * recall_score(y_true, y_pred)\\n deno = (precision_score(y_true, y_pred) + recall_score(y_true, y_pred))\\n return num / deno\",\n \"def ForbesI_calc(TP, FP, FN, TN):\\n try:\\n n = TP + FP + FN + TN\\n part1 = (TP + FP) * (TP + FN)\\n return (n * TP) / part1\\n except Exception:\\n return \\\"None\\\"\",\n \"def f1_score(guess, answer):\\n if guess is None or answer is None:\\n return 0\\n score = prec_recall_f1_score(normalize_answer(guess).split(), normalize_answer(answer).split())\\n\\n return score\",\n \"def _get_evaluations(self, pred_Y, Y):\\n\\n tp = fp = tn = fn = 0\\n for i in range(len(pred_Y)):\\n if pred_Y[i] == 1 and Y[i] == 1:\\n tp += 1\\n elif pred_Y[i] == 0 and Y[i] == 0:\\n tn += 1\\n elif pred_Y[i] == 1 and Y[i] == 0:\\n fp += 1\\n else:\\n fn += 1\\n tp = float(tp)\\n fp = float(fp)\\n tn = float(tn)\\n fn = float(fn)\\n return tp, fp, tn, fn\",\n \"def precision_recall_fscore(true, predicted, beta=1, labels=None, pos_label=None, average=None):\\n\\n # Build contingency table as ldict\\n ldict = {}\\n for l in labels:\\n ldict[l] = {\\\"tp\\\": 0., \\\"fp\\\": 0., \\\"fn\\\": 0., \\\"support\\\": 0.}\\n\\n for t, p in zip(true, predicted):\\n if t == p:\\n ldict[t][\\\"tp\\\"] += 1\\n else:\\n ldict[t][\\\"fn\\\"] += 1\\n ldict[p][\\\"fp\\\"] += 1\\n ldict[t][\\\"support\\\"] += 1\\n\\n # Calculate precision, recall and F-beta score per class\\n beta2 = beta ** 2\\n for l, d in ldict.items():\\n try:\\n ldict[l][\\\"precision\\\"] = d[\\\"tp\\\"]/(d[\\\"tp\\\"] + d[\\\"fp\\\"])\\n except ZeroDivisionError: ldict[l][\\\"precision\\\"] = 0.0\\n try: ldict[l][\\\"recall\\\"] = d[\\\"tp\\\"]/(d[\\\"tp\\\"] + d[\\\"fn\\\"])\\n except ZeroDivisionError: ldict[l][\\\"recall\\\"] = 0.0\\n try: ldict[l][\\\"fscore\\\"] = (1 + beta2) * (ldict[l][\\\"precision\\\"] * ldict[l][\\\"recall\\\"]) / (beta2 * ldict[l][\\\"precision\\\"] + ldict[l][\\\"recall\\\"])\\n except ZeroDivisionError: ldict[l][\\\"fscore\\\"] = 0.0\\n\\n # If there is only 1 label of interest, return the scores. No averaging needs to be done.\\n if pos_label:\\n d = ldict[pos_label]\\n return (d[\\\"precision\\\"], d[\\\"recall\\\"], d[\\\"fscore\\\"])\\n # If there are multiple labels of interest, macro-average scores.\\n else:\\n for label in ldict.keys():\\n avg_precision = sum(l[\\\"precision\\\"] for l in ldict.values()) / len(ldict)\\n avg_recall = sum(l[\\\"recall\\\"] for l in ldict.values()) / len(ldict)\\n avg_fscore = sum(l[\\\"fscore\\\"] for l in ldict.values()) / len(ldict)\\n return (avg_precision, avg_recall, avg_fscore)\",\n \"def comp_recall_precision_f1(nr_correct, nr_predicted, nr_total):\\n recall = comp_recall(nr_correct, nr_total)\\n precision = comp_precision(nr_correct, nr_predicted)\\n f1 = comp_f1(precision, recall)\\n return recall, precision, f1\",\n \"def calculate_precision(num_tp, num_fp, num_fn):\\n if (num_tp + num_fp) == 0:\\n return 1\\n else:\\n return num_tp / (num_tp + num_fp)\",\n \"def pf_analysis():\\r\\n\\r\\n global params\\r\\n n = params['n']\\r\\n level = params['level']\\r\\n pfmin = params['pfmin']\\r\\n pfmax = params['pfmax']\\r\\n pfstep = params['pfstep']\\r\\n ns = params['ns']\\r\\n nt = params['nt']\\r\\n po = params['po']\\r\\n pe = params['pe']\\r\\n pf_dir = create_dir(TIMES_PATH + 'pf')\\r\\n filename = datetime.datetime.now().strftime(DATE_FORMAT) + '.csv'\\r\\n with open(pf_dir + filename, 'wb') as csvfile:\\r\\n fw = csv.writer(csvfile)\\r\\n fw.writerow(('lv', 'ns', 'nt', 'no', 'ne', 'pf', 'nf',\\r\\n 'method1', 'method2', 'method3_1', 'method3_2'))\\r\\n pf = pfmin\\r\\n while pf <= pfmax:\\r\\n no = max(int(round(po * nt)), 1)\\r\\n ne = max(int(round(pe * no)), 1)\\r\\n nf = max(int(round(pf * nt)), 1)\\r\\n times = [0] * 4\\r\\n for i in range(n):\\r\\n times = map(sum, zip(times, get_times(level, ns, nt, no, ne, nf)))\\r\\n show_progress('pf', pf, pfmin, pfmax, pfstep, i, n)\\r\\n times = map(lambda x: float(x) / n, times)\\r\\n fw.writerow((level, ns, nt, no, ne, pf, nf) + tuple(times))\\r\\n pf += pfstep\\r\\n csvfile.close()\",\n \"def f1_score(y_true, y_pred, threshold, macro = False, eps = 1e-9):\\n\\n y_pred = torch.ge(y_pred.float(), threshold).float()\\n\\n y_true = y_true.float()\\n\\n tp_l = (y_pred * y_true).sum(0).float()\\n\\n fp_l = (y_pred * (1 - y_true)).sum(0).float()\\n\\n fn_l = ((1 - y_pred) * y_true).sum(0).float()\\n\\n precision_label = tp_l.div(tp_l + fp_l + eps)\\n\\n recall_label = tp_l.div(tp_l + fn_l + eps)\\n\\n if macro:\\n\\n f1_macro = torch.mean((precision_label * recall_label).div(precision_label + recall_label + eps) * 2)\\n\\n return f1_macro.item(), torch.mean(precision_label).item(), torch.mean(recall_label).item()\\n\\n else: \\n\\n tp = tp_l.sum()\\n\\n fp = fp_l.sum()\\n\\n fn = fn_l.sum()\\n\\n precision = tp / (tp + fp + eps)\\n\\n recall = tp / (tp + fn + eps)\\n\\n f1_micro = (precision * recall).div(precision + recall + eps) * 2\\n\\n return f1_micro.item(), precision.item(), recall.item()\",\n \"def get_f1_scores(labels_true: np.ndarray, labels_pred: np.ndarray, return_precision_recall: bool = False) \\\\\\n -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray, np.ndarray]]:\\n confusion = get_confusion_matrix(labels_true, labels_pred)\\n n_labels = confusion.shape[0]\\n counts_correct = confusion.diagonal()\\n counts_true = confusion.dot(np.ones(n_labels))\\n counts_pred = confusion.T.dot(np.ones(n_labels))\\n mask = counts_true > 0\\n recalls = np.zeros(n_labels)\\n recalls[mask] = counts_correct[mask] / counts_true[mask]\\n precisions = np.zeros(n_labels)\\n mask = counts_pred > 0\\n precisions[mask] = counts_correct[mask] / counts_pred[mask]\\n f1_scores = np.zeros(n_labels)\\n mask = (counts_true > 0) & (counts_pred > 0)\\n f1_scores[mask] = 2 / (1 / precisions[mask] + 1 / recalls[mask])\\n if return_precision_recall:\\n return f1_scores, precisions, recalls\\n else:\\n return f1_scores\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6962998","0.6783924","0.6656604","0.6580796","0.6549494","0.6458977","0.64446396","0.6435898","0.64287984","0.64278877","0.6422356","0.64145064","0.6384937","0.6361993","0.6317291","0.6312312","0.6308689","0.62624353","0.6238393","0.6236581","0.62225837","0.620662","0.6198069","0.61691785","0.6150987","0.6089687","0.60885495","0.6073363","0.60612994","0.60547537","0.6024896","0.6017973","0.6012496","0.60000324","0.5994209","0.59833974","0.598248","0.5970905","0.59658706","0.5934642","0.59292763","0.5921837","0.59199345","0.59086835","0.5896231","0.58907515","0.5888978","0.58826864","0.58766234","0.5872612","0.58670974","0.5863872","0.5863398","0.5860244","0.58473957","0.58443546","0.58414096","0.5830486","0.5827783","0.5824083","0.5822615","0.5816421","0.5814933","0.58034676","0.5797972","0.5796924","0.5792248","0.5790198","0.5788521","0.57858443","0.5771554","0.5770117","0.5762093","0.57522696","0.57461745","0.5729985","0.5725242","0.57239914","0.57214886","0.5695604","0.5690994","0.5686855","0.5685916","0.5685642","0.56829","0.56811297","0.5676253","0.56730044","0.5660902","0.5658045","0.56572485","0.5656619","0.5654083","0.5653604","0.56323975","0.5625748","0.5620386","0.5619333","0.56128854","0.56068426","0.5586715"],"string":"[\n \"0.6962998\",\n \"0.6783924\",\n \"0.6656604\",\n \"0.6580796\",\n \"0.6549494\",\n \"0.6458977\",\n \"0.64446396\",\n \"0.6435898\",\n \"0.64287984\",\n \"0.64278877\",\n \"0.6422356\",\n \"0.64145064\",\n \"0.6384937\",\n \"0.6361993\",\n \"0.6317291\",\n \"0.6312312\",\n \"0.6308689\",\n \"0.62624353\",\n \"0.6238393\",\n \"0.6236581\",\n \"0.62225837\",\n \"0.620662\",\n \"0.6198069\",\n \"0.61691785\",\n \"0.6150987\",\n \"0.6089687\",\n \"0.60885495\",\n \"0.6073363\",\n \"0.60612994\",\n \"0.60547537\",\n \"0.6024896\",\n \"0.6017973\",\n \"0.6012496\",\n \"0.60000324\",\n \"0.5994209\",\n \"0.59833974\",\n \"0.598248\",\n \"0.5970905\",\n \"0.59658706\",\n \"0.5934642\",\n \"0.59292763\",\n \"0.5921837\",\n \"0.59199345\",\n \"0.59086835\",\n \"0.5896231\",\n \"0.58907515\",\n \"0.5888978\",\n \"0.58826864\",\n \"0.58766234\",\n \"0.5872612\",\n \"0.58670974\",\n \"0.5863872\",\n \"0.5863398\",\n \"0.5860244\",\n \"0.58473957\",\n \"0.58443546\",\n \"0.58414096\",\n \"0.5830486\",\n \"0.5827783\",\n \"0.5824083\",\n \"0.5822615\",\n \"0.5816421\",\n \"0.5814933\",\n \"0.58034676\",\n \"0.5797972\",\n \"0.5796924\",\n \"0.5792248\",\n \"0.5790198\",\n \"0.5788521\",\n \"0.57858443\",\n \"0.5771554\",\n \"0.5770117\",\n \"0.5762093\",\n \"0.57522696\",\n \"0.57461745\",\n \"0.5729985\",\n \"0.5725242\",\n \"0.57239914\",\n \"0.57214886\",\n \"0.5695604\",\n \"0.5690994\",\n \"0.5686855\",\n \"0.5685916\",\n \"0.5685642\",\n \"0.56829\",\n \"0.56811297\",\n \"0.5676253\",\n \"0.56730044\",\n \"0.5660902\",\n \"0.5658045\",\n \"0.56572485\",\n \"0.5656619\",\n \"0.5654083\",\n \"0.5653604\",\n \"0.56323975\",\n \"0.5625748\",\n \"0.5620386\",\n \"0.5619333\",\n \"0.56128854\",\n \"0.56068426\",\n \"0.5586715\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21491,"cells":{"query":{"kind":"string","value":"Saves the network architecture as a .txt file. Arguments"},"document":{"kind":"string","value":"def save_arch(model, save_folder):\n with open(save_folder + '/architecture.txt','w') as a_save:\n model.summary(print_fn=lambda x: a_save.write(x + '\\n'))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def save(self, path=\"\"):\n path = path + \"model_\" + str(self.name) + \".txt\"\n if os.path.isfile(path):\n os.remove(path)\n f = open(path, \"w+\")\n for ident in self.networks:\n f.write(ident + \"_\" + self.networks[ident].descriptor.codify_components() + \"_\" + str(self.networks[ident].taking.size) + \",\" + self.networks[ident].taking.type + \"_\" + str(self.networks[ident].producing.size) + \",\" + self.networks[ident].producing.type + \"_\" +\n str(self.networks[ident].depth) + \"_\" + \",\".join(self.reachable[ident]) + \"_\" + \",\".join(self.comps_below[ident]) + \"\\n\")\n f.write(\"\\n\")\n\n for ident in self.inputs:\n f.write(ident + \"_\" + str(self.inputs[ident].producing.size) + \"_\" + self.inputs[ident].producing.type + \"_\" + str(self.inputs[ident].depth) + \"\\n\")\n f.write(\"\\n\")\n\n for ident in self.outputs:\n f.write(ident + \"_\" + str(self.outputs[ident].taking.size) + \"_\" + self.outputs[ident].taking.type + \"_\" + str(self.outputs[ident].depth) + \"_\" + \",\".join(self.comps_below[ident]) + \"\\n\")\n f.write(\"\\n\")\n\n for con in self.connections:\n f.write(self.connections[con].codify() + \"\\n\")\n #f.write(\"\\n\")\n\n f.close()\n\n return path","def save_network_architecture(self,network_path):\n net_architecture = {}\n net_architecture['y_res'] = self.y_res\n net_architecture['x_res'] = self.x_res\n net_architecture['n_input_channels'] = self.n_input_channels\n net_architecture['n_output_classes'] = self.n_output_classes\n net_architecture['fc1_dropout'] = self.fc1_dropout\n net_architecture['alpha'] = self.alpha\n net_architecture['n_samples_trained'] = self.n_samples_trained\n net_architecture['n_class_samples_trained'] = self.n_class_samples_trained\n net_architecture['n_samples_list'] = self.n_samples_list\n net_architecture['n_class_samples_list'] = self.n_class_samples_list\n net_architecture['accuracy_list'] = self.accuracy_list\n net_architecture['precision_list'] = self.precision_list\n net_architecture['recall_list'] = self.recall_list\n net_architecture['F1_list'] = self.F1_list\n np.save(os.path.join( \\\n network_path,'net_architecture.npy'), net_architecture)\n self.log(\"Network architecture saved to file:\\n{}\".format(\n os.path.join(network_path,'net_architecture.npy')))","def save_network_architecture(self,network_path):\n net_architecture = {}\n net_architecture['y_res'] = self.y_res\n net_architecture['x_res'] = self.x_res\n net_architecture['n_input_channels'] = self.n_input_channels\n net_architecture['n_output_classes'] = self.n_output_classes\n net_architecture['fc1_n_chan'] = self.fc1_n_chan\n net_architecture['fc1_dropout'] = self.fc1_dropout\n net_architecture['alpha'] = self.alpha\n net_architecture['n_samples_trained'] = self.n_samples_trained\n net_architecture['n_class_samples_trained'] = self.n_class_samples_trained\n net_architecture['n_samples_list'] = self.n_samples_list\n net_architecture['n_class_samples_list'] = self.n_class_samples_list\n net_architecture['accuracy_list'] = self.accuracy_list\n net_architecture['precision_list'] = self.precision_list\n net_architecture['recall_list'] = self.recall_list\n net_architecture['F1_list'] = self.F1_list\n np.save(os.path.join( \\\n network_path,'net_architecture.npy'), net_architecture)\n self.log(\"Network architecture saved to file:\\n{}\".format(\n os.path.join(network_path,'net_architecture.npy')))","def save_architecture(model, path_out):\n # Redirect the print output the a textfile\n orig_stdout = sys.stdout\n # and store the architecture\n f = file(os.path.join(path_out, \"architecture.txt\"), 'w')\n sys.stdout = f\n model.summary()\n # Reset the print output direction\n sys.stdout = orig_stdout\n f.close()\n\n open(os.path.join(path_out, \"config.json\"), 'w').write(model.to_json())","def save_network_architecture(self,network_path):\n net_architecture = {}\n net_architecture['y_res'] = self.y_res\n net_architecture['x_res'] = self.x_res\n net_architecture['n_input_channels'] = self.n_input_channels\n net_architecture['n_output_classes'] = self.n_output_classes\n net_architecture['conv1_size'] = self.conv1_size\n net_architecture['conv1_n_chan'] = self.conv1_n_chan\n net_architecture['conv1_n_pool'] = self.conv1_n_pool\n net_architecture['conv2_size'] = self.conv2_size\n net_architecture['conv2_n_chan'] = self.conv2_n_chan\n net_architecture['conv2_n_pool'] = self.conv2_n_pool\n net_architecture['fc1_n_chan'] = self.fc1_n_chan\n net_architecture['fc1_dropout'] = self.fc1_dropout\n net_architecture['alpha'] = self.alpha\n net_architecture['n_samples_trained'] = self.n_samples_trained\n net_architecture['n_class_samples_trained'] = self.n_class_samples_trained\n net_architecture['n_samples_list'] = self.n_samples_list\n net_architecture['n_class_samples_list'] = self.n_class_samples_list\n net_architecture['accuracy_list'] = self.accuracy_list\n net_architecture['precision_list'] = self.precision_list\n net_architecture['recall_list'] = self.recall_list\n net_architecture['F1_list'] = self.F1_list\n np.save(os.path.join( \\\n network_path,'net_architecture.npy'), net_architecture)\n self.log(\"Network architecture saved to file:\\n{}\".format(\n os.path.join(network_path,'net_architecture.npy')))","def write_network_file(self, model, **kwargs):\n model.set_names()\n # Output network file\n output_file = self.output_path + \"/network.txt\"\n\n self.network_have_substations = False\n\n # Lists for storing strings\n source_string_list = []\n overhead_string_list = []\n overhead_byphase_string_list = []\n underground_string_list = []\n switch_string_list = []\n fuse_string_list = []\n recloser_string_list = []\n breaker_string_list = []\n capacitor_string_list = []\n two_windings_transformer_string_list = []\n three_windings_transformer_string_list = []\n regulator_string_list = []\n converter_string_list = []\n converter_control_string_list = []\n pv_settings_string_list = []\n bess_settings_string_list = []\n dg_generation_string_list = []\n\n # The linecodes dictionary is used to group lines which have the same properties\n # (impedance matrix, ampacity...)\n # This dictionary will be outputed in write_equipment_file\n ID = 0\n self.linecodes_overhead = {}\n ID_cable = 0\n self.cablecodes = {}\n ID_cap = 0\n self.capcodes = {}\n ID_trans = 0\n self.two_windings_trans_codes = {}\n ID_reg = 0\n self.reg_codes = {}\n ID_trans_3w = 0\n self.three_windings_trans_codes = {}\n ID_cond = 0\n self.bess_codes = {}\n ID_bess = 0\n self.conductors = {}\n self.switchcodes = {}\n self.fusecodes = {}\n self.reclosercodes = {}\n self.breakercodes = {}\n self.irradiance_profiles = {}\n\n intermediate_nodes = []\n\n self.sources = {}\n\n self.substations = []\n\n # Open the output file...\n with open(output_file, \"w\") as f:\n\n # before doing anything, we need to get all transformers that have a regulator connected to them\n # In CYME, Regulators do not need to have a transformer object, so we need to ignore the transformers with regulators\n self.transformers_to_ignore = [\n i.connected_transformer\n for i in model.models\n if isinstance(i, Regulator)\n ]\n\n # Build connector_string_mapping\n # TODO integrate into rest of model so we don't have to loop twice over ditto elements\n for i in model.models:\n if (\n hasattr(i, \"from_element\")\n and i.from_element is not None\n and hasattr(i, \"from_element_connection_index\")\n and i.from_element_connection_index is not None\n ):\n self.node_connector_string_mapping[\n (i.from_element, i.from_element_connection_index)\n ] = \"{f}_{t}\".format(f=i.from_element, t=i.to_element)\n if (\n len(\n self.node_connector_string_mapping[\n (i.from_element, i.from_element_connection_index)\n ]\n )\n > 64\n ):\n hasher = hashlib.sha1()\n hasher.update(\n self.node_connector_string_mapping[\n (i.from_element, i.from_element_connection_index)\n ].encode(\"utf-8\")\n )\n self.node_connector_string_mapping[\n (i.from_element, i.from_element_connection_index)\n ] = hasher.hexdigest()\n\n if (\n hasattr(i, \"to_element\")\n and i.to_element is not None\n and hasattr(i, \"to_element_connection_index\")\n and i.to_element_connection_index is not None\n ):\n self.node_connector_string_mapping[\n (i.to_element, i.to_element_connection_index)\n ] = \"{f}_{t}\".format(f=i.from_element, t=i.to_element)\n if (\n len(\n self.node_connector_string_mapping[\n (i.to_element, i.to_element_connection_index)\n ]\n )\n > 64\n ):\n hasher = hashlib.sha1()\n hasher.update(\n self.node_connector_string_mapping[\n (i.to_element, i.to_element_connection_index)\n ].encode(\"utf-8\")\n )\n self.node_connector_string_mapping[\n (i.to_element, i.to_element_connection_index)\n ] = hasher.hexdigest()\n\n # Loop over the DiTTo objects\n for i in model.models:\n\n if hasattr(i, \"drop\") and i.drop == 1:\n continue\n\n # If we get a PowerSource object\n #\n if isinstance(i, PowerSource):\n # Check that the PowerSouce object is an external power source\n if hasattr(i, \"is_sourcebus\") and i.is_sourcebus == 1:\n # Empty new source string\n new_source_string = \"\"\n self.substations.append({})\n\n if (\n hasattr(i, \"connecting_element\")\n and i.connecting_element is not None\n ):\n self.sources[i.connecting_element] = None\n new_source_string += i.connecting_element\n self.substations[-1][\n \"connecting_element\"\n ] = i.connecting_element\n else:\n continue\n\n if (\n hasattr(i, \"nominal_voltage\")\n and i.nominal_voltage is not None\n ):\n new_source_string += \",\" + str(i.nominal_voltage * 10 ** -3)\n self.sources[i.connecting_element] = str(\n i.nominal_voltage * 10 ** -3\n )\n self.substations[-1][\"KVLL\"] = str(\n i.nominal_voltage * 10 ** -3\n )\n elif (\n hasattr(i, \"connecting_element\")\n and i.connecting_element is not None\n and i.connecting_element in model.model_names\n and hasattr(model[i.connecting_element], \"nominal_voltage\")\n and model[i.connecting_element].nominal_voltage is not None\n ):\n voltage = model[i.connecting_element].nominal_voltage\n new_source_string += \",\" + str(voltage * 10 ** -3)\n self.sources[i.connecting_element] = str(voltage * 10 ** -3)\n self.substations[-1][\"KVLL\"] = str(voltage * 10 ** -3)\n else:\n new_source_string += \",\"\n\n if hasattr(i, \"phase_angle\") and i.phase_angle is not None:\n new_source_string += \",\" + str(i.phase_angle)\n new_source_string += \",\" + str(i.phase_angle - 120)\n new_source_string += \",\" + str(i.phase_angle + 120)\n self.substations[-1][\"phase_angle\"] = str(i.phase_angle)\n else:\n new_source_string += \",,,\"\n\n if (\n hasattr(i, \"positive_sequence_impedance\")\n and i.positive_sequence_impedance is not None\n ):\n new_source_string += (\n \",\"\n + str(i.positive_sequence_impedance.real)\n + \",\"\n + str(i.positive_sequence_impedance.imag)\n )\n self.substations[-1][\"R1\"] = str(\n i.positive_sequence_impedance.real\n )\n self.substations[-1][\"X1\"] = str(\n i.positive_sequence_impedance.imag\n )\n else:\n new_source_string += \",,\"\n\n if (\n hasattr(i, \"zero_sequence_impedance\")\n and i.zero_sequence_impedance is not None\n ):\n new_source_string += (\n \",\"\n + str(i.zero_sequence_impedance.real)\n + \",\"\n + str(i.zero_sequence_impedance.imag)\n )\n self.substations[-1][\"R0\"] = str(\n i.zero_sequence_impedance.real\n )\n self.substations[-1][\"X0\"] = str(\n i.zero_sequence_impedance.imag\n )\n else:\n new_source_string += \",,\"\n\n if (\n hasattr(i, \"negative_sequence_impedance\")\n and i.negative_sequence_impedance is not None\n ):\n new_source_string += (\n \",\"\n + str(i.negative_sequence_impedance.real)\n + \",\"\n + str(i.negative_sequence_impedance.imag)\n )\n elif (\n hasattr(i, \"zero_sequence_impedance\")\n and i.zero_sequence_impedance is not None\n ):\n new_source_string += (\n \",\"\n + str(i.zero_sequence_impedance.real)\n + \",\"\n + str(i.zero_sequence_impedance.imag)\n )\n else:\n new_source_string += \",,\"\n\n # OperatingVoltages\n try:\n new_source_string += \",{v},{v},{v},0\".format(\n v=i.nominal_voltage * 10 ** -3\n )\n except:\n new_source_string += \",,,,0\"\n pass\n\n if hasattr(i, \"rated_power\") and i.rated_power is not None:\n self.substations[-1][\"MVA\"] = str(i.rated_power * 10 ** -6)\n\n if new_source_string != \"\":\n source_string_list.append(new_source_string)\n\n # If we get a Node object\n #\n if isinstance(i, Node):\n\n # Empty new node string\n new_node_string = \"\"\n\n # Empty new bus string (for bus representations of nodes with two coords)\n new_bus_string = \"\"\n\n # Name\n if hasattr(i, \"name\") and i.name is not None:\n self.nodeID_list.append(i.name)\n else:\n continue\n\n # CoordX and CoordY\n if (\n hasattr(i, \"positions\")\n and i.positions is not None\n and len(i.positions) == 1\n ):\n new_node_string += i.name\n try:\n new_node_string += \",\" + str(i.positions[0].long)\n except:\n new_node_string += \",0\"\n pass\n\n try:\n new_node_string += \",\" + str(i.positions[0].lat)\n except:\n new_node_string += \",0\"\n pass\n elif (\n hasattr(i, \"positions\")\n and i.positions is not None\n and len(i.positions) >= 2\n ):\n new_bus_string += i.name\n try:\n new_bus_string += \",\" + str(i.positions[0].long)\n except:\n new_bus_string += \",0\"\n pass\n\n try:\n new_bus_string += \",\" + str(i.positions[0].lat)\n except:\n new_bus_string += \",0\"\n pass\n\n try:\n new_bus_string += \",\" + str(i.positions[-1].long)\n except:\n new_bus_string += \",0\"\n pass\n\n try:\n new_bus_string += \",\" + str(i.positions[-1].lat)\n except:\n new_bus_string += \",0\"\n pass\n new_bus_string += \",2\" # Set width of 2\n for j in range(1, len(i.positions) - 1):\n sectionid = \"\"\n if (i.name, j - 1) in self.node_connector_string_mapping:\n sectionid = self.node_connector_string_mapping[\n (i.name, j - 1)\n ]\n new_node_connector_string = \"{n},{x},{y},{s}\".format(\n n=i.name,\n x=i.positions[j].long,\n y=i.positions[j].lat,\n s=sectionid,\n )\n self.node_connector_string_list.append(\n new_node_connector_string\n )\n\n else:\n new_node_string += i.name\n new_node_string += \",0,0\"\n\n # Add the node string to the list\n if new_node_string != \"\":\n self.node_string_list.append(new_node_string)\n\n if new_bus_string != \"\":\n self.bus_string_list.append(new_bus_string)\n\n # If we get a Line object\n #\n if isinstance(i, Line):\n\n matching_list = {\n \"overhead\": overhead_string_list,\n \"by_phase\": overhead_byphase_string_list,\n \"underground\": underground_string_list,\n \"switch\": switch_string_list,\n \"fuse\": fuse_string_list,\n \"recloser\": recloser_string_list,\n \"breaker\": breaker_string_list,\n }\n\n # Empty new strings for sections and overhead lines\n new_section_line = \"\"\n new_line_string = \"\"\n line_type = \"overhead\" # Line type is set to overhead by default\n\n # Name\n if hasattr(i, \"name\") and i.name is not None:\n\n # Get the type\n #\n # (In DiTTo, a line object can be used to represent overhead and underground lines,\n # as well as switches and fuses).\n #\n if hasattr(i, \"line_type\"):\n\n # if i.line_type is None:\n\n # Fuses and reclosers are modelled in OpenDSS as an object monitoring a line.\n # In RNM, this dummy line is actually a switch, meaning that we have in DiTTo\n # line objects where is_switch==1 AND is_fuse==1 (or is_recloser==1)\n # We want to output these as fuses or reclosers, not as switches\n # Hence the following:\n # if hasattr(i, 'is_fuse') and i.is_fuse==1:\n # line_type='fuse'\n\n # elif hasattr(i, 'is_recloser') and i.is_recloser==1:\n # line_type='recloser'\n # ONLY if line is not a fuse nor a recloser, but is a switch do we output a switch...\n # elif hasattr(i, 'is_switch') and i.is_switch==1:\n # line_type='switch'\n\n if i.line_type is not None:\n if i.line_type.lower() == \"underground\":\n line_type = \"underground\"\n\n if (\n hasattr(i, \"nominal_voltage\")\n and i.nominal_voltage is not None\n and i.nominal_voltage < 600\n ):\n line_type = \"underground\" # for triplex lines\n\n if hasattr(i, \"is_fuse\") and i.is_fuse == 1:\n line_type = \"fuse\"\n\n elif hasattr(i, \"is_recloser\") and i.is_recloser == 1:\n line_type = \"recloser\"\n\n elif hasattr(i, \"is_breaker\") and i.is_breaker == 1:\n line_type = \"breaker\"\n\n # ONLY if line is not a fuse nor a recloser, but is a switch do we output a switch...\n elif hasattr(i, \"is_switch\") and i.is_switch == 1:\n line_type = \"switch\"\n\n # From element for sections\n if (\n hasattr(i, \"from_element\")\n and i.from_element is not None\n and hasattr(i, \"to_element\")\n and i.to_element is not None\n ):\n new_section_ID = \"{f}_{t}\".format(\n f=i.from_element, t=i.to_element\n )\n if hasattr(i, \"feeder_name\") and i.feeder_name is not None:\n if i.feeder_name in self.section_feeder_mapping:\n while (\n new_section_ID\n in self.section_feeder_mapping[i.feeder_name]\n ):\n new_section_ID = (\n new_section_ID + \"*\"\n ) # This is used to deal with duplicate lines from same from and to nodes\n if len(new_section_ID) > 64:\n hasher = hashlib.sha1()\n hasher.update(\n new_section_ID.encode(\"utf-8\")\n )\n new_section_ID = hasher.hexdigest()\n if len(new_section_ID) > 64:\n hasher = hashlib.sha1()\n hasher.update(new_section_ID.encode(\"utf-8\"))\n new_section_ID = hasher.hexdigest()\n new_line_string += new_section_ID\n from_index = 0\n to_index = 0\n if (\n hasattr(i, \"from_element_connection_index\")\n and i.from_element_connection_index is not None\n ):\n from_index = i.from_element_connection_index\n if (\n hasattr(i, \"to_element_connection_index\")\n and i.to_element_connection_index is not None\n ):\n to_index = i.to_element_connection_index\n new_section_line = \"{id},{f},{fi},{t},{ti}\".format(\n id=new_section_ID,\n f=i.from_element,\n fi=from_index,\n t=i.to_element,\n ti=to_index,\n )\n if hasattr(i, \"feeder_name\") and i.feeder_name is not None:\n if i.feeder_name in self.section_feeder_mapping:\n self.section_feeder_mapping[i.feeder_name].append(\n new_section_ID\n )\n else:\n self.section_feeder_mapping[i.feeder_name] = [\n new_section_ID\n ]\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n ):\n self.section_headnode_mapping[\n i.feeder_name\n ] = i.substation_name\n else:\n raise ValueError(\n \"Line {name} does not have from and to.\".format(\n name=i.name\n )\n )\n\n if (\n hasattr(i, \"positions\")\n and i.positions is not None\n and len(i.positions) > 0\n ):\n for seg_number, position in enumerate(i.positions):\n intermediate_nodes.append(\n [\n new_section_ID,\n seg_number,\n position.long,\n position.lat,\n ]\n )\n\n # Phases of the section\n #\n new_section_line += \",\"\n phases = []\n cond_id = {}\n if hasattr(i, \"wires\") and i.wires is not None:\n i.wires = [w for w in i.wires if w.drop != 1]\n for wire in i.wires:\n\n if hasattr(wire, \"phase\") and wire.phase is not None:\n # Do not count the neutral(s)...\n if wire.phase in [\"A\", \"B\", \"C\"]:\n new_section_line += wire.phase\n phases.append(wire.phase)\n\n new_code = \"\"\n if (\n hasattr(wire, \"diameter\")\n and wire.diameter is not None\n ):\n new_code += \",{}\".format(wire.diameter)\n else:\n new_code += \",\"\n\n if hasattr(wire, \"gmr\") and wire.gmr is not None:\n new_code += \",{}\".format(wire.gmr)\n\n # These calculations require no neutral wire as output (since these equations assume no kron reduction)\n # They serve the purpose of getting the impedance matrix output in CYME to match the impedance matrix from DiTTo\n # NOTE: a 2x2 impedance matrix is probably derived from R1, R0, X1, X0 and isn't actually a 2-wire or even a kron reduced matrix.\n # To get the cross-terms to match would require a kron reduction, often of imaginary wire resistances to get the cross-terms to match\n # For that reason, we let CYME apply the cross terms with their default spacing. This may cause some differences in the powerflow\n # i.e. WARNING - 2x2 matrix cross terms won't match\n\n elif wire.gmr is None and (\n len(i.impedance_matrix) == 1\n or len(i.impedance_matrix) == 2\n ):\n\n if isinstance(i.impedance_matrix, list):\n x_in_miles = i.impedance_matrix[0][0].imag\n else:\n x_in_miles = i.impedance_matrix[0].imag\n x_in_miles = (\n x_in_miles * 1609.34\n ) # internally impedance per meter\n coeff1 = 0.12134\n coeff2 = 7.93402\n gmr_in_feet = 1 / (\n math.exp((x_in_miles / coeff1) - coeff2)\n ) # Solving Kerstin 4.41 for GMR\n gmr_in_cm = 30.48 * gmr_in_feet\n new_code += \",{}\".format(gmr_in_cm)\n else:\n new_code += \",\"\n\n if (\n hasattr(wire, \"resistance\")\n and wire.resistance is not None\n ):\n new_code += \",{}\".format(wire.resistance)\n elif wire.resistance is None and (\n len(i.impedance_matrix) == 1\n or len(i.impedance_matrix) == 2\n ): # Calculate the resistance from the impedance matrix\n if isinstance(i.impedance_matrix, list):\n r_in_miles = i.impedance_matrix[0][0].real\n else:\n r_in_miles = i.impedance_matrix[0].real\n r_in_miles = (\n r_in_miles * 1609.34\n ) # internally impedance per meter\n resistance = r_in_miles - 0.09530 # From Kersting\n resistance = (\n resistance / 1.60934\n ) # output in ohms per km\n new_code += \",{}\".format(resistance)\n\n else:\n new_code += \",\"\n\n if (\n hasattr(wire, \"ampacity\")\n and wire.ampacity is not None\n ):\n new_code += \",{}\".format(wire.ampacity)\n else:\n new_code += \",\"\n\n if (\n hasattr(wire, \"emergency_ampacity\")\n and wire.emergency_ampacity is not None\n ):\n new_code += \",{}\".format(wire.emergency_ampacity)\n else:\n new_code += \",\".format(wire.emergency_ampacity)\n\n # if line_type=='underground':\n # If we have a name for the wire, we use it as the equipment id\n if (\n hasattr(wire, \"nameclass\")\n and wire.nameclass is not None\n and wire.nameclass != \"\"\n ):\n wire_name = wire.nameclass\n # If not already in the conductors dictionary, add it\n if wire_name not in self.conductors:\n self.conductors[wire_name] = new_code\n cond_id[wire.phase] = wire_name\n # If we do not have a name for the wire, we create one:\n # The IDs will be wire_1, wire_2,...\n else:\n found = False\n # Try to find if we already have the conductor stored\n for key, value in self.conductors.items():\n if value == new_code:\n cond_id[wire.phase] = key\n found = True\n # If not, create it\n if not found:\n ID_cond += 1\n self.conductors[\n \"conductor_{}\".format(ID_cond)\n ] = new_code\n cond_id[wire.phase] = ID_cond\n\n # Impedance matrix\n #\n # Here, we group lines that have the same characteristics:\n # R0,R1,X0,X1,ampacity\n # We create am ID for these lines (Here a simple integer)\n #\n # If we have a switch, we just use default because there is no way (to my knowledge)\n # to provide the impedance matrix for a switch in CYME\n frequency = 60 # Need to make this changable\n if line_type == \"switch\":\n if (\n i.nameclass is not None\n and i.nameclass != \"\"\n and i.wires[0].ampacity is not None\n and i.nominal_voltage is not None\n ):\n new_code2 = \"{amps},{amps},{amps},{amps},{amps},{kvll},0,,,,,,,,0,0,0,0,0,\".format(\n amps=i.wires[0].ampacity,\n kvll=i.nominal_voltage * 10 ** -3,\n )\n\n if (\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n not in self.switchcodes\n ):\n self.switchcodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ] = new_code2\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n\n elif (\n self.switchcodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ]\n != new_code2\n ):\n found = False\n for k, v in self.switchcodes.items():\n if new_code2 == v:\n new_line_string += \",\" + str(k)\n found = True\n if not found:\n self.switchcodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ] = new_code2\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n else:\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n\n else:\n new_line_string += \",DEFAULT\"\n\n elif line_type == \"fuse\":\n if (\n i.nameclass is not None\n and i.nameclass != \"\"\n and i.wires[0].ampacity is not None\n and i.nominal_voltage is not None\n ):\n new_code2 = \"{amps},{amps},{amps},{amps},{amps},{kvll},0,600.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0,0,0,,,,\".format(\n amps=i.wires[0].ampacity,\n kvll=i.nominal_voltage * 10 ** -3,\n )\n\n if (\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n not in self.fusecodes\n ):\n self.fusecodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ] = new_code2\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n\n elif (\n self.fusecodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ]\n != new_code2\n ):\n found = False\n for k, v in self.fusecodes.items():\n if new_code2 == v:\n new_line_string += \",\" + str(k)\n found = True\n if not found:\n self.fusecodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ] = new_code2\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n else:\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n\n else:\n new_line_string += \",DEFAULT\"\n\n elif line_type == \"recloser\":\n if (\n i.nameclass is not None\n and i.nameclass != \"\"\n and i.wires[0].ampacity is not None\n and i.nominal_voltage is not None\n ):\n new_code2 = \"{amps},{amps},{amps},{amps},{amps},{kvll},0,600.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0,0,0,0,0,0,,1,,\".format(\n amps=i.wires[0].ampacity,\n kvll=i.nominal_voltage * 10 ** -3,\n )\n\n if (\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n not in self.reclosercodes\n ):\n self.reclosercodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ] = new_code2\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n\n elif (\n self.reclosercodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ]\n != new_code2\n ):\n found = False\n for k, v in self.reclosercodes.items():\n if new_code2 == v:\n new_line_string += \",\" + str(k)\n found = True\n if not found:\n self.reclosercodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ] = new_code2\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n else:\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n\n else:\n new_line_string += \",DEFAULT\"\n\n elif line_type == \"breaker\":\n if (\n i.nameclass is not None\n and i.nameclass != \"\"\n and i.wires[0].ampacity is not None\n and i.nominal_voltage is not None\n ):\n new_code2 = \"{amps},{amps},{amps},{amps},{amps},{kvll},0,600.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0,0,0,0,0,0,\".format(\n amps=i.wires[0].ampacity,\n kvll=i.nominal_voltage * 10 ** -3,\n )\n\n if (\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n not in self.breakercodes\n ):\n self.breakercodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ] = new_code2\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n\n elif (\n self.breakercodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ]\n != new_code2\n ):\n found = False\n for k, v in self.breakercodes.items():\n if new_code2 == v:\n new_line_string += \",\" + str(k)\n found = True\n if not found:\n self.breakercodes[\n i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n ] = new_code2\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n else:\n new_line_string += (\n \",\"\n + i.nameclass\n + \"_\"\n + str(int(i.nominal_voltage))\n + \"_\"\n + str(int(i.wires[0].ampacity))\n )\n\n else:\n new_line_string += \",DEFAULT\"\n\n elif line_type == \"underground\":\n tt = {}\n if (\n hasattr(i, \"nominal_voltage\")\n and i.nominal_voltage is not None\n ):\n if (\n i.nominal_voltage is not None\n and i.nominal_voltage < 600\n and len(i.wires) <= 2\n ): # LV lines are assigned as triplex unless they're three phase\n tt[\"cabletype\"] = 2\n else:\n tt[\"cabletype\"] = 0\n\n else:\n tt[\"cabletype\"] = 0\n\n if (\n hasattr(i, \"impedance_matrix\")\n and i.impedance_matrix is not None\n ):\n z_diag = 0\n z_offdiag = 0\n try:\n for kk in range(len(i.impedance_matrix)):\n if i.impedance_matrix[kk][kk] != 0:\n z_diag = i.impedance_matrix[kk][kk]\n for jj in range(len(i.impedance_matrix)):\n if jj == kk:\n continue\n if i.impedance_matrix[kk][jj] != 0:\n z_offdiag = i.impedance_matrix[kk][\n jj\n ]\n\n except:\n try:\n z_diag = i.impedance_matrix[0]\n z_offdiag = i.impedance_matrix[0]\n except:\n raise ValueError(\n \"Cannot get a value from impedance matrix for line {}\".format(\n i.name\n )\n )\n coeff = 10 ** 3\n z0 = z_diag + 2 * z_offdiag\n z1 = z_diag - z_offdiag\n\n tt[\"R0\"] = z0.real * coeff\n tt[\"X0\"] = z0.imag * coeff\n try:\n pos_seq_imp = i.impedance_matrix[1][1]\n tt[\"R1\"] = z1.real * coeff\n tt[\"X1\"] = z1.imag * coeff\n except:\n tt[\"R1\"] = tt[\"R0\"]\n tt[\"X1\"] = tt[\"X0\"]\n pass\n try:\n neg_seq_imp = i.impedance_matrix[2][2]\n tt[\"R2\"] = z1.real * coeff\n tt[\"X2\"] = z1.imag * coeff\n except:\n tt[\"R2\"] = tt[\"R1\"]\n tt[\"X2\"] = tt[\"X1\"]\n pass\n\n if (\n hasattr(i, \"capacitance_matrix\")\n and i.capacitance_matrix is not None\n ):\n c_diag = 0\n c_offdiag = 0\n try:\n for kk in range(len(i.impedance_matrix)):\n if i.capacitance_matrix[kk][kk] != 0:\n c_diag = i.capacitance_matrix[kk][kk]\n for jj in range(\n len(i.capacitance_matrix)\n ):\n if jj == kk:\n continue\n if (\n i.capacitance_matrix[kk][jj]\n != 0\n ):\n c_offdiag = i.capacitance_matrix[\n kk\n ][\n jj\n ]\n\n except:\n try:\n c_diag = i.capacitance_matrix[0]\n c_offdiag = i.capacitance_matrix[0]\n except:\n import pdb\n\n pdb.set_trace()\n raise ValueError(\n \"Cannot get a value from impedance matrix for line {}\".format(\n i.name\n )\n )\n coeff = 10 ** 3\n c0 = c_diag + 2 * c_offdiag\n c1 = c_diag - c_offdiag\n\n tt[\"B0\"] = (\n c0.real * 2 * math.pi * frequency\n ) # Don't multiply by km conversion since cyme output in micro siemens\n tt[\"B1\"] = c1.real * 2 * math.pi * frequency #\n\n else:\n tt[\"B1\"] = 0\n tt[\"B0\"] = 0\n try:\n tt[\"amps\"] = i.wires[0].ampacity\n except:\n tt[\"amps\"] = 0\n pass\n\n if (\n hasattr(i.wires[0], \"nameclass\")\n and i.wires[0].nameclass is not None\n and i.wires[0].nameclass != \"\"\n ):\n cable_name = i.wires[0].nameclass\n self.cablecodes[cable_name] = tt\n new_line_string += \",\" + cable_name\n else:\n if len(self.cablecodes) == 0:\n ID_cable += 1\n self.cablecodes[\"cable\" + str(ID_cable)] = tt\n new_line_string += \",cable_\" + str(ID_cable)\n else:\n found = False\n for k, v in self.cablecodes.items():\n if v == tt:\n new_line_string += \",cable_\" + str(k)\n found = True\n if not found:\n ID_cable += 1\n self.cablecodes[\n \"cable\" + str(ID_cable)\n ] = tt\n new_line_string += \",cable_\" + str(ID_cable)\n\n else: # We use impedance_matrix if it exists and we have 3 phases. otherwise we use by_phase. TODO: change to by_phase whenever we have the wire information for it.\n # try:\n tt = {}\n if \"A\" in cond_id:\n tt[\"CondID_A\"] = cond_id[\"A\"]\n else:\n tt[\"CondID_A\"] = \"NONE\"\n if \"B\" in cond_id:\n tt[\"CondID_B\"] = cond_id[\"B\"]\n else:\n tt[\"CondID_B\"] = \"NONE\"\n if \"C\" in cond_id:\n tt[\"CondID_C\"] = cond_id[\"C\"]\n else:\n tt[\"CondID_C\"] = \"NONE\"\n if \"N\" in cond_id:\n tt[\"CondID_N\"] = cond_id[\"N\"]\n else:\n tt[\"CondID_N\"] = \"NONE\"\n if \"N1\" in cond_id:\n tt[\"CondID_N1\"] = cond_id[\"N1\"]\n else:\n tt[\"CondID_N1\"] = \"NONE\"\n if \"N2\" in cond_id:\n tt[\"CondID_N2\"] = cond_id[\"N2\"]\n else:\n tt[\"CondID_N2\"] = \"NONE\"\n\n if hasattr(i, \"wires\") and i.wires is not None:\n for wire in i.wires:\n if hasattr(wire, \"phase\") and str(wire.phase) in [\n \"A\",\n \"B\",\n \"C\",\n ]:\n p = str(wire.phase)\n if (\n hasattr(wire, \"ampacity\")\n and wire.ampacity is not None\n ):\n try:\n tt[\"Amps{}\".format(p)] = wire.ampacity\n except:\n tt[\"Amps{}\".format(p)] = \"DEFAULT\"\n pass\n\n # If we have 3 phases, use OVERHEADLINE SETTING\n if len(phases) == 3 and i.impedance_matrix is not None:\n\n tt.update(\n {\"SpacingID\": \"DEFAULT\", \"UserDefinedImpedances\": 1}\n )\n\n for k, p1 in enumerate(phases):\n for j, p2 in enumerate(phases):\n if j == k:\n tt[\"R{p}\".format(p=p1)] = (\n i.impedance_matrix[k][j].real * 10 ** 3\n )\n tt[\"X{p}\".format(p=p1)] = (\n i.impedance_matrix[k][j].imag * 10 ** 3\n )\n if i.capacitance_matrix is not None and len(\n i.capacitance_matrix\n ) == len(i.impedance_matrix):\n tt[\"B{p}\".format(p=p1)] = (\n i.capacitance_matrix[k][j].real\n * 2\n * math.pi\n * frequency\n * 10 ** 3\n )\n else:\n tt[\"Ba\"] = 0\n tt[\"Bb\"] = 0\n tt[\"Bc\"] = 0\n elif j > k:\n if p1 == \"A\" and p2 == \"C\":\n tt[\"MutualResistanceCA\"] = (\n i.impedance_matrix[k][j].real\n * 10 ** 3\n )\n tt[\"MutualReactanceCA\"] = (\n i.impedance_matrix[k][j].imag\n * 10 ** 3\n )\n if i.capacitance_matrix is not None and len(\n i.capacitance_matrix\n ) == len(\n i.impedance_matrix\n ):\n tt[\"MutualShuntSusceptanceCA\"] = (\n i.capacitance_matrix[k][j].real\n * 2\n * math.pi\n * frequency\n * 10 ** 3\n )\n else:\n tt[\"MutualShuntSusceptanceCA\"] = 0\n else:\n tt[\n \"MutualResistance{p1}{p2}\".format(\n p1=p1, p2=p2\n )\n ] = (\n i.impedance_matrix[k][j].real\n * 10 ** 3\n )\n tt[\n \"MutualReactance{p1}{p2}\".format(\n p1=p1, p2=p2\n )\n ] = (\n i.impedance_matrix[k][j].imag\n * 10 ** 3\n )\n if i.capacitance_matrix is not None and len(\n i.capacitance_matrix\n ) == len(\n i.impedance_matrix\n ):\n tt[\n \"MutualShuntSusceptance{p1}{p2}\".format(\n p1=p1, p2=p2\n )\n ] = (\n i.capacitance_matrix[k][j].real\n * 2\n * math.pi\n * frequency\n * 10 ** 3\n )\n else:\n tt[\"MutualShuntSusceptanceAB\"] = 0\n tt[\"MutualShuntSusceptanceBC\"] = 0\n\n if (\n hasattr(i, \"nameclass\")\n and i.nameclass is not None\n and i.nameclass != \"\"\n ):\n line_nameclass = i.nameclass\n self.linecodes_overhead[line_nameclass] = tt\n new_line_string += \",\" + line_nameclass\n else:\n # If the linecode dictionary is empty, just add the new element\n if len(self.linecodes_overhead) == 0:\n ID += 1\n self.linecodes_overhead[ID] = tt\n new_line_string += \",line_\" + str(ID)\n\n # Otherwise, loop over the dict to find a matching linecode\n else:\n found = False\n for k, v in self.linecodes_overhead.items():\n if v == tt:\n new_line_string += \",\" + str(k)\n found = True\n if not found:\n ID += 1\n self.linecodes_overhead[\n \"line_\" + str(ID)\n ] = tt\n new_line_string += \",line_\" + str(ID)\n\n # If we have less than 3 phases, then use a BY_PHASE configuration\n else:\n line_type = \"by_phase\" # Change the line_type to write the line under the proper header\n\n # Add device number and phase conductor IDs\n new_line_string += \",{device},{condIDA},{condIDB},{condIDC}\".format(\n device=new_section_ID,\n condIDA=tt[\"CondID_A\"],\n condIDB=tt[\"CondID_B\"],\n condIDC=tt[\"CondID_C\"],\n )\n\n # Add neutral conductor IDs\n #\n # If we have valid IDs for BOTH N1 and N2, then use that\n if (\n tt[\"CondID_N1\"] != \"NONE\"\n and tt[\"CondID_N2\"] != \"NONE\"\n ):\n new_line_string += \",{condIDN1},{condIDN2}\".format(\n condIDN1=tt[\"CondID_N1\"],\n condIDN2=tt[\"CondID_N2\"],\n )\n # Otherwise, if we have a valid ID for N, then use that as condIDN1 and use whatever we have for N2\n elif tt[\"CondID_N\"] != \"NONE\":\n new_line_string += \",{condIDN1},{condIDN2}\".format(\n condIDN1=tt[\"CondID_N\"],\n condIDN2=tt[\"CondID_N2\"],\n )\n # Otherwise, do as for case 1\n else:\n new_line_string += \",{condIDN1},{condIDN2}\".format(\n condIDN1=tt[\"CondID_N1\"],\n condIDN2=tt[\"CondID_N2\"],\n )\n\n # Use Default spacing\n #\n # TODO: User-defined spacing support\n #\n if len(phases) == 1:\n new_line_string += \",N_ABOVE_1PH\"\n if len(phases) == 2:\n new_line_string += \",N_ABOVE_2PH\"\n if len(phases) == 3:\n new_line_string += \",N_ABOVE_3PH\"\n\n # Length\n if hasattr(i, \"length\") and i.length is not None:\n if (\n line_type != \"switch\"\n and line_type != \"fuse\"\n and line_type != \"recloser\"\n and line_type != \"breaker\"\n ):\n try:\n new_line_string += \",\" + str(i.length)\n except:\n new_line_string += \",\"\n pass\n else:\n if (\n line_type != \"switch\"\n and line_type != \"fuse\"\n and line_type != \"recloser\"\n and line_type != \"breaker\"\n ):\n new_line_string += \",\"\n\n if line_type == \"switch\" or line_type == \"breaker\":\n closed_phase = np.sort(\n [\n wire.phase\n for wire in i.wires\n if wire.is_open == 0\n and wire.phase not in [\"N\", \"N1\", \"N2\"]\n ]\n )\n if len(closed_phase) == 0:\n new_line_string += \",M,None,0\"\n else:\n new_line_string += \",M,{},0\".format(\n reduce(lambda x, y: x + y, closed_phase)\n )\n\n if line_type == \"fuse\" or line_type == \"recloser\":\n closed_phase = np.sort(\n [\n wire.phase\n for wire in i.wires\n if wire.phase not in [\"N\", \"N1\", \"N2\"]\n ]\n )\n new_line_string += \",M,{},0\".format(\n reduce(lambda x, y: x + y, closed_phase)\n )\n\n # ConnectionStatus\n new_line_string += \",0\" # Assumes the line is connected because there is no connected field in DiTTo\n\n # DeviceNumber\n if (\n line_type == \"switch\"\n or line_type == \"fuse\"\n or line_type == \"recloser\"\n or line_type == \"breaker\"\n ):\n new_line_string += \",\" + new_section_ID\n\n if line_type == \"underground\":\n new_line_string += (\n \",10,2\" # DistanceBetweenConductors, CableConfiguration\n )\n\n # Add the strings to the lists\n #\n if new_section_line != \"\":\n self.section_line_list.append(new_section_line)\n # If the object is inside of a substation...\n if hasattr(i, \"is_substation\") and i.is_substation == 1:\n # ...it should have the name of the substation specified in the 'substation_name' attribute\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n and i.substation_name != \"\"\n ):\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\n ff_name = \"substation_{}\".format(i.substation_name)\n self.network_have_substations = True\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\n elif (\n hasattr(i, \"feeder_name\")\n and i.feeder_name is not None\n and i.feeder_name != \"\"\n ):\n ff_name = i.feeder_name\n\n if ff_name in self.section_line_feeder_mapping:\n self.section_line_feeder_mapping[ff_name].append(\n new_section_line\n )\n else:\n self.section_line_feeder_mapping[ff_name] = [\n new_section_line\n ]\n\n if new_line_string != \"\":\n try:\n matching_list[line_type].append(new_line_string)\n except:\n pass\n\n if isinstance(i, Storage):\n bess_string = \"\"\n new_bess_setting_string = \"\"\n new_converter_string = \"\"\n new_converter_control_setting_string = \"\"\n\n if (\n hasattr(i, \"name\")\n and i.name is not None\n and hasattr(i, \"connecting_element\")\n and i.connecting_element is not None\n and (\n i.connecting_element in model.model_names\n or \"load_\" + i.connecting_element in model.model_names\n )\n ):\n new_section_ID = \"{f}_{t}\".format(\n f=i.connecting_element, t=i.name\n )\n if len(new_section_ID) > 64:\n hasher = hashlib.sha1()\n hasher.update(new_section_ID.encode(\"utf-8\"))\n new_section_ID = hasher.hexdigest()\n\n new_section = (\n new_section_ID\n + \",{f},0,{t},0,\".format( # Assume only one index for the load connection point\n f=i.connecting_element, t=i.name\n )\n )\n\n new_node_string = \"{n}\".format(n=i.name)\n if hasattr(i, \"positions\") and i.positions is not None:\n try:\n new_node_string += \",\" + str(i.positions[0].long)\n except:\n new_node_string += \",0\"\n pass\n\n try:\n new_node_string += \",\" + str(i.positions[0].lat)\n except:\n new_node_string += \",0\"\n pass\n else:\n new_node_string += \",0,0\"\n self.node_string_list.append(new_node_string)\n\n phases = \"\"\n if i.phase_storages is not None:\n for ps in i.phase_storages:\n if ps.phase in [\"A\", \"B\", \"C\"]:\n new_section += ps.phase\n phases += ps.phase\n\n # If the object is inside of a substation...\n if hasattr(i, \"is_substation\") and i.is_substation == 1:\n # ...it should have the name of the substation specified in the 'substation_name' attribute\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n and i.substation_name != \"\"\n ):\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\n ff_name = \"substation_{}\".format(i.substation_name)\n self.network_have_substations = True\n\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\n elif (\n hasattr(i, \"feeder_name\")\n and i.feeder_name is not None\n and i.feeder_name != \"\"\n ):\n ff_name = i.feeder_name\n\n self.section_line_list.append(new_section)\n if ff_name in self.section_line_feeder_mapping:\n self.section_line_feeder_mapping[ff_name].append(\n new_section\n )\n else:\n self.section_line_feeder_mapping[ff_name] = [new_section]\n\n new_converter_string += (\n new_section_ID + \",80,\"\n ) # 45 is the CYME code for PV devices\n new_converter_control_setting_string += (\n new_section_ID + \",80,0,0,\"\n ) # The controlindex and timetrigger indices are both zero\n\n if hasattr(i, \"rated_kWh\") and i.rated_kWh is not None:\n bess_string += str(i.rated_kWh * 10 ** -3)\n bess_string += \",\"\n\n if hasattr(i, \"rated_power\") and i.rated_power is not None:\n bess_string += str(i.rated_power * 10 ** -3)\n bess_string += \",\"\n\n # Use for both charging and discharging power\n if hasattr(i, \"rated_power\") and i.rated_power is not None:\n bess_string += str(i.rated_power * 10 ** -3)\n bess_string += \",\"\n\n if (\n hasattr(i, \"charging_efficiency\")\n and i.charging_efficiency is not None\n ):\n bess_string += str(i.charging_efficiency)\n bess_string += \",\"\n\n if (\n hasattr(i, \"discharging_efficiency\")\n and i.discharging_efficiency is not None\n ):\n bess_string += str(i.discharging_efficiency)\n\n bess_type = \"\"\n if bess_string in self.bess_codes:\n bess_type = self.bess_codes[bess_string]\n else:\n ID_bess += 1\n bess_type = \"BESS_\" + str(ID_bess)\n self.bess_codes[bess_string] = bess_type\n\n bess_string = bess_type + \",\" + bess_string\n\n new_bess_setting_string += (\n new_section_ID\n + \",M,\"\n + new_section_ID\n + \",\"\n + bess_type\n + \",\"\n + phases\n + \",\"\n )\n\n if (\n hasattr(i, \"stored_kWh\")\n and i.stored_kWh is not None\n and hasattr(i, \"rated_kWh\")\n and i.rated_kWh is not None\n and i.rated_kWh != 0\n ):\n new_bess_setting_string += str(\n int(i.stored_kWh / i.rated_kWh * 100)\n )\n\n if hasattr(i, \"active_rating\") and i.active_rating is not None:\n if (\n hasattr(i, \"reactive_rating\")\n and i.reactive_rating is not None\n ):\n new_converter_string += (\n str(\n math.sqrt(\n i.reactive_rating ** 2\n + i.active_rating ** 2\n )\n / 1000.0\n )\n + \",\"\n )\n else:\n new_converter_string += (\n str(i.active_rating / 1000.0) + \",\"\n )\n new_converter_string += str(i.active_rating / 1000.0) + \",\"\n elif hasattr(i, \"rated_power\") and i.rated_power is not None:\n if (\n hasattr(i, \"reactive_rating\")\n and i.reactive_rating is not None\n ):\n new_converter_string += (\n str(\n math.sqrt(\n i.reactive_rating ** 2\n + (i.rated_power * 1.1) ** 2\n )\n / 1000.0\n )\n + \",\"\n )\n else:\n new_converter_string += (\n str(i.rated_power * 1.1 / 1000.0) + \",\"\n )\n new_converter_string += (\n str(i.rated_power * 1.1 / 1000.0) + \",\"\n ) # Default value sets inverter to be oversized by 10%\n else:\n new_converter_string += \",,\"\n\n if (\n hasattr(i, \"reactive_rating\")\n and i.reactive_rating is not None\n ):\n new_converter_string += (\n str(i.reactive_rating / 1000.0) + \",\"\n )\n elif hasattr(i, \"rated_power\") and i.rated_power is not None:\n new_converter_string += (\n str(i.rated_power * 1.1 / 1000.0) + \",\"\n ) # Default value sets inverter to be oversized by 10% and active=reactive\n else:\n new_converter_string += \",\"\n\n if hasattr(i, \"rated_power\") and i.rated_power is not None:\n new_dg_generation_string += str(i.rated_power / 1000.0)\n elif hasattr(i, \"rated_power\") and i.rated_power is not None:\n new_dg_generation_string += str(i.rated_power / 1000.0)\n new_dg_generation_string += \",\"\n if (\n hasattr(i, \"min_powerfactor\")\n and i.min_powerfactor is not None\n ):\n new_converter_string += str(i.powerfactor * 100)\n new_dg_generation_string += str(i.powerfactor * 100)\n new_dg_generation_string += \",\"\n new_converter_string += \",\"\n if hasattr(i, \"fall_limit\") and i.fall_limit is not None:\n new_converter_string += str(i.fall_limit)\n new_converter_string += \",\"\n if hasattr(i, \"rise_limit\") and i.rise_limit is not None:\n new_converter_string += str(i.rise_limit)\n new_converter_string += \",\"\n if (hasattr(i, \"fall_limit\") and i.fall_limit is not None) or (\n hasattr(i, \"rise_limit\") and i.rise_limit is not None\n ):\n new_converter_string += \"0\" # Using units of % per minute\n\n if hasattr(i, \"control_type\") and i.control_type is not None:\n if (\n i.control_type.lower() == \"voltvar_vars_over_watts\"\n or i.control_type.lower() == \"voltvar\"\n ): # use default voltvar curve in cyme\n new_converter_control_setting_string += \"1\"\n if i.control_type.lower() == \"voltvar_watts_over_vars\":\n new_converter_control_setting_string += \"0\"\n if i.control_type.lower() == \"voltvar_fixed_vars\":\n new_converter_control_setting_string += \"2\"\n if i.control_type.lower() == \"voltvar_novars\":\n new_converter_control_setting_string += \"3\"\n if i.control_type.lower() == \"voltwatt\":\n new_converter_control_setting_string += \"5\"\n if i.control_type.lower() == \"watt_powerfactor\":\n new_converter_control_setting_string += \"6\"\n if i.control_type.lower() == \"powerfactor\":\n new_converter_control_setting_string += \"10\"\n\n new_converter_control_setting_string += \",\"\n if (\n i.control_type.lower() == \"voltvar_fixed_vars\"\n and i.var_injection is not None\n ):\n new_converter_control_setting_string += (\n str(i.var_injection) + \",2,\"\n ) # 2 is the code for the pecentage reactive power available\n else:\n new_converter_control_setting_string += \",,\"\n if (\n i.control_type.lower() == \"voltvar_watts_over_vars\"\n or i.control_type.lower() == \"voltvar_vars_over_watts\"\n ) and i.voltvar_curve is not None:\n new_converter_control_setting_string += (\n i.voltvar_curve + \",,\"\n )\n elif (\n i.control_type.lower() == \"voltwatt\"\n and i.voltwatt_curve is not None\n ):\n new_converter_control_setting_string += (\n i.voltwatt_curve + \",0,\"\n ) # 0 is the code for using the active power rating\n elif (\n i.control_type.lower() == \"watt_powerfactor\"\n and i.watt_powerfactor_curve is not None\n ):\n new_converter_control_setting_string += (\n i.watt_powerfactor_curve + \",0,\"\n ) # 0 is the code for using the active power rating\n else:\n new_converter_control_setting_string += \",,\"\n else:\n new_converter_control_setting_string += \"10\" + \",\" * 5\n\n if new_converter_string != \"\":\n converter_string_list.append(new_converter_string)\n if new_converter_control_setting_string != \"\":\n converter_control_string_list.append(\n new_converter_control_setting_string\n )\n\n if new_bess_setting_string != \"\":\n bess_settings_string_list.append(new_bess_setting_string)\n\n # If we get a Photovoltaic object\n\n if isinstance(i, Photovoltaic):\n new_converter_string = \"\"\n new_converter_control_setting_string = \"\"\n new_pv_setting_string = \"\"\n new_dg_generation_string = \"\"\n if (\n hasattr(i, \"name\")\n and i.name is not None\n and hasattr(i, \"connecting_element\")\n and i.connecting_element is not None\n and (\n i.connecting_element in model.model_names\n or \"load_\" + i.connecting_element in model.model_names\n )\n ):\n new_section_ID = \"{f}_{t}\".format(\n f=i.connecting_element, t=i.name\n )\n if len(new_section_ID) > 64:\n hasher = hashlib.sha1()\n hasher.update(new_section_ID.encode(\"utf-8\"))\n new_section_ID = hasher.hexdigest()\n\n new_section = (\n new_section_ID\n + \",{f},0,{t},0,\".format( # Assume only one index for the load connection point\n f=i.connecting_element, t=i.name\n )\n )\n\n new_node_string = \"{n}\".format(n=i.name)\n if hasattr(i, \"positions\") and i.positions is not None:\n try:\n new_node_string += \",\" + str(i.positions[0].long)\n except:\n new_node_string += \",0\"\n pass\n\n try:\n new_node_string += \",\" + str(i.positions[0].lat)\n except:\n new_node_string += \",0\"\n pass\n else:\n new_node_string += \",0,0\"\n self.node_string_list.append(new_node_string)\n\n phases = \"\"\n for phase in i.phases:\n if phase.default_value in [\"A\", \"B\", \"C\"]:\n new_section += phase.default_value\n phases += phase.default_value\n self.section_line_list.append(new_section)\n if hasattr(i, \"feeder_name\") and i.feeder_name is not None:\n if i.feeder_name in self.section_line_feeder_mapping:\n self.section_line_feeder_mapping[i.feeder_name].append(\n new_section\n )\n else:\n self.section_line_feeder_mapping[i.feeder_name] = [\n new_section\n ]\n\n if hasattr(i, \"feeder_name\") and i.feeder_name is not None:\n if i.feeder_name in self.section_feeder_mapping:\n self.section_feeder_mapping[i.feeder_name].append(\n new_section_ID\n )\n else:\n self.section_feeder_mapping[i.feeder_name] = [\n new_section_ID\n ]\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n ):\n self.section_headnode_mapping[\n i.feeder_name\n ] = i.substation_name\n\n new_converter_string += (\n new_section_ID + \",45,\"\n ) # 45 is the CYME code for PV devices\n new_converter_control_setting_string += (\n new_section_ID + \",45,0,0,\"\n ) # The controlindex and timetrigger indices are both zero\n new_pv_setting_string += (\n new_section_ID + \",M,\" + new_section_ID + \",DEFAULT,\"\n ) # Use the default CYME PV configuration for the moment.\n new_dg_generation_string += new_section_ID + \"45,DEFAULT,\"\n # DGGENERATIONMODEL is not included as this just sets the LoadModelName which is DEFAULT\n\n if hasattr(i, \"rated_power\") and i.rated_power is not None:\n panel_area = math.ceil(\n i.rated_power / 1000 / 0.08\n ) # Each panel produces 0.08 kw\n num_x, num_y = self.smallest_perimeter(panel_area)\n if min(num_x, num_y) == 1:\n num_x, num_y = self.smallest_perimeter(\n panel_area + 1\n ) # if area is prime\n new_pv_setting_string += str(num_x) + \",\" + str(num_y) + \",\"\n elif (\n hasattr(i, \"active_rating\") and i.active_rating is not None\n ):\n panel_area = math.ceil(\n i.active_rating / 1.1 / 1000 / 0.08\n ) # Each panel produces 0.08 kw. Assume 10% inverter oversize\n num_x, num_y = self.smallest_perimeter(panel_area)\n if min(num_x, num_y) == 1:\n num_x, num_y = self.smallest_perimeter(\n panel_area + 1\n ) # if area is prime\n new_pv_setting_string += str(num_x) + \",\" + str(num_y) + \",\"\n else:\n new_pv_setting_string += (\n \",,\" # This will produce garbage output power\n )\n\n if hasattr(i, \"temperature\") and i.temperature is not None:\n new_pv_setting_string += str(i.temperature)\n\n new_pv_setting_string += \",\" + phases\n\n if hasattr(i, \"active_rating\") and i.active_rating is not None:\n if (\n hasattr(i, \"reactive_rating\")\n and i.reactive_rating is not None\n ):\n new_converter_string += (\n str(\n math.sqrt(\n i.reactive_rating ** 2\n + i.active_rating ** 2\n )\n / 1000.0\n )\n + \",\"\n )\n else:\n new_converter_string += (\n str(i.active_rating / 1000.0) + \",\"\n )\n new_converter_string += str(i.active_rating / 1000.0) + \",\"\n elif hasattr(i, \"rated_power\") and i.rated_power is not None:\n if (\n hasattr(i, \"reactive_rating\")\n and i.reactive_rating is not None\n ):\n new_converter_string += (\n str(\n math.sqrt(\n i.reactive_rating ** 2\n + (i.rated_power * 1.1) ** 2\n )\n / 1000.0\n )\n + \",\"\n )\n else:\n new_converter_string += (\n str(i.rated_power * 1.1 / 1000.0) + \",\"\n )\n new_converter_string += (\n str(i.rated_power * 1.1 / 1000.0) + \",\"\n ) # Default value sets inverter to be oversized by 10%\n else:\n new_converter_string += \",,\"\n\n if (\n hasattr(i, \"reactive_rating\")\n and i.reactive_rating is not None\n ):\n new_converter_string += (\n str(i.reactive_rating / 1000.0) + \",\"\n )\n elif hasattr(i, \"rated_power\") and i.rated_power is not None:\n new_converter_string += (\n str(i.rated_power * 1.1 / 1000.0) + \",\"\n ) # Default value sets inverter to be oversized by 10% and active=reactive\n else:\n new_converter_string += \",\"\n\n if hasattr(i, \"rated_power\") and i.rated_power is not None:\n new_dg_generation_string += str(i.rated_power / 1000.0)\n elif hasattr(i, \"rated_power\") and i.rated_power is not None:\n new_dg_generation_string += str(i.rated_power / 1000.0)\n new_dg_generation_string += \",\"\n if (\n hasattr(i, \"min_powerfactor\")\n and i.min_powerfactor is not None\n ):\n new_converter_string += str(i.powerfactor * 100)\n new_dg_generation_string += str(i.powerfactor * 100)\n new_dg_generation_string += \",\"\n new_converter_string += \",\"\n if hasattr(i, \"fall_limit\") and i.fall_limit is not None:\n new_converter_string += str(i.fall_limit)\n new_converter_string += \",\"\n if hasattr(i, \"rise_limit\") and i.rise_limit is not None:\n new_converter_string += str(i.rise_limit)\n new_converter_string += \",\"\n if (hasattr(i, \"fall_limit\") and i.fall_limit is not None) or (\n hasattr(i, \"rise_limit\") and i.rise_limit is not None\n ):\n new_converter_string += \"0\" # Using units of % per minute\n\n if hasattr(i, \"control_type\") and i.control_type is not None:\n if (\n i.control_type.lower() == \"voltvar_vars_over_watts\"\n or i.control_type.lower() == \"voltvar\"\n ): # use default voltvar curve in cyme\n new_converter_control_setting_string += \"1\"\n if i.control_type.lower() == \"voltvar_watts_over_vars\":\n new_converter_control_setting_string += \"0\"\n if i.control_type.lower() == \"voltvar_fixed_vars\":\n new_converter_control_setting_string += \"2\"\n if i.control_type.lower() == \"voltvar_novars\":\n new_converter_control_setting_string += \"3\"\n if i.control_type.lower() == \"voltwatt\":\n new_converter_control_setting_string += \"5\"\n if i.control_type.lower() == \"watt_powerfactor\":\n new_converter_control_setting_string += \"6\"\n if i.control_type.lower() == \"powerfactor\":\n new_converter_control_setting_string += \"10\"\n\n new_converter_control_setting_string += \",\"\n if (\n i.control_type.lower() == \"voltvar_fixed_vars\"\n and i.var_injection is not None\n ):\n new_converter_control_setting_string += (\n str(i.var_injection) + \",2,\"\n ) # 2 is the code for the pecentage reactive power available\n else:\n new_converter_control_setting_string += \",,\"\n if (\n i.control_type.lower() == \"voltvar_watts_over_vars\"\n or i.control_type.lower() == \"voltvar_vars_over_watts\"\n ) and i.voltvar_curve is not None:\n new_converter_control_setting_string += (\n i.voltvar_curve + \",,\"\n )\n elif (\n i.control_type.lower() == \"voltwatt\"\n and i.voltwatt_curve is not None\n ):\n new_converter_control_setting_string += (\n i.voltwatt_curve + \",0,\"\n ) # 0 is the code for using the active power rating\n elif (\n i.control_type.lower() == \"watt_powerfactor\"\n and i.watt_powerfactor_curve is not None\n ):\n new_converter_control_setting_string += (\n i.watt_powerfactor_curve + \",0,\"\n ) # 0 is the code for using the active power rating\n else:\n new_converter_control_setting_string += \",,\"\n\n if (\n i.control_type.lower() == \"powerfactor\"\n and i.powerfactor is not None\n ):\n new_converter_control_setting_string += str(\n i.powerfactor\n )\n else:\n new_converter_control_setting_string += (\n \"10,,,,,100\" # Use Powerfactor as default\n )\n\n if (\n hasattr(i, \"timeseries\")\n and i.timeseries is not None\n and len(i.timeseries) > 0\n and i.timeseries[0].data_label is not None\n and i.timeseries[0].data_location is not None\n ):\n new_pv_setting_string += \",0,{loc}\".format(\n loc=i.timeseries[0].data_label\n )\n self.irradiance_profiles[\n i.timeseries[0].data_label\n ] = i.timeseries[0].data_location\n else:\n new_pv_setting_string += \",1,\"\n\n else:\n if hasattr(i, \"name\"):\n logger.warning(\n \"PV \"\n + i.name\n + \" was not connected and has not been written to CYME\"\n )\n else:\n logger.warning(\"PV element is unnamed\")\n\n if new_converter_string != \"\":\n converter_string_list.append(new_converter_string)\n if new_converter_control_setting_string != \"\":\n converter_control_string_list.append(\n new_converter_control_setting_string\n )\n if new_pv_setting_string != \"\":\n pv_settings_string_list.append(new_pv_setting_string)\n if new_dg_generation_string != \"\":\n dg_generation_string_list.append(new_dg_generation_string)\n\n # If we get a Capacitor object\n #\n if isinstance(i, Capacitor):\n\n # Empty new capacitor string\n new_capacitor_line = \"\"\n new_capacitor_object_line = \"\"\n\n # Connecting element\n # We need to create a new section since there is no physical line connecting\n # capacitors to the rest of the feeder in DiTTo, but CYME needs a section for this\n new_section = None\n if (\n hasattr(i, \"name\")\n and i.name is not None\n and hasattr(i, \"connecting_element\")\n and i.connecting_element is not None\n ):\n try:\n new_section_ID = \"{f}_{t}\".format(\n f=i.connecting_element, t=i.name\n )\n if len(new_section_ID) > 64:\n hasher = hashlib.sha1()\n hasher.update(new_section_ID.encode(\"utf-8\"))\n new_section_ID = hasher.hexdigest()\n new_section = (\n new_section_ID\n + \",{f},0,{t},0,\".format( # assume only one connection point for capacitors\n f=i.connecting_element, t=i.name\n )\n )\n new_capacitor_line += new_section_ID\n if i.connecting_element not in self.nodeID_list:\n self.nodeID_list.append(i.connecting_element)\n self.node_string_list.append(\n \"{},0,0\".format(i.connecting_element)\n )\n if i.name not in self.nodeID_list:\n if hasattr(i, \"positions\") and i.positions is not None:\n try:\n X = i.positions[0].long\n Y = i.positions[0].lat\n except:\n X = 0\n Y = 0\n pass\n else:\n X = 0\n Y = 0\n self.nodeID_list.append(i.name)\n self.node_string_list.append(\n \"{name},{X},{Y}\".format(name=i.name, X=X, Y=Y)\n )\n if hasattr(i, \"feeder_name\") and i.feeder_name is not None:\n if i.feeder_name in self.section_feeder_mapping:\n self.section_feeder_mapping[i.feeder_name].append(\n new_section_ID\n )\n else:\n self.section_feeder_mapping[i.feeder_name] = [\n new_section_ID\n ]\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n ):\n self.section_headnode_mapping[\n i.feeder_name\n ] = i.substation_name\n except:\n continue\n\n # Connection type\n if hasattr(i, \"connection_type\") and i.connection_type is not None:\n try:\n new_capacitor_line += \",\" + i.connection_type\n except:\n new_capacitor_line += \",\"\n pass\n else:\n new_capacitor_line += \",\"\n\n # KVAR and Phase\n phases = []\n if (\n hasattr(i, \"phase_capacitors\")\n and i.phase_capacitors is not None\n ):\n total_var = 0\n one_var = 0\n switched_vars = {}\n # new_capacitor_line+=','\n for phase_capacitor in i.phase_capacitors:\n if (\n hasattr(phase_capacitor, \"phase\")\n and phase_capacitor.phase is not None\n ):\n phases.append(phase_capacitor.phase)\n if new_section is not None:\n new_section += str(phase_capacitor.phase)\n\n if (\n hasattr(phase_capacitor, \"var\")\n and phase_capacitor.var is not None\n ):\n total_var += phase_capacitor.var\n if (\n phase_capacitor.var is not None\n and phase_capacitor.phase is not None\n ):\n switched_vars[\n phase_capacitor.phase.upper()\n ] = phase_capacitor.var\n if \"A\" in switched_vars:\n new_capacitor_line += \",\" + str(\n switched_vars[\"A\"] * 10 ** -3\n )\n one_var = switched_vars[\"A\"]\n else:\n new_capacitor_line += \",\"\n if \"B\" in switched_vars:\n new_capacitor_line += \",\" + str(\n switched_vars[\"B\"] * 10 ** -3\n )\n one_var = switched_vars[\"B\"]\n else:\n new_capacitor_line += \",\"\n if \"C\" in switched_vars:\n new_capacitor_line += \",\" + str(\n switched_vars[\"C\"] * 10 ** -3\n )\n one_var = switched_vars[\"C\"]\n else:\n new_capacitor_line += \",\"\n if total_var > 0:\n new_capacitor_object_line += str(one_var * 10 ** -3) + \",\"\n else:\n new_capacitor_object_line += \",\"\n pass\n\n # KV\n if hasattr(i, \"nominal_voltage\") and i.nominal_voltage is not None:\n try:\n if len(phases) == 1:\n new_capacitor_line += \",\" + str(\n i.nominal_voltage * 10 ** -3\n )\n new_capacitor_object_line += (\n str(i.nominal_voltage * 10 ** -3) + \",\"\n )\n else:\n new_capacitor_line += \",\" + str(\n i.nominal_voltage * 10 ** -3 / math.sqrt(3)\n )\n new_capacitor_object_line += (\n str(i.nominal_voltage * 10 ** -3 / math.sqrt(3))\n + \",\"\n )\n except:\n new_capacitor_line += \",\"\n new_capacitor_object_line += \",\"\n pass\n\n if hasattr(i, \"mode\") and i.mode is not None:\n if i.mode.lower() == \"currentFlow\":\n new_capacitor_line += \",2\"\n elif i.mode.lower() == \"voltage\":\n new_capacitor_line += \",1\"\n elif i.mode.lower() == \"activepower\":\n new_capacitor_line += \",4\"\n elif i.mode.lower() == \"reactivepower\":\n new_capacitor_line += \",7\"\n elif i.mode.lower() == \"timescheduled\":\n new_capacitor_line += \",6\"\n else:\n new_capacitor_line += \",0\"\n else:\n new_capacitor_line += \",\"\n\n if hasattr(i, \"low\") and i.low is not None:\n new_capacitor_line += (\n \",\" + str(i.low) + \",\" + str(i.low) + \",\" + str(i.low)\n )\n else:\n new_capacitor_line += \",,,\"\n\n if hasattr(i, \"high\") and i.high is not None:\n new_capacitor_line += (\n \",\" + str(i.high) + \",\" + str(i.high) + \",\" + str(i.high)\n )\n else:\n new_capacitor_line += \",,,\"\n\n found = False\n for k, d in self.capcodes.items():\n if d == new_capacitor_object_line:\n new_capacitor_line += (\n \",\" + new_section_ID + \",capacitor_\" + str(k)\n )\n found = True\n if not found:\n ID_cap += 1\n self.capcodes[ID_cap] = new_capacitor_object_line\n new_capacitor_line += (\n \",\" + new_section_ID + \",capacitor_\" + str(ID_cap)\n )\n\n new_capacitor_line += \",S,0\" # Location and ConnectionStatus\n\n if new_capacitor_line != \"\":\n capacitor_string_list.append(new_capacitor_line)\n\n if new_section is not None:\n self.section_line_list.append(new_section)\n # If the object is inside of a substation...\n if hasattr(i, \"is_substation\") and i.is_substation == 1:\n # ...it should have the name of the substation specified in the 'substation_name' attribute\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n and i.substation_name != \"\"\n ):\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\n ff_name = \"substation_{}\".format(i.substation_name)\n self.network_have_substations = True\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\n elif (\n hasattr(i, \"feeder_name\")\n and i.feeder_name is not None\n and i.feeder_name != \"\"\n ):\n ff_name = i.feeder_name\n\n if ff_name in self.section_line_feeder_mapping:\n self.section_line_feeder_mapping[ff_name].append(\n new_section\n )\n else:\n self.section_line_feeder_mapping[ff_name] = [new_section]\n\n # If we get a Regulator\n #\n if isinstance(i, Regulator) and not (\n hasattr(i, \"ltc\") and i.ltc is not None and i.ltc\n ):\n\n new_regulator_string = \"\"\n new_regulator_object_line = \"\"\n\n # We need to get bus1 and bus2 to create the section bus1_bus2\n new_section = None\n new_section_ID = None\n if (\n hasattr(i, \"from_element\")\n and i.from_element is not None\n and hasattr(i, \"to_element\")\n and i.to_element is not None\n ):\n # try:\n from_index = 0\n to_index = 0\n if (\n hasattr(i, \"from_element_connection_index\")\n and i.from_element_connection_index is not None\n ):\n from_index = i.from_element_connection_index\n if (\n hasattr(i, \"to_element_connection_index\")\n and i.to_element_connection_index is not None\n ):\n to_index = i.to_element_connection_index\n new_section_ID = \"{f}_{t}\".format(\n f=i.from_element, t=i.to_element\n )\n if len(new_section_ID) > 64:\n hasher = hashlib.sha1()\n hasher.update(new_section_ID.encode(\"utf-8\"))\n new_section_ID = hasher.hexdigest()\n new_section = new_section_ID + \",{f},{fi},{t},{ti},\".format(\n f=i.from_element, fi=from_index, t=i.to_element, ti=to_index\n )\n if hasattr(i, \"feeder_name\") and i.feeder_name is not None:\n if i.feeder_name in self.section_feeder_mapping:\n self.section_feeder_mapping[i.feeder_name].append(\n new_section_ID\n )\n else:\n self.section_feeder_mapping[i.feeder_name] = [\n new_section_ID\n ]\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n ):\n self.section_headnode_mapping[\n i.feeder_name\n ] = i.substation_name\n # except:\n # pass\n\n # If we have a regulator with two windings that have different\n # voltages, we create a new section and a new transformer connected to it\n # in order to have the voltage change\n winding1 = None\n winding2 = None\n from_element = None\n to_element = None\n from_index = 0\n to_index = 0\n windings_local = []\n if hasattr(i, \"windings\") and i.windings is not None:\n if (\n len(i.windings) >= 2\n and hasattr(i.windings[0], \"nominal_voltage\")\n and hasattr(i.windings[1], \"nominal_voltage\")\n and i.windings[0].nominal_voltage is not None\n and i.windings[1].nominal_voltage is not None\n ):\n winding1 = i.windings[0]\n winding2 = i.windings[1]\n if (\n hasattr(i, \"from_element\")\n and i.from_element is not None\n and hasattr(i, \"to_element\")\n and i.to_element is not None\n ):\n from_element = i.from_element\n to_element = i.to_element\n\n if (\n hasattr(i, \"from_element_connection_index\")\n and i.from_element_connection_index is not None\n ):\n from_index = i.from_element_connection_index\n if (\n hasattr(i, \"to_element_connection_index\")\n and i.to_element_connection_index is not None\n ):\n to_index = i.to_element_connection_index\n if winding1 is not None and winding2 is not None:\n windings_local = [winding1, winding2]\n if winding1.nominal_voltage != winding2.nominal_voltage:\n new_trans_sectionID = \"{f}_{t}\".format(\n f=from_element, t=to_element + \"_reg\"\n )\n if len(new_trans_sectionID) > 64:\n hasher = hashlib.sha1()\n hasher.update(new_trans_sectionID.encode(\"utf-8\"))\n new_trans_sectionID = hasher.hexdigest()\n new_trans_section = (\n new_trans_sectionID\n + \",{f},{fi},{t},{ti},\".format(\n f=from_element,\n fi=from_index,\n t=to_element + \"_reg\",\n ti=to_index,\n )\n )\n new_section_ID = \"{f}_{t}\".format(\n f=to_element + \"_reg\", t=to_element\n )\n if len(new_section_ID) > 64:\n hasher = hashlib.sha1()\n hasher.update(new_section_ID.encode(\"utf-8\"))\n new_section_ID = hasher.hexdigest()\n new_section = new_section_ID + \",{f},{fi},{t},{ti},\".format(\n f=to_element + \"_reg\",\n fi=from_index,\n t=to_element,\n ti=to_index,\n )\n if hasattr(i, \"feeder_name\") and i.feeder_name is not None:\n if i.feeder_name in self.section_feeder_mapping:\n self.section_feeder_mapping[i.feeder_name].append(\n new_section_ID\n )\n else:\n self.section_feeder_mapping[i.feeder_name] = [\n new_section_ID\n ]\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n ):\n self.section_headnode_mapping[\n i.feeder_name\n ] = i.substation_name\n self.nodeID_list.append(to_element + \"_reg\")\n self.node_string_list.append(\n \"{},0,0\".format(to_element + \"_reg\")\n )\n new_transformer_line = \"\"\n new_transformer_object_line = \"\"\n phase_on = \"\"\n if (\n hasattr(winding1, \"phase_windings\")\n and winding1.phase_windings is not None\n ):\n for phase_winding in winding1.phase_windings:\n if new_trans_section is not None:\n if (\n hasattr(phase_winding, \"phase\")\n and phase_winding.phase is not None\n ):\n new_trans_section += str(\n phase_winding.phase\n )\n phase_on += str(phase_winding.phase)\n\n if (\n new_trans_section is not None\n and new_trans_section not in self.section_line_list\n ):\n self.section_line_list.append(new_trans_section)\n # If the object is inside of a substation...\n if hasattr(i, \"is_substation\") and i.is_substation == 1:\n # ...it should have the name of the substation specified in the 'substation_name' attribute\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n and i.substation_name != \"\"\n ):\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\n ff_name = \"substation_{}\".format(\n i.substation_name\n )\n self.network_have_substations = True\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\n elif (\n hasattr(i, \"feeder_name\")\n and i.feeder_name is not None\n and i.feeder_name != \"\"\n ):\n ff_name = i.feeder_name\n\n if ff_name in self.section_line_feeder_mapping:\n self.section_line_feeder_mapping[ff_name].append(\n new_section\n )\n else:\n self.section_line_feeder_mapping[ff_name] = [\n new_section\n ]\n\n if (\n hasattr(winding1, \"phase_windings\")\n and winding1.phase_windings is not None\n ):\n try:\n if len(winding1.phase_windings) == 1:\n TYPE = 1\n elif len(winding1.phase_windings) == 3:\n TYPE = 2\n else:\n TYPE = 3\n except:\n TYPE = 3\n pass\n else:\n TYPE = 3\n\n try:\n new_transformer_line += new_trans_sectionID\n except:\n pass\n\n # CoordX and CoordY\n if hasattr(i, \"positions\") and i.positions is not None:\n try:\n new_transformer_line += \",\" + str(\n i.positions[0].long\n )\n new_transformer_line += \",\" + str(\n i.positions[0].lat\n )\n except:\n new_transformer_line += \",,\"\n pass\n\n CONN = \"\"\n try:\n new_transformer_line += (\n \",\"\n + self.transformer_connection_configuration_mapping(\n winding1.connection_type,\n winding2.connection_type,\n \"transformer_settings\",\n )\n )\n CONN = self.transformer_connection_configuration_mapping(\n winding1.connection_type, winding2.connection_type\n )\n except:\n new_transformer_line += \",\"\n pass\n\n phase_shift = 0\n if CONN == \"0\" or CONN == \"4\":\n phase_shift = 0\n if CONN == \"1\" or CONN == \"2\":\n phase_shift = 1\n\n try:\n new_transformer_line += \",\" + phase_on\n except:\n new_transformer_line += \",\"\n pass\n\n if (\n hasattr(winding1, \"resistance\")\n and hasattr(winding2, \"resistance\")\n and winding1.resistance is not None\n and winding2.resistance is not None\n ):\n # Resistance is given as a percentage of the KVA of the corresponding winding\n try:\n RH = (\n winding1.resistance\n * 10 ** -2\n * winding1.rated_power\n * 10 ** -3\n )\n RL = (\n winding2.resistance\n * 10 ** -2\n * winding2.rated_power\n * 10 ** -3\n )\n except:\n RH = 0\n RL = 0\n pass\n\n # We have ZHL=(RH+RL)+XHLj\n #\n # Compute the X over R ratio\n try:\n XR = (XHL) / (RH + RL)\n XR0 = XR\n except:\n XR = 0\n XR0 = 0\n pass\n #\n # |ZHL|=sqrt((RH+RL)^2 + XHL^2)\n try:\n _ZHL_ = math.sqrt((RH + RL) ** 2 + XHL ** 2)\n except:\n _ZHL_ = 0\n pass\n\n #\n # Expressed in percentage of the KVA base\n try:\n Z1 = _ZHL_ * 100.0 / (winding1.rated_power * 10 ** -3)\n except:\n Z1 = 0\n pass\n Z0 = Z1\n\n # Total kva\n try:\n KVA = windings_local[0].rated_power\n except:\n pass\n\n for w, winding in enumerate(windings_local):\n\n if hasattr(winding, \"nominal_voltage\"):\n try:\n if w == 0:\n KVLLprim = (\n winding.nominal_voltage * 10 ** -3\n )\n if transformer_object.is_center_tap == True:\n KVLLprim = round(\n KVLLprim / (3 ** 0.5), 2\n ) # produces output in L-N format if center-tap rather than L-L\n VoltageUnit = (\n 1 # Voltage declared in KV, not in KVLL\n )\n elif w == 1:\n KVLLsec = winding.nominal_voltage * 10 ** -3\n VoltageUnit = (\n 1 # Voltage declared in KV, not in KVLL\n )\n except:\n pass\n # NoLoadLosses\n if (\n hasattr(i, \"noload_loss\")\n and i.noload_loss is not None\n ):\n # TODO: Make sure noloadlosses is in % in DiTTo, or change what is next.\n NoLoadLosses = i.noload_loss / 100.0 * KVA\n else:\n NoLoadLosses = \"\"\n\n new_transformer_object_line += \"{type},{kva},{voltageunit},{kvllprim},{kvllsec},{Z1},{Z0},{XR},{XR0},{Conn},{WindingType},{noloadloss},{phaseshift},{isltc}\".format(\n type=TYPE,\n kva=KVA,\n voltageunit=VoltageUnit,\n kvllprim=KVLLprim,\n kvllsec=KVLLsec,\n Conn=CONN,\n Z1=Z1,\n Z0=Z0,\n XR=XR,\n XR0=XR0,\n WindingType=1,\n noloadloss=NoLoadLosses,\n phaseshift=phase_shift,\n isltc=0,\n )\n\n found = False\n for k, d in self.two_windings_trans_codes.items():\n if d == new_transformer_object_line:\n new_transformer_line += (\n \",transformer_\"\n + str(k)\n + \",transformer_\"\n + str(k)\n )\n found = True\n if not found:\n ID_trans += 1\n self.two_windings_trans_codes[\n ID_trans\n ] = new_transformer_object_line\n new_transformer_line += (\n \",transformer_\"\n + str(ID_trans)\n + \",transformer_\"\n + str(ID_trans)\n )\n\n new_transformer_line += \",{PhaseShiftType},M,100,100,None,0\".format(\n PhaseShiftType=phase_shift\n ) # Phase shift, Location, PrimTap,SecondaryTap, ODPrimPh, and ConnectionStatus\n\n if new_transformer_line != \"\":\n two_windings_transformer_string_list.append(\n new_transformer_line\n )\n\n if hasattr(winding1, \"phase_windings\"):\n for phase_winding in winding1.phase_windings:\n try:\n new_section += str(phase_winding.phase)\n except:\n pass\n\n if (\n new_section is not None\n and new_section not in self.section_line_list\n ):\n self.section_line_list.append(new_section)\n # If the object is inside of a substation...\n if hasattr(i, \"is_substation\") and i.is_substation == 1:\n # ...it should have the name of the substation specified in the 'substation_name' attribute\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n and i.substation_name != \"\"\n ):\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\n ff_name = \"substation_{}\".format(i.substation_name)\n self.network_have_substations = True\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\n elif (\n hasattr(i, \"feeder_name\")\n and i.feeder_name is not None\n and i.feeder_name != \"\"\n ):\n ff_name = i.feeder_name\n\n if ff_name in self.section_line_feeder_mapping:\n self.section_line_feeder_mapping[ff_name].append(\n new_section\n )\n else:\n self.section_line_feeder_mapping[ff_name] = [new_section]\n\n try:\n new_regulator_string += new_section_ID\n except:\n pass\n\n # CoordX and CoordY\n if hasattr(i, \"positions\") and i.positions is not None:\n try:\n new_regulator_string += \",\" + str(i.positions[0].long)\n new_regulator_string += \",\" + str(i.positions[0].lat)\n except:\n new_regulator_string += \",,\"\n pass\n else:\n new_regulator_string += \",,\"\n\n # if hasattr(i, \"pt_phase\") and i.pt_phase is not None:\n # try:\n # new_regulator_string += \",\" + str(i.pt_phase)\n # except:\n # new_regulator_string += \",\"\n # pass\n # else:\n # new_regulator_string += \",\"\n\n _KVA = 0\n _KVLN = 0\n _Rset = {\"A\": 0, \"B\": 0, \"C\": 0}\n _Xset = {\"A\": 0, \"B\": 0, \"C\": 0}\n _regphases = []\n if len(windings_local) >= 2:\n try:\n _KVA = windings_local[0].rated_power * 10 ** -3\n except:\n pass\n _KVLN = (\n windings_local[-1].nominal_voltage / math.sqrt(3) * 10 ** -3\n )\n\n if (\n hasattr(winding1, \"phase_windings\")\n and winding1.phase_windings is not None\n ):\n for phase_winding in winding1.phase_windings:\n try:\n _regphases.append(phase_winding.phase)\n _Rset[\n phase_winding.phase\n ] = phase_winding.compensator_r\n _Xset[\n phase_winding.phase\n ] = phase_winding.compensator_x\n except:\n pass\n\n new_regulator_string += \",\"\n for phase in _regphases:\n new_regulator_string += phase\n\n _band = None\n if hasattr(i, \"bandwidth\") and i.bandwidth is not None:\n try:\n new_regulator_string += \",\" + str(i.bandwidth)\n _band = str(i.bandwidth)\n except:\n new_regulator_string += \",\"\n pass\n else:\n new_regulator_string += \",\"\n\n _CT = None\n if hasattr(i, \"ct_ratio\") and i.ct_ratio is not None:\n try:\n new_regulator_string += \",\" + str(i.ct_ratio)\n _CT = str(i.ct_ratio)\n except:\n new_regulator_string += \",\"\n else:\n new_regulator_string += \",\"\n\n _PT = None\n if hasattr(i, \"pt_ratio\") and i.pt_ratio is not None:\n try:\n new_regulator_string += \",\" + str(i.pt_ratio)\n _PT = str(i.pt_ratio)\n except:\n new_regulator_string += \",\"\n else:\n new_regulator_string += \",\"\n\n if hasattr(i, \"setpoint\") and i.setpoint is not None:\n scaled_setpoint = i.setpoint * 120 / 100.0\n try:\n new_regulator_string += (\n \",\"\n + str(scaled_setpoint)\n + \",\"\n + str(scaled_setpoint)\n + \",\"\n + str(scaled_setpoint)\n ) # Assume same setpoint on all phases\n except:\n new_regulator_string += \",,,\"\n else:\n new_regulator_string += \",,,\"\n\n new_regulator_object_line = \"{kva},{band},{ct},{pt},{Type},{KVLN},{MaxBuck},{MaxBoost},{Taps},{Reversible}\".format(\n kva=_KVA,\n band=_band,\n ct=_CT,\n pt=_PT,\n Type=0,\n KVLN=_KVLN,\n MaxBuck=10,\n MaxBoost=10,\n Taps=32,\n Reversible=0,\n )\n\n found = False\n for k, d in self.reg_codes.items():\n if d == new_regulator_object_line:\n new_regulator_string += \",regulator_{id},{secid}\".format(\n id=k, secid=new_section_ID\n )\n found = True\n if not found:\n ID_reg += 1\n self.reg_codes[ID_reg] = new_regulator_object_line\n new_regulator_string += \",regulator_{id},{secid}\".format(\n id=ID_reg, secid=new_section_ID\n )\n\n # Location, MaxBuck, MaxBoost, SettingOption, RsetA, RsetB, RsetC, XsetA,\n # XsetB, XsetC, TapA, TapB, TapC, and ConnectionStatus\n new_regulator_string += \",M,10,10,T,{RsetA},{RsetB},{RsetC},{XsetA},{XsetB},{XsetC},0,0,0,0\".format(\n RsetA=_Rset[\"A\"],\n RsetB=_Rset[\"B\"],\n RsetC=_Rset[\"C\"],\n XsetA=_Xset[\"A\"],\n XsetB=_Xset[\"B\"],\n XsetC=_Xset[\"C\"],\n )\n\n if new_regulator_string != \"\":\n regulator_string_list.append(new_regulator_string)\n\n # If we get a Transformer object\n #\n if (\n isinstance(i, PowerTransformer)\n and (i.name not in self.transformers_to_ignore)\n ) or (\n isinstance(i, Regulator)\n and (hasattr(i, \"ltc\") and i.ltc is not None and i.ltc == 1)\n ):\n\n transformer_object = i\n\n # These are only set if it's an LTC\n Setpoint = \"\"\n ControlType = \"\"\n LowerBandwidth = \"\"\n UpperBandwidth = \"\"\n MaxBoost = \"\"\n MaxBuck = \"\"\n is_ltc = 0\n if isinstance(i, Regulator):\n is_ltc = 1\n Setpoint = i.setpoint\n if hasattr(i, \"connected_transformer\"):\n transformer_object = model[i.connected_transformer]\n ControlType = \"0\"\n else:\n raise ValueError(\n \"An LTC regulator needs a connecting transformer\"\n )\n\n # We need to get bus1 and bus2 to create the section bus1_bus2\n new_section = None\n new_section_ID = None\n if (\n hasattr(transformer_object, \"from_element\")\n and transformer_object.from_element is not None\n and hasattr(transformer_object, \"to_element\")\n and transformer_object.to_element is not None\n ):\n from_index = 0\n to_index = 0\n if (\n hasattr(transformer_object, \"from_element_connection_index\")\n and transformer_object.from_element_connection_index\n is not None\n ):\n from_index = (\n transformer_object.from_element_connection_index\n )\n if (\n hasattr(transformer_object, \"to_element_connection_index\")\n and transformer_object.to_element_connection_index\n is not None\n ):\n to_index = transformer_object.to_element_connection_index\n\n new_section_ID = \"{f}_{t}\".format(\n f=transformer_object.from_element,\n t=transformer_object.to_element,\n )\n\n if len(new_section_ID) > 64:\n hasher = hashlib.sha1()\n hasher.update(new_section_ID.encode(\"utf-8\"))\n new_section_ID = hasher.hexdigest()\n new_section = new_section_ID + \",{f},{fi},{t},{ti},\".format(\n f=transformer_object.from_element,\n fi=from_index,\n t=transformer_object.to_element,\n ti=to_index,\n )\n # If it's a regulator, use the regulator object to find the feeder and substation if they're set\n if hasattr(i, \"feeder_name\") and i.feeder_name is not None:\n if i.feeder_name in self.section_feeder_mapping:\n self.section_feeder_mapping[i.feeder_name].append(\n new_section_ID\n )\n else:\n self.section_feeder_mapping[i.feeder_name] = [\n new_section_ID\n ]\n if (\n hasattr(i, \"substation_name\")\n and i.substation_name is not None\n ):\n self.section_headnode_mapping[\n i.feeder_name\n ] = i.substation_name\n\n # Set Regulator attributes if its an LTC\n\n if hasattr(i, \"bandwidth\") and i.bandwidth is not None:\n bandcenter = 0\n if hasattr(i, \"bandcenter\") and i.bandcenter is not None:\n bandcenter = i.bandcenter\n LowerBandwidth = str(abs(bandcenter - i.bandwidth))\n UpperBandwidth = str(abs(bandcenter + i.bandwidth))\n\n if hasattr(i, \"highstep\") and i.highstep is not None:\n MaxBoost = str(i.highstep)\n\n if hasattr(i, \"highstep\") and i.highstep is not None:\n MaxBuck = str(i.lowstep)\n\n # Find out if we have a two or three windings transformer\n if (\n hasattr(transformer_object, \"windings\")\n and transformer_object.windings is not None\n ):\n\n phase_on = \"\"\n if (\n hasattr(transformer_object.windings[0], \"phase_windings\")\n and transformer_object.windings[0].phase_windings\n is not None\n ):\n for phase_winding in transformer_object.windings[\n 0\n ].phase_windings:\n if new_section is not None:\n if (\n hasattr(phase_winding, \"phase\")\n and phase_winding.phase is not None\n ):\n new_section += str(phase_winding.phase)\n phase_on += str(phase_winding.phase)\n\n if (\n new_section is not None\n and new_section not in self.section_line_list\n ):\n self.section_line_list.append(new_section)\n # If the object is inside of a substation...\n if (\n hasattr(transformer_object, \"is_substation\")\n and transformer_object.is_substation == 1\n ):\n # ...it should have the name of the substation specified in the 'substation_name' attribute\n if (\n hasattr(transformer_object, \"substation_name\")\n and transformer_object.substation_name is not None\n and transformer_object.substation_name != \"\"\n ):\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\n ff_name = \"substation_{}\".format(\n transformer_object.substation_name\n )\n self.network_have_substations = True\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\n elif (\n hasattr(transformer_object, \"feeder_name\")\n and transformer_object.feeder_name is not None\n and transformer_object.feeder_name != \"\"\n ):\n ff_name = transformer_object.feeder_name\n\n if ff_name in self.section_line_feeder_mapping:\n self.section_line_feeder_mapping[ff_name].append(\n new_section\n )\n else:\n self.section_line_feeder_mapping[ff_name] = [\n new_section\n ]\n\n # Case 1: Two Windings\n #\n if (\n len(transformer_object.windings) == 2\n or transformer_object.is_center_tap == True\n ):\n # Empty new transformer string\n new_transformer_line = \"\"\n new_transformer_object_line = \"\"\n\n if (\n hasattr(\n transformer_object.windings[0], \"phase_windings\"\n )\n and transformer_object.windings[0].phase_windings\n is not None\n ):\n try:\n if (\n transformer_object.is_center_tap == True\n and len(\n transformer_object.windings[\n 0\n ].phase_windings\n )\n == 1\n ):\n TYPE = 4\n elif (\n len(\n transformer_object.windings[\n 0\n ].phase_windings\n )\n == 1\n ):\n TYPE = 1\n elif (\n len(\n transformer_object.windings[\n 0\n ].phase_windings\n )\n == 3\n ):\n TYPE = 2\n else:\n TYPE = 3\n except:\n TYPE = 3\n pass\n else:\n TYPE = 3\n\n try:\n new_transformer_line += new_section_ID\n except:\n pass\n\n # CoordX and CoordY\n if (\n hasattr(transformer_object, \"positions\")\n and transformer_object.positions is not None\n ):\n try:\n new_transformer_line += \",\" + str(\n transformer_object.positions[0].long\n )\n new_transformer_line += \",\" + str(\n transformer_object.positions[0].lat\n )\n except:\n new_transformer_line += \",,\"\n pass\n\n CONN = \"\"\n try:\n if TYPE == 4:\n CONN = \"0\" # Center Tap not a configuration for transformer object. Leave as Y-Y\n new_transformer_line += \",15\"\n else:\n new_transformer_line += (\n \",\"\n + self.transformer_connection_configuration_mapping(\n transformer_object.windings[\n 0\n ].connection_type,\n transformer_object.windings[\n 1\n ].connection_type,\n \"transformer_settings\",\n )\n )\n CONN = self.transformer_connection_configuration_mapping(\n transformer_object.windings[0].connection_type,\n transformer_object.windings[1].connection_type,\n )\n except:\n new_transformer_line += \",\"\n pass\n\n phase_shift = 0\n if CONN == \"0\" or CONN == \"4\":\n phase_shift = 0\n if CONN == \"1\" or CONN == \"2\":\n phase_shift = 1\n\n try:\n new_transformer_line += \",\" + phase_on\n except:\n new_transformer_line += \",\"\n pass\n\n # Compute the impedances of center tap transformers. These should be three windings, one phase transformers in DiTTo\n # with the is_center_tap flag set to 1\n if TYPE == 4:\n if (\n hasattr(transformer_object, \"reactances\")\n and transformer_object.reactances is not None\n and len(i.reactances) == 3\n ):\n XHL, XHT, XLT = transformer_object.reactances\n if (\n hasattr(\n transformer_object.windings[0], \"resistance\"\n )\n and hasattr(\n transformer_object.windings[1], \"resistance\"\n )\n and hasattr(\n transformer_object.windings[2], \"resistance\"\n )\n and transformer_object.windings[0].resistance\n is not None\n and transformer_object.windings[1].resistance\n is not None\n and transformer_object.windings[2].resistance\n is not None\n ):\n R0, R1, R2 = [\n w.resistance\n for w in transformer_object.windings\n ]\n KVA_BASE = (\n transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n XR, Z1 = self.get_center_tap_impedances(\n R0, R1, R2, XHL, XHT, XLT, KVA_BASE\n )\n XR0 = XR\n Z0 = Z1\n\n else:\n if (\n hasattr(transformer_object, \"reactances\")\n and transformer_object.reactances is not None\n and len(transformer_object.reactances) == 1\n ):\n XHL_perct = transformer_object.reactances[0]\n # XHL is in percentage of the KVA of the FIRST winding\n try:\n XHL = (\n XHL_perct\n * 10 ** -2\n * transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n except:\n XHL = 0\n pass\n\n if (\n hasattr(\n transformer_object.windings[0], \"resistance\"\n )\n and hasattr(\n transformer_object.windings[1], \"resistance\"\n )\n and transformer_object.windings[0].resistance\n is not None\n and transformer_object.windings[1].resistance\n is not None\n ):\n # Resistance is given as a percentage of the KVA of the corresponding winding\n try:\n RH = (\n transformer_object.windings[0].resistance\n * 10 ** -2\n * transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n RL = (\n transformer_object.windings[1].resistance\n * 10 ** -2\n * transformer_object.windings[1].rated_power\n * 10 ** -3\n )\n except:\n RH = 0\n RL = 0\n pass\n\n # We have ZHL=(RH+RL)+XHLj\n #\n # Compute the X over R ratio\n try:\n XR = (XHL) / (RH + RL)\n XR0 = XR\n except:\n XR = 0\n XR0 = 0\n pass\n #\n # |ZHL|=sqrt((RH+RL)^2 + XHL^2)\n try:\n _ZHL_ = math.sqrt((RH + RL) ** 2 + XHL ** 2)\n except:\n _ZHL_ = 0\n pass\n\n #\n # Expressed in percentage of the KVA base\n try:\n Z1 = (\n _ZHL_\n * 100.0\n / (\n transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n )\n except:\n Z1 = 0\n pass\n Z0 = Z1\n\n # Total kva\n try:\n KVA = (\n transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n except:\n KVA = \"DEFAULT\"\n pass\n\n for w, winding in enumerate(transformer_object.windings):\n # try:\n # KVA+=winding.rated_power*10**-3\n # except:\n # pass\n\n if hasattr(winding, \"nominal_voltage\"):\n # If we have a one phase transformer or a delta transformer, we specify voltage in KV, not in KVLL\n # This is done by setting the voltageUnit keyword to 1\n if (\n len(\n transformer_object.windings[\n 0\n ].phase_windings\n )\n <= 1\n or len(\n transformer_object.windings[\n 0\n ].phase_windings\n )\n == 2\n ):\n if w == 0:\n KVLLprim = (\n winding.nominal_voltage * 10 ** -3\n )\n # if transformer_object.is_center_tap == True:\n # KVLLprim = round(\n # KVLLprim / (3 ** 0.5), 2\n # ) # produces output in L-N format if center-tap rather than L-L\n voltageUnit = (\n 1 # Voltage declared in KV, not in KVLL\n )\n elif w == 1:\n # In addition, if we have a center tap, we need to add the secondary and tertiary voltages here\n if TYPE == 4:\n try:\n KVLLsec = (\n winding.nominal_voltage\n * 10 ** -3\n + transformer_object.windings[\n 2\n ].nominal_voltage\n * 10 ** -3\n )\n voltageUnit = 1 # Voltage declared in KV, not in KVLL\n except:\n KVLLsec = \"DEFAULT\"\n pass\n else:\n KVLLsec = (\n winding.nominal_voltage * 10 ** -3\n )\n voltageUnit = 1 # Voltage declared in KV, not in KVLL\n # If we have a three phase transformer, we need to specify the voltage in KVLL.\n # This is done by setting the voltageUnit to 0, and multiplying the voltage by sqrt(3)\n # Note: If we have three phases, the transformer shouln't be a center tap\n elif (\n len(\n transformer_object.windings[\n 0\n ].phase_windings\n )\n == 3\n ):\n if w == 0:\n KVLLprim = (\n winding.nominal_voltage * 10 ** -3\n ) # *math.sqrt(3)\n if transformer_object.is_center_tap == True:\n KVLLprim = round(\n KVLLprim / (3 ** 0.5), 2\n ) # produces output in L-N format if center-tap rather than L-L\n voltageUnit = 0\n if w == 1:\n KVLLsec = (\n winding.nominal_voltage * 10 ** -3\n ) # *math.sqrt(3)\n voltageUnit = 0\n\n # NoLoadLosses\n if (\n hasattr(transformer_object, \"noload_loss\")\n and transformer_object.noload_loss is not None\n ):\n # TODO: Make sure noloadlosses is in % in DiTTo, or change what is next.\n NOLOADLOSS = (\n transformer_object.noload_loss / 100.0 * KVA\n )\n else:\n NOLOADLOSS = \"\"\n\n new_transformer_object_line += \"{type},{kva},{voltageUnit},{kvllprim},{kvllsec},{Z1},{Z0},{XR},{XR0},{Conn},{WindingType},{noloadloss},{phaseshift},{isltc}\".format(\n phaseshift=phase_shift,\n type=TYPE,\n kva=KVA,\n voltageUnit=voltageUnit,\n kvllprim=KVLLprim,\n kvllsec=KVLLsec,\n Conn=CONN,\n Z1=Z1,\n Z0=Z0,\n XR=XR,\n XR0=XR0,\n WindingType=1,\n noloadloss=NOLOADLOSS,\n isltc=is_ltc,\n )\n\n found = False\n for k, d in self.two_windings_trans_codes.items():\n if d == new_transformer_object_line:\n new_transformer_line += (\n \",transformer_\" + str(k) + \",\" + new_section_ID\n )\n found = True\n if not found:\n ID_trans += 1\n self.two_windings_trans_codes[\n ID_trans\n ] = new_transformer_object_line\n new_transformer_line += (\n \",transformer_\"\n + str(ID_trans)\n + \",\"\n + new_section_ID\n )\n\n new_transformer_line += \",{PhaseShiftType},M,100,100,None,0\".format(\n PhaseShiftType=phase_shift\n ) # Phase shift, Location, PrimTap,SecondaryTap, ODPrimPh, and ConnectionStatus\n\n try:\n TAP = 1.0 / float(\n transformer_object.windings[1]\n .phase_windings[0]\n .tap_position\n )\n new_transformer_line += \",{}\".format(TAP)\n except:\n new_transformer_line += \",\"\n pass\n\n # Apply the LTC settings. These are empty if it's just a transformer\n new_transformer_line += \",{setpoint},{controltype},{lowerbandwidth},{upperbandwidth},{maxbuck},{maxboost}\".format(\n setpoint=Setpoint,\n controltype=ControlType,\n lowerbandwidth=LowerBandwidth,\n upperbandwidth=UpperBandwidth,\n maxbuck=MaxBuck,\n maxboost=MaxBoost,\n )\n\n if new_transformer_line != \"\":\n two_windings_transformer_string_list.append(\n new_transformer_line\n )\n\n # Case 2: Three Windings\n #\n elif len(transformer_object.windings) == 3:\n # Empty new transformer string\n new_transformer_line = \"\"\n new_transformer_object_line = \"\"\n\n # Name\n if (\n hasattr(transformer_object, \"name\")\n and transformer_object.name is not None\n ):\n try:\n new_transformer_line += new_section_ID\n except:\n pass\n\n # CoordX and CoordY\n if (\n hasattr(transformer_object, \"positions\")\n and transformer_object.positions is not None\n ):\n try:\n new_transformer_line += \",\" + str(\n transformer_object.positions[0].long\n )\n new_transformer_line += \",\" + str(\n transformer_object.positions[0].lat\n )\n except:\n new_transformer_line += \",,\"\n pass\n\n _primary_rated_capacity = None\n _secondary_rated_capacity = None\n _tertiary_rated_capacity = None\n _primary_voltage = None\n _secondary_voltage = None\n _tertiary_voltage = None\n _primary_connection = None\n _secondary_connection = None\n _tertiary_connection = None\n R = {}\n XHL_perct, XLT_perct, XHT_perct = None, None, None\n for w, winding in enumerate(transformer_object.windings):\n if (\n hasattr(winding, \"rated_power\")\n and winding.rated_power is not None\n ):\n if w == 0:\n _primary_rated_capacity = str(\n winding.rated_power * 10 ** -3\n )\n if w == 1:\n _secondary_rated_capacity = str(\n winding.rated_power * 10 ** -3\n )\n if w == 2:\n _tertiary_rated_capacity = str(\n winding.rated_power * 10 ** -3\n )\n\n if (\n hasattr(winding, \"connection_type\")\n and winding.connection_type is not None\n ):\n if w == 0:\n _primary_connection = winding.connection_type\n if w == 1:\n _secondary_connection = winding.connection_type\n if w == 2:\n _tertiary_connection = winding.connection_type\n\n if (\n hasattr(winding, \"nominal_voltage\")\n and winding.nominal_voltage is not None\n ):\n try:\n new_transformer_line += \",\" + str(\n winding.nominal_voltage * 10 ** -3\n )\n except:\n new_transformer_line += \",\"\n pass\n if w == 0:\n _primary_voltage = str(\n winding.nominal_voltage * 10 ** -3\n )\n if w == 1:\n _secondary_voltage = str(\n winding.nominal_voltage * 10 ** -3\n )\n if w == 2:\n _tertiary_voltage = str(\n winding.nominal_voltage * 10 ** -3\n )\n\n else:\n new_transformer_line += \",\"\n\n if (\n hasattr(winding, \"resistance\")\n and winding.resistance is not None\n ):\n try:\n R[w] = (\n winding.resistance\n * winding.rated_power\n * 10 ** -3\n )\n except:\n R[w] = None\n pass\n\n if (\n hasattr(transformer_object, \"reactances\")\n and i.reactances is not None\n ):\n try:\n XHL_perct, XLT_perct, XHT_perct = i.reactances\n except:\n pass\n\n if XHL_perct is not None:\n try:\n XHL = (\n XHL_perct\n * 10 ** -2\n * transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n except:\n XHL = None\n pass\n if XLT_perct is not None:\n try:\n XLT = (\n XLT_perct\n * 10 ** -2\n * transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n except:\n XLT = None\n pass\n if XHT_perct is not None:\n try:\n XHT = (\n XHT_perct\n * 10 ** -2\n * transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n except:\n XHT = None\n pass\n\n if (\n sum([x is None for x in R]) == 0\n and XHL is not None\n and XLT is not None\n and XHT is not None\n ):\n ZHL = complex(R[0] + R[1], XHL)\n ZLT = complex(R[1] + R[2], XLT)\n ZHT = complex(R[0] + R[2], XHT)\n\n _PrimaryToSecondaryXR1 = ZHL.imag / ZHL.real\n _PrimaryToSecondaryXR0 = _PrimaryToSecondaryXR1\n\n _PrimaryToTertiaryXR1 = ZHT.imag / ZHT.real\n _PrimaryToTertiaryXR0 = _PrimaryToTertiaryXR1\n\n _SecondaryToTertiaryXR1 = ZLT.imag / ZLT.real\n _SecondaryToTertiaryXR0 = _SecondaryToTertiaryXR1\n\n _PrimaryToSecondaryZ1 = (\n math.sqrt(ZHL.real ** 2 + ZHL.imag ** 2)\n * 100.0\n / (\n transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n )\n _PrimaryToSecondaryZ0 = _PrimaryToSecondaryZ1\n\n _PrimaryToTertiaryZ1 = (\n math.sqrt(ZHT.real ** 2 + ZHT.imag ** 2)\n * 100.0\n / (\n transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n )\n _PrimaryToTertiaryZ0 = _PrimaryToTertiaryZ1\n\n _SecondaryToTertiaryZ1 = (\n math.sqrt(ZLT.real ** 2 + ZLT.imag ** 2)\n * 100.0\n / (\n transformer_object.windings[0].rated_power\n * 10 ** -3\n )\n )\n _SecondaryToTertiaryZ0 = _SecondaryToTertiaryZ1\n\n # NoLoadLosses\n if (\n hasattr(transformer_object, \"noload_loss\")\n and transformer_object.noload_loss is not None\n ):\n # TODO: Make sure noloadlosses is in % in DiTTo, or change what is next.\n NOLOADLOSS = (\n transformer_object.noload_loss / 100.0 * KVA\n )\n else:\n NOLOADLOSS = \"\"\n\n new_transformer_object_line = \"{kva1},{kv1},{conn1},,,,,,,{kva2},{kv2},{conn2},{kva3},{kv3},{conn3},\".format(\n kva1=_primary_rated_capacity,\n kv1=_primary_voltage,\n conn1=_primary_connection,\n kva2=_secondary_rated_capacity,\n kv2=_secondary_voltage,\n conn2=_secondary_connection,\n kva3=_tertiary_rated_capacity,\n kv3=_tertiary_voltage,\n conn3=_tertiary_connection,\n )\n new_transformer_object_line += \"{PrimaryToSecondaryZ1},{PrimaryToSecondaryZ0},{PrimaryToSecondaryXR1},{PrimaryToSecondaryXR0},{PrimaryToTertiaryZ1},{PrimaryToTertiaryZ0},{PrimaryToTertiaryXR1},{PrimaryToTertiaryXR0},{SecondaryToTertiaryZ1},{SecondaryToTertiaryZ0}\".format(\n PrimaryToSecondaryZ1=_PrimaryToSecondaryZ1,\n PrimaryToSecondaryZ0=_PrimaryToSecondaryZ0,\n PrimaryToSecondaryXR1=_PrimaryToSecondaryXR1,\n PrimaryToSecondaryXR0=_PrimaryToSecondaryXR0,\n PrimaryToTertiaryZ1=_PrimaryToTertiaryZ1,\n PrimaryToTertiaryZ0=_PrimaryToTertiaryZ0,\n PrimaryToTertiaryXR1=_PrimaryToTertiaryXR1,\n PrimaryToTertiaryXR0=_PrimaryToTertiaryXR0,\n SecondaryToTertiaryZ1=_SecondaryToTertiaryZ1,\n SecondaryToTertiaryZ0=_SecondaryToTertiaryZ0,\n )\n new_transformer_object_line += \",{SecondaryToTertiaryXR1},{SecondaryToTertiaryXR0},{SecondaryCapacityLimit1},{SecondaryCapacityLimit2},{TertiaryCapacityLimit1},{TertiaryCapacityLimit2},{TertiaryConnection},{noloadloss}\".format(\n SecondaryToTertiaryXR1=_SecondaryToTertiaryXR1,\n SecondaryToTertiaryXR0=_SecondaryToTertiaryXR0,\n SecondaryCapacityLimit1=0,\n SecondaryCapacityLimit2=0,\n TertiaryCapacityLimit1=0,\n TertiaryCapacityLimit2=0,\n TertiaryConnection=0,\n noloadloss=NOLOADLOSS,\n )\n\n found = False\n for k, d in self.three_windings_trans_codes.items():\n if d == new_transformer_object_line:\n new_transformer_line += (\n \",3_wdg_transformer_\"\n + str(k)\n + \",\"\n + new_section_ID\n )\n found = True\n if not found:\n ID_trans_3w += 1\n self.three_windings_trans_codes[\n ID_trans_3w\n ] = new_transformer_object_line\n new_transformer_line += (\n \",3_wdg_transformer_\"\n + str(ID_trans_3w)\n + \",\"\n + new_section_ID\n )\n\n new_transformer_line += \",{Location},{tertiarynodeID},{PrimaryFixedTapSetting},{SecondaryFixedTapSetting},{ConnectionStatus}\".format(\n Location=\"M\",\n tertiarynodeID=0,\n PrimaryFixedTapSetting=0,\n SecondaryFixedTapSetting=0,\n ConnectionStatus=0,\n )\n\n try:\n TAP = 1.0 / float(\n transformer_object.windings[1]\n .phase_windings[0]\n .tap_position\n )\n new_transformer_line += \",{}\".format(TAP)\n except:\n new_transformer_line += \",\"\n pass\n\n if new_transformer_line != \"\":\n three_windings_transformer_string_list.append(\n new_transformer_line\n )\n\n # Write everything to the network file\n #\n # HEADER\n #\n f.write(\"[GENERAL]\\n\")\n\n # DATE\n #\n current_date = datetime.now().strftime(\"%B %d, %Y at %H:%M:%S\")\n f.write(\"DATE={}\\n\".format(current_date))\n\n # CYME version\n #\n f.write(\"CYME_VERSION=8.02\\n\")\n\n # Unit system\n #\n f.write(\"\\n[SI]\\n\")\n\n # Nodes\n #\n f.write(\"\\n[NODE]\\n\")\n f.write(\"FORMAT_NODE=NodeID,CoordX,CoordY\\n\")\n\n for node_string in self.node_string_list:\n f.write(node_string + \"\\n\")\n\n if len(self.bus_string_list) > 0:\n f.write(\"FORMAT_NODE=NodeID,CoordX1,CoordY1,CoordX2,CoordY2,Width\\n\")\n for bus_string in self.bus_string_list:\n f.write(bus_string + \"\\n\")\n\n # Intermediate nodes\n #\n f.write(\"\\n[INTERMEDIATE NODES]\\n\")\n f.write(\"FORMAT_INTERMEDIATENODE=SectionID,SeqNumber,CoordX,CoordY\\n\")\n\n for inter in intermediate_nodes:\n f.write(\n \"{SectionID},{SegNumber},{CoordX},{CoordY}\\n\".format(\n SectionID=inter[0],\n SegNumber=inter[1],\n CoordX=inter[2],\n CoordY=inter[3],\n )\n )\n\n # Sources\n #\n f.write(\"\\n[SOURCE]\\n\")\n f.write(\"FORMAT_SOURCE=SourceID,DeviceNumber,NodeID,NetworkID\\n\")\n k = 0\n self.substation_IDs = {}\n\n for _source, _voltage in self.sources.items():\n # _source should be the name of the headnode for one feeder_metadata object\n # TODO: Find a better way to find it\n for obj in model.models:\n if isinstance(obj, Feeder_metadata) and obj.headnode == _source:\n sourceID = obj.headnode + \"_src\"\n nodeID = obj.headnode\n NetworkID = obj.name\n k += 1\n for j, sub in enumerate(self.substations):\n if sub[\"connecting_element\"] == _source:\n self.substations[j][\"sub_ID\"] = \"sub_\" + str(k)\n self.substation_IDs[_source] = \"sub{}\".format(k)\n f.write(\n \"sub_{k},sub_{k},{nodeID},{NetID}\\n\".format(\n sourceID=sourceID, k=k, nodeID=nodeID, NetID=NetworkID\n )\n )\n\n f.write(\"\\n[HEADNODES]\\n\")\n f.write(\"FORMAT_HEADNODES=NodeID,NetworkID\\n\")\n # k=0\n # for source_string in source_string_list:\n # k+=1\n # nodeID=source_string.split(',')[0]\n # f.write('{nodeID},{NetID}\\n'.format(nodeID=nodeID, NetID=k))\n for f_name, section_l in self.section_feeder_mapping.items():\n # for kk in model.models:\n # if isinstance(kk,Feeder_metadata):\n # print(kk.name, kk.headnode)\n # import pdb;pdb.set_trace()\n if f_name != \"\":\n head = model[\n f_name\n ].headnode # self.section_headnode_mapping[f_name]\n f.write(\"{nodeID},{NetID}\\n\".format(nodeID=head, NetID=f_name))\n\n # Source equivalent\n #\n f.write(\"\\n[SOURCE EQUIVALENT]\\n\")\n f.write(\n \"FORMAT_SOURCEEQUIVALENT=NodeID,Voltage,OperatingAngle1,OperatingAngle2,OperatingAngle3,PositiveSequenceResistance,PositiveSequenceReactance,ZeroSequenceResistance,ZeroSequenceReactance,NegativeSequenceResistance,NegativeSequenceReactance,OperatingVoltage1,OperatingVoltage2,OperatingVoltage3,ImpedanceUnit\\n\"\n )\n\n id_from_source = []\n for source_string in source_string_list:\n id_from_source.append(source_string.split(\",\")[0])\n f.write(source_string + \"\\n\")\n\n for f_name, section_l in self.section_line_feeder_mapping.items():\n if f_name != \"subtransmission\" and \"substation\" not in f_name:\n temp = model[f_name]\n if (\n hasattr(temp, \"nominal_voltage\")\n and temp.nominal_voltage is not None\n ):\n volt = temp.nominal_voltage * 10 ** -3\n else:\n volt = model[temp.headnode].nominal_voltage * 10 ** -3\n if temp.headnode not in id_from_source:\n f.write(\n \"{node_id},{voltage},{angle1},{angle2},{angle3},{R1},{X1},{R0},{X0},{R2},{X2},{voltage},{voltage},{voltage},0\\n\".format(\n node_id=temp.headnode,\n voltage=volt,\n angle1=temp.operating_angle1,\n angle2=temp.operating_angle2,\n angle3=temp.operating_angle3,\n R1=temp.positive_sequence_resistance,\n X1=temp.positive_sequence_reactance,\n R0=temp.zero_sequence_resistance,\n X0=temp.zero_sequence_reactance,\n R2=temp.negative_sequence_resistance,\n X2=temp.negative_sequence_reactance,\n )\n )\n\n # Sections\n #\n f.write(\"\\n[SECTION]\\n\")\n\n # Always write the SECTION format\n f.write(\n \"FORMAT_SECTION=SectionID,FromNodeID,FromNodeIndex,ToNodeID,ToNodeIndex,Phase,SubNetworkId\\n\"\n )\n\n # Always write the FEEDER format\n f.write(\"FORMAT_FEEDER=NetworkID,HeadNodeID,CoordSet\\n\")\n\n # If we have subtransmission, then write the TRANSMISSIONLINE format\n if \"subtransmission\" in self.section_line_feeder_mapping:\n f.write(\"FORMAT_TRANSMISSIONLINE=NetworkID,HeadNodeID,CoordSet\\n\")\n\n # If we have a substation (have to have \"substation in the name...),\n # then write the SUBSTATION format\n if self.network_have_substations:\n f.write(\"FORMAT_SUBSTATION=NetworkID,HeadNodeID,CoordSet\\n\")\n\n #####################################\n # TO REMOVE ????????\n ####################################\n #\n # k=0\n # for source_string in source_string_list:\n # k+=1\n # f.write('FEEDER={NetID},{HeadNodeID},{coordset}\\n'.format(NetID=k,HeadNodeID=source_string.split(',')[0],coordset=0))\n\n # section_list=self.merge_regulators(self.section_line_list)\n # for section_line in section_list:\n # f.write(section_line+'\\n')\n #######################################\n\n for f_name, section_l in self.section_line_feeder_mapping.items():\n if \"substation\" in f_name:\n head = \"\"\n else:\n head = model[\n f_name\n ].headnode # self.section_headnode_mapping[f_name]\n # If we are considering the subtransmission network, use TRANSMISSIONLINE\n if f_name == \"subtransmission\":\n f.write(\n \"TRANSMISSIONLINE={NetID},{HeadNodeID},{coordset}\\n\".format(\n NetID=f_name, HeadNodeID=head, coordset=1\n )\n )\n subnetID = \"\"\n # If substation is in the name of the \"feeder\", then use SUBSTATION\n elif \"substation\" in f_name:\n f.write(\n \"SUBSTATION={NetID},{HeadNodeID},{coordset}\\n\".format(\n NetID=f_name.split(\"ation_\")[1], HeadNodeID=head, coordset=1\n )\n )\n subnetID = f_name.split(\"ation_\")[1]\n # Otherwise, it should be an actual feeder, so use FEEDER\n else:\n f.write(\n \"FEEDER={NetID},{HeadNodeID},{coordset}\\n\".format(\n NetID=f_name, HeadNodeID=head, coordset=1\n )\n )\n subnetID = \"\"\n # Then, write all the sections belonging to this subnetwork\n for sec in section_l:\n f.write(sec + \",{}\".format(subnetID) + \"\\n\")\n\n # Subnetworks\n #\n # Use subnetworks only for substations\n # TODO: Let the user specify what should be subnetworked...\n #\n if self.network_have_substations:\n f.write(\"\\n[SUBNETWORKS]\\n\")\n f.write(\n \"FORMAT_SUBNETWORKS=SubNetID,Angle,X,Y,Height,Length,SymbolID,SubNetTypeID,Version,SymbolReferenceSize,TextReferenceSize,CoordSet\\n\"\n )\n for f_name, section_l in self.section_line_feeder_mapping.items():\n if \"substation\" in f_name:\n # We need to find the X,Y coordinates for the subnetwork\n # (CASE 1) - First, we try setting these coordinates as the average of the LV elements.\n # (CASE 2) - If this does not work, we try using the average of all the substation elements.\n # (CASE 3) - If this does not work either, we try using the global average (all Nodes in the system), such that\n # the subnetwork is more or less in the middle of the system.\n # (CASE 4) - Finally, if nothing works, set the coordinates as (0,0)...\n defaultX = []\n defaultY = []\n by_nominal_voltage_X = {}\n by_nominal_voltage_Y = {}\n all_coordsX = []\n all_coordsY = []\n #\n # TODO: Better way to do this???\n #\n for obj in model.models:\n # (CASE 3) - Just append all Node's valid coordinates to all_coordsX and all_coordsY\n if (\n isinstance(obj, Node)\n and len(obj.positions) > 0\n and obj.positions[0] is not None\n and obj.positions[0].lat is not None\n and obj.positions[0].long is not None\n ):\n all_coordsX.append(obj.positions[0].long)\n all_coordsY.append(obj.positions[0].lat)\n # (CASE 1) - Since we don't know what the LV value is beforehand, we store all coordinates by nominal voltage\n # in the dictionaries by_nominal_voltage_X and by_nominal_voltage_Y.\n if (\n isinstance(obj, Node)\n and obj.substation_name == f_name.split(\"ation_\")[1]\n and obj.is_substation_connection == 1\n ):\n if obj.nominal_voltage is not None:\n if (\n len(obj.positions) > 0\n and obj.positions[0] is not None\n ):\n if (\n obj.positions[0].lat is not None\n and obj.positions[0].long is not None\n ):\n if (\n obj.nominal_voltage\n in by_nominal_voltage_X\n and obj.nominal_voltage\n in by_nominal_voltage_Y\n ):\n by_nominal_voltage_X[\n obj.nominal_voltage\n ].append(obj.positions[0].long)\n by_nominal_voltage_Y[\n obj.nominal_voltage\n ].append(obj.positions[0].lat)\n else:\n by_nominal_voltage_X[\n obj.nominal_voltage\n ] = [obj.positions[0].long]\n by_nominal_voltage_Y[\n obj.nominal_voltage\n ] = [obj.positions[0].lat]\n # (CASE 2) - If the nominal voltage was None, then add the coordinates to the default list\n else:\n if (\n len(obj.positions) > 0\n and obj.positions[0] is not None\n ):\n if (\n obj.positions[0].lat is not None\n and obj.positions[0].long is not None\n ):\n defaultX.append(obj.positions[0].long)\n defaultY.append(obj.positions[0].lat)\n # (CASE 1)\n if len(list(by_nominal_voltage_X.keys())) > 0:\n low_voltage = min(list(by_nominal_voltage_X.keys()))\n Xs = by_nominal_voltage_X[low_voltage]\n Ys = by_nominal_voltage_Y[low_voltage]\n # (CASE 2)\n else:\n Xs = defaultX\n Ys = defaultY\n # If we were able to sample some coordinates, take the average\n if len(Xs) > 0 and len(Ys) > 0:\n X = np.mean(Xs)\n Y = np.mean(Ys) + 50 / 2.0\n # (CASE 3)\n elif len(all_coordsX) > 0 and len(all_coordsY) > 0:\n X = np.mean(all_coordsX)\n Y = np.mean(all_coordsY)\n # (CASE 4) - Otherwise, set to 0,0 (best effort...)\n else:\n logger.warning(\n \"Could not find any coordinate for substation {s}. Setting the subnetwork coordinates to (0,0)...\".format(\n s=f_name\n )\n )\n X = 0\n Y = 0\n f.write(\n \"{NetID},0,{X},{Y},{Height},{Length},-1,Geographically Referenced,-1,5,0.251957,1\\n\".format(\n NetID=f_name.split(\"ation_\")[1],\n X=X,\n Y=Y,\n Height=50.00,\n Length=50.00,\n )\n )\n\n # Subnetwork Connections\n #\n # Use subnetwork connections only for substations\n # TODO: Let the user specify what should be subnetworked\n if self.network_have_substations:\n f.write(\"\\n[SUBNETWORK CONNECTIONS]\\n\")\n f.write(\n \"FORMAT_SUBNETWORKCONNECTIONS=SubNetID,NodeID,ConnectorCoordX,ConnectorCoordY\\n\"\n )\n for f_name, section_l in self.section_line_feeder_mapping.items():\n if \"substation\" in f_name:\n # We need to find all the connections between the subnetwork and the rest of the system\n # Use the \"is_substation_connection\" attribute of Node objects\n #\n # TODO: Better way to do this???\n for obj in model.models:\n if (\n isinstance(obj, Node)\n and obj.is_substation_connection == 1\n and obj.substation_name == f_name.split(\"ation_\")[1]\n ):\n # We also need the coordinates of this connection.\n # Use the coordinates of the Node\n if obj.positions is not None and len(obj.positions) > 0:\n X = obj.positions[0].long\n Y = obj.positions[0].lat\n # If we don't have coordinates, then set to (0,0)....\n else:\n X = 0\n Y = 0\n f.write(\n \"{NetID},{NodeID},{X},{Y}\\n\".format(\n NetID=f_name.split(\"ation_\")[1],\n NodeID=obj.name,\n X=X,\n Y=Y,\n )\n )\n\n # Overhead lines\n #\n if len(overhead_string_list) > 0:\n f.write(\"\\n[OVERHEADLINE SETTING]\\n\")\n f.write(\n \"FORMAT_OVERHEADLINESETTING=SectionID,LineCableID,Length,ConnectionStatus\\n\"\n )\n for overhead_string in overhead_string_list:\n f.write(overhead_string + \"\\n\")\n\n # Overhead by phase lines\n #\n if len(overhead_byphase_string_list) > 0:\n f.write(\"\\n[OVERHEAD BYPHASE SETTING]\\n\")\n f.write(\n \"FORMAT_OVERHEADBYPHASESETTING=SectionID,DeviceNumber,CondID_A,CondID_B,CondID_C,CondID_N1,CondID_N2,SpacingID,Length,ConnectionStatus\\n\"\n )\n for overhead_byphase_string in overhead_byphase_string_list:\n f.write(overhead_byphase_string + \"\\n\")\n\n # Underground lines\n #\n if len(underground_string_list) > 0:\n f.write(\"\\n[UNDERGROUNDLINE SETTING]\\n\")\n f.write(\n \"FORMAT_UNDERGROUNDLINESETTING=SectionID,LineCableID,Length,ConnectionStatus,DistanceBetweenConductors,CableConfiguration\\n\"\n )\n for underground_string in underground_string_list:\n f.write(underground_string + \"\\n\")\n\n # Switches\n #\n if len(switch_string_list) > 0:\n f.write(\"\\n[SWITCH SETTING]\\n\")\n f.write(\n \"FORMAT_SWITCHSETTING=SectionID,EqID,Location,ClosedPhase,Locked,ConnectionStatus,DeviceNumber\\n\"\n )\n for switch_string in switch_string_list:\n f.write(switch_string + \"\\n\")\n\n # Fuses\n #\n if len(fuse_string_list) > 0:\n f.write(\"\\n[FUSE SETTING]\\n\")\n f.write(\n \"FORMAT_FUSESETTING=SectionID,EqID,Location,ClosedPhase,Locked,ConnectionStatus,DeviceNumber\\n\"\n )\n for fuse_string in fuse_string_list:\n f.write(fuse_string + \"\\n\")\n\n # Reclosers\n #\n if len(recloser_string_list) > 0:\n f.write(\"\\n[RECLOSER SETTING]\\n\")\n f.write(\n \"FORMAT_RECLOSERSETTING=SectionID,EqID,Location,ClosedPhase,Locked,ConnectionStatus,DeviceNumber\\n\"\n )\n for recloser_string in recloser_string_list:\n f.write(recloser_string + \"\\n\")\n\n # Breakers\n #\n if len(breaker_string_list) > 0:\n f.write(\"\\n[BREAKER SETTING]\\n\")\n f.write(\n \"FORMAT_BREAKERSETTING=SectionID,EqID,Location,ClosedPhase,Locked,ConnectionStatus,DeviceNumber\\n\"\n )\n for breaker_string in breaker_string_list:\n f.write(breaker_string + \"\\n\")\n\n # Capacitors\n #\n if len(capacitor_string_list) > 0:\n f.write(\"\\n[SHUNT CAPACITOR SETTING]\\n\")\n f.write(\n \"FORMAT_SHUNTCAPACITORSETTING=SectionID,Connection,SwitchedKVARA,SwitchedKVARB,SwitchedKVARC,KV,Control,OnValueA,OnValueB,OnValueC,OffValueA,OffValueB,OffValueC,DeviceNumber,ShuntCapacitorID,Location,ConnectionStatus\\n\"\n )\n for capacitor_string in capacitor_string_list:\n f.write(capacitor_string + \"\\n\")\n\n # Transformers\n #\n # 2 WINDINGS\n #\n if len(two_windings_transformer_string_list) > 0:\n f.write(\"\\n[TRANSFORMER SETTING]\\n\")\n f.write(\n \"FORMAT_TRANSFORMERSETTING=SectionID,CoordX,CoordY,Conn,PhaseON,EqID,DeviceNumber,PhaseShiftType,Location,PrimTap,SecondaryTap,ODPrimPh,ConnectionStatus,Tap,SetPoint,ControlType,LowerBandwidth,UpperBandwidth,Maxbuck,Maxboost\\n\"\n )\n for transformer_string in two_windings_transformer_string_list:\n f.write(transformer_string + \"\\n\")\n\n # 3 WINDINGS\n #\n if len(three_windings_transformer_string_list) > 0:\n f.write(\"\\n[THREE WINDING TRANSFORMER SETTING]\\n\")\n f.write(\n \"FORMAT_THREEWINDINGTRANSFORMERSETTING=SectionID,CoordX,CoordY,PrimaryBaseVoltage,SecondaryBaseVoltage,TertiaryBaseVoltage,EqID,DeviceNumber,Location,TertiaryNodeID,PrimaryFixedTapSetting,SecondaryFixedTapSetting,ConnectionStatus,Tap\\n\"\n )\n for transformer_string in three_windings_transformer_string_list:\n f.write(transformer_string + \"\\n\")\n\n # Regulators\n if len(regulator_string_list) > 0:\n # Merge the Regulators\n regulator_string_list_merged = self.merge_regulators(\n regulator_string_list\n )\n f.write(\"\\n[REGULATOR SETTING]\\n\")\n f.write(\n \"FORMAT_REGULATORSETTING=SectionID,CoordX,CoordY,PhaseON,BandWidth,CT,PT,VsetA,VsetB,VsetC,EqID,DeviceNumber,Location,MaxBuck,MaxBoost,SettingOption,RsetA,RsetB,RsetC,XsetA,XsetB,XsetC,TapA,TapB,TapC,ConnectionStatus\\n\"\n )\n for regulator_string in regulator_string_list_merged:\n f.write(regulator_string + \"\\n\")\n\n if len(converter_string_list) > 0:\n f.write(\"\\n[CONVERTER]\\n\")\n f.write(\n \"FORMAT_CONVERTER=DeviceNumber,DeviceType,ConverterRating,ActivePowerRating,ReactivePowerRating,MinimumPowerFactor,PowerFallLimit,PowerRiseLimit,RiseFallUnit\\n\"\n )\n for i in converter_string_list:\n f.write(i)\n f.write(\"\\n\")\n\n if len(converter_control_string_list) > 0:\n f.write(\"\\n[CONVERTER CONTROL SETTING]\\n\")\n f.write(\n \"FORMAT_CONVERTERCONTROLSETTING=DeviceNumber,DeviceType,ControlIndex,TimeTriggerIndex,ControlType,FixedVarInjection,InjectionReference,ConverterControlID,PowerReference,PowerFactor\\n\"\n )\n for i in converter_control_string_list:\n f.write(i)\n f.write(\"\\n\")\n\n if len(pv_settings_string_list) > 0:\n f.write(\"\\n[PHOTOVOLTAIC SETTINGS]\\n\")\n f.write(\n \"FORMAT_PHOTOVOLTAICSETTING=SectionID,Location,DeviceNumber,EquipmentID,NS,NP,AmbientTemperature,Phase,ConstantInsolation,InsolationModelID\\n\"\n )\n for i in pv_settings_string_list:\n f.write(i)\n f.write(\"\\n\")\n\n if len(dg_generation_string_list) > 0:\n f.write(\"\\n[DGGENERATIONMODEL]\\n\")\n f.write(\n \"FORMAT_DGGENERATIONMODEL=DeviceNumber,DeviceType,LoadModelName,ActiveGeneration,PowerFactor\\n\"\n )\n for i in dg_generation_string_list:\n f.write(i)\n f.write(\"\\n\")\n\n if len(self.node_connector_string_list) > 0:\n f.write(\"\\n[NODE CONNECTOR]\\n\")\n f.write(\"FORMAT_NODECONNECTOR=NodeID,CoordX,CoordY,SectionID\\n\")\n for i in self.node_connector_string_list:\n f.write(i)\n f.write(\"\\n\")\n\n if len(bess_settings_string_list) > 0:\n f.write(\"\\n[BESS SETTINGS]\\n\")\n f.write(\n \"FORMAT_BESSSETTING=SectionID,Location,DeviceNumber,EquipmentID,Phase,InitialSOC\\n\"\n )\n for i in bess_settings_string_list:\n f.write(i)\n f.write(\"\\n\")","def save_network(network, fpath):\n\twith open(fpath, \"wb\") as f:\n\t\tpickle.dump(network, f)","def save_utility_network(self,path_save):\n print(\"Save the neural network to : \"+path_save)\n self.nn.save_on_file(path_save)","def _write_network_file(graph, out_name, out_format=None, data=False,weight=False):\n\n if out_format==None:\n out_format=\"edges\"\n os.makedirs(os.path.dirname(out_name), exist_ok=True)\n #print(\"writing graph of format \" + out_format + \" at \" + out_name)\n if out_format == 'edges':\n nx.write_edgelist(graph, \"%s.edges\" % (out_name), data=data)\n elif out_format == 'gefx':\n nx.write_gexf(graph, \"%s.gefx\" % (out_name))\n elif out_format == 'gml':\n nx.write_gml(graph, \"%s.gml\" % (out_name))\n elif out_format == 'pajek':\n nx.write_pajek(graph, \"%s.pajek\" % (out_name))\n elif out_format == 'ncol':\n nx.write_edgelist(graph, \"%s.ncol\" % (out_name), delimiter='\\t',data=weight)\n elif out_format == 'graphML' :\n g = nx.write_graphml(graph, \"%s.graphml\" % (out_name))\n else:\n raise Exception(\"UNKNOWN FORMAT \" + out_format)","def save_graph(graph, file_name):\r\n print \"Saving network into \"+file_name\r\n f = open(file_name, 'w')\r\n f.write(str(len(graph))+'\\n')\r\n for citizen in graph:\r\n f.write(str(citizen.id) + ';' + str(citizen.location) + ';' + str(citizen.influence_level) + ';' + \\\r\n str(citizen.proactivity_level) + '\\n')\r\n for op in citizen.opinions.keys():\r\n value = citizen.opinions[op].weight\r\n f.write(str(op)+':'+str(value)+';')\r\n f.write('\\n')\r\n for friend in citizen.friends:\r\n f.write(str(friend.id) + ';')\r\n f.write('\\n')\r\n f.close()","def save_graph(self, filename, fileType):\n if fileType == \"GML Format\":\n nx.write_gml(self.graph, filename+\".gml\")\n if fileType == \"Adjacency list\":\n nx.write_adjlist(self.graph, filename+\".adjlist\")\n if fileType == \"YAML\":\n nx.write_yaml(self.graph, filename + \".yaml\")","def save(self):\n self.save_network_architecture( network_path=self.network_path )\n self.save_network_parameters(\n file_name='net_parameters', file_path=self.network_path )","def dump_net_to_file(net_def, filename):\n\n print(\"DUMP TO FILE:\\n{}\\n\".format(net_def))\n\n with open(filename, \"w\") as fd:\n line = json.dumps(net_def)\n fd.write(\"{}\\n\".format(line))\n\n print(\"Wrote neural net to {}\".format(filename))","def export_network(file_name, net) -> None:\r\n file = open(file_name, 'wb')\r\n file.write(pickle.dumps(net.__dict__))\r\n file.close()","def to_net(self, filename):\n if len(self.nodes1)>0:\n h = open(filename, \"w\")\n for n1,n2,s in zip(self.nodes1, self.nodes2, self.signs):\n h.write(\"%s -> %s %s\\n\" % (n1, n2, s))\n h.close()","def save_nn(self, networkname= 'nn'):\n np.save(f\"{networkname}_data.npy\", self.weights_and_biases)\n print(f\"Data saved to {networkname}_data.npy\")","def save_net(net, filepath):\n\twith open(filepath, 'wb+') as fh:\n\t\tdump(obj = net, file = fh, protocol = -1)","def but_save_net(self):\n if isinstance(self.nn_obj, dict):\n if platform == \"linux\" or platform == \"linux2\":\n path=tk.filedialog.asksaveasfilename(filetypes = [('LM NN file','.csv')])\n elif platform == \"win32\":\n path=tk.filedialog.asksaveasfilename(filetypes = [('LM NN file','.csv')], defaultextension=\"*.*\")\n else:\n path=tk.filedialog.asksaveasfilename(filetypes = [('LM NN file','.csv')])\n elif isinstance(self.nn_obj, Net_tr):\n if platform == \"linux\" or platform == \"linux2\":\n path=tk.filedialog.asksaveasfilename(filetypes = [(\"Torch NN file\",\".pt\")])\n elif platform == \"win32\":\n path=tk.filedialog.asksaveasfilename(filetypes = [(\"Torch NN file\",\".pt\")], defaultextension=\"*.*\")\n else:\n path=tk.filedialog.asksaveasfilename(filetypes = [(\"Torch NN file\",\".pt\")])\n else:\n tk.messagebox.showerror(\"Error\", \"Crete NN\")\n return\n save_nn(self.nn_obj, path)","def save_network(nodes, edges, name, pid):\n d = {'nodes': nodes, 'edges': edges, 'name': name, 'pid': pid}\n\n out_filename = \"{0}-{1}.pickle\".format(\n datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\"),\n pid\n )\n with open(out_filename, 'wb') as out_file:\n pickle.dump(d, out_file)","def save_state(self, path='/home/lukas/weights/'):\r\n stuff_in_path = os.listdir(path)\r\n counter = 0\r\n for i in stuff_in_path:\r\n if 'parameters' in i:\r\n counter += 1\r\n with open(path + 'info.txt', mode='a') as f:\r\n f.write('counter: %i \\taccuracy: %.8f%% \\tloss: %.8f\\n' % (counter, returnList(self.accuracy)[-1] * 100, returnList(self.loss)[-1]))\r\n\r\n parameters = [ self.batchsize_train,\r\n self.iterator,\r\n self.n_hidden_layers,\r\n self.n_hidden_neurons,\r\n self.n_input_neurons,\r\n self.n_output_neurons,\r\n self.hid_transfer.__name__,\r\n self.out_transfer.__name__]\r\n try:\r\n print '[Network] Saving network status ...'\r\n np.save(path + 'parameters' + str(counter), parameters)\r\n np.save(path + 'weights' + str(counter), self.weights)\r\n np.save(path + 'bias' + str(counter), self.bias)\r\n np.save(path + 'weights_gradient' + str(counter), self.weights_gradient)\r\n np.save(path + 'bias_gradient' + str(counter), self.bias_gradient)\r\n np.save(path + 'loss' + str(counter), self.loss)\r\n np.save(path + 'accuracy' + str(counter), self.accuracy)\r\n np.save(path + 'r_weights' + str(counter), self.r_weights)\r\n np.save(path + 'r_bias' + str(counter), self.r_bias)\r\n print '\\033[92m' + '[Network] Network status succesfully saved' + '\\033[0m'\r\n\r\n except Exception as e:\r\n print '\\033[1m' + '\\033[91m' + '[Network] Could not correctly save network status:' + '\\033[0m'\r\n print e.message","def save_network(self, file_name):\n data = {\n \"layers_num\": self.layers_num,\n \"weights\": [w.tolist() for w in self.weights],\n \"biases\": [b.tolist() for b in self.biases],\n \"act_func\": str(self.act_func.__name__),\n \"cost_func\": str(self.cost_func.__name__),\n \"metric\": str(self.metric.__name__)\n }\n\n with open(file_name, 'w') as file:\n json.dump(data, file)","def save_network(self, **kwargs):\n raise NotImplementedError","def save(net, txt_dict, path):\n dict_m = net.state_dict()\n _ = txt_dict\n torch.save(dict_m,path)","def saveGraph(self, filename):\n nx.write_yaml(self.G,filename)","def save_network(save_file, training_round, digit):\n with open(save_file, 'wb') as f:\n np.save(f, S.w)\n np.save(f, S.w_min)\n np.save(f, S.w_max)\n np.save(f, S.a_plus)\n np.save(f, S.a_minus)\n np.save(f, S.b_plus)\n np.save(f, S.b_minus)\n np.save(f, Output.v_th)\n np.save(f, training_set.flatten())\n np.save(f, training_round)\n np.save(f, digit)","def save_to_file(self, representation, filename) -> bool:\n filename = \"data/\" + filename\n output_matrix = self.get_graph(representation)\n if isinstance(output_matrix, list):\n with open(filename, \"w+\") as f:\n for row in output_matrix:\n f.write(\" \".join(str(item) for item in row))\n f.write(\"\\n\")\n return True\n elif isinstance(output_matrix, np.ndarray):\n with open(filename, \"w+\") as f:\n np.savetxt(f, output_matrix, fmt=\"%i\")\n return True\n else:\n return False","def save(self, filename, path=\".\"):\n if not self.trained:\n if self.verbose:\n print(\"Neural Network Model Class - Save Function: No trained model\")\n return -1\n\n if filename is None:\n if self.verbose:\n print(\"Neural Network Model Class - Save Function: No file name\")\n return -1\n\n #trn_params\n self.trn_params.save('%s_trn_params.pickle'%(filename),path=path)\n #model\n # serialize model to JSON\n model_json = self.model.to_json()\n with open(\"%s/%s_model.json\"%(path,filename), \"w\") as json_file:\n json_file.write(model_json)\n # serialize weights to HDF5\n self.model.save_weights(\"%s/%s_model.h5\"%(path,filename))\n\n #trn_desc\n pickle.dump([self.trn_desc], open(\"%s/%s_trn_desc.pickle\"%(path,filename), \"wb\"))","def save_depfile(depdata,outname,is31=True): \n\n if outname==None:\n print('save_depfile requires a filename to save.')\n return\n try:\n fp=open(outname,'w')\n except IOError:\n print('save_depfile: invalid filename.')\n return data\n if is31:\n fp.write('Node Number = %d\\n' % len(depdata['node_num']) )\n for i in range(0,len(depdata['node_num'])):\n fp.write('%f %f %f\\n'% (depdata['x'][i],depdata['y'][i],depdata['h'][i]))\n fp.close()\n \n return","def save_net(self, file_path):\n \tserialized_weights = [w.tolist() for w \\\n in self.stacked_net.weights]\n \tserialized_biases = [b.tolist() for b \\\n in self.stacked_net.biases]\n \tparams = {'weights':serialized_weights,\\\n 'biases':serialized_biases}\n \twith open(file_path,'w') as f:\n \t\tf.write(json.dumps(params))","def save_model(self):\n self.pred_net.save((self.save_path / \"iqn_pred_net\").absolute().as_posix())\n self.target_net.save((self.save_path / \"iqn_target_net\").absolute().as_posix())","def save_network(self, which_epoch):\n save_filename = '%s_net.pkl' % (which_epoch)\n save_path = os.path.join(self.save_dir, save_filename)\n if len(self.gpu_ids) > 0 and torch.cuda.is_available():\n torch.save(self.net.module.cpu().state_dict(), save_path)\n self.net.cuda(self.gpu_ids[0])\n else:\n torch.save(self.net.cpu().state_dict(), save_path)","def print_network(self, model, name):\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n #print(model)\n print(name)\n print(\"The number of parameters: {}\".format(num_params))\n\n with open(os.path.join(self.train_dir,'model_arch.txt'), 'a') as fp:\n print(model, file=fp)\n print(name, file=fp)\n print(\"The number of parameters: {}\".format(num_params),file=fp)","def write_labels():\n with open('../data/labels.txt', 'w') as labels_file:\n labels = generate_labels()\n labels_file.write('\\n'.join(labels))","def save_network(self, sess, filename):\n dir_path = os.path.dirname(os.path.realpath(__file__))\n dir_path += '/Models/'\n dir_path += filename\n saver = tf.train.Saver()\n saver.save(sess, dir_path)","def Save2Pajek(filepath, adjmatrix, labels=[], directed=False, weighted=False):\n # 0) SECURITY CHECK\n N = len(adjmatrix)\n if labels:\n if len(labels) != N:\n raise ValueError( \"List of labels not aligned with network size\" )\n\n # 1) OPEN THE TARGET FILE\n outfile = open(filepath, 'w')\n\n # 2) SAVE INFORMATION OF THE NODES\n print('*Vertices', N, file=outfile)\n\n # Wrie the list of nodes if labels have been given\n if labels:\n for i in range(N):\n # line = '%d \"%s\"' %(i+1, labels[i])\n line = '%d\\t\"%s\"' % (i + 1, labels[i])\n print(line, file=outfile)\n\n # 3) SAVE THE LINKS\n # Save the links AND their WEIGHTS\n if weighted:\n # 3.1) Find whether weights are integers or floats\n if adjmatrix[0, 0].dtype in [np.uint8, np.uint, np.int8, np.int]:\n formatstring = '%d %d %d'\n elif adjmatrix[0, 0].dtype in [np.float16, np.float32, np.float, np.float64]:\n formatstring = '%d %d %f'\n\n # 3.2) Save the ARCS if directed\n if directed:\n print('*Arcs', file=outfile)\n for i in range(N):\n neighbours = adjmatrix[i].nonzero()[0]\n for j in neighbours:\n line = formatstring % (i + 1, j + 1, adjmatrix[i, j])\n print(line, file=outfile)\n\n # 3.2) Save the EDGES, if undirected\n else:\n print('*Edges', file=outfile)\n for i in range(N):\n neighbours = adjmatrix[i].nonzero()[0]\n for j in neighbours:\n if j > i:\n line = formatstring % (i + 1, j + 1, adjmatrix[i, j])\n print(line, file=outfile)\n\n # Save ONLY the adjacency list\n else:\n formatstring = '%d %d'\n\n # 3.1) Save the ARCS if directed\n if directed:\n print('*Arcs', file=outfile)\n for i in range(N):\n neighbours = adjmatrix[i].nonzero()[0]\n for j in neighbours:\n line = formatstring % (i + 1, j + 1)\n print(line, file=outfile)\n\n # 3.1) Save the EDGES, if undirected\n else:\n print('*Edges', file=outfile)\n for i in range(N):\n neighbours = adjmatrix[i].nonzero()[0]\n for j in neighbours:\n if j > i:\n line = formatstring % (i + 1, j + 1)\n print(line, file=outfile)\n\n # 4) CLOSE FILE AND FINISH\n outfile.close()","def imwrite_architecture(layers, fpath, **kwargs):\n pydot_graph = make_architecture_pydot_graph(layers, **kwargs)\n\n ext = fpath[fpath.rfind('.') + 1:]\n with open(fpath, 'w') as fid:\n fid.write(pydot_graph.create(format=ext))","def save (self, filename) :\n\t\tserialFile = open (filename, \"wb\")\n\t\tpickle.dump (self.production_rules, serialFile)\n\t\tpickle.dump (self.unitrelation, serialFile)\n\t\tpickle.dump (self.labels, serialFile)\n\t\tpickle.dump (self.keeper, serialFile)\n\t\tpickle.dump (self.strnodes, serialFile)\n\t\tpickle.dump (self.tokens, serialFile)\n\t\tserialFile.close()","def save(self, name, path=None):\n if path is None:\n path = '.'\n if path[0] == '~':\n path = os.getenv(\"HOME\") + path[1:]\n\n try:\n with open(os.path.join(path, name), 'wb') as f:\n pickle.dump(self, f)\n except IOError as e:\n msg = str(e) + '\\nNeuralNetwork.save failed.'\n raise DNNetIOError(msg)","def save2file(self):\n ids_input = []\n labels_input = []\n ids_path = os.path.join(self.path, 'ids')\n if not os.path.exists(ids_path):\n os.makedirs(ids_path)\n labels_path = os.path.join(self.path, 'labels')\n if not os.path.exists(labels_path):\n os.makedirs(labels_path)\n ids_total = len(self.test)\n for i in range(ids_total):\n ids_input = self.test[i][0]\n labels_input = self.test[i][1]\n file_name = \"ids/\" + str(i) + \".bin\"\n file_path = os.path.join(self.path, file_name)\n np.array(ids_input, dtype=np.int32).tofile(file_path)\n file_name = \"labels/\" + str(i) + \".bin\"\n file_path = os.path.join(self.path, file_name)\n np.array(labels_input, dtype=np.int32).tofile(file_path)\n print(\"\\n ****** Success! ******\\n \")","def save_network(session, tf_variables, file_path):\n variable_values = session.run(tf_variables)\n with open(file_path, mode='wb') as f:\n pickle.dump(variable_values, f)","def model_architecture_to_file(model, save_path, show_shapes=True):\n plot_model(model, to_file=save_path + \"_model_architecture.png\", show_shapes=show_shapes)","def save(nntagger, args):\n outdir = args.save\n modelname = outdir + \".model\"\n nntagger.model.save(modelname)\n import pickle\n myparams = {\"num_words\": len(nntagger.w2i),\n \"num_chars\": len(nntagger.c2i),\n \"w2i\": nntagger.w2i,\n \"c2i\": nntagger.c2i,\n \"tag2idx\": nntagger.tag2idx,\n \"activation\": nntagger.activation,\n \"in_dim\": nntagger.in_dim,\n \"h_dim\": nntagger.h_dim,\n \"c_in_dim\": nntagger.c_in_dim,\n \"h_layers\": nntagger.h_layers\n }\n pickle.dump(myparams, open( modelname+\".pickle\", \"wb\" ) )\n print(\"model stored: {}\".format(modelname), file=sys.stderr)","def save(uNetwork, uDir):\n ## first of all, save the network spec\n out = open(uDir + \"net_spec.py\", \"w\")\n out.write(\"spec = \" + str(uNetwork.spec))\n out.close()\n \n ## then, save the state of each layer\n layers = uNetwork.layers\n\n for l in range(len(layers) - 1):\n if layers[l].node_sharing:\n ## save just one node\n layers[l].pipes[0][0].send(\"clone_state\")\n state = layers[l].pipes[0][0].recv()\n \n ## save coincidences and PCG\n np.save(uDir + str(l) + \".0.0.coincidences\", state['coincidences'])\n np.save(uDir + str(l) + \".0.0.PCG\", state['PCG'])\n\n else:\n for i in range(len(layers[l].nodes)): \n for j in range(len(layers[l].nodes[i])):\n layers[l].pipes[i][j].send(\"clone_state\")\n state = layers[l].pipes[i][j].recv()\n\n np.save(uDir + str(l) + \".\" + str(i) + \".\" + str(j) + \".coincidences\", state['coincidences'])\n np.save(uDir + str(l) + \".\" + str(i) + \".\" + str(j) + \".PCG\", state['PCG'])\n\n ## then, save also the output layer\n layers[-1].pipes[0][0].send(\"clone_state\")\n state = layers[-1].pipes[0][0].recv()\n np.save(uDir + str(len(layers) - 1) + \".0.0.coincidences\", state['coincidences'])\n np.save(uDir + str(len(layers) - 1) + \".0.0.cls_prior_prob\", state['cls_prior_prob'])\n np.save(uDir + str(len(layers) - 1) + \".0.0.PCW\", state['PCW'])","def save_to_disk(self, file_name = \"vehicle_classifier.pkl\"):\n self.classifier.save_to_disk(file_name)","def save_port(self):\n if self.instrument == Instruments.SERVER_LIDAR:\n instrument_str = 'Lidar'\n elif self.instrument == Instruments.SERVER_LSP:\n instrument_str = 'LSP'\n else:\n print('Error!!! Instrument is not correctly defined')\n return\n\n line = 'port=%i' % self.port\n save_path = self.work_dir + ('network_%s.cfg' % instrument_str)\n\n with open(save_path, 'w') as f:\n f.write(line)","def save(self, step=None):\n with self._graph.as_default():\n path = os.path.join(self._save_path, 'model/weights.ckpt')\n if step is not None:\n self._saver.save(self.sess, path, global_step=step)\n else:\n self._saver.save(self.sess, path)\n with open(os.path.join(self._save_path, 'LOG.txt'), 'a') as f:\n f.write('Saving Model to: ' + path + '\\n')\n\n # Pickle network architecture into a file.\n path = os.path.join(self._save_path, 'model/net_arch.pickle')\n with open(path, 'wb') as handle:\n pickle.dump(self.network_architecture, handle, protocol=pickle.HIGHEST_PROTOCOL)","def output_classLabel_to_txt(save_path):\n file_obj = open(save_path,'w')\n length = len(class_label)\n for i in range(0,length):\n line = '%d:%s'%(i,class_label[i])\n file_obj.writelines(line+'\\n')\n return True","def write_telluric_transmission_to_file(wls,T,outpath):\n import pickle\n print('------Saving teluric transmission to '+outpath)\n with open(outpath, 'wb') as f: pickle.dump((wls,T),f)","def save(self, folder):\n try:\n os.makedirs(folder)\n print(\"Created directory for generated code.\")\n except FileExistsError:\n pass\n\n with open(os.path.join(folder, \"network.cpp\"), \"w\") as f:\n f.write(self.network_code)\n\n with open(os.path.join(folder, \"network.h\"), \"w\") as f:\n f.write(self.network_header)\n\n # with open(os.path.join(folder, \"network_initialization.cpp\"), \"w\") as f:\n # f.write(self.constructor_code)\n #\n # with open(os.path.join(folder, \"network_initialization.h\"), \"w\") as f:\n # f.write(self.buffer_declaration)\n #\n # with open(os.path.join(folder, \"network_cleanup.cpp\"), \"w\") as f:\n # f.write(self.destructor_code)\n #\n # with open(os.path.join(folder, \"network_cleanup.h\"), \"w\") as f:\n # f.write(self.cleanup_header)\n\n with open(os.path.join(folder, \"network.weights.bin\"), \"wb\") as f:\n for packed_struct in self.packed_file:\n f.write(packed_struct)\n\n with open(os.path.join(folder, \"Makefile\"), \"w\") as f:\n f.write(self.makefile)\n\n with open(os.path.join(folder, \"dummy_input.cpp\"), \"w\") as f:\n f.write(self.dummy_input)\n\n with open(os.path.join(folder, \"reference_input.cpp\"), \"w\") as f:\n f.write(self.reference_input)","def save(self, name, hide=False):\n\n save = [self.neurons, self.weights]\n prefix = \"\"\n if hide:\n prefix = \".\"\n np.save(str(prefix + name + \".npy\"), save)\n\n if not self.silent:\n print(\"[NoxmainNetwork]: Network \\\"\" + str(name) + \"\\\" with neurons \" + str(self.neurons) + \" saved!\")","def save_knowledge(net, filepath):\n\tknowledge = get_knowledge(net)\n\tsavez(filepath, *knowledge)","def save_config(network, filename):\n with open(filename, \"wt\") as my_file:\n my_file.write(network.to_json())\n return None","def write_graph(g, filename):\n with open(filename, 'w') as f:\n f.write(repr(g))","def model_architecture(self, filename=None):\n list_summary = []\n self.model.summary(print_fn=lambda x: list_summary.append(x))\n summary = \"\\n\".join(list_summary)\n\n if filename:\n with open(filename + '.txt', 'w') as f:\n f.write(summary)\n\n from keras.utils import plot_model\n plot_model(self.model, filename + '.jpg')\n\n return summary","def save(self, current_epoch, path, file_type, save_weights=True):\r\n\r\n if (current_epoch == 0):\r\n # Saves the architecture\r\n architecture = {\r\n \"word_embedding_size\" : self._word_embedding_size,\r\n 'rels_descs_embed_type' : self._rels_descs_embed_type,\r\n 'rels_embedder_hidden_size': self._rels_embedder_hidden_size,\r\n }\r\n if (bool(self._mlp_params_dict)):\r\n architecture['mlp_params_dict'] = self._mlp_params_dict\r\n else:\r\n architecture['mlp_params_dict'] = {\r\n \"layers_sizes\" : self._mlp_layers,\r\n \"activation_functions\": self._mlp_activations,\r\n \"dropout_values\" : self._mlp_dropout_values,\r\n }\r\n torch.save(architecture, path + \"architecture.act\")\r\n\r\n # Saves the weights for the current_epoch, associated either with a checkpoint or the best performing model.\r\n if (save_weights):\r\n torch.save(self.state_dict(), path + \"weights\" + file_type)","def save(self):\n\t\tpath = input (\"To save ports scanned to file, please enter a filename, with or without path.\")\n\t\tf = None\n\t\tif not path.endswith('.txt'):\n\t\t\tpath+='.txt'\n\t\ttry:\n\t\t\tf=open(path, 'w')\n\t\texcept Exception as e:\n\t\t\tprint('file save failed, error from path')\n\t\t\tprint (e)\n\t\t\treturn\n\t\ttry:\n\t\t\tfor host in self.host_and_ports.keys():\n\t\t\t\tf.write(host + '\\n')\n\t\t\t\tfor port in self.host_and_ports[host]:\n\t\t\t\t\tf.write(str(port) +'\\n')\n\t\t\t\tf.write(\"\\n\")\n\t\texcept Exception as e:\n\t\t\tprint(e)","def save_network(self, expert_index, in_epoch):\r\n for i in range(self.layer_nums):\r\n for j in range(self.expert_nums):\r\n self.W[i][j, :, :].cpu().detach().numpy().tofile(\r\n os.path.join(\"C:/Users/rr/Desktop/sscc-main/model/nsm/model/part\", str(in_epoch)+'wc%0i%0i%0i_w.bin' % (expert_index, i, j)))\r\n self.B[i][j, :, :].cpu().detach().numpy().tofile(\r\n os.path.join(\"C:/Users/rr/Desktop/sscc-main/model/nsm/model/part\", str(in_epoch)+'wc%0i%0i%0i_b.bin' % (expert_index, i, j))\r\n )","def export_topology(topology, filename='topology.gml'):\n\n nx.write_gml(topology, filename)","def write(self, outfilename):\n\n nx.write_gpickle(self.graph, outfilename)","def serialize(self, outputDataFile):\n\n print \"Serializing graph to {} ...\".format(outputDataFile)\n fileWrite = open(outputDataFile, \"w\")\n turtle = self.graph.serialize(None, format='n3')\n fileWrite.writelines(turtle)\n fileWrite.close()\n print \"Serialization done.\"","def to_file(self, fn):\n store.store_dict(fn, 'trainalgorithm', self.to_dict())","def save_graph(self, path):\n if path.split('.')[-1]=='gexf':\n nx.write_gexf(self.graph, path)\n else:\n nx.write_gpickle(self.graph, path)","def writeDarknet(b, of):\n with open(of, \"w\") as fh:\n for r in b:\n cx = (r[1]+r[3])*0.5*iw\n cy = (r[2]+r[4])*0.5*ih\n w = (r[3] - r[1])*iw\n h = (r[4] - r[2])*ih\n fh.write(\"%d %f %f %f %f\\n\" % ( labels[r[0]], cx*dw, cy*dh, w*dw, h*dh) )","def store(self, path, time_step):\n with self.graph.as_default():\n file_name = os.path.join(path, \"network\")\n print(\"Saving networks...\")\n self.saver.save(self.sess, file_name, time_step)\n print(\"Saved!\")","def save_networks(self, which_epoch):\n for name in self.model_names:\n if isinstance(name, str):\n save_filename = '%s_net_%s.pth' % (which_epoch, name)\n save_path = os.path.join(self.save_dir, save_filename)\n net = getattr(self, 'net_' + name)\n torch.save(net.cpu().state_dict(), save_path)\n if len(self.gpu_ids) > 0 and torch.cuda.is_available():\n net.cuda()","def display_network_architecture(self):\n self.log(\"\\n-------- Network architecture --------\")\n self.log(\"y_res: {}\".format(self.y_res))\n self.log(\"x_res: {}\".format(self.x_res))\n self.log(\"n_input_channels: {}\".format(self.n_input_channels))\n self.log(\"n_output_classes: {}\".format(self.n_output_classes))\n self.log(\"input_dropout: {}\".format(self.fc1_dropout))\n self.log(\"alpha: {}\".format(self.alpha))\n self.log(\"n_samples_trained: {}\".format(self.n_samples_trained))\n for c in range(self.n_output_classes):\n self.log( \" * Class {}, m = {}\".format( \\\n c, self.n_class_samples_trained[c] ) )","def write_graph(graph, filename):\n with open(filename, 'w') as file: # open the file\n # record the number of nodes and edges\n num_nodes, num_edges = GraphProcessing.compute_num_nodes(graph), GraphProcessing.compute_num_edges(graph)\n file.write(\" \".join(list([str(num_nodes), str(num_edges)])) + \"\\n\")\n for source_node in graph.keys(): # for every node in the graph\n # for every other node and corresponding weight\n for terminal_node, weight in graph[source_node].items():\n # write the edge to the file as the first node, second node and edge weight\n file.write(\" \".join(list([str(source_node), str(terminal_node), str(weight)])) + \"\\n\")","def save_model(net, path):\n x_conv_weights = sess.run(net.parameters)\n x_bn_params = sess.run(get_batch_norm_vars(net))\n np.save(path, [x_conv_weights, x_bn_params])\n print(\"\\x1b[35mSaved model to:\\x1b[0m\", path)","def save(self, path):\n torch.save({\"epoch\": self.epoch,\n \"state_dict\": self.state_dict()}, path)\n self.logger.info(\"Saved controller network to %s\", path)","def save(self, filename):\n with open(filename, 'wb') as f:\n pickle.dump({'wi': self.W_input_to_hidden, 'wo': self.W_hidden_to_output}, f)","def save_bin(words,data,fname):\n\n out=open(fname,\"wb\")\n\n rows,dims=data.shape\n out.write(\"{} {}\\n\".format(rows,dims).encode(\"utf-8\"))\n counter=0\n\n for i,w in enumerate(words):\n out.write(w.encode(\"utf-8\"))\n out.write(\" \".encode(\"utf-8\"))\n out.write(struct.pack(\"{}f\".format(dims),*data[i,:]))\n counter+=1\n \n out.close()\n print(\"Model saved to\",fname,file=sys.stderr)","def save(self):\n filename = os.path.expanduser(\"~/\" + self.name)\n print(filename)\n np.savetxt(filename + \"_left.txt\", self.central)\n np.savetxt(filename + \"_right.txt\", self.boundaries)","def WriteSrnModelToFile(filename, model):\n\n # Write the .hpp file\n WriteHeaderFileForSrnModel(filename, model)\n\n # Write the .cpp fil\n WriteSourceFileForSrnModel(filename, model)","def write_to_disk(self):\n text_file = open(self.file_path, \"w\")\n text_file.write(str(self))\n text_file.close()\n # dump to pickle\n pickle.dump(self.blockchain, open(self.pickle_path, \"wb\"))","def save_chain_to_file(config_dict, samplesOutlet, samplesInlet, samplesFD, logPostList, w_num):\n outlet_path = f\"outputs/{config_dict['dir_name']}/AIES_LWR-outlet-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\"\n inlet_path = f\"outputs/{config_dict['dir_name']}/AIES_LWR-inlet-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\"\n FD_path = f\"outputs/{config_dict['dir_name']}/AIES_LWR-FD-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\"\n logPostList_path = f\"outputs/{config_dict['dir_name']}/AIES_LWR-FD-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-LogPostList.txt\"\n np.savetxt(outlet_path, samplesOutlet)\n np.savetxt(inlet_path, samplesInlet)\n np.savetxt(FD_path, samplesFD)\n np.savetxt(logPostList_path, logPostList)\n\n Run_settings = gen_run_setting_str(config_dict)\n run_settings_path = f\"outputs/{config_dict['dir_name']}/run_settings.txt\"\n with open(run_settings_path, 'w') as f:\n f.write(Run_settings)\n if config_dict[\"save_to_S3\"] == True:\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", outlet_path), local_path=outlet_path)\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", inlet_path), local_path=inlet_path)\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", FD_path), local_path=FD_path)\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", logPostList_path), local_path=logPostList_path)\n upload_chain(s3_path=os.path.join(\"AIES_LWR\", run_settings_path), local_path=run_settings_path)","def display_network_architecture(self):\n self.log(\"\\n-------- Network architecture --------\")\n self.log(\"y_res: {}\".format(self.y_res))\n self.log(\"x_res: {}\".format(self.x_res))\n self.log(\"n_input_channels: {}\".format(self.n_input_channels))\n self.log(\"n_output_classes: {}\".format(self.n_output_classes))\n self.log(\"fc1_n_chan: {}\".format(self.fc1_n_chan))\n self.log(\"fc1_dropout: {}\".format(self.fc1_dropout))\n self.log(\"alpha: {}\".format(self.alpha))\n self.log(\"n_samples_trained: {}\".format(self.n_samples_trained))\n for c in range(self.n_output_classes):\n self.log( \" * Class {}, m = {}\".format( \\\n c, self.n_class_samples_trained[c] ) )","def matlab_export(self, filename):\n\n import scipy.io as sio\n matdata = {}\n for nn in range(self.num_networks):\n for ll in range(len(self.networks[nn].layers)):\n wstring = 'ws' + str(nn) + str(ll)\n matdata[wstring] = self.networks[nn].layers[ll].weights\n bstring = 'bs' + str(nn) + str(ll)\n matdata[bstring] = self.networks[nn].layers[ll].biases\n\n sio.savemat(filename, matdata)","def write_to_train_file(files: List, train_file_path: str) -> None:\n f = open(train_file_path, \"w\")\n text_to_save = \"\"\n for i, img_path in enumerate(files):\n img_path_stripped = img_path.replace(\"/darknet\", \"\")\n if i == len(files) - 1:\n text_to_save += img_path_stripped\n else:\n text_to_save += img_path_stripped + \"\\n\"\n\n f.write(text_to_save)\n f.close()","def save(self, filename):\n hebbian_weights = open(filename, \"w\")\n for i in xrange(self.hidden):\n hebbian_weights.write(\"\\t\".join(self.vis_layer[i].get_weights()) + '\\n')\n for i in xrange(self.layers):\n for j in xrange(self.hidden):\n hebbian_weights.write(\"\\t\".join(self.hidden_layers[i][j].get_weights()) + '\\n')\n hebbian_weights.write(\"\\t\".join(self.output_neuron.get_weights()) + '\\n')\n hebbian_weights.close()","def save_model(self, model_file):\n net_params = self.get_policy_param() # get model params\n # torch.save(net, save_epoch + '.pkl') # 保存整个网络\n torch.save(net_params, model_file)","def generate_train_txt(name, path):\n with open(path + '/test.txt', 'a') as file:\n file.write('/content/YOLO_metric/data/obj/' + name + '\\n')","def saveGraph (self, filename) :\n\t\tss = \"digraph {\\n\"\n\t\tfor key, rules in self.production_rules.items() :\n\t\t\tfor rule in rules :\n\t\t\t\tr = [op.val for op in rule]\n\t\t\t\tr = [i.replace (\"-\", \"\") for i in r]\n\t\t\t\tr = [i.replace (\".\", \"\") for i in r]\n\t\t\t\tr = [i.replace (\"\\'\\'\", \"eps\") for i in r]\n\t\t\t\tr = [i.replace (\"\\\"\\\"\", \"eps\") for i in r]\n\t\t\t\tr = [i.replace (\"/\", \"_\") for i in r]\n\t\t\t\tk = key.replace (\"-\", \"\")\n\t\t\t\tk = k.replace (\"/\", \"_\")\n\t\t\t\tk = k.replace (\".\", \"_tok\")\n\t\t\t\tss += \"\\t\" + k + \" -> \" \n\t\t\t\tss += \" -> \".join (r)\n\t\t\t\tss += \" ;\\n\"\n\t\tss += \"}\"\n\t\tfilestream = open (filename + '.dot', 'w') \n\t\tfilestream.write(ss)\n\t\tfilestream.close ()\n\t\tcmd = 'dot -Tpng -o ' + filename + '.png ' + filename + '.dot'\n\t\tos.system (cmd)\n\t\tcmd = 'rm ' + filename + '.dot'\n\t\tos.system (cmd)","def display_network_architecture(self):\n self.log(\"\\n-------- Network architecture --------\")\n self.log(\"y_res: {}\".format(self.y_res))\n self.log(\"x_res: {}\".format(self.x_res))\n self.log(\"n_input_channels: {}\".format(self.n_input_channels))\n self.log(\"n_output_classes: {}\".format(self.n_output_classes))\n self.log(\"conv1_size: {}\".format(self.conv1_size))\n self.log(\"conv1_n_chan: {}\".format(self.conv1_n_chan))\n self.log(\"conv1_n_pool: {}\".format(self.conv1_n_pool))\n self.log(\"conv2_size: {}\".format(self.conv2_size))\n self.log(\"conv2_n_chan: {}\".format(self.conv2_n_chan))\n self.log(\"conv2_n_pool: {}\".format(self.conv2_n_pool))\n self.log(\"fc1_n_chan: {}\".format(self.fc1_n_chan))\n self.log(\"fc1_dropout: {}\".format(self.fc1_dropout))\n self.log(\"alpha: {}\".format(self.alpha))\n self.log(\"n_samples_trained: {}\".format(self.n_samples_trained))\n for c in range(self.n_output_classes):\n self.log( \" * Class {}, m = {}\".format( \\\n c, self.n_class_samples_trained[c] ) )","def write_to_txt(batch, filepath, typ='vector', verbose ='dataset'):\n if typ == 'params':\n with open(filepath, \"w\") as txt:\n for param_pack in batch:\n txt.write(\"{} ; {} ; {} \\n\".format(param_pack.alphaL, \n param_pack.alphaR, param_pack.label))\n #txt.write(str(param_pack.alphaL) +\", \"+str(param_pack.alphaR) +\"\\n\")\n elif typ == 'vector':\n if verbose == 'human':\n with open(filepath, \"w\") as txt:\n for vector in batch:\n txt.write(str(vector[0]) + \"\\n\")\n txt.write(str(vector[1]) + \"\\n\")\n elif verbose == 'dataset':\n with open(filepath, \"w\") as txt:\n for vector in batch:\n #txt.write(str(vector[0].x) +\";\"+str(vector[0].y) +\";\"+ str(vector[0].angle) +\";\"+ str(vector[0].norm()) + \"\\n\")\n txt.write(str(vector[1].x) +\";\"+ str(vector[1].angle) +\";\"+ str(vector[1].norm()) + \"\\n\")","def SaveLabels(filepath, labels):\n # 1) Create a string with all the text to be stored\n text = '\\n'.join(labels)\n\n # 2) Open the datafile and save the text\n with open(filepath, 'w') as outfile:\n outfile.write(text)","def save_networks(self, epoch):\n for name in self.network_names:\n if isinstance(name, str):\n save_filename = '{0}_net_{1}.pth'.format(epoch, name)\n save_path = os.path.join(self.save_dir, save_filename)\n net = getattr(self, 'net')\n\n if self.use_cuda:\n torch.save(net.cpu().state_dict(), save_path)\n net.to(self.device)\n else:\n torch.save(net.cpu().state_dict(), save_path)","def save(self, nodesName = False, edgesName = False, mode = \"authorities\"):\n\t\tif nodesName:\n\t\t\tself.outputNodes = nodesName\n\t\tif edgesName:\n\t\t\tself.outputEdges = edgesName\n\n\t\tif mode == \"authorities\":\n\t\t\tself.saveNodes()\n\t\telif mode == \"cluster\":\n\t\t\tself.saveCluster()","def export_to_file(self, path, graph_format):\n try:\n logging.info(\"Saving RDF data to \" + str(path))\n with open(path, \"wb\") as out_file:\n out_file.write(self.g.serialize(format=graph_format, encoding=\"UTF-8\"))\n except Exception as e:\n logging.error(\"Error while saving RDF results \"+str(e))","def save_file(self, *args):\n if args[0] == 'Save':\n filename = args[0]\n\n # Checks if user input is valid or null for filename. if null, assigns a default filename\n if args[1].text_field.text:\n filename = args[1].text_field.text\n\n f = open('output/' + filename + '.txt', 'w')\n f.write('\\nRegister Content: \\n')\n for k, v in REGISTER.items():\n f.write('\\n' + k.upper() + ':' + ' ' + v.upper() + '\\n')\n\n i = 0\n f.write('\\nMemory Content: \\n')\n while i < len(RAM):\n f.write(f'\\n{RAM[i]} {RAM[i + 1]}')\n i += 2\n\n toast('File saved in output folder as ' + filename + '.txt')\n f.close()\n\n else:\n toast('File save cancelled')","def to_file(self, file_path, smirnoff_data):\n pass","def save_model(self, name: str):\n\n # Saving the current config\n self.cM.create_config(name + \".cfg\")\n\n # Saving all Vocabs\n pickle.dump(self.output_field.vocab, open(name + \".out_voc\", \"wb\"))\n pickle.dump(self.input_field.vocab, open(name + \".in_voc\", \"wb\"))\n\n # Saving the actual network\n if os.path.exists(name + \".auto\"):\n # If auto saving found, simply rename it\n logging.info(f\"Autostopper STOP\")\n os.rename(name + \".auto\", name + \".ph\")\n else:\n self.network.save_model(name + \".ph\")","def cmd_wq(self):\n out_file = open(\"DoubleLinkedList.txt\", \"w\")\n out_file.write(str(self.get_text()))\n out_file.close()\n print(\"File saved to DoubleLinkedList.txt\")","def save_file():\n filepath = asksaveasfilename(\n defaultextension=\"txt\",\n filetypes=[(\"Text Files\", \"*.txt\"), (\"All Files\", \"*.*\")],\n )\n if not filepath:\n return\n with open(filepath, \"w\") as output_file:\n text = txt_edit.get(\"1.0\", tk.END)\n output_file.write(text)\n window.title(f\"Switch port Consolidation - {filepath}\")","def Save(self, filename: str):\n data_object = {\n \"input_layer_count\" : self.input_layer_size,\n \"hidden_layer_count\" : self.hidden_layer_size,\n \"output_layer_count\" : self.output_layer_size,\n\n \"hidden_layer_biases\" : self.hidden_layer_biases.tolist(),\n \"output_layer_biases\" : self.output_layer_biases.tolist(),\n\n \"input_to_hidden_weights\" : self.input_to_hidden_weights.tolist(),\n \"hidden_to_output_weights\" : self.hidden_to_output_weights.tolist()\n }\n\n with open(filename, \"w\") as f:\n json.dump(data_object, f)","def write_model_info(content=None):\n _info_dir = os.path.join(CKPT_DIR, UNIQUE_NAME)\n create_dir(_info_dir)\n if content is None:\n content = f\"Backbone: {BACKBONE}\\nLR: {LEARNING_RATE}\\n\" \\\n f\"Resolution: {IMAGE_SIZE}\\nAugmentations: {AUG_PROBABILITY}\"\n\n with open(os.path.join(_info_dir, 'info.txt'), 'a') as fp:\n fp.write(content + '\\n')","def save(self, filename):\n fptr = open(filename, 'w')\n for node in self.val_l:\n fptr.write(str(node) + \" \" + str(self.val_l[node]) +\n \" \" + str(self.val_c[node]) + \"\\n\")\n fptr.close()","def save(self, filename):\n with open(filename, 'wb') as f:\n pickle.dump({'wi': self.W_input_to_hidden, 'wh':\n self.W_hidden_to_hidden, 'wo': self.W_hidden_to_output}, f)","def _createNetwork(self,verbose):\n filename,n,rulesList = self.filename,self.n,self.rulesList\n if self.verbose:\n mult = 2\n if self.MichaelisMenten:\n mult = 4\n start,startWall = cpuTime(),wallTime()\n print(\"\")\n print(\"Creating network with \"+str(n)+\" activation sites\")\n print(\" and \"+str(len(rulesList))+\" additional rules (\" \\\n +str(mult*(n+len(rulesList)))+\" parameters).\")\n \n namesList = writeBNGL.writeBNGLnetwork(n,rulesList,filename, \\\n MichaelisMenten=self.MichaelisMenten)\n self._runBNGLfile(filename)\n \n if self.verbose:\n print(\"Network creation took \"+bothTimeStr(start,startWall))\n \n return namesList","def save(model, save_name):\n dirs = configparser.ConfigParser()\n dirs.read(\"config/dir_config.ini\")\n\n save_name = os.path.splitext(save_name)[0]\n path = os.path.join(dirs[\"save_dirs\"][\"models\"], save_name + \".h5\")\n info = os.path.join(dirs[\"save_dirs\"][\"models\"], save_name + \"_info.txt\")\n\n with open(info, \"w\") as file:\n model.summary(print_fn=lambda x: file.write(f\"{x}\\n\"))\n model.save(path, overwrite=False)","def to_file(self, file): \n try:\n import dill as pickle\n except ImportError:\n logger.error(\"Cannot write to file, dill not installed \\n\"\n \"pip install dill\")\n return\n try:\n logger.info('Writing GeologicalModel to: {}'.format(file))\n pickle.dump(self,open(file,'wb'))\n except pickle.PicklingError:\n logger.error('Error saving file')"],"string":"[\n \"def save(self, path=\\\"\\\"):\\n path = path + \\\"model_\\\" + str(self.name) + \\\".txt\\\"\\n if os.path.isfile(path):\\n os.remove(path)\\n f = open(path, \\\"w+\\\")\\n for ident in self.networks:\\n f.write(ident + \\\"_\\\" + self.networks[ident].descriptor.codify_components() + \\\"_\\\" + str(self.networks[ident].taking.size) + \\\",\\\" + self.networks[ident].taking.type + \\\"_\\\" + str(self.networks[ident].producing.size) + \\\",\\\" + self.networks[ident].producing.type + \\\"_\\\" +\\n str(self.networks[ident].depth) + \\\"_\\\" + \\\",\\\".join(self.reachable[ident]) + \\\"_\\\" + \\\",\\\".join(self.comps_below[ident]) + \\\"\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n\\n for ident in self.inputs:\\n f.write(ident + \\\"_\\\" + str(self.inputs[ident].producing.size) + \\\"_\\\" + self.inputs[ident].producing.type + \\\"_\\\" + str(self.inputs[ident].depth) + \\\"\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n\\n for ident in self.outputs:\\n f.write(ident + \\\"_\\\" + str(self.outputs[ident].taking.size) + \\\"_\\\" + self.outputs[ident].taking.type + \\\"_\\\" + str(self.outputs[ident].depth) + \\\"_\\\" + \\\",\\\".join(self.comps_below[ident]) + \\\"\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n\\n for con in self.connections:\\n f.write(self.connections[con].codify() + \\\"\\\\n\\\")\\n #f.write(\\\"\\\\n\\\")\\n\\n f.close()\\n\\n return path\",\n \"def save_network_architecture(self,network_path):\\n net_architecture = {}\\n net_architecture['y_res'] = self.y_res\\n net_architecture['x_res'] = self.x_res\\n net_architecture['n_input_channels'] = self.n_input_channels\\n net_architecture['n_output_classes'] = self.n_output_classes\\n net_architecture['fc1_dropout'] = self.fc1_dropout\\n net_architecture['alpha'] = self.alpha\\n net_architecture['n_samples_trained'] = self.n_samples_trained\\n net_architecture['n_class_samples_trained'] = self.n_class_samples_trained\\n net_architecture['n_samples_list'] = self.n_samples_list\\n net_architecture['n_class_samples_list'] = self.n_class_samples_list\\n net_architecture['accuracy_list'] = self.accuracy_list\\n net_architecture['precision_list'] = self.precision_list\\n net_architecture['recall_list'] = self.recall_list\\n net_architecture['F1_list'] = self.F1_list\\n np.save(os.path.join( \\\\\\n network_path,'net_architecture.npy'), net_architecture)\\n self.log(\\\"Network architecture saved to file:\\\\n{}\\\".format(\\n os.path.join(network_path,'net_architecture.npy')))\",\n \"def save_network_architecture(self,network_path):\\n net_architecture = {}\\n net_architecture['y_res'] = self.y_res\\n net_architecture['x_res'] = self.x_res\\n net_architecture['n_input_channels'] = self.n_input_channels\\n net_architecture['n_output_classes'] = self.n_output_classes\\n net_architecture['fc1_n_chan'] = self.fc1_n_chan\\n net_architecture['fc1_dropout'] = self.fc1_dropout\\n net_architecture['alpha'] = self.alpha\\n net_architecture['n_samples_trained'] = self.n_samples_trained\\n net_architecture['n_class_samples_trained'] = self.n_class_samples_trained\\n net_architecture['n_samples_list'] = self.n_samples_list\\n net_architecture['n_class_samples_list'] = self.n_class_samples_list\\n net_architecture['accuracy_list'] = self.accuracy_list\\n net_architecture['precision_list'] = self.precision_list\\n net_architecture['recall_list'] = self.recall_list\\n net_architecture['F1_list'] = self.F1_list\\n np.save(os.path.join( \\\\\\n network_path,'net_architecture.npy'), net_architecture)\\n self.log(\\\"Network architecture saved to file:\\\\n{}\\\".format(\\n os.path.join(network_path,'net_architecture.npy')))\",\n \"def save_architecture(model, path_out):\\n # Redirect the print output the a textfile\\n orig_stdout = sys.stdout\\n # and store the architecture\\n f = file(os.path.join(path_out, \\\"architecture.txt\\\"), 'w')\\n sys.stdout = f\\n model.summary()\\n # Reset the print output direction\\n sys.stdout = orig_stdout\\n f.close()\\n\\n open(os.path.join(path_out, \\\"config.json\\\"), 'w').write(model.to_json())\",\n \"def save_network_architecture(self,network_path):\\n net_architecture = {}\\n net_architecture['y_res'] = self.y_res\\n net_architecture['x_res'] = self.x_res\\n net_architecture['n_input_channels'] = self.n_input_channels\\n net_architecture['n_output_classes'] = self.n_output_classes\\n net_architecture['conv1_size'] = self.conv1_size\\n net_architecture['conv1_n_chan'] = self.conv1_n_chan\\n net_architecture['conv1_n_pool'] = self.conv1_n_pool\\n net_architecture['conv2_size'] = self.conv2_size\\n net_architecture['conv2_n_chan'] = self.conv2_n_chan\\n net_architecture['conv2_n_pool'] = self.conv2_n_pool\\n net_architecture['fc1_n_chan'] = self.fc1_n_chan\\n net_architecture['fc1_dropout'] = self.fc1_dropout\\n net_architecture['alpha'] = self.alpha\\n net_architecture['n_samples_trained'] = self.n_samples_trained\\n net_architecture['n_class_samples_trained'] = self.n_class_samples_trained\\n net_architecture['n_samples_list'] = self.n_samples_list\\n net_architecture['n_class_samples_list'] = self.n_class_samples_list\\n net_architecture['accuracy_list'] = self.accuracy_list\\n net_architecture['precision_list'] = self.precision_list\\n net_architecture['recall_list'] = self.recall_list\\n net_architecture['F1_list'] = self.F1_list\\n np.save(os.path.join( \\\\\\n network_path,'net_architecture.npy'), net_architecture)\\n self.log(\\\"Network architecture saved to file:\\\\n{}\\\".format(\\n os.path.join(network_path,'net_architecture.npy')))\",\n \"def write_network_file(self, model, **kwargs):\\n model.set_names()\\n # Output network file\\n output_file = self.output_path + \\\"/network.txt\\\"\\n\\n self.network_have_substations = False\\n\\n # Lists for storing strings\\n source_string_list = []\\n overhead_string_list = []\\n overhead_byphase_string_list = []\\n underground_string_list = []\\n switch_string_list = []\\n fuse_string_list = []\\n recloser_string_list = []\\n breaker_string_list = []\\n capacitor_string_list = []\\n two_windings_transformer_string_list = []\\n three_windings_transformer_string_list = []\\n regulator_string_list = []\\n converter_string_list = []\\n converter_control_string_list = []\\n pv_settings_string_list = []\\n bess_settings_string_list = []\\n dg_generation_string_list = []\\n\\n # The linecodes dictionary is used to group lines which have the same properties\\n # (impedance matrix, ampacity...)\\n # This dictionary will be outputed in write_equipment_file\\n ID = 0\\n self.linecodes_overhead = {}\\n ID_cable = 0\\n self.cablecodes = {}\\n ID_cap = 0\\n self.capcodes = {}\\n ID_trans = 0\\n self.two_windings_trans_codes = {}\\n ID_reg = 0\\n self.reg_codes = {}\\n ID_trans_3w = 0\\n self.three_windings_trans_codes = {}\\n ID_cond = 0\\n self.bess_codes = {}\\n ID_bess = 0\\n self.conductors = {}\\n self.switchcodes = {}\\n self.fusecodes = {}\\n self.reclosercodes = {}\\n self.breakercodes = {}\\n self.irradiance_profiles = {}\\n\\n intermediate_nodes = []\\n\\n self.sources = {}\\n\\n self.substations = []\\n\\n # Open the output file...\\n with open(output_file, \\\"w\\\") as f:\\n\\n # before doing anything, we need to get all transformers that have a regulator connected to them\\n # In CYME, Regulators do not need to have a transformer object, so we need to ignore the transformers with regulators\\n self.transformers_to_ignore = [\\n i.connected_transformer\\n for i in model.models\\n if isinstance(i, Regulator)\\n ]\\n\\n # Build connector_string_mapping\\n # TODO integrate into rest of model so we don't have to loop twice over ditto elements\\n for i in model.models:\\n if (\\n hasattr(i, \\\"from_element\\\")\\n and i.from_element is not None\\n and hasattr(i, \\\"from_element_connection_index\\\")\\n and i.from_element_connection_index is not None\\n ):\\n self.node_connector_string_mapping[\\n (i.from_element, i.from_element_connection_index)\\n ] = \\\"{f}_{t}\\\".format(f=i.from_element, t=i.to_element)\\n if (\\n len(\\n self.node_connector_string_mapping[\\n (i.from_element, i.from_element_connection_index)\\n ]\\n )\\n > 64\\n ):\\n hasher = hashlib.sha1()\\n hasher.update(\\n self.node_connector_string_mapping[\\n (i.from_element, i.from_element_connection_index)\\n ].encode(\\\"utf-8\\\")\\n )\\n self.node_connector_string_mapping[\\n (i.from_element, i.from_element_connection_index)\\n ] = hasher.hexdigest()\\n\\n if (\\n hasattr(i, \\\"to_element\\\")\\n and i.to_element is not None\\n and hasattr(i, \\\"to_element_connection_index\\\")\\n and i.to_element_connection_index is not None\\n ):\\n self.node_connector_string_mapping[\\n (i.to_element, i.to_element_connection_index)\\n ] = \\\"{f}_{t}\\\".format(f=i.from_element, t=i.to_element)\\n if (\\n len(\\n self.node_connector_string_mapping[\\n (i.to_element, i.to_element_connection_index)\\n ]\\n )\\n > 64\\n ):\\n hasher = hashlib.sha1()\\n hasher.update(\\n self.node_connector_string_mapping[\\n (i.to_element, i.to_element_connection_index)\\n ].encode(\\\"utf-8\\\")\\n )\\n self.node_connector_string_mapping[\\n (i.to_element, i.to_element_connection_index)\\n ] = hasher.hexdigest()\\n\\n # Loop over the DiTTo objects\\n for i in model.models:\\n\\n if hasattr(i, \\\"drop\\\") and i.drop == 1:\\n continue\\n\\n # If we get a PowerSource object\\n #\\n if isinstance(i, PowerSource):\\n # Check that the PowerSouce object is an external power source\\n if hasattr(i, \\\"is_sourcebus\\\") and i.is_sourcebus == 1:\\n # Empty new source string\\n new_source_string = \\\"\\\"\\n self.substations.append({})\\n\\n if (\\n hasattr(i, \\\"connecting_element\\\")\\n and i.connecting_element is not None\\n ):\\n self.sources[i.connecting_element] = None\\n new_source_string += i.connecting_element\\n self.substations[-1][\\n \\\"connecting_element\\\"\\n ] = i.connecting_element\\n else:\\n continue\\n\\n if (\\n hasattr(i, \\\"nominal_voltage\\\")\\n and i.nominal_voltage is not None\\n ):\\n new_source_string += \\\",\\\" + str(i.nominal_voltage * 10 ** -3)\\n self.sources[i.connecting_element] = str(\\n i.nominal_voltage * 10 ** -3\\n )\\n self.substations[-1][\\\"KVLL\\\"] = str(\\n i.nominal_voltage * 10 ** -3\\n )\\n elif (\\n hasattr(i, \\\"connecting_element\\\")\\n and i.connecting_element is not None\\n and i.connecting_element in model.model_names\\n and hasattr(model[i.connecting_element], \\\"nominal_voltage\\\")\\n and model[i.connecting_element].nominal_voltage is not None\\n ):\\n voltage = model[i.connecting_element].nominal_voltage\\n new_source_string += \\\",\\\" + str(voltage * 10 ** -3)\\n self.sources[i.connecting_element] = str(voltage * 10 ** -3)\\n self.substations[-1][\\\"KVLL\\\"] = str(voltage * 10 ** -3)\\n else:\\n new_source_string += \\\",\\\"\\n\\n if hasattr(i, \\\"phase_angle\\\") and i.phase_angle is not None:\\n new_source_string += \\\",\\\" + str(i.phase_angle)\\n new_source_string += \\\",\\\" + str(i.phase_angle - 120)\\n new_source_string += \\\",\\\" + str(i.phase_angle + 120)\\n self.substations[-1][\\\"phase_angle\\\"] = str(i.phase_angle)\\n else:\\n new_source_string += \\\",,,\\\"\\n\\n if (\\n hasattr(i, \\\"positive_sequence_impedance\\\")\\n and i.positive_sequence_impedance is not None\\n ):\\n new_source_string += (\\n \\\",\\\"\\n + str(i.positive_sequence_impedance.real)\\n + \\\",\\\"\\n + str(i.positive_sequence_impedance.imag)\\n )\\n self.substations[-1][\\\"R1\\\"] = str(\\n i.positive_sequence_impedance.real\\n )\\n self.substations[-1][\\\"X1\\\"] = str(\\n i.positive_sequence_impedance.imag\\n )\\n else:\\n new_source_string += \\\",,\\\"\\n\\n if (\\n hasattr(i, \\\"zero_sequence_impedance\\\")\\n and i.zero_sequence_impedance is not None\\n ):\\n new_source_string += (\\n \\\",\\\"\\n + str(i.zero_sequence_impedance.real)\\n + \\\",\\\"\\n + str(i.zero_sequence_impedance.imag)\\n )\\n self.substations[-1][\\\"R0\\\"] = str(\\n i.zero_sequence_impedance.real\\n )\\n self.substations[-1][\\\"X0\\\"] = str(\\n i.zero_sequence_impedance.imag\\n )\\n else:\\n new_source_string += \\\",,\\\"\\n\\n if (\\n hasattr(i, \\\"negative_sequence_impedance\\\")\\n and i.negative_sequence_impedance is not None\\n ):\\n new_source_string += (\\n \\\",\\\"\\n + str(i.negative_sequence_impedance.real)\\n + \\\",\\\"\\n + str(i.negative_sequence_impedance.imag)\\n )\\n elif (\\n hasattr(i, \\\"zero_sequence_impedance\\\")\\n and i.zero_sequence_impedance is not None\\n ):\\n new_source_string += (\\n \\\",\\\"\\n + str(i.zero_sequence_impedance.real)\\n + \\\",\\\"\\n + str(i.zero_sequence_impedance.imag)\\n )\\n else:\\n new_source_string += \\\",,\\\"\\n\\n # OperatingVoltages\\n try:\\n new_source_string += \\\",{v},{v},{v},0\\\".format(\\n v=i.nominal_voltage * 10 ** -3\\n )\\n except:\\n new_source_string += \\\",,,,0\\\"\\n pass\\n\\n if hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n self.substations[-1][\\\"MVA\\\"] = str(i.rated_power * 10 ** -6)\\n\\n if new_source_string != \\\"\\\":\\n source_string_list.append(new_source_string)\\n\\n # If we get a Node object\\n #\\n if isinstance(i, Node):\\n\\n # Empty new node string\\n new_node_string = \\\"\\\"\\n\\n # Empty new bus string (for bus representations of nodes with two coords)\\n new_bus_string = \\\"\\\"\\n\\n # Name\\n if hasattr(i, \\\"name\\\") and i.name is not None:\\n self.nodeID_list.append(i.name)\\n else:\\n continue\\n\\n # CoordX and CoordY\\n if (\\n hasattr(i, \\\"positions\\\")\\n and i.positions is not None\\n and len(i.positions) == 1\\n ):\\n new_node_string += i.name\\n try:\\n new_node_string += \\\",\\\" + str(i.positions[0].long)\\n except:\\n new_node_string += \\\",0\\\"\\n pass\\n\\n try:\\n new_node_string += \\\",\\\" + str(i.positions[0].lat)\\n except:\\n new_node_string += \\\",0\\\"\\n pass\\n elif (\\n hasattr(i, \\\"positions\\\")\\n and i.positions is not None\\n and len(i.positions) >= 2\\n ):\\n new_bus_string += i.name\\n try:\\n new_bus_string += \\\",\\\" + str(i.positions[0].long)\\n except:\\n new_bus_string += \\\",0\\\"\\n pass\\n\\n try:\\n new_bus_string += \\\",\\\" + str(i.positions[0].lat)\\n except:\\n new_bus_string += \\\",0\\\"\\n pass\\n\\n try:\\n new_bus_string += \\\",\\\" + str(i.positions[-1].long)\\n except:\\n new_bus_string += \\\",0\\\"\\n pass\\n\\n try:\\n new_bus_string += \\\",\\\" + str(i.positions[-1].lat)\\n except:\\n new_bus_string += \\\",0\\\"\\n pass\\n new_bus_string += \\\",2\\\" # Set width of 2\\n for j in range(1, len(i.positions) - 1):\\n sectionid = \\\"\\\"\\n if (i.name, j - 1) in self.node_connector_string_mapping:\\n sectionid = self.node_connector_string_mapping[\\n (i.name, j - 1)\\n ]\\n new_node_connector_string = \\\"{n},{x},{y},{s}\\\".format(\\n n=i.name,\\n x=i.positions[j].long,\\n y=i.positions[j].lat,\\n s=sectionid,\\n )\\n self.node_connector_string_list.append(\\n new_node_connector_string\\n )\\n\\n else:\\n new_node_string += i.name\\n new_node_string += \\\",0,0\\\"\\n\\n # Add the node string to the list\\n if new_node_string != \\\"\\\":\\n self.node_string_list.append(new_node_string)\\n\\n if new_bus_string != \\\"\\\":\\n self.bus_string_list.append(new_bus_string)\\n\\n # If we get a Line object\\n #\\n if isinstance(i, Line):\\n\\n matching_list = {\\n \\\"overhead\\\": overhead_string_list,\\n \\\"by_phase\\\": overhead_byphase_string_list,\\n \\\"underground\\\": underground_string_list,\\n \\\"switch\\\": switch_string_list,\\n \\\"fuse\\\": fuse_string_list,\\n \\\"recloser\\\": recloser_string_list,\\n \\\"breaker\\\": breaker_string_list,\\n }\\n\\n # Empty new strings for sections and overhead lines\\n new_section_line = \\\"\\\"\\n new_line_string = \\\"\\\"\\n line_type = \\\"overhead\\\" # Line type is set to overhead by default\\n\\n # Name\\n if hasattr(i, \\\"name\\\") and i.name is not None:\\n\\n # Get the type\\n #\\n # (In DiTTo, a line object can be used to represent overhead and underground lines,\\n # as well as switches and fuses).\\n #\\n if hasattr(i, \\\"line_type\\\"):\\n\\n # if i.line_type is None:\\n\\n # Fuses and reclosers are modelled in OpenDSS as an object monitoring a line.\\n # In RNM, this dummy line is actually a switch, meaning that we have in DiTTo\\n # line objects where is_switch==1 AND is_fuse==1 (or is_recloser==1)\\n # We want to output these as fuses or reclosers, not as switches\\n # Hence the following:\\n # if hasattr(i, 'is_fuse') and i.is_fuse==1:\\n # line_type='fuse'\\n\\n # elif hasattr(i, 'is_recloser') and i.is_recloser==1:\\n # line_type='recloser'\\n # ONLY if line is not a fuse nor a recloser, but is a switch do we output a switch...\\n # elif hasattr(i, 'is_switch') and i.is_switch==1:\\n # line_type='switch'\\n\\n if i.line_type is not None:\\n if i.line_type.lower() == \\\"underground\\\":\\n line_type = \\\"underground\\\"\\n\\n if (\\n hasattr(i, \\\"nominal_voltage\\\")\\n and i.nominal_voltage is not None\\n and i.nominal_voltage < 600\\n ):\\n line_type = \\\"underground\\\" # for triplex lines\\n\\n if hasattr(i, \\\"is_fuse\\\") and i.is_fuse == 1:\\n line_type = \\\"fuse\\\"\\n\\n elif hasattr(i, \\\"is_recloser\\\") and i.is_recloser == 1:\\n line_type = \\\"recloser\\\"\\n\\n elif hasattr(i, \\\"is_breaker\\\") and i.is_breaker == 1:\\n line_type = \\\"breaker\\\"\\n\\n # ONLY if line is not a fuse nor a recloser, but is a switch do we output a switch...\\n elif hasattr(i, \\\"is_switch\\\") and i.is_switch == 1:\\n line_type = \\\"switch\\\"\\n\\n # From element for sections\\n if (\\n hasattr(i, \\\"from_element\\\")\\n and i.from_element is not None\\n and hasattr(i, \\\"to_element\\\")\\n and i.to_element is not None\\n ):\\n new_section_ID = \\\"{f}_{t}\\\".format(\\n f=i.from_element, t=i.to_element\\n )\\n if hasattr(i, \\\"feeder_name\\\") and i.feeder_name is not None:\\n if i.feeder_name in self.section_feeder_mapping:\\n while (\\n new_section_ID\\n in self.section_feeder_mapping[i.feeder_name]\\n ):\\n new_section_ID = (\\n new_section_ID + \\\"*\\\"\\n ) # This is used to deal with duplicate lines from same from and to nodes\\n if len(new_section_ID) > 64:\\n hasher = hashlib.sha1()\\n hasher.update(\\n new_section_ID.encode(\\\"utf-8\\\")\\n )\\n new_section_ID = hasher.hexdigest()\\n if len(new_section_ID) > 64:\\n hasher = hashlib.sha1()\\n hasher.update(new_section_ID.encode(\\\"utf-8\\\"))\\n new_section_ID = hasher.hexdigest()\\n new_line_string += new_section_ID\\n from_index = 0\\n to_index = 0\\n if (\\n hasattr(i, \\\"from_element_connection_index\\\")\\n and i.from_element_connection_index is not None\\n ):\\n from_index = i.from_element_connection_index\\n if (\\n hasattr(i, \\\"to_element_connection_index\\\")\\n and i.to_element_connection_index is not None\\n ):\\n to_index = i.to_element_connection_index\\n new_section_line = \\\"{id},{f},{fi},{t},{ti}\\\".format(\\n id=new_section_ID,\\n f=i.from_element,\\n fi=from_index,\\n t=i.to_element,\\n ti=to_index,\\n )\\n if hasattr(i, \\\"feeder_name\\\") and i.feeder_name is not None:\\n if i.feeder_name in self.section_feeder_mapping:\\n self.section_feeder_mapping[i.feeder_name].append(\\n new_section_ID\\n )\\n else:\\n self.section_feeder_mapping[i.feeder_name] = [\\n new_section_ID\\n ]\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n ):\\n self.section_headnode_mapping[\\n i.feeder_name\\n ] = i.substation_name\\n else:\\n raise ValueError(\\n \\\"Line {name} does not have from and to.\\\".format(\\n name=i.name\\n )\\n )\\n\\n if (\\n hasattr(i, \\\"positions\\\")\\n and i.positions is not None\\n and len(i.positions) > 0\\n ):\\n for seg_number, position in enumerate(i.positions):\\n intermediate_nodes.append(\\n [\\n new_section_ID,\\n seg_number,\\n position.long,\\n position.lat,\\n ]\\n )\\n\\n # Phases of the section\\n #\\n new_section_line += \\\",\\\"\\n phases = []\\n cond_id = {}\\n if hasattr(i, \\\"wires\\\") and i.wires is not None:\\n i.wires = [w for w in i.wires if w.drop != 1]\\n for wire in i.wires:\\n\\n if hasattr(wire, \\\"phase\\\") and wire.phase is not None:\\n # Do not count the neutral(s)...\\n if wire.phase in [\\\"A\\\", \\\"B\\\", \\\"C\\\"]:\\n new_section_line += wire.phase\\n phases.append(wire.phase)\\n\\n new_code = \\\"\\\"\\n if (\\n hasattr(wire, \\\"diameter\\\")\\n and wire.diameter is not None\\n ):\\n new_code += \\\",{}\\\".format(wire.diameter)\\n else:\\n new_code += \\\",\\\"\\n\\n if hasattr(wire, \\\"gmr\\\") and wire.gmr is not None:\\n new_code += \\\",{}\\\".format(wire.gmr)\\n\\n # These calculations require no neutral wire as output (since these equations assume no kron reduction)\\n # They serve the purpose of getting the impedance matrix output in CYME to match the impedance matrix from DiTTo\\n # NOTE: a 2x2 impedance matrix is probably derived from R1, R0, X1, X0 and isn't actually a 2-wire or even a kron reduced matrix.\\n # To get the cross-terms to match would require a kron reduction, often of imaginary wire resistances to get the cross-terms to match\\n # For that reason, we let CYME apply the cross terms with their default spacing. This may cause some differences in the powerflow\\n # i.e. WARNING - 2x2 matrix cross terms won't match\\n\\n elif wire.gmr is None and (\\n len(i.impedance_matrix) == 1\\n or len(i.impedance_matrix) == 2\\n ):\\n\\n if isinstance(i.impedance_matrix, list):\\n x_in_miles = i.impedance_matrix[0][0].imag\\n else:\\n x_in_miles = i.impedance_matrix[0].imag\\n x_in_miles = (\\n x_in_miles * 1609.34\\n ) # internally impedance per meter\\n coeff1 = 0.12134\\n coeff2 = 7.93402\\n gmr_in_feet = 1 / (\\n math.exp((x_in_miles / coeff1) - coeff2)\\n ) # Solving Kerstin 4.41 for GMR\\n gmr_in_cm = 30.48 * gmr_in_feet\\n new_code += \\\",{}\\\".format(gmr_in_cm)\\n else:\\n new_code += \\\",\\\"\\n\\n if (\\n hasattr(wire, \\\"resistance\\\")\\n and wire.resistance is not None\\n ):\\n new_code += \\\",{}\\\".format(wire.resistance)\\n elif wire.resistance is None and (\\n len(i.impedance_matrix) == 1\\n or len(i.impedance_matrix) == 2\\n ): # Calculate the resistance from the impedance matrix\\n if isinstance(i.impedance_matrix, list):\\n r_in_miles = i.impedance_matrix[0][0].real\\n else:\\n r_in_miles = i.impedance_matrix[0].real\\n r_in_miles = (\\n r_in_miles * 1609.34\\n ) # internally impedance per meter\\n resistance = r_in_miles - 0.09530 # From Kersting\\n resistance = (\\n resistance / 1.60934\\n ) # output in ohms per km\\n new_code += \\\",{}\\\".format(resistance)\\n\\n else:\\n new_code += \\\",\\\"\\n\\n if (\\n hasattr(wire, \\\"ampacity\\\")\\n and wire.ampacity is not None\\n ):\\n new_code += \\\",{}\\\".format(wire.ampacity)\\n else:\\n new_code += \\\",\\\"\\n\\n if (\\n hasattr(wire, \\\"emergency_ampacity\\\")\\n and wire.emergency_ampacity is not None\\n ):\\n new_code += \\\",{}\\\".format(wire.emergency_ampacity)\\n else:\\n new_code += \\\",\\\".format(wire.emergency_ampacity)\\n\\n # if line_type=='underground':\\n # If we have a name for the wire, we use it as the equipment id\\n if (\\n hasattr(wire, \\\"nameclass\\\")\\n and wire.nameclass is not None\\n and wire.nameclass != \\\"\\\"\\n ):\\n wire_name = wire.nameclass\\n # If not already in the conductors dictionary, add it\\n if wire_name not in self.conductors:\\n self.conductors[wire_name] = new_code\\n cond_id[wire.phase] = wire_name\\n # If we do not have a name for the wire, we create one:\\n # The IDs will be wire_1, wire_2,...\\n else:\\n found = False\\n # Try to find if we already have the conductor stored\\n for key, value in self.conductors.items():\\n if value == new_code:\\n cond_id[wire.phase] = key\\n found = True\\n # If not, create it\\n if not found:\\n ID_cond += 1\\n self.conductors[\\n \\\"conductor_{}\\\".format(ID_cond)\\n ] = new_code\\n cond_id[wire.phase] = ID_cond\\n\\n # Impedance matrix\\n #\\n # Here, we group lines that have the same characteristics:\\n # R0,R1,X0,X1,ampacity\\n # We create am ID for these lines (Here a simple integer)\\n #\\n # If we have a switch, we just use default because there is no way (to my knowledge)\\n # to provide the impedance matrix for a switch in CYME\\n frequency = 60 # Need to make this changable\\n if line_type == \\\"switch\\\":\\n if (\\n i.nameclass is not None\\n and i.nameclass != \\\"\\\"\\n and i.wires[0].ampacity is not None\\n and i.nominal_voltage is not None\\n ):\\n new_code2 = \\\"{amps},{amps},{amps},{amps},{amps},{kvll},0,,,,,,,,0,0,0,0,0,\\\".format(\\n amps=i.wires[0].ampacity,\\n kvll=i.nominal_voltage * 10 ** -3,\\n )\\n\\n if (\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n not in self.switchcodes\\n ):\\n self.switchcodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ] = new_code2\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n\\n elif (\\n self.switchcodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ]\\n != new_code2\\n ):\\n found = False\\n for k, v in self.switchcodes.items():\\n if new_code2 == v:\\n new_line_string += \\\",\\\" + str(k)\\n found = True\\n if not found:\\n self.switchcodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ] = new_code2\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n else:\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n\\n else:\\n new_line_string += \\\",DEFAULT\\\"\\n\\n elif line_type == \\\"fuse\\\":\\n if (\\n i.nameclass is not None\\n and i.nameclass != \\\"\\\"\\n and i.wires[0].ampacity is not None\\n and i.nominal_voltage is not None\\n ):\\n new_code2 = \\\"{amps},{amps},{amps},{amps},{amps},{kvll},0,600.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0,0,0,,,,\\\".format(\\n amps=i.wires[0].ampacity,\\n kvll=i.nominal_voltage * 10 ** -3,\\n )\\n\\n if (\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n not in self.fusecodes\\n ):\\n self.fusecodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ] = new_code2\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n\\n elif (\\n self.fusecodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ]\\n != new_code2\\n ):\\n found = False\\n for k, v in self.fusecodes.items():\\n if new_code2 == v:\\n new_line_string += \\\",\\\" + str(k)\\n found = True\\n if not found:\\n self.fusecodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ] = new_code2\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n else:\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n\\n else:\\n new_line_string += \\\",DEFAULT\\\"\\n\\n elif line_type == \\\"recloser\\\":\\n if (\\n i.nameclass is not None\\n and i.nameclass != \\\"\\\"\\n and i.wires[0].ampacity is not None\\n and i.nominal_voltage is not None\\n ):\\n new_code2 = \\\"{amps},{amps},{amps},{amps},{amps},{kvll},0,600.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0,0,0,0,0,0,,1,,\\\".format(\\n amps=i.wires[0].ampacity,\\n kvll=i.nominal_voltage * 10 ** -3,\\n )\\n\\n if (\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n not in self.reclosercodes\\n ):\\n self.reclosercodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ] = new_code2\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n\\n elif (\\n self.reclosercodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ]\\n != new_code2\\n ):\\n found = False\\n for k, v in self.reclosercodes.items():\\n if new_code2 == v:\\n new_line_string += \\\",\\\" + str(k)\\n found = True\\n if not found:\\n self.reclosercodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ] = new_code2\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n else:\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n\\n else:\\n new_line_string += \\\",DEFAULT\\\"\\n\\n elif line_type == \\\"breaker\\\":\\n if (\\n i.nameclass is not None\\n and i.nameclass != \\\"\\\"\\n and i.wires[0].ampacity is not None\\n and i.nominal_voltage is not None\\n ):\\n new_code2 = \\\"{amps},{amps},{amps},{amps},{amps},{kvll},0,600.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0,0,0,0,0,0,\\\".format(\\n amps=i.wires[0].ampacity,\\n kvll=i.nominal_voltage * 10 ** -3,\\n )\\n\\n if (\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n not in self.breakercodes\\n ):\\n self.breakercodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ] = new_code2\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n\\n elif (\\n self.breakercodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ]\\n != new_code2\\n ):\\n found = False\\n for k, v in self.breakercodes.items():\\n if new_code2 == v:\\n new_line_string += \\\",\\\" + str(k)\\n found = True\\n if not found:\\n self.breakercodes[\\n i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n ] = new_code2\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n else:\\n new_line_string += (\\n \\\",\\\"\\n + i.nameclass\\n + \\\"_\\\"\\n + str(int(i.nominal_voltage))\\n + \\\"_\\\"\\n + str(int(i.wires[0].ampacity))\\n )\\n\\n else:\\n new_line_string += \\\",DEFAULT\\\"\\n\\n elif line_type == \\\"underground\\\":\\n tt = {}\\n if (\\n hasattr(i, \\\"nominal_voltage\\\")\\n and i.nominal_voltage is not None\\n ):\\n if (\\n i.nominal_voltage is not None\\n and i.nominal_voltage < 600\\n and len(i.wires) <= 2\\n ): # LV lines are assigned as triplex unless they're three phase\\n tt[\\\"cabletype\\\"] = 2\\n else:\\n tt[\\\"cabletype\\\"] = 0\\n\\n else:\\n tt[\\\"cabletype\\\"] = 0\\n\\n if (\\n hasattr(i, \\\"impedance_matrix\\\")\\n and i.impedance_matrix is not None\\n ):\\n z_diag = 0\\n z_offdiag = 0\\n try:\\n for kk in range(len(i.impedance_matrix)):\\n if i.impedance_matrix[kk][kk] != 0:\\n z_diag = i.impedance_matrix[kk][kk]\\n for jj in range(len(i.impedance_matrix)):\\n if jj == kk:\\n continue\\n if i.impedance_matrix[kk][jj] != 0:\\n z_offdiag = i.impedance_matrix[kk][\\n jj\\n ]\\n\\n except:\\n try:\\n z_diag = i.impedance_matrix[0]\\n z_offdiag = i.impedance_matrix[0]\\n except:\\n raise ValueError(\\n \\\"Cannot get a value from impedance matrix for line {}\\\".format(\\n i.name\\n )\\n )\\n coeff = 10 ** 3\\n z0 = z_diag + 2 * z_offdiag\\n z1 = z_diag - z_offdiag\\n\\n tt[\\\"R0\\\"] = z0.real * coeff\\n tt[\\\"X0\\\"] = z0.imag * coeff\\n try:\\n pos_seq_imp = i.impedance_matrix[1][1]\\n tt[\\\"R1\\\"] = z1.real * coeff\\n tt[\\\"X1\\\"] = z1.imag * coeff\\n except:\\n tt[\\\"R1\\\"] = tt[\\\"R0\\\"]\\n tt[\\\"X1\\\"] = tt[\\\"X0\\\"]\\n pass\\n try:\\n neg_seq_imp = i.impedance_matrix[2][2]\\n tt[\\\"R2\\\"] = z1.real * coeff\\n tt[\\\"X2\\\"] = z1.imag * coeff\\n except:\\n tt[\\\"R2\\\"] = tt[\\\"R1\\\"]\\n tt[\\\"X2\\\"] = tt[\\\"X1\\\"]\\n pass\\n\\n if (\\n hasattr(i, \\\"capacitance_matrix\\\")\\n and i.capacitance_matrix is not None\\n ):\\n c_diag = 0\\n c_offdiag = 0\\n try:\\n for kk in range(len(i.impedance_matrix)):\\n if i.capacitance_matrix[kk][kk] != 0:\\n c_diag = i.capacitance_matrix[kk][kk]\\n for jj in range(\\n len(i.capacitance_matrix)\\n ):\\n if jj == kk:\\n continue\\n if (\\n i.capacitance_matrix[kk][jj]\\n != 0\\n ):\\n c_offdiag = i.capacitance_matrix[\\n kk\\n ][\\n jj\\n ]\\n\\n except:\\n try:\\n c_diag = i.capacitance_matrix[0]\\n c_offdiag = i.capacitance_matrix[0]\\n except:\\n import pdb\\n\\n pdb.set_trace()\\n raise ValueError(\\n \\\"Cannot get a value from impedance matrix for line {}\\\".format(\\n i.name\\n )\\n )\\n coeff = 10 ** 3\\n c0 = c_diag + 2 * c_offdiag\\n c1 = c_diag - c_offdiag\\n\\n tt[\\\"B0\\\"] = (\\n c0.real * 2 * math.pi * frequency\\n ) # Don't multiply by km conversion since cyme output in micro siemens\\n tt[\\\"B1\\\"] = c1.real * 2 * math.pi * frequency #\\n\\n else:\\n tt[\\\"B1\\\"] = 0\\n tt[\\\"B0\\\"] = 0\\n try:\\n tt[\\\"amps\\\"] = i.wires[0].ampacity\\n except:\\n tt[\\\"amps\\\"] = 0\\n pass\\n\\n if (\\n hasattr(i.wires[0], \\\"nameclass\\\")\\n and i.wires[0].nameclass is not None\\n and i.wires[0].nameclass != \\\"\\\"\\n ):\\n cable_name = i.wires[0].nameclass\\n self.cablecodes[cable_name] = tt\\n new_line_string += \\\",\\\" + cable_name\\n else:\\n if len(self.cablecodes) == 0:\\n ID_cable += 1\\n self.cablecodes[\\\"cable\\\" + str(ID_cable)] = tt\\n new_line_string += \\\",cable_\\\" + str(ID_cable)\\n else:\\n found = False\\n for k, v in self.cablecodes.items():\\n if v == tt:\\n new_line_string += \\\",cable_\\\" + str(k)\\n found = True\\n if not found:\\n ID_cable += 1\\n self.cablecodes[\\n \\\"cable\\\" + str(ID_cable)\\n ] = tt\\n new_line_string += \\\",cable_\\\" + str(ID_cable)\\n\\n else: # We use impedance_matrix if it exists and we have 3 phases. otherwise we use by_phase. TODO: change to by_phase whenever we have the wire information for it.\\n # try:\\n tt = {}\\n if \\\"A\\\" in cond_id:\\n tt[\\\"CondID_A\\\"] = cond_id[\\\"A\\\"]\\n else:\\n tt[\\\"CondID_A\\\"] = \\\"NONE\\\"\\n if \\\"B\\\" in cond_id:\\n tt[\\\"CondID_B\\\"] = cond_id[\\\"B\\\"]\\n else:\\n tt[\\\"CondID_B\\\"] = \\\"NONE\\\"\\n if \\\"C\\\" in cond_id:\\n tt[\\\"CondID_C\\\"] = cond_id[\\\"C\\\"]\\n else:\\n tt[\\\"CondID_C\\\"] = \\\"NONE\\\"\\n if \\\"N\\\" in cond_id:\\n tt[\\\"CondID_N\\\"] = cond_id[\\\"N\\\"]\\n else:\\n tt[\\\"CondID_N\\\"] = \\\"NONE\\\"\\n if \\\"N1\\\" in cond_id:\\n tt[\\\"CondID_N1\\\"] = cond_id[\\\"N1\\\"]\\n else:\\n tt[\\\"CondID_N1\\\"] = \\\"NONE\\\"\\n if \\\"N2\\\" in cond_id:\\n tt[\\\"CondID_N2\\\"] = cond_id[\\\"N2\\\"]\\n else:\\n tt[\\\"CondID_N2\\\"] = \\\"NONE\\\"\\n\\n if hasattr(i, \\\"wires\\\") and i.wires is not None:\\n for wire in i.wires:\\n if hasattr(wire, \\\"phase\\\") and str(wire.phase) in [\\n \\\"A\\\",\\n \\\"B\\\",\\n \\\"C\\\",\\n ]:\\n p = str(wire.phase)\\n if (\\n hasattr(wire, \\\"ampacity\\\")\\n and wire.ampacity is not None\\n ):\\n try:\\n tt[\\\"Amps{}\\\".format(p)] = wire.ampacity\\n except:\\n tt[\\\"Amps{}\\\".format(p)] = \\\"DEFAULT\\\"\\n pass\\n\\n # If we have 3 phases, use OVERHEADLINE SETTING\\n if len(phases) == 3 and i.impedance_matrix is not None:\\n\\n tt.update(\\n {\\\"SpacingID\\\": \\\"DEFAULT\\\", \\\"UserDefinedImpedances\\\": 1}\\n )\\n\\n for k, p1 in enumerate(phases):\\n for j, p2 in enumerate(phases):\\n if j == k:\\n tt[\\\"R{p}\\\".format(p=p1)] = (\\n i.impedance_matrix[k][j].real * 10 ** 3\\n )\\n tt[\\\"X{p}\\\".format(p=p1)] = (\\n i.impedance_matrix[k][j].imag * 10 ** 3\\n )\\n if i.capacitance_matrix is not None and len(\\n i.capacitance_matrix\\n ) == len(i.impedance_matrix):\\n tt[\\\"B{p}\\\".format(p=p1)] = (\\n i.capacitance_matrix[k][j].real\\n * 2\\n * math.pi\\n * frequency\\n * 10 ** 3\\n )\\n else:\\n tt[\\\"Ba\\\"] = 0\\n tt[\\\"Bb\\\"] = 0\\n tt[\\\"Bc\\\"] = 0\\n elif j > k:\\n if p1 == \\\"A\\\" and p2 == \\\"C\\\":\\n tt[\\\"MutualResistanceCA\\\"] = (\\n i.impedance_matrix[k][j].real\\n * 10 ** 3\\n )\\n tt[\\\"MutualReactanceCA\\\"] = (\\n i.impedance_matrix[k][j].imag\\n * 10 ** 3\\n )\\n if i.capacitance_matrix is not None and len(\\n i.capacitance_matrix\\n ) == len(\\n i.impedance_matrix\\n ):\\n tt[\\\"MutualShuntSusceptanceCA\\\"] = (\\n i.capacitance_matrix[k][j].real\\n * 2\\n * math.pi\\n * frequency\\n * 10 ** 3\\n )\\n else:\\n tt[\\\"MutualShuntSusceptanceCA\\\"] = 0\\n else:\\n tt[\\n \\\"MutualResistance{p1}{p2}\\\".format(\\n p1=p1, p2=p2\\n )\\n ] = (\\n i.impedance_matrix[k][j].real\\n * 10 ** 3\\n )\\n tt[\\n \\\"MutualReactance{p1}{p2}\\\".format(\\n p1=p1, p2=p2\\n )\\n ] = (\\n i.impedance_matrix[k][j].imag\\n * 10 ** 3\\n )\\n if i.capacitance_matrix is not None and len(\\n i.capacitance_matrix\\n ) == len(\\n i.impedance_matrix\\n ):\\n tt[\\n \\\"MutualShuntSusceptance{p1}{p2}\\\".format(\\n p1=p1, p2=p2\\n )\\n ] = (\\n i.capacitance_matrix[k][j].real\\n * 2\\n * math.pi\\n * frequency\\n * 10 ** 3\\n )\\n else:\\n tt[\\\"MutualShuntSusceptanceAB\\\"] = 0\\n tt[\\\"MutualShuntSusceptanceBC\\\"] = 0\\n\\n if (\\n hasattr(i, \\\"nameclass\\\")\\n and i.nameclass is not None\\n and i.nameclass != \\\"\\\"\\n ):\\n line_nameclass = i.nameclass\\n self.linecodes_overhead[line_nameclass] = tt\\n new_line_string += \\\",\\\" + line_nameclass\\n else:\\n # If the linecode dictionary is empty, just add the new element\\n if len(self.linecodes_overhead) == 0:\\n ID += 1\\n self.linecodes_overhead[ID] = tt\\n new_line_string += \\\",line_\\\" + str(ID)\\n\\n # Otherwise, loop over the dict to find a matching linecode\\n else:\\n found = False\\n for k, v in self.linecodes_overhead.items():\\n if v == tt:\\n new_line_string += \\\",\\\" + str(k)\\n found = True\\n if not found:\\n ID += 1\\n self.linecodes_overhead[\\n \\\"line_\\\" + str(ID)\\n ] = tt\\n new_line_string += \\\",line_\\\" + str(ID)\\n\\n # If we have less than 3 phases, then use a BY_PHASE configuration\\n else:\\n line_type = \\\"by_phase\\\" # Change the line_type to write the line under the proper header\\n\\n # Add device number and phase conductor IDs\\n new_line_string += \\\",{device},{condIDA},{condIDB},{condIDC}\\\".format(\\n device=new_section_ID,\\n condIDA=tt[\\\"CondID_A\\\"],\\n condIDB=tt[\\\"CondID_B\\\"],\\n condIDC=tt[\\\"CondID_C\\\"],\\n )\\n\\n # Add neutral conductor IDs\\n #\\n # If we have valid IDs for BOTH N1 and N2, then use that\\n if (\\n tt[\\\"CondID_N1\\\"] != \\\"NONE\\\"\\n and tt[\\\"CondID_N2\\\"] != \\\"NONE\\\"\\n ):\\n new_line_string += \\\",{condIDN1},{condIDN2}\\\".format(\\n condIDN1=tt[\\\"CondID_N1\\\"],\\n condIDN2=tt[\\\"CondID_N2\\\"],\\n )\\n # Otherwise, if we have a valid ID for N, then use that as condIDN1 and use whatever we have for N2\\n elif tt[\\\"CondID_N\\\"] != \\\"NONE\\\":\\n new_line_string += \\\",{condIDN1},{condIDN2}\\\".format(\\n condIDN1=tt[\\\"CondID_N\\\"],\\n condIDN2=tt[\\\"CondID_N2\\\"],\\n )\\n # Otherwise, do as for case 1\\n else:\\n new_line_string += \\\",{condIDN1},{condIDN2}\\\".format(\\n condIDN1=tt[\\\"CondID_N1\\\"],\\n condIDN2=tt[\\\"CondID_N2\\\"],\\n )\\n\\n # Use Default spacing\\n #\\n # TODO: User-defined spacing support\\n #\\n if len(phases) == 1:\\n new_line_string += \\\",N_ABOVE_1PH\\\"\\n if len(phases) == 2:\\n new_line_string += \\\",N_ABOVE_2PH\\\"\\n if len(phases) == 3:\\n new_line_string += \\\",N_ABOVE_3PH\\\"\\n\\n # Length\\n if hasattr(i, \\\"length\\\") and i.length is not None:\\n if (\\n line_type != \\\"switch\\\"\\n and line_type != \\\"fuse\\\"\\n and line_type != \\\"recloser\\\"\\n and line_type != \\\"breaker\\\"\\n ):\\n try:\\n new_line_string += \\\",\\\" + str(i.length)\\n except:\\n new_line_string += \\\",\\\"\\n pass\\n else:\\n if (\\n line_type != \\\"switch\\\"\\n and line_type != \\\"fuse\\\"\\n and line_type != \\\"recloser\\\"\\n and line_type != \\\"breaker\\\"\\n ):\\n new_line_string += \\\",\\\"\\n\\n if line_type == \\\"switch\\\" or line_type == \\\"breaker\\\":\\n closed_phase = np.sort(\\n [\\n wire.phase\\n for wire in i.wires\\n if wire.is_open == 0\\n and wire.phase not in [\\\"N\\\", \\\"N1\\\", \\\"N2\\\"]\\n ]\\n )\\n if len(closed_phase) == 0:\\n new_line_string += \\\",M,None,0\\\"\\n else:\\n new_line_string += \\\",M,{},0\\\".format(\\n reduce(lambda x, y: x + y, closed_phase)\\n )\\n\\n if line_type == \\\"fuse\\\" or line_type == \\\"recloser\\\":\\n closed_phase = np.sort(\\n [\\n wire.phase\\n for wire in i.wires\\n if wire.phase not in [\\\"N\\\", \\\"N1\\\", \\\"N2\\\"]\\n ]\\n )\\n new_line_string += \\\",M,{},0\\\".format(\\n reduce(lambda x, y: x + y, closed_phase)\\n )\\n\\n # ConnectionStatus\\n new_line_string += \\\",0\\\" # Assumes the line is connected because there is no connected field in DiTTo\\n\\n # DeviceNumber\\n if (\\n line_type == \\\"switch\\\"\\n or line_type == \\\"fuse\\\"\\n or line_type == \\\"recloser\\\"\\n or line_type == \\\"breaker\\\"\\n ):\\n new_line_string += \\\",\\\" + new_section_ID\\n\\n if line_type == \\\"underground\\\":\\n new_line_string += (\\n \\\",10,2\\\" # DistanceBetweenConductors, CableConfiguration\\n )\\n\\n # Add the strings to the lists\\n #\\n if new_section_line != \\\"\\\":\\n self.section_line_list.append(new_section_line)\\n # If the object is inside of a substation...\\n if hasattr(i, \\\"is_substation\\\") and i.is_substation == 1:\\n # ...it should have the name of the substation specified in the 'substation_name' attribute\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n and i.substation_name != \\\"\\\"\\n ):\\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\\n ff_name = \\\"substation_{}\\\".format(i.substation_name)\\n self.network_have_substations = True\\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\\n elif (\\n hasattr(i, \\\"feeder_name\\\")\\n and i.feeder_name is not None\\n and i.feeder_name != \\\"\\\"\\n ):\\n ff_name = i.feeder_name\\n\\n if ff_name in self.section_line_feeder_mapping:\\n self.section_line_feeder_mapping[ff_name].append(\\n new_section_line\\n )\\n else:\\n self.section_line_feeder_mapping[ff_name] = [\\n new_section_line\\n ]\\n\\n if new_line_string != \\\"\\\":\\n try:\\n matching_list[line_type].append(new_line_string)\\n except:\\n pass\\n\\n if isinstance(i, Storage):\\n bess_string = \\\"\\\"\\n new_bess_setting_string = \\\"\\\"\\n new_converter_string = \\\"\\\"\\n new_converter_control_setting_string = \\\"\\\"\\n\\n if (\\n hasattr(i, \\\"name\\\")\\n and i.name is not None\\n and hasattr(i, \\\"connecting_element\\\")\\n and i.connecting_element is not None\\n and (\\n i.connecting_element in model.model_names\\n or \\\"load_\\\" + i.connecting_element in model.model_names\\n )\\n ):\\n new_section_ID = \\\"{f}_{t}\\\".format(\\n f=i.connecting_element, t=i.name\\n )\\n if len(new_section_ID) > 64:\\n hasher = hashlib.sha1()\\n hasher.update(new_section_ID.encode(\\\"utf-8\\\"))\\n new_section_ID = hasher.hexdigest()\\n\\n new_section = (\\n new_section_ID\\n + \\\",{f},0,{t},0,\\\".format( # Assume only one index for the load connection point\\n f=i.connecting_element, t=i.name\\n )\\n )\\n\\n new_node_string = \\\"{n}\\\".format(n=i.name)\\n if hasattr(i, \\\"positions\\\") and i.positions is not None:\\n try:\\n new_node_string += \\\",\\\" + str(i.positions[0].long)\\n except:\\n new_node_string += \\\",0\\\"\\n pass\\n\\n try:\\n new_node_string += \\\",\\\" + str(i.positions[0].lat)\\n except:\\n new_node_string += \\\",0\\\"\\n pass\\n else:\\n new_node_string += \\\",0,0\\\"\\n self.node_string_list.append(new_node_string)\\n\\n phases = \\\"\\\"\\n if i.phase_storages is not None:\\n for ps in i.phase_storages:\\n if ps.phase in [\\\"A\\\", \\\"B\\\", \\\"C\\\"]:\\n new_section += ps.phase\\n phases += ps.phase\\n\\n # If the object is inside of a substation...\\n if hasattr(i, \\\"is_substation\\\") and i.is_substation == 1:\\n # ...it should have the name of the substation specified in the 'substation_name' attribute\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n and i.substation_name != \\\"\\\"\\n ):\\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\\n ff_name = \\\"substation_{}\\\".format(i.substation_name)\\n self.network_have_substations = True\\n\\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\\n elif (\\n hasattr(i, \\\"feeder_name\\\")\\n and i.feeder_name is not None\\n and i.feeder_name != \\\"\\\"\\n ):\\n ff_name = i.feeder_name\\n\\n self.section_line_list.append(new_section)\\n if ff_name in self.section_line_feeder_mapping:\\n self.section_line_feeder_mapping[ff_name].append(\\n new_section\\n )\\n else:\\n self.section_line_feeder_mapping[ff_name] = [new_section]\\n\\n new_converter_string += (\\n new_section_ID + \\\",80,\\\"\\n ) # 45 is the CYME code for PV devices\\n new_converter_control_setting_string += (\\n new_section_ID + \\\",80,0,0,\\\"\\n ) # The controlindex and timetrigger indices are both zero\\n\\n if hasattr(i, \\\"rated_kWh\\\") and i.rated_kWh is not None:\\n bess_string += str(i.rated_kWh * 10 ** -3)\\n bess_string += \\\",\\\"\\n\\n if hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n bess_string += str(i.rated_power * 10 ** -3)\\n bess_string += \\\",\\\"\\n\\n # Use for both charging and discharging power\\n if hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n bess_string += str(i.rated_power * 10 ** -3)\\n bess_string += \\\",\\\"\\n\\n if (\\n hasattr(i, \\\"charging_efficiency\\\")\\n and i.charging_efficiency is not None\\n ):\\n bess_string += str(i.charging_efficiency)\\n bess_string += \\\",\\\"\\n\\n if (\\n hasattr(i, \\\"discharging_efficiency\\\")\\n and i.discharging_efficiency is not None\\n ):\\n bess_string += str(i.discharging_efficiency)\\n\\n bess_type = \\\"\\\"\\n if bess_string in self.bess_codes:\\n bess_type = self.bess_codes[bess_string]\\n else:\\n ID_bess += 1\\n bess_type = \\\"BESS_\\\" + str(ID_bess)\\n self.bess_codes[bess_string] = bess_type\\n\\n bess_string = bess_type + \\\",\\\" + bess_string\\n\\n new_bess_setting_string += (\\n new_section_ID\\n + \\\",M,\\\"\\n + new_section_ID\\n + \\\",\\\"\\n + bess_type\\n + \\\",\\\"\\n + phases\\n + \\\",\\\"\\n )\\n\\n if (\\n hasattr(i, \\\"stored_kWh\\\")\\n and i.stored_kWh is not None\\n and hasattr(i, \\\"rated_kWh\\\")\\n and i.rated_kWh is not None\\n and i.rated_kWh != 0\\n ):\\n new_bess_setting_string += str(\\n int(i.stored_kWh / i.rated_kWh * 100)\\n )\\n\\n if hasattr(i, \\\"active_rating\\\") and i.active_rating is not None:\\n if (\\n hasattr(i, \\\"reactive_rating\\\")\\n and i.reactive_rating is not None\\n ):\\n new_converter_string += (\\n str(\\n math.sqrt(\\n i.reactive_rating ** 2\\n + i.active_rating ** 2\\n )\\n / 1000.0\\n )\\n + \\\",\\\"\\n )\\n else:\\n new_converter_string += (\\n str(i.active_rating / 1000.0) + \\\",\\\"\\n )\\n new_converter_string += str(i.active_rating / 1000.0) + \\\",\\\"\\n elif hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n if (\\n hasattr(i, \\\"reactive_rating\\\")\\n and i.reactive_rating is not None\\n ):\\n new_converter_string += (\\n str(\\n math.sqrt(\\n i.reactive_rating ** 2\\n + (i.rated_power * 1.1) ** 2\\n )\\n / 1000.0\\n )\\n + \\\",\\\"\\n )\\n else:\\n new_converter_string += (\\n str(i.rated_power * 1.1 / 1000.0) + \\\",\\\"\\n )\\n new_converter_string += (\\n str(i.rated_power * 1.1 / 1000.0) + \\\",\\\"\\n ) # Default value sets inverter to be oversized by 10%\\n else:\\n new_converter_string += \\\",,\\\"\\n\\n if (\\n hasattr(i, \\\"reactive_rating\\\")\\n and i.reactive_rating is not None\\n ):\\n new_converter_string += (\\n str(i.reactive_rating / 1000.0) + \\\",\\\"\\n )\\n elif hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n new_converter_string += (\\n str(i.rated_power * 1.1 / 1000.0) + \\\",\\\"\\n ) # Default value sets inverter to be oversized by 10% and active=reactive\\n else:\\n new_converter_string += \\\",\\\"\\n\\n if hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n new_dg_generation_string += str(i.rated_power / 1000.0)\\n elif hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n new_dg_generation_string += str(i.rated_power / 1000.0)\\n new_dg_generation_string += \\\",\\\"\\n if (\\n hasattr(i, \\\"min_powerfactor\\\")\\n and i.min_powerfactor is not None\\n ):\\n new_converter_string += str(i.powerfactor * 100)\\n new_dg_generation_string += str(i.powerfactor * 100)\\n new_dg_generation_string += \\\",\\\"\\n new_converter_string += \\\",\\\"\\n if hasattr(i, \\\"fall_limit\\\") and i.fall_limit is not None:\\n new_converter_string += str(i.fall_limit)\\n new_converter_string += \\\",\\\"\\n if hasattr(i, \\\"rise_limit\\\") and i.rise_limit is not None:\\n new_converter_string += str(i.rise_limit)\\n new_converter_string += \\\",\\\"\\n if (hasattr(i, \\\"fall_limit\\\") and i.fall_limit is not None) or (\\n hasattr(i, \\\"rise_limit\\\") and i.rise_limit is not None\\n ):\\n new_converter_string += \\\"0\\\" # Using units of % per minute\\n\\n if hasattr(i, \\\"control_type\\\") and i.control_type is not None:\\n if (\\n i.control_type.lower() == \\\"voltvar_vars_over_watts\\\"\\n or i.control_type.lower() == \\\"voltvar\\\"\\n ): # use default voltvar curve in cyme\\n new_converter_control_setting_string += \\\"1\\\"\\n if i.control_type.lower() == \\\"voltvar_watts_over_vars\\\":\\n new_converter_control_setting_string += \\\"0\\\"\\n if i.control_type.lower() == \\\"voltvar_fixed_vars\\\":\\n new_converter_control_setting_string += \\\"2\\\"\\n if i.control_type.lower() == \\\"voltvar_novars\\\":\\n new_converter_control_setting_string += \\\"3\\\"\\n if i.control_type.lower() == \\\"voltwatt\\\":\\n new_converter_control_setting_string += \\\"5\\\"\\n if i.control_type.lower() == \\\"watt_powerfactor\\\":\\n new_converter_control_setting_string += \\\"6\\\"\\n if i.control_type.lower() == \\\"powerfactor\\\":\\n new_converter_control_setting_string += \\\"10\\\"\\n\\n new_converter_control_setting_string += \\\",\\\"\\n if (\\n i.control_type.lower() == \\\"voltvar_fixed_vars\\\"\\n and i.var_injection is not None\\n ):\\n new_converter_control_setting_string += (\\n str(i.var_injection) + \\\",2,\\\"\\n ) # 2 is the code for the pecentage reactive power available\\n else:\\n new_converter_control_setting_string += \\\",,\\\"\\n if (\\n i.control_type.lower() == \\\"voltvar_watts_over_vars\\\"\\n or i.control_type.lower() == \\\"voltvar_vars_over_watts\\\"\\n ) and i.voltvar_curve is not None:\\n new_converter_control_setting_string += (\\n i.voltvar_curve + \\\",,\\\"\\n )\\n elif (\\n i.control_type.lower() == \\\"voltwatt\\\"\\n and i.voltwatt_curve is not None\\n ):\\n new_converter_control_setting_string += (\\n i.voltwatt_curve + \\\",0,\\\"\\n ) # 0 is the code for using the active power rating\\n elif (\\n i.control_type.lower() == \\\"watt_powerfactor\\\"\\n and i.watt_powerfactor_curve is not None\\n ):\\n new_converter_control_setting_string += (\\n i.watt_powerfactor_curve + \\\",0,\\\"\\n ) # 0 is the code for using the active power rating\\n else:\\n new_converter_control_setting_string += \\\",,\\\"\\n else:\\n new_converter_control_setting_string += \\\"10\\\" + \\\",\\\" * 5\\n\\n if new_converter_string != \\\"\\\":\\n converter_string_list.append(new_converter_string)\\n if new_converter_control_setting_string != \\\"\\\":\\n converter_control_string_list.append(\\n new_converter_control_setting_string\\n )\\n\\n if new_bess_setting_string != \\\"\\\":\\n bess_settings_string_list.append(new_bess_setting_string)\\n\\n # If we get a Photovoltaic object\\n\\n if isinstance(i, Photovoltaic):\\n new_converter_string = \\\"\\\"\\n new_converter_control_setting_string = \\\"\\\"\\n new_pv_setting_string = \\\"\\\"\\n new_dg_generation_string = \\\"\\\"\\n if (\\n hasattr(i, \\\"name\\\")\\n and i.name is not None\\n and hasattr(i, \\\"connecting_element\\\")\\n and i.connecting_element is not None\\n and (\\n i.connecting_element in model.model_names\\n or \\\"load_\\\" + i.connecting_element in model.model_names\\n )\\n ):\\n new_section_ID = \\\"{f}_{t}\\\".format(\\n f=i.connecting_element, t=i.name\\n )\\n if len(new_section_ID) > 64:\\n hasher = hashlib.sha1()\\n hasher.update(new_section_ID.encode(\\\"utf-8\\\"))\\n new_section_ID = hasher.hexdigest()\\n\\n new_section = (\\n new_section_ID\\n + \\\",{f},0,{t},0,\\\".format( # Assume only one index for the load connection point\\n f=i.connecting_element, t=i.name\\n )\\n )\\n\\n new_node_string = \\\"{n}\\\".format(n=i.name)\\n if hasattr(i, \\\"positions\\\") and i.positions is not None:\\n try:\\n new_node_string += \\\",\\\" + str(i.positions[0].long)\\n except:\\n new_node_string += \\\",0\\\"\\n pass\\n\\n try:\\n new_node_string += \\\",\\\" + str(i.positions[0].lat)\\n except:\\n new_node_string += \\\",0\\\"\\n pass\\n else:\\n new_node_string += \\\",0,0\\\"\\n self.node_string_list.append(new_node_string)\\n\\n phases = \\\"\\\"\\n for phase in i.phases:\\n if phase.default_value in [\\\"A\\\", \\\"B\\\", \\\"C\\\"]:\\n new_section += phase.default_value\\n phases += phase.default_value\\n self.section_line_list.append(new_section)\\n if hasattr(i, \\\"feeder_name\\\") and i.feeder_name is not None:\\n if i.feeder_name in self.section_line_feeder_mapping:\\n self.section_line_feeder_mapping[i.feeder_name].append(\\n new_section\\n )\\n else:\\n self.section_line_feeder_mapping[i.feeder_name] = [\\n new_section\\n ]\\n\\n if hasattr(i, \\\"feeder_name\\\") and i.feeder_name is not None:\\n if i.feeder_name in self.section_feeder_mapping:\\n self.section_feeder_mapping[i.feeder_name].append(\\n new_section_ID\\n )\\n else:\\n self.section_feeder_mapping[i.feeder_name] = [\\n new_section_ID\\n ]\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n ):\\n self.section_headnode_mapping[\\n i.feeder_name\\n ] = i.substation_name\\n\\n new_converter_string += (\\n new_section_ID + \\\",45,\\\"\\n ) # 45 is the CYME code for PV devices\\n new_converter_control_setting_string += (\\n new_section_ID + \\\",45,0,0,\\\"\\n ) # The controlindex and timetrigger indices are both zero\\n new_pv_setting_string += (\\n new_section_ID + \\\",M,\\\" + new_section_ID + \\\",DEFAULT,\\\"\\n ) # Use the default CYME PV configuration for the moment.\\n new_dg_generation_string += new_section_ID + \\\"45,DEFAULT,\\\"\\n # DGGENERATIONMODEL is not included as this just sets the LoadModelName which is DEFAULT\\n\\n if hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n panel_area = math.ceil(\\n i.rated_power / 1000 / 0.08\\n ) # Each panel produces 0.08 kw\\n num_x, num_y = self.smallest_perimeter(panel_area)\\n if min(num_x, num_y) == 1:\\n num_x, num_y = self.smallest_perimeter(\\n panel_area + 1\\n ) # if area is prime\\n new_pv_setting_string += str(num_x) + \\\",\\\" + str(num_y) + \\\",\\\"\\n elif (\\n hasattr(i, \\\"active_rating\\\") and i.active_rating is not None\\n ):\\n panel_area = math.ceil(\\n i.active_rating / 1.1 / 1000 / 0.08\\n ) # Each panel produces 0.08 kw. Assume 10% inverter oversize\\n num_x, num_y = self.smallest_perimeter(panel_area)\\n if min(num_x, num_y) == 1:\\n num_x, num_y = self.smallest_perimeter(\\n panel_area + 1\\n ) # if area is prime\\n new_pv_setting_string += str(num_x) + \\\",\\\" + str(num_y) + \\\",\\\"\\n else:\\n new_pv_setting_string += (\\n \\\",,\\\" # This will produce garbage output power\\n )\\n\\n if hasattr(i, \\\"temperature\\\") and i.temperature is not None:\\n new_pv_setting_string += str(i.temperature)\\n\\n new_pv_setting_string += \\\",\\\" + phases\\n\\n if hasattr(i, \\\"active_rating\\\") and i.active_rating is not None:\\n if (\\n hasattr(i, \\\"reactive_rating\\\")\\n and i.reactive_rating is not None\\n ):\\n new_converter_string += (\\n str(\\n math.sqrt(\\n i.reactive_rating ** 2\\n + i.active_rating ** 2\\n )\\n / 1000.0\\n )\\n + \\\",\\\"\\n )\\n else:\\n new_converter_string += (\\n str(i.active_rating / 1000.0) + \\\",\\\"\\n )\\n new_converter_string += str(i.active_rating / 1000.0) + \\\",\\\"\\n elif hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n if (\\n hasattr(i, \\\"reactive_rating\\\")\\n and i.reactive_rating is not None\\n ):\\n new_converter_string += (\\n str(\\n math.sqrt(\\n i.reactive_rating ** 2\\n + (i.rated_power * 1.1) ** 2\\n )\\n / 1000.0\\n )\\n + \\\",\\\"\\n )\\n else:\\n new_converter_string += (\\n str(i.rated_power * 1.1 / 1000.0) + \\\",\\\"\\n )\\n new_converter_string += (\\n str(i.rated_power * 1.1 / 1000.0) + \\\",\\\"\\n ) # Default value sets inverter to be oversized by 10%\\n else:\\n new_converter_string += \\\",,\\\"\\n\\n if (\\n hasattr(i, \\\"reactive_rating\\\")\\n and i.reactive_rating is not None\\n ):\\n new_converter_string += (\\n str(i.reactive_rating / 1000.0) + \\\",\\\"\\n )\\n elif hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n new_converter_string += (\\n str(i.rated_power * 1.1 / 1000.0) + \\\",\\\"\\n ) # Default value sets inverter to be oversized by 10% and active=reactive\\n else:\\n new_converter_string += \\\",\\\"\\n\\n if hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n new_dg_generation_string += str(i.rated_power / 1000.0)\\n elif hasattr(i, \\\"rated_power\\\") and i.rated_power is not None:\\n new_dg_generation_string += str(i.rated_power / 1000.0)\\n new_dg_generation_string += \\\",\\\"\\n if (\\n hasattr(i, \\\"min_powerfactor\\\")\\n and i.min_powerfactor is not None\\n ):\\n new_converter_string += str(i.powerfactor * 100)\\n new_dg_generation_string += str(i.powerfactor * 100)\\n new_dg_generation_string += \\\",\\\"\\n new_converter_string += \\\",\\\"\\n if hasattr(i, \\\"fall_limit\\\") and i.fall_limit is not None:\\n new_converter_string += str(i.fall_limit)\\n new_converter_string += \\\",\\\"\\n if hasattr(i, \\\"rise_limit\\\") and i.rise_limit is not None:\\n new_converter_string += str(i.rise_limit)\\n new_converter_string += \\\",\\\"\\n if (hasattr(i, \\\"fall_limit\\\") and i.fall_limit is not None) or (\\n hasattr(i, \\\"rise_limit\\\") and i.rise_limit is not None\\n ):\\n new_converter_string += \\\"0\\\" # Using units of % per minute\\n\\n if hasattr(i, \\\"control_type\\\") and i.control_type is not None:\\n if (\\n i.control_type.lower() == \\\"voltvar_vars_over_watts\\\"\\n or i.control_type.lower() == \\\"voltvar\\\"\\n ): # use default voltvar curve in cyme\\n new_converter_control_setting_string += \\\"1\\\"\\n if i.control_type.lower() == \\\"voltvar_watts_over_vars\\\":\\n new_converter_control_setting_string += \\\"0\\\"\\n if i.control_type.lower() == \\\"voltvar_fixed_vars\\\":\\n new_converter_control_setting_string += \\\"2\\\"\\n if i.control_type.lower() == \\\"voltvar_novars\\\":\\n new_converter_control_setting_string += \\\"3\\\"\\n if i.control_type.lower() == \\\"voltwatt\\\":\\n new_converter_control_setting_string += \\\"5\\\"\\n if i.control_type.lower() == \\\"watt_powerfactor\\\":\\n new_converter_control_setting_string += \\\"6\\\"\\n if i.control_type.lower() == \\\"powerfactor\\\":\\n new_converter_control_setting_string += \\\"10\\\"\\n\\n new_converter_control_setting_string += \\\",\\\"\\n if (\\n i.control_type.lower() == \\\"voltvar_fixed_vars\\\"\\n and i.var_injection is not None\\n ):\\n new_converter_control_setting_string += (\\n str(i.var_injection) + \\\",2,\\\"\\n ) # 2 is the code for the pecentage reactive power available\\n else:\\n new_converter_control_setting_string += \\\",,\\\"\\n if (\\n i.control_type.lower() == \\\"voltvar_watts_over_vars\\\"\\n or i.control_type.lower() == \\\"voltvar_vars_over_watts\\\"\\n ) and i.voltvar_curve is not None:\\n new_converter_control_setting_string += (\\n i.voltvar_curve + \\\",,\\\"\\n )\\n elif (\\n i.control_type.lower() == \\\"voltwatt\\\"\\n and i.voltwatt_curve is not None\\n ):\\n new_converter_control_setting_string += (\\n i.voltwatt_curve + \\\",0,\\\"\\n ) # 0 is the code for using the active power rating\\n elif (\\n i.control_type.lower() == \\\"watt_powerfactor\\\"\\n and i.watt_powerfactor_curve is not None\\n ):\\n new_converter_control_setting_string += (\\n i.watt_powerfactor_curve + \\\",0,\\\"\\n ) # 0 is the code for using the active power rating\\n else:\\n new_converter_control_setting_string += \\\",,\\\"\\n\\n if (\\n i.control_type.lower() == \\\"powerfactor\\\"\\n and i.powerfactor is not None\\n ):\\n new_converter_control_setting_string += str(\\n i.powerfactor\\n )\\n else:\\n new_converter_control_setting_string += (\\n \\\"10,,,,,100\\\" # Use Powerfactor as default\\n )\\n\\n if (\\n hasattr(i, \\\"timeseries\\\")\\n and i.timeseries is not None\\n and len(i.timeseries) > 0\\n and i.timeseries[0].data_label is not None\\n and i.timeseries[0].data_location is not None\\n ):\\n new_pv_setting_string += \\\",0,{loc}\\\".format(\\n loc=i.timeseries[0].data_label\\n )\\n self.irradiance_profiles[\\n i.timeseries[0].data_label\\n ] = i.timeseries[0].data_location\\n else:\\n new_pv_setting_string += \\\",1,\\\"\\n\\n else:\\n if hasattr(i, \\\"name\\\"):\\n logger.warning(\\n \\\"PV \\\"\\n + i.name\\n + \\\" was not connected and has not been written to CYME\\\"\\n )\\n else:\\n logger.warning(\\\"PV element is unnamed\\\")\\n\\n if new_converter_string != \\\"\\\":\\n converter_string_list.append(new_converter_string)\\n if new_converter_control_setting_string != \\\"\\\":\\n converter_control_string_list.append(\\n new_converter_control_setting_string\\n )\\n if new_pv_setting_string != \\\"\\\":\\n pv_settings_string_list.append(new_pv_setting_string)\\n if new_dg_generation_string != \\\"\\\":\\n dg_generation_string_list.append(new_dg_generation_string)\\n\\n # If we get a Capacitor object\\n #\\n if isinstance(i, Capacitor):\\n\\n # Empty new capacitor string\\n new_capacitor_line = \\\"\\\"\\n new_capacitor_object_line = \\\"\\\"\\n\\n # Connecting element\\n # We need to create a new section since there is no physical line connecting\\n # capacitors to the rest of the feeder in DiTTo, but CYME needs a section for this\\n new_section = None\\n if (\\n hasattr(i, \\\"name\\\")\\n and i.name is not None\\n and hasattr(i, \\\"connecting_element\\\")\\n and i.connecting_element is not None\\n ):\\n try:\\n new_section_ID = \\\"{f}_{t}\\\".format(\\n f=i.connecting_element, t=i.name\\n )\\n if len(new_section_ID) > 64:\\n hasher = hashlib.sha1()\\n hasher.update(new_section_ID.encode(\\\"utf-8\\\"))\\n new_section_ID = hasher.hexdigest()\\n new_section = (\\n new_section_ID\\n + \\\",{f},0,{t},0,\\\".format( # assume only one connection point for capacitors\\n f=i.connecting_element, t=i.name\\n )\\n )\\n new_capacitor_line += new_section_ID\\n if i.connecting_element not in self.nodeID_list:\\n self.nodeID_list.append(i.connecting_element)\\n self.node_string_list.append(\\n \\\"{},0,0\\\".format(i.connecting_element)\\n )\\n if i.name not in self.nodeID_list:\\n if hasattr(i, \\\"positions\\\") and i.positions is not None:\\n try:\\n X = i.positions[0].long\\n Y = i.positions[0].lat\\n except:\\n X = 0\\n Y = 0\\n pass\\n else:\\n X = 0\\n Y = 0\\n self.nodeID_list.append(i.name)\\n self.node_string_list.append(\\n \\\"{name},{X},{Y}\\\".format(name=i.name, X=X, Y=Y)\\n )\\n if hasattr(i, \\\"feeder_name\\\") and i.feeder_name is not None:\\n if i.feeder_name in self.section_feeder_mapping:\\n self.section_feeder_mapping[i.feeder_name].append(\\n new_section_ID\\n )\\n else:\\n self.section_feeder_mapping[i.feeder_name] = [\\n new_section_ID\\n ]\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n ):\\n self.section_headnode_mapping[\\n i.feeder_name\\n ] = i.substation_name\\n except:\\n continue\\n\\n # Connection type\\n if hasattr(i, \\\"connection_type\\\") and i.connection_type is not None:\\n try:\\n new_capacitor_line += \\\",\\\" + i.connection_type\\n except:\\n new_capacitor_line += \\\",\\\"\\n pass\\n else:\\n new_capacitor_line += \\\",\\\"\\n\\n # KVAR and Phase\\n phases = []\\n if (\\n hasattr(i, \\\"phase_capacitors\\\")\\n and i.phase_capacitors is not None\\n ):\\n total_var = 0\\n one_var = 0\\n switched_vars = {}\\n # new_capacitor_line+=','\\n for phase_capacitor in i.phase_capacitors:\\n if (\\n hasattr(phase_capacitor, \\\"phase\\\")\\n and phase_capacitor.phase is not None\\n ):\\n phases.append(phase_capacitor.phase)\\n if new_section is not None:\\n new_section += str(phase_capacitor.phase)\\n\\n if (\\n hasattr(phase_capacitor, \\\"var\\\")\\n and phase_capacitor.var is not None\\n ):\\n total_var += phase_capacitor.var\\n if (\\n phase_capacitor.var is not None\\n and phase_capacitor.phase is not None\\n ):\\n switched_vars[\\n phase_capacitor.phase.upper()\\n ] = phase_capacitor.var\\n if \\\"A\\\" in switched_vars:\\n new_capacitor_line += \\\",\\\" + str(\\n switched_vars[\\\"A\\\"] * 10 ** -3\\n )\\n one_var = switched_vars[\\\"A\\\"]\\n else:\\n new_capacitor_line += \\\",\\\"\\n if \\\"B\\\" in switched_vars:\\n new_capacitor_line += \\\",\\\" + str(\\n switched_vars[\\\"B\\\"] * 10 ** -3\\n )\\n one_var = switched_vars[\\\"B\\\"]\\n else:\\n new_capacitor_line += \\\",\\\"\\n if \\\"C\\\" in switched_vars:\\n new_capacitor_line += \\\",\\\" + str(\\n switched_vars[\\\"C\\\"] * 10 ** -3\\n )\\n one_var = switched_vars[\\\"C\\\"]\\n else:\\n new_capacitor_line += \\\",\\\"\\n if total_var > 0:\\n new_capacitor_object_line += str(one_var * 10 ** -3) + \\\",\\\"\\n else:\\n new_capacitor_object_line += \\\",\\\"\\n pass\\n\\n # KV\\n if hasattr(i, \\\"nominal_voltage\\\") and i.nominal_voltage is not None:\\n try:\\n if len(phases) == 1:\\n new_capacitor_line += \\\",\\\" + str(\\n i.nominal_voltage * 10 ** -3\\n )\\n new_capacitor_object_line += (\\n str(i.nominal_voltage * 10 ** -3) + \\\",\\\"\\n )\\n else:\\n new_capacitor_line += \\\",\\\" + str(\\n i.nominal_voltage * 10 ** -3 / math.sqrt(3)\\n )\\n new_capacitor_object_line += (\\n str(i.nominal_voltage * 10 ** -3 / math.sqrt(3))\\n + \\\",\\\"\\n )\\n except:\\n new_capacitor_line += \\\",\\\"\\n new_capacitor_object_line += \\\",\\\"\\n pass\\n\\n if hasattr(i, \\\"mode\\\") and i.mode is not None:\\n if i.mode.lower() == \\\"currentFlow\\\":\\n new_capacitor_line += \\\",2\\\"\\n elif i.mode.lower() == \\\"voltage\\\":\\n new_capacitor_line += \\\",1\\\"\\n elif i.mode.lower() == \\\"activepower\\\":\\n new_capacitor_line += \\\",4\\\"\\n elif i.mode.lower() == \\\"reactivepower\\\":\\n new_capacitor_line += \\\",7\\\"\\n elif i.mode.lower() == \\\"timescheduled\\\":\\n new_capacitor_line += \\\",6\\\"\\n else:\\n new_capacitor_line += \\\",0\\\"\\n else:\\n new_capacitor_line += \\\",\\\"\\n\\n if hasattr(i, \\\"low\\\") and i.low is not None:\\n new_capacitor_line += (\\n \\\",\\\" + str(i.low) + \\\",\\\" + str(i.low) + \\\",\\\" + str(i.low)\\n )\\n else:\\n new_capacitor_line += \\\",,,\\\"\\n\\n if hasattr(i, \\\"high\\\") and i.high is not None:\\n new_capacitor_line += (\\n \\\",\\\" + str(i.high) + \\\",\\\" + str(i.high) + \\\",\\\" + str(i.high)\\n )\\n else:\\n new_capacitor_line += \\\",,,\\\"\\n\\n found = False\\n for k, d in self.capcodes.items():\\n if d == new_capacitor_object_line:\\n new_capacitor_line += (\\n \\\",\\\" + new_section_ID + \\\",capacitor_\\\" + str(k)\\n )\\n found = True\\n if not found:\\n ID_cap += 1\\n self.capcodes[ID_cap] = new_capacitor_object_line\\n new_capacitor_line += (\\n \\\",\\\" + new_section_ID + \\\",capacitor_\\\" + str(ID_cap)\\n )\\n\\n new_capacitor_line += \\\",S,0\\\" # Location and ConnectionStatus\\n\\n if new_capacitor_line != \\\"\\\":\\n capacitor_string_list.append(new_capacitor_line)\\n\\n if new_section is not None:\\n self.section_line_list.append(new_section)\\n # If the object is inside of a substation...\\n if hasattr(i, \\\"is_substation\\\") and i.is_substation == 1:\\n # ...it should have the name of the substation specified in the 'substation_name' attribute\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n and i.substation_name != \\\"\\\"\\n ):\\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\\n ff_name = \\\"substation_{}\\\".format(i.substation_name)\\n self.network_have_substations = True\\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\\n elif (\\n hasattr(i, \\\"feeder_name\\\")\\n and i.feeder_name is not None\\n and i.feeder_name != \\\"\\\"\\n ):\\n ff_name = i.feeder_name\\n\\n if ff_name in self.section_line_feeder_mapping:\\n self.section_line_feeder_mapping[ff_name].append(\\n new_section\\n )\\n else:\\n self.section_line_feeder_mapping[ff_name] = [new_section]\\n\\n # If we get a Regulator\\n #\\n if isinstance(i, Regulator) and not (\\n hasattr(i, \\\"ltc\\\") and i.ltc is not None and i.ltc\\n ):\\n\\n new_regulator_string = \\\"\\\"\\n new_regulator_object_line = \\\"\\\"\\n\\n # We need to get bus1 and bus2 to create the section bus1_bus2\\n new_section = None\\n new_section_ID = None\\n if (\\n hasattr(i, \\\"from_element\\\")\\n and i.from_element is not None\\n and hasattr(i, \\\"to_element\\\")\\n and i.to_element is not None\\n ):\\n # try:\\n from_index = 0\\n to_index = 0\\n if (\\n hasattr(i, \\\"from_element_connection_index\\\")\\n and i.from_element_connection_index is not None\\n ):\\n from_index = i.from_element_connection_index\\n if (\\n hasattr(i, \\\"to_element_connection_index\\\")\\n and i.to_element_connection_index is not None\\n ):\\n to_index = i.to_element_connection_index\\n new_section_ID = \\\"{f}_{t}\\\".format(\\n f=i.from_element, t=i.to_element\\n )\\n if len(new_section_ID) > 64:\\n hasher = hashlib.sha1()\\n hasher.update(new_section_ID.encode(\\\"utf-8\\\"))\\n new_section_ID = hasher.hexdigest()\\n new_section = new_section_ID + \\\",{f},{fi},{t},{ti},\\\".format(\\n f=i.from_element, fi=from_index, t=i.to_element, ti=to_index\\n )\\n if hasattr(i, \\\"feeder_name\\\") and i.feeder_name is not None:\\n if i.feeder_name in self.section_feeder_mapping:\\n self.section_feeder_mapping[i.feeder_name].append(\\n new_section_ID\\n )\\n else:\\n self.section_feeder_mapping[i.feeder_name] = [\\n new_section_ID\\n ]\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n ):\\n self.section_headnode_mapping[\\n i.feeder_name\\n ] = i.substation_name\\n # except:\\n # pass\\n\\n # If we have a regulator with two windings that have different\\n # voltages, we create a new section and a new transformer connected to it\\n # in order to have the voltage change\\n winding1 = None\\n winding2 = None\\n from_element = None\\n to_element = None\\n from_index = 0\\n to_index = 0\\n windings_local = []\\n if hasattr(i, \\\"windings\\\") and i.windings is not None:\\n if (\\n len(i.windings) >= 2\\n and hasattr(i.windings[0], \\\"nominal_voltage\\\")\\n and hasattr(i.windings[1], \\\"nominal_voltage\\\")\\n and i.windings[0].nominal_voltage is not None\\n and i.windings[1].nominal_voltage is not None\\n ):\\n winding1 = i.windings[0]\\n winding2 = i.windings[1]\\n if (\\n hasattr(i, \\\"from_element\\\")\\n and i.from_element is not None\\n and hasattr(i, \\\"to_element\\\")\\n and i.to_element is not None\\n ):\\n from_element = i.from_element\\n to_element = i.to_element\\n\\n if (\\n hasattr(i, \\\"from_element_connection_index\\\")\\n and i.from_element_connection_index is not None\\n ):\\n from_index = i.from_element_connection_index\\n if (\\n hasattr(i, \\\"to_element_connection_index\\\")\\n and i.to_element_connection_index is not None\\n ):\\n to_index = i.to_element_connection_index\\n if winding1 is not None and winding2 is not None:\\n windings_local = [winding1, winding2]\\n if winding1.nominal_voltage != winding2.nominal_voltage:\\n new_trans_sectionID = \\\"{f}_{t}\\\".format(\\n f=from_element, t=to_element + \\\"_reg\\\"\\n )\\n if len(new_trans_sectionID) > 64:\\n hasher = hashlib.sha1()\\n hasher.update(new_trans_sectionID.encode(\\\"utf-8\\\"))\\n new_trans_sectionID = hasher.hexdigest()\\n new_trans_section = (\\n new_trans_sectionID\\n + \\\",{f},{fi},{t},{ti},\\\".format(\\n f=from_element,\\n fi=from_index,\\n t=to_element + \\\"_reg\\\",\\n ti=to_index,\\n )\\n )\\n new_section_ID = \\\"{f}_{t}\\\".format(\\n f=to_element + \\\"_reg\\\", t=to_element\\n )\\n if len(new_section_ID) > 64:\\n hasher = hashlib.sha1()\\n hasher.update(new_section_ID.encode(\\\"utf-8\\\"))\\n new_section_ID = hasher.hexdigest()\\n new_section = new_section_ID + \\\",{f},{fi},{t},{ti},\\\".format(\\n f=to_element + \\\"_reg\\\",\\n fi=from_index,\\n t=to_element,\\n ti=to_index,\\n )\\n if hasattr(i, \\\"feeder_name\\\") and i.feeder_name is not None:\\n if i.feeder_name in self.section_feeder_mapping:\\n self.section_feeder_mapping[i.feeder_name].append(\\n new_section_ID\\n )\\n else:\\n self.section_feeder_mapping[i.feeder_name] = [\\n new_section_ID\\n ]\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n ):\\n self.section_headnode_mapping[\\n i.feeder_name\\n ] = i.substation_name\\n self.nodeID_list.append(to_element + \\\"_reg\\\")\\n self.node_string_list.append(\\n \\\"{},0,0\\\".format(to_element + \\\"_reg\\\")\\n )\\n new_transformer_line = \\\"\\\"\\n new_transformer_object_line = \\\"\\\"\\n phase_on = \\\"\\\"\\n if (\\n hasattr(winding1, \\\"phase_windings\\\")\\n and winding1.phase_windings is not None\\n ):\\n for phase_winding in winding1.phase_windings:\\n if new_trans_section is not None:\\n if (\\n hasattr(phase_winding, \\\"phase\\\")\\n and phase_winding.phase is not None\\n ):\\n new_trans_section += str(\\n phase_winding.phase\\n )\\n phase_on += str(phase_winding.phase)\\n\\n if (\\n new_trans_section is not None\\n and new_trans_section not in self.section_line_list\\n ):\\n self.section_line_list.append(new_trans_section)\\n # If the object is inside of a substation...\\n if hasattr(i, \\\"is_substation\\\") and i.is_substation == 1:\\n # ...it should have the name of the substation specified in the 'substation_name' attribute\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n and i.substation_name != \\\"\\\"\\n ):\\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\\n ff_name = \\\"substation_{}\\\".format(\\n i.substation_name\\n )\\n self.network_have_substations = True\\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\\n elif (\\n hasattr(i, \\\"feeder_name\\\")\\n and i.feeder_name is not None\\n and i.feeder_name != \\\"\\\"\\n ):\\n ff_name = i.feeder_name\\n\\n if ff_name in self.section_line_feeder_mapping:\\n self.section_line_feeder_mapping[ff_name].append(\\n new_section\\n )\\n else:\\n self.section_line_feeder_mapping[ff_name] = [\\n new_section\\n ]\\n\\n if (\\n hasattr(winding1, \\\"phase_windings\\\")\\n and winding1.phase_windings is not None\\n ):\\n try:\\n if len(winding1.phase_windings) == 1:\\n TYPE = 1\\n elif len(winding1.phase_windings) == 3:\\n TYPE = 2\\n else:\\n TYPE = 3\\n except:\\n TYPE = 3\\n pass\\n else:\\n TYPE = 3\\n\\n try:\\n new_transformer_line += new_trans_sectionID\\n except:\\n pass\\n\\n # CoordX and CoordY\\n if hasattr(i, \\\"positions\\\") and i.positions is not None:\\n try:\\n new_transformer_line += \\\",\\\" + str(\\n i.positions[0].long\\n )\\n new_transformer_line += \\\",\\\" + str(\\n i.positions[0].lat\\n )\\n except:\\n new_transformer_line += \\\",,\\\"\\n pass\\n\\n CONN = \\\"\\\"\\n try:\\n new_transformer_line += (\\n \\\",\\\"\\n + self.transformer_connection_configuration_mapping(\\n winding1.connection_type,\\n winding2.connection_type,\\n \\\"transformer_settings\\\",\\n )\\n )\\n CONN = self.transformer_connection_configuration_mapping(\\n winding1.connection_type, winding2.connection_type\\n )\\n except:\\n new_transformer_line += \\\",\\\"\\n pass\\n\\n phase_shift = 0\\n if CONN == \\\"0\\\" or CONN == \\\"4\\\":\\n phase_shift = 0\\n if CONN == \\\"1\\\" or CONN == \\\"2\\\":\\n phase_shift = 1\\n\\n try:\\n new_transformer_line += \\\",\\\" + phase_on\\n except:\\n new_transformer_line += \\\",\\\"\\n pass\\n\\n if (\\n hasattr(winding1, \\\"resistance\\\")\\n and hasattr(winding2, \\\"resistance\\\")\\n and winding1.resistance is not None\\n and winding2.resistance is not None\\n ):\\n # Resistance is given as a percentage of the KVA of the corresponding winding\\n try:\\n RH = (\\n winding1.resistance\\n * 10 ** -2\\n * winding1.rated_power\\n * 10 ** -3\\n )\\n RL = (\\n winding2.resistance\\n * 10 ** -2\\n * winding2.rated_power\\n * 10 ** -3\\n )\\n except:\\n RH = 0\\n RL = 0\\n pass\\n\\n # We have ZHL=(RH+RL)+XHLj\\n #\\n # Compute the X over R ratio\\n try:\\n XR = (XHL) / (RH + RL)\\n XR0 = XR\\n except:\\n XR = 0\\n XR0 = 0\\n pass\\n #\\n # |ZHL|=sqrt((RH+RL)^2 + XHL^2)\\n try:\\n _ZHL_ = math.sqrt((RH + RL) ** 2 + XHL ** 2)\\n except:\\n _ZHL_ = 0\\n pass\\n\\n #\\n # Expressed in percentage of the KVA base\\n try:\\n Z1 = _ZHL_ * 100.0 / (winding1.rated_power * 10 ** -3)\\n except:\\n Z1 = 0\\n pass\\n Z0 = Z1\\n\\n # Total kva\\n try:\\n KVA = windings_local[0].rated_power\\n except:\\n pass\\n\\n for w, winding in enumerate(windings_local):\\n\\n if hasattr(winding, \\\"nominal_voltage\\\"):\\n try:\\n if w == 0:\\n KVLLprim = (\\n winding.nominal_voltage * 10 ** -3\\n )\\n if transformer_object.is_center_tap == True:\\n KVLLprim = round(\\n KVLLprim / (3 ** 0.5), 2\\n ) # produces output in L-N format if center-tap rather than L-L\\n VoltageUnit = (\\n 1 # Voltage declared in KV, not in KVLL\\n )\\n elif w == 1:\\n KVLLsec = winding.nominal_voltage * 10 ** -3\\n VoltageUnit = (\\n 1 # Voltage declared in KV, not in KVLL\\n )\\n except:\\n pass\\n # NoLoadLosses\\n if (\\n hasattr(i, \\\"noload_loss\\\")\\n and i.noload_loss is not None\\n ):\\n # TODO: Make sure noloadlosses is in % in DiTTo, or change what is next.\\n NoLoadLosses = i.noload_loss / 100.0 * KVA\\n else:\\n NoLoadLosses = \\\"\\\"\\n\\n new_transformer_object_line += \\\"{type},{kva},{voltageunit},{kvllprim},{kvllsec},{Z1},{Z0},{XR},{XR0},{Conn},{WindingType},{noloadloss},{phaseshift},{isltc}\\\".format(\\n type=TYPE,\\n kva=KVA,\\n voltageunit=VoltageUnit,\\n kvllprim=KVLLprim,\\n kvllsec=KVLLsec,\\n Conn=CONN,\\n Z1=Z1,\\n Z0=Z0,\\n XR=XR,\\n XR0=XR0,\\n WindingType=1,\\n noloadloss=NoLoadLosses,\\n phaseshift=phase_shift,\\n isltc=0,\\n )\\n\\n found = False\\n for k, d in self.two_windings_trans_codes.items():\\n if d == new_transformer_object_line:\\n new_transformer_line += (\\n \\\",transformer_\\\"\\n + str(k)\\n + \\\",transformer_\\\"\\n + str(k)\\n )\\n found = True\\n if not found:\\n ID_trans += 1\\n self.two_windings_trans_codes[\\n ID_trans\\n ] = new_transformer_object_line\\n new_transformer_line += (\\n \\\",transformer_\\\"\\n + str(ID_trans)\\n + \\\",transformer_\\\"\\n + str(ID_trans)\\n )\\n\\n new_transformer_line += \\\",{PhaseShiftType},M,100,100,None,0\\\".format(\\n PhaseShiftType=phase_shift\\n ) # Phase shift, Location, PrimTap,SecondaryTap, ODPrimPh, and ConnectionStatus\\n\\n if new_transformer_line != \\\"\\\":\\n two_windings_transformer_string_list.append(\\n new_transformer_line\\n )\\n\\n if hasattr(winding1, \\\"phase_windings\\\"):\\n for phase_winding in winding1.phase_windings:\\n try:\\n new_section += str(phase_winding.phase)\\n except:\\n pass\\n\\n if (\\n new_section is not None\\n and new_section not in self.section_line_list\\n ):\\n self.section_line_list.append(new_section)\\n # If the object is inside of a substation...\\n if hasattr(i, \\\"is_substation\\\") and i.is_substation == 1:\\n # ...it should have the name of the substation specified in the 'substation_name' attribute\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n and i.substation_name != \\\"\\\"\\n ):\\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\\n ff_name = \\\"substation_{}\\\".format(i.substation_name)\\n self.network_have_substations = True\\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\\n elif (\\n hasattr(i, \\\"feeder_name\\\")\\n and i.feeder_name is not None\\n and i.feeder_name != \\\"\\\"\\n ):\\n ff_name = i.feeder_name\\n\\n if ff_name in self.section_line_feeder_mapping:\\n self.section_line_feeder_mapping[ff_name].append(\\n new_section\\n )\\n else:\\n self.section_line_feeder_mapping[ff_name] = [new_section]\\n\\n try:\\n new_regulator_string += new_section_ID\\n except:\\n pass\\n\\n # CoordX and CoordY\\n if hasattr(i, \\\"positions\\\") and i.positions is not None:\\n try:\\n new_regulator_string += \\\",\\\" + str(i.positions[0].long)\\n new_regulator_string += \\\",\\\" + str(i.positions[0].lat)\\n except:\\n new_regulator_string += \\\",,\\\"\\n pass\\n else:\\n new_regulator_string += \\\",,\\\"\\n\\n # if hasattr(i, \\\"pt_phase\\\") and i.pt_phase is not None:\\n # try:\\n # new_regulator_string += \\\",\\\" + str(i.pt_phase)\\n # except:\\n # new_regulator_string += \\\",\\\"\\n # pass\\n # else:\\n # new_regulator_string += \\\",\\\"\\n\\n _KVA = 0\\n _KVLN = 0\\n _Rset = {\\\"A\\\": 0, \\\"B\\\": 0, \\\"C\\\": 0}\\n _Xset = {\\\"A\\\": 0, \\\"B\\\": 0, \\\"C\\\": 0}\\n _regphases = []\\n if len(windings_local) >= 2:\\n try:\\n _KVA = windings_local[0].rated_power * 10 ** -3\\n except:\\n pass\\n _KVLN = (\\n windings_local[-1].nominal_voltage / math.sqrt(3) * 10 ** -3\\n )\\n\\n if (\\n hasattr(winding1, \\\"phase_windings\\\")\\n and winding1.phase_windings is not None\\n ):\\n for phase_winding in winding1.phase_windings:\\n try:\\n _regphases.append(phase_winding.phase)\\n _Rset[\\n phase_winding.phase\\n ] = phase_winding.compensator_r\\n _Xset[\\n phase_winding.phase\\n ] = phase_winding.compensator_x\\n except:\\n pass\\n\\n new_regulator_string += \\\",\\\"\\n for phase in _regphases:\\n new_regulator_string += phase\\n\\n _band = None\\n if hasattr(i, \\\"bandwidth\\\") and i.bandwidth is not None:\\n try:\\n new_regulator_string += \\\",\\\" + str(i.bandwidth)\\n _band = str(i.bandwidth)\\n except:\\n new_regulator_string += \\\",\\\"\\n pass\\n else:\\n new_regulator_string += \\\",\\\"\\n\\n _CT = None\\n if hasattr(i, \\\"ct_ratio\\\") and i.ct_ratio is not None:\\n try:\\n new_regulator_string += \\\",\\\" + str(i.ct_ratio)\\n _CT = str(i.ct_ratio)\\n except:\\n new_regulator_string += \\\",\\\"\\n else:\\n new_regulator_string += \\\",\\\"\\n\\n _PT = None\\n if hasattr(i, \\\"pt_ratio\\\") and i.pt_ratio is not None:\\n try:\\n new_regulator_string += \\\",\\\" + str(i.pt_ratio)\\n _PT = str(i.pt_ratio)\\n except:\\n new_regulator_string += \\\",\\\"\\n else:\\n new_regulator_string += \\\",\\\"\\n\\n if hasattr(i, \\\"setpoint\\\") and i.setpoint is not None:\\n scaled_setpoint = i.setpoint * 120 / 100.0\\n try:\\n new_regulator_string += (\\n \\\",\\\"\\n + str(scaled_setpoint)\\n + \\\",\\\"\\n + str(scaled_setpoint)\\n + \\\",\\\"\\n + str(scaled_setpoint)\\n ) # Assume same setpoint on all phases\\n except:\\n new_regulator_string += \\\",,,\\\"\\n else:\\n new_regulator_string += \\\",,,\\\"\\n\\n new_regulator_object_line = \\\"{kva},{band},{ct},{pt},{Type},{KVLN},{MaxBuck},{MaxBoost},{Taps},{Reversible}\\\".format(\\n kva=_KVA,\\n band=_band,\\n ct=_CT,\\n pt=_PT,\\n Type=0,\\n KVLN=_KVLN,\\n MaxBuck=10,\\n MaxBoost=10,\\n Taps=32,\\n Reversible=0,\\n )\\n\\n found = False\\n for k, d in self.reg_codes.items():\\n if d == new_regulator_object_line:\\n new_regulator_string += \\\",regulator_{id},{secid}\\\".format(\\n id=k, secid=new_section_ID\\n )\\n found = True\\n if not found:\\n ID_reg += 1\\n self.reg_codes[ID_reg] = new_regulator_object_line\\n new_regulator_string += \\\",regulator_{id},{secid}\\\".format(\\n id=ID_reg, secid=new_section_ID\\n )\\n\\n # Location, MaxBuck, MaxBoost, SettingOption, RsetA, RsetB, RsetC, XsetA,\\n # XsetB, XsetC, TapA, TapB, TapC, and ConnectionStatus\\n new_regulator_string += \\\",M,10,10,T,{RsetA},{RsetB},{RsetC},{XsetA},{XsetB},{XsetC},0,0,0,0\\\".format(\\n RsetA=_Rset[\\\"A\\\"],\\n RsetB=_Rset[\\\"B\\\"],\\n RsetC=_Rset[\\\"C\\\"],\\n XsetA=_Xset[\\\"A\\\"],\\n XsetB=_Xset[\\\"B\\\"],\\n XsetC=_Xset[\\\"C\\\"],\\n )\\n\\n if new_regulator_string != \\\"\\\":\\n regulator_string_list.append(new_regulator_string)\\n\\n # If we get a Transformer object\\n #\\n if (\\n isinstance(i, PowerTransformer)\\n and (i.name not in self.transformers_to_ignore)\\n ) or (\\n isinstance(i, Regulator)\\n and (hasattr(i, \\\"ltc\\\") and i.ltc is not None and i.ltc == 1)\\n ):\\n\\n transformer_object = i\\n\\n # These are only set if it's an LTC\\n Setpoint = \\\"\\\"\\n ControlType = \\\"\\\"\\n LowerBandwidth = \\\"\\\"\\n UpperBandwidth = \\\"\\\"\\n MaxBoost = \\\"\\\"\\n MaxBuck = \\\"\\\"\\n is_ltc = 0\\n if isinstance(i, Regulator):\\n is_ltc = 1\\n Setpoint = i.setpoint\\n if hasattr(i, \\\"connected_transformer\\\"):\\n transformer_object = model[i.connected_transformer]\\n ControlType = \\\"0\\\"\\n else:\\n raise ValueError(\\n \\\"An LTC regulator needs a connecting transformer\\\"\\n )\\n\\n # We need to get bus1 and bus2 to create the section bus1_bus2\\n new_section = None\\n new_section_ID = None\\n if (\\n hasattr(transformer_object, \\\"from_element\\\")\\n and transformer_object.from_element is not None\\n and hasattr(transformer_object, \\\"to_element\\\")\\n and transformer_object.to_element is not None\\n ):\\n from_index = 0\\n to_index = 0\\n if (\\n hasattr(transformer_object, \\\"from_element_connection_index\\\")\\n and transformer_object.from_element_connection_index\\n is not None\\n ):\\n from_index = (\\n transformer_object.from_element_connection_index\\n )\\n if (\\n hasattr(transformer_object, \\\"to_element_connection_index\\\")\\n and transformer_object.to_element_connection_index\\n is not None\\n ):\\n to_index = transformer_object.to_element_connection_index\\n\\n new_section_ID = \\\"{f}_{t}\\\".format(\\n f=transformer_object.from_element,\\n t=transformer_object.to_element,\\n )\\n\\n if len(new_section_ID) > 64:\\n hasher = hashlib.sha1()\\n hasher.update(new_section_ID.encode(\\\"utf-8\\\"))\\n new_section_ID = hasher.hexdigest()\\n new_section = new_section_ID + \\\",{f},{fi},{t},{ti},\\\".format(\\n f=transformer_object.from_element,\\n fi=from_index,\\n t=transformer_object.to_element,\\n ti=to_index,\\n )\\n # If it's a regulator, use the regulator object to find the feeder and substation if they're set\\n if hasattr(i, \\\"feeder_name\\\") and i.feeder_name is not None:\\n if i.feeder_name in self.section_feeder_mapping:\\n self.section_feeder_mapping[i.feeder_name].append(\\n new_section_ID\\n )\\n else:\\n self.section_feeder_mapping[i.feeder_name] = [\\n new_section_ID\\n ]\\n if (\\n hasattr(i, \\\"substation_name\\\")\\n and i.substation_name is not None\\n ):\\n self.section_headnode_mapping[\\n i.feeder_name\\n ] = i.substation_name\\n\\n # Set Regulator attributes if its an LTC\\n\\n if hasattr(i, \\\"bandwidth\\\") and i.bandwidth is not None:\\n bandcenter = 0\\n if hasattr(i, \\\"bandcenter\\\") and i.bandcenter is not None:\\n bandcenter = i.bandcenter\\n LowerBandwidth = str(abs(bandcenter - i.bandwidth))\\n UpperBandwidth = str(abs(bandcenter + i.bandwidth))\\n\\n if hasattr(i, \\\"highstep\\\") and i.highstep is not None:\\n MaxBoost = str(i.highstep)\\n\\n if hasattr(i, \\\"highstep\\\") and i.highstep is not None:\\n MaxBuck = str(i.lowstep)\\n\\n # Find out if we have a two or three windings transformer\\n if (\\n hasattr(transformer_object, \\\"windings\\\")\\n and transformer_object.windings is not None\\n ):\\n\\n phase_on = \\\"\\\"\\n if (\\n hasattr(transformer_object.windings[0], \\\"phase_windings\\\")\\n and transformer_object.windings[0].phase_windings\\n is not None\\n ):\\n for phase_winding in transformer_object.windings[\\n 0\\n ].phase_windings:\\n if new_section is not None:\\n if (\\n hasattr(phase_winding, \\\"phase\\\")\\n and phase_winding.phase is not None\\n ):\\n new_section += str(phase_winding.phase)\\n phase_on += str(phase_winding.phase)\\n\\n if (\\n new_section is not None\\n and new_section not in self.section_line_list\\n ):\\n self.section_line_list.append(new_section)\\n # If the object is inside of a substation...\\n if (\\n hasattr(transformer_object, \\\"is_substation\\\")\\n and transformer_object.is_substation == 1\\n ):\\n # ...it should have the name of the substation specified in the 'substation_name' attribute\\n if (\\n hasattr(transformer_object, \\\"substation_name\\\")\\n and transformer_object.substation_name is not None\\n and transformer_object.substation_name != \\\"\\\"\\n ):\\n # Add 'substation_' prefix to easily distinguish substation from feeders or transmission lines\\n ff_name = \\\"substation_{}\\\".format(\\n transformer_object.substation_name\\n )\\n self.network_have_substations = True\\n # If the object is not inside of a substation, then use the feeder_name attribute if it exists\\n elif (\\n hasattr(transformer_object, \\\"feeder_name\\\")\\n and transformer_object.feeder_name is not None\\n and transformer_object.feeder_name != \\\"\\\"\\n ):\\n ff_name = transformer_object.feeder_name\\n\\n if ff_name in self.section_line_feeder_mapping:\\n self.section_line_feeder_mapping[ff_name].append(\\n new_section\\n )\\n else:\\n self.section_line_feeder_mapping[ff_name] = [\\n new_section\\n ]\\n\\n # Case 1: Two Windings\\n #\\n if (\\n len(transformer_object.windings) == 2\\n or transformer_object.is_center_tap == True\\n ):\\n # Empty new transformer string\\n new_transformer_line = \\\"\\\"\\n new_transformer_object_line = \\\"\\\"\\n\\n if (\\n hasattr(\\n transformer_object.windings[0], \\\"phase_windings\\\"\\n )\\n and transformer_object.windings[0].phase_windings\\n is not None\\n ):\\n try:\\n if (\\n transformer_object.is_center_tap == True\\n and len(\\n transformer_object.windings[\\n 0\\n ].phase_windings\\n )\\n == 1\\n ):\\n TYPE = 4\\n elif (\\n len(\\n transformer_object.windings[\\n 0\\n ].phase_windings\\n )\\n == 1\\n ):\\n TYPE = 1\\n elif (\\n len(\\n transformer_object.windings[\\n 0\\n ].phase_windings\\n )\\n == 3\\n ):\\n TYPE = 2\\n else:\\n TYPE = 3\\n except:\\n TYPE = 3\\n pass\\n else:\\n TYPE = 3\\n\\n try:\\n new_transformer_line += new_section_ID\\n except:\\n pass\\n\\n # CoordX and CoordY\\n if (\\n hasattr(transformer_object, \\\"positions\\\")\\n and transformer_object.positions is not None\\n ):\\n try:\\n new_transformer_line += \\\",\\\" + str(\\n transformer_object.positions[0].long\\n )\\n new_transformer_line += \\\",\\\" + str(\\n transformer_object.positions[0].lat\\n )\\n except:\\n new_transformer_line += \\\",,\\\"\\n pass\\n\\n CONN = \\\"\\\"\\n try:\\n if TYPE == 4:\\n CONN = \\\"0\\\" # Center Tap not a configuration for transformer object. Leave as Y-Y\\n new_transformer_line += \\\",15\\\"\\n else:\\n new_transformer_line += (\\n \\\",\\\"\\n + self.transformer_connection_configuration_mapping(\\n transformer_object.windings[\\n 0\\n ].connection_type,\\n transformer_object.windings[\\n 1\\n ].connection_type,\\n \\\"transformer_settings\\\",\\n )\\n )\\n CONN = self.transformer_connection_configuration_mapping(\\n transformer_object.windings[0].connection_type,\\n transformer_object.windings[1].connection_type,\\n )\\n except:\\n new_transformer_line += \\\",\\\"\\n pass\\n\\n phase_shift = 0\\n if CONN == \\\"0\\\" or CONN == \\\"4\\\":\\n phase_shift = 0\\n if CONN == \\\"1\\\" or CONN == \\\"2\\\":\\n phase_shift = 1\\n\\n try:\\n new_transformer_line += \\\",\\\" + phase_on\\n except:\\n new_transformer_line += \\\",\\\"\\n pass\\n\\n # Compute the impedances of center tap transformers. These should be three windings, one phase transformers in DiTTo\\n # with the is_center_tap flag set to 1\\n if TYPE == 4:\\n if (\\n hasattr(transformer_object, \\\"reactances\\\")\\n and transformer_object.reactances is not None\\n and len(i.reactances) == 3\\n ):\\n XHL, XHT, XLT = transformer_object.reactances\\n if (\\n hasattr(\\n transformer_object.windings[0], \\\"resistance\\\"\\n )\\n and hasattr(\\n transformer_object.windings[1], \\\"resistance\\\"\\n )\\n and hasattr(\\n transformer_object.windings[2], \\\"resistance\\\"\\n )\\n and transformer_object.windings[0].resistance\\n is not None\\n and transformer_object.windings[1].resistance\\n is not None\\n and transformer_object.windings[2].resistance\\n is not None\\n ):\\n R0, R1, R2 = [\\n w.resistance\\n for w in transformer_object.windings\\n ]\\n KVA_BASE = (\\n transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n XR, Z1 = self.get_center_tap_impedances(\\n R0, R1, R2, XHL, XHT, XLT, KVA_BASE\\n )\\n XR0 = XR\\n Z0 = Z1\\n\\n else:\\n if (\\n hasattr(transformer_object, \\\"reactances\\\")\\n and transformer_object.reactances is not None\\n and len(transformer_object.reactances) == 1\\n ):\\n XHL_perct = transformer_object.reactances[0]\\n # XHL is in percentage of the KVA of the FIRST winding\\n try:\\n XHL = (\\n XHL_perct\\n * 10 ** -2\\n * transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n except:\\n XHL = 0\\n pass\\n\\n if (\\n hasattr(\\n transformer_object.windings[0], \\\"resistance\\\"\\n )\\n and hasattr(\\n transformer_object.windings[1], \\\"resistance\\\"\\n )\\n and transformer_object.windings[0].resistance\\n is not None\\n and transformer_object.windings[1].resistance\\n is not None\\n ):\\n # Resistance is given as a percentage of the KVA of the corresponding winding\\n try:\\n RH = (\\n transformer_object.windings[0].resistance\\n * 10 ** -2\\n * transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n RL = (\\n transformer_object.windings[1].resistance\\n * 10 ** -2\\n * transformer_object.windings[1].rated_power\\n * 10 ** -3\\n )\\n except:\\n RH = 0\\n RL = 0\\n pass\\n\\n # We have ZHL=(RH+RL)+XHLj\\n #\\n # Compute the X over R ratio\\n try:\\n XR = (XHL) / (RH + RL)\\n XR0 = XR\\n except:\\n XR = 0\\n XR0 = 0\\n pass\\n #\\n # |ZHL|=sqrt((RH+RL)^2 + XHL^2)\\n try:\\n _ZHL_ = math.sqrt((RH + RL) ** 2 + XHL ** 2)\\n except:\\n _ZHL_ = 0\\n pass\\n\\n #\\n # Expressed in percentage of the KVA base\\n try:\\n Z1 = (\\n _ZHL_\\n * 100.0\\n / (\\n transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n )\\n except:\\n Z1 = 0\\n pass\\n Z0 = Z1\\n\\n # Total kva\\n try:\\n KVA = (\\n transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n except:\\n KVA = \\\"DEFAULT\\\"\\n pass\\n\\n for w, winding in enumerate(transformer_object.windings):\\n # try:\\n # KVA+=winding.rated_power*10**-3\\n # except:\\n # pass\\n\\n if hasattr(winding, \\\"nominal_voltage\\\"):\\n # If we have a one phase transformer or a delta transformer, we specify voltage in KV, not in KVLL\\n # This is done by setting the voltageUnit keyword to 1\\n if (\\n len(\\n transformer_object.windings[\\n 0\\n ].phase_windings\\n )\\n <= 1\\n or len(\\n transformer_object.windings[\\n 0\\n ].phase_windings\\n )\\n == 2\\n ):\\n if w == 0:\\n KVLLprim = (\\n winding.nominal_voltage * 10 ** -3\\n )\\n # if transformer_object.is_center_tap == True:\\n # KVLLprim = round(\\n # KVLLprim / (3 ** 0.5), 2\\n # ) # produces output in L-N format if center-tap rather than L-L\\n voltageUnit = (\\n 1 # Voltage declared in KV, not in KVLL\\n )\\n elif w == 1:\\n # In addition, if we have a center tap, we need to add the secondary and tertiary voltages here\\n if TYPE == 4:\\n try:\\n KVLLsec = (\\n winding.nominal_voltage\\n * 10 ** -3\\n + transformer_object.windings[\\n 2\\n ].nominal_voltage\\n * 10 ** -3\\n )\\n voltageUnit = 1 # Voltage declared in KV, not in KVLL\\n except:\\n KVLLsec = \\\"DEFAULT\\\"\\n pass\\n else:\\n KVLLsec = (\\n winding.nominal_voltage * 10 ** -3\\n )\\n voltageUnit = 1 # Voltage declared in KV, not in KVLL\\n # If we have a three phase transformer, we need to specify the voltage in KVLL.\\n # This is done by setting the voltageUnit to 0, and multiplying the voltage by sqrt(3)\\n # Note: If we have three phases, the transformer shouln't be a center tap\\n elif (\\n len(\\n transformer_object.windings[\\n 0\\n ].phase_windings\\n )\\n == 3\\n ):\\n if w == 0:\\n KVLLprim = (\\n winding.nominal_voltage * 10 ** -3\\n ) # *math.sqrt(3)\\n if transformer_object.is_center_tap == True:\\n KVLLprim = round(\\n KVLLprim / (3 ** 0.5), 2\\n ) # produces output in L-N format if center-tap rather than L-L\\n voltageUnit = 0\\n if w == 1:\\n KVLLsec = (\\n winding.nominal_voltage * 10 ** -3\\n ) # *math.sqrt(3)\\n voltageUnit = 0\\n\\n # NoLoadLosses\\n if (\\n hasattr(transformer_object, \\\"noload_loss\\\")\\n and transformer_object.noload_loss is not None\\n ):\\n # TODO: Make sure noloadlosses is in % in DiTTo, or change what is next.\\n NOLOADLOSS = (\\n transformer_object.noload_loss / 100.0 * KVA\\n )\\n else:\\n NOLOADLOSS = \\\"\\\"\\n\\n new_transformer_object_line += \\\"{type},{kva},{voltageUnit},{kvllprim},{kvllsec},{Z1},{Z0},{XR},{XR0},{Conn},{WindingType},{noloadloss},{phaseshift},{isltc}\\\".format(\\n phaseshift=phase_shift,\\n type=TYPE,\\n kva=KVA,\\n voltageUnit=voltageUnit,\\n kvllprim=KVLLprim,\\n kvllsec=KVLLsec,\\n Conn=CONN,\\n Z1=Z1,\\n Z0=Z0,\\n XR=XR,\\n XR0=XR0,\\n WindingType=1,\\n noloadloss=NOLOADLOSS,\\n isltc=is_ltc,\\n )\\n\\n found = False\\n for k, d in self.two_windings_trans_codes.items():\\n if d == new_transformer_object_line:\\n new_transformer_line += (\\n \\\",transformer_\\\" + str(k) + \\\",\\\" + new_section_ID\\n )\\n found = True\\n if not found:\\n ID_trans += 1\\n self.two_windings_trans_codes[\\n ID_trans\\n ] = new_transformer_object_line\\n new_transformer_line += (\\n \\\",transformer_\\\"\\n + str(ID_trans)\\n + \\\",\\\"\\n + new_section_ID\\n )\\n\\n new_transformer_line += \\\",{PhaseShiftType},M,100,100,None,0\\\".format(\\n PhaseShiftType=phase_shift\\n ) # Phase shift, Location, PrimTap,SecondaryTap, ODPrimPh, and ConnectionStatus\\n\\n try:\\n TAP = 1.0 / float(\\n transformer_object.windings[1]\\n .phase_windings[0]\\n .tap_position\\n )\\n new_transformer_line += \\\",{}\\\".format(TAP)\\n except:\\n new_transformer_line += \\\",\\\"\\n pass\\n\\n # Apply the LTC settings. These are empty if it's just a transformer\\n new_transformer_line += \\\",{setpoint},{controltype},{lowerbandwidth},{upperbandwidth},{maxbuck},{maxboost}\\\".format(\\n setpoint=Setpoint,\\n controltype=ControlType,\\n lowerbandwidth=LowerBandwidth,\\n upperbandwidth=UpperBandwidth,\\n maxbuck=MaxBuck,\\n maxboost=MaxBoost,\\n )\\n\\n if new_transformer_line != \\\"\\\":\\n two_windings_transformer_string_list.append(\\n new_transformer_line\\n )\\n\\n # Case 2: Three Windings\\n #\\n elif len(transformer_object.windings) == 3:\\n # Empty new transformer string\\n new_transformer_line = \\\"\\\"\\n new_transformer_object_line = \\\"\\\"\\n\\n # Name\\n if (\\n hasattr(transformer_object, \\\"name\\\")\\n and transformer_object.name is not None\\n ):\\n try:\\n new_transformer_line += new_section_ID\\n except:\\n pass\\n\\n # CoordX and CoordY\\n if (\\n hasattr(transformer_object, \\\"positions\\\")\\n and transformer_object.positions is not None\\n ):\\n try:\\n new_transformer_line += \\\",\\\" + str(\\n transformer_object.positions[0].long\\n )\\n new_transformer_line += \\\",\\\" + str(\\n transformer_object.positions[0].lat\\n )\\n except:\\n new_transformer_line += \\\",,\\\"\\n pass\\n\\n _primary_rated_capacity = None\\n _secondary_rated_capacity = None\\n _tertiary_rated_capacity = None\\n _primary_voltage = None\\n _secondary_voltage = None\\n _tertiary_voltage = None\\n _primary_connection = None\\n _secondary_connection = None\\n _tertiary_connection = None\\n R = {}\\n XHL_perct, XLT_perct, XHT_perct = None, None, None\\n for w, winding in enumerate(transformer_object.windings):\\n if (\\n hasattr(winding, \\\"rated_power\\\")\\n and winding.rated_power is not None\\n ):\\n if w == 0:\\n _primary_rated_capacity = str(\\n winding.rated_power * 10 ** -3\\n )\\n if w == 1:\\n _secondary_rated_capacity = str(\\n winding.rated_power * 10 ** -3\\n )\\n if w == 2:\\n _tertiary_rated_capacity = str(\\n winding.rated_power * 10 ** -3\\n )\\n\\n if (\\n hasattr(winding, \\\"connection_type\\\")\\n and winding.connection_type is not None\\n ):\\n if w == 0:\\n _primary_connection = winding.connection_type\\n if w == 1:\\n _secondary_connection = winding.connection_type\\n if w == 2:\\n _tertiary_connection = winding.connection_type\\n\\n if (\\n hasattr(winding, \\\"nominal_voltage\\\")\\n and winding.nominal_voltage is not None\\n ):\\n try:\\n new_transformer_line += \\\",\\\" + str(\\n winding.nominal_voltage * 10 ** -3\\n )\\n except:\\n new_transformer_line += \\\",\\\"\\n pass\\n if w == 0:\\n _primary_voltage = str(\\n winding.nominal_voltage * 10 ** -3\\n )\\n if w == 1:\\n _secondary_voltage = str(\\n winding.nominal_voltage * 10 ** -3\\n )\\n if w == 2:\\n _tertiary_voltage = str(\\n winding.nominal_voltage * 10 ** -3\\n )\\n\\n else:\\n new_transformer_line += \\\",\\\"\\n\\n if (\\n hasattr(winding, \\\"resistance\\\")\\n and winding.resistance is not None\\n ):\\n try:\\n R[w] = (\\n winding.resistance\\n * winding.rated_power\\n * 10 ** -3\\n )\\n except:\\n R[w] = None\\n pass\\n\\n if (\\n hasattr(transformer_object, \\\"reactances\\\")\\n and i.reactances is not None\\n ):\\n try:\\n XHL_perct, XLT_perct, XHT_perct = i.reactances\\n except:\\n pass\\n\\n if XHL_perct is not None:\\n try:\\n XHL = (\\n XHL_perct\\n * 10 ** -2\\n * transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n except:\\n XHL = None\\n pass\\n if XLT_perct is not None:\\n try:\\n XLT = (\\n XLT_perct\\n * 10 ** -2\\n * transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n except:\\n XLT = None\\n pass\\n if XHT_perct is not None:\\n try:\\n XHT = (\\n XHT_perct\\n * 10 ** -2\\n * transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n except:\\n XHT = None\\n pass\\n\\n if (\\n sum([x is None for x in R]) == 0\\n and XHL is not None\\n and XLT is not None\\n and XHT is not None\\n ):\\n ZHL = complex(R[0] + R[1], XHL)\\n ZLT = complex(R[1] + R[2], XLT)\\n ZHT = complex(R[0] + R[2], XHT)\\n\\n _PrimaryToSecondaryXR1 = ZHL.imag / ZHL.real\\n _PrimaryToSecondaryXR0 = _PrimaryToSecondaryXR1\\n\\n _PrimaryToTertiaryXR1 = ZHT.imag / ZHT.real\\n _PrimaryToTertiaryXR0 = _PrimaryToTertiaryXR1\\n\\n _SecondaryToTertiaryXR1 = ZLT.imag / ZLT.real\\n _SecondaryToTertiaryXR0 = _SecondaryToTertiaryXR1\\n\\n _PrimaryToSecondaryZ1 = (\\n math.sqrt(ZHL.real ** 2 + ZHL.imag ** 2)\\n * 100.0\\n / (\\n transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n )\\n _PrimaryToSecondaryZ0 = _PrimaryToSecondaryZ1\\n\\n _PrimaryToTertiaryZ1 = (\\n math.sqrt(ZHT.real ** 2 + ZHT.imag ** 2)\\n * 100.0\\n / (\\n transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n )\\n _PrimaryToTertiaryZ0 = _PrimaryToTertiaryZ1\\n\\n _SecondaryToTertiaryZ1 = (\\n math.sqrt(ZLT.real ** 2 + ZLT.imag ** 2)\\n * 100.0\\n / (\\n transformer_object.windings[0].rated_power\\n * 10 ** -3\\n )\\n )\\n _SecondaryToTertiaryZ0 = _SecondaryToTertiaryZ1\\n\\n # NoLoadLosses\\n if (\\n hasattr(transformer_object, \\\"noload_loss\\\")\\n and transformer_object.noload_loss is not None\\n ):\\n # TODO: Make sure noloadlosses is in % in DiTTo, or change what is next.\\n NOLOADLOSS = (\\n transformer_object.noload_loss / 100.0 * KVA\\n )\\n else:\\n NOLOADLOSS = \\\"\\\"\\n\\n new_transformer_object_line = \\\"{kva1},{kv1},{conn1},,,,,,,{kva2},{kv2},{conn2},{kva3},{kv3},{conn3},\\\".format(\\n kva1=_primary_rated_capacity,\\n kv1=_primary_voltage,\\n conn1=_primary_connection,\\n kva2=_secondary_rated_capacity,\\n kv2=_secondary_voltage,\\n conn2=_secondary_connection,\\n kva3=_tertiary_rated_capacity,\\n kv3=_tertiary_voltage,\\n conn3=_tertiary_connection,\\n )\\n new_transformer_object_line += \\\"{PrimaryToSecondaryZ1},{PrimaryToSecondaryZ0},{PrimaryToSecondaryXR1},{PrimaryToSecondaryXR0},{PrimaryToTertiaryZ1},{PrimaryToTertiaryZ0},{PrimaryToTertiaryXR1},{PrimaryToTertiaryXR0},{SecondaryToTertiaryZ1},{SecondaryToTertiaryZ0}\\\".format(\\n PrimaryToSecondaryZ1=_PrimaryToSecondaryZ1,\\n PrimaryToSecondaryZ0=_PrimaryToSecondaryZ0,\\n PrimaryToSecondaryXR1=_PrimaryToSecondaryXR1,\\n PrimaryToSecondaryXR0=_PrimaryToSecondaryXR0,\\n PrimaryToTertiaryZ1=_PrimaryToTertiaryZ1,\\n PrimaryToTertiaryZ0=_PrimaryToTertiaryZ0,\\n PrimaryToTertiaryXR1=_PrimaryToTertiaryXR1,\\n PrimaryToTertiaryXR0=_PrimaryToTertiaryXR0,\\n SecondaryToTertiaryZ1=_SecondaryToTertiaryZ1,\\n SecondaryToTertiaryZ0=_SecondaryToTertiaryZ0,\\n )\\n new_transformer_object_line += \\\",{SecondaryToTertiaryXR1},{SecondaryToTertiaryXR0},{SecondaryCapacityLimit1},{SecondaryCapacityLimit2},{TertiaryCapacityLimit1},{TertiaryCapacityLimit2},{TertiaryConnection},{noloadloss}\\\".format(\\n SecondaryToTertiaryXR1=_SecondaryToTertiaryXR1,\\n SecondaryToTertiaryXR0=_SecondaryToTertiaryXR0,\\n SecondaryCapacityLimit1=0,\\n SecondaryCapacityLimit2=0,\\n TertiaryCapacityLimit1=0,\\n TertiaryCapacityLimit2=0,\\n TertiaryConnection=0,\\n noloadloss=NOLOADLOSS,\\n )\\n\\n found = False\\n for k, d in self.three_windings_trans_codes.items():\\n if d == new_transformer_object_line:\\n new_transformer_line += (\\n \\\",3_wdg_transformer_\\\"\\n + str(k)\\n + \\\",\\\"\\n + new_section_ID\\n )\\n found = True\\n if not found:\\n ID_trans_3w += 1\\n self.three_windings_trans_codes[\\n ID_trans_3w\\n ] = new_transformer_object_line\\n new_transformer_line += (\\n \\\",3_wdg_transformer_\\\"\\n + str(ID_trans_3w)\\n + \\\",\\\"\\n + new_section_ID\\n )\\n\\n new_transformer_line += \\\",{Location},{tertiarynodeID},{PrimaryFixedTapSetting},{SecondaryFixedTapSetting},{ConnectionStatus}\\\".format(\\n Location=\\\"M\\\",\\n tertiarynodeID=0,\\n PrimaryFixedTapSetting=0,\\n SecondaryFixedTapSetting=0,\\n ConnectionStatus=0,\\n )\\n\\n try:\\n TAP = 1.0 / float(\\n transformer_object.windings[1]\\n .phase_windings[0]\\n .tap_position\\n )\\n new_transformer_line += \\\",{}\\\".format(TAP)\\n except:\\n new_transformer_line += \\\",\\\"\\n pass\\n\\n if new_transformer_line != \\\"\\\":\\n three_windings_transformer_string_list.append(\\n new_transformer_line\\n )\\n\\n # Write everything to the network file\\n #\\n # HEADER\\n #\\n f.write(\\\"[GENERAL]\\\\n\\\")\\n\\n # DATE\\n #\\n current_date = datetime.now().strftime(\\\"%B %d, %Y at %H:%M:%S\\\")\\n f.write(\\\"DATE={}\\\\n\\\".format(current_date))\\n\\n # CYME version\\n #\\n f.write(\\\"CYME_VERSION=8.02\\\\n\\\")\\n\\n # Unit system\\n #\\n f.write(\\\"\\\\n[SI]\\\\n\\\")\\n\\n # Nodes\\n #\\n f.write(\\\"\\\\n[NODE]\\\\n\\\")\\n f.write(\\\"FORMAT_NODE=NodeID,CoordX,CoordY\\\\n\\\")\\n\\n for node_string in self.node_string_list:\\n f.write(node_string + \\\"\\\\n\\\")\\n\\n if len(self.bus_string_list) > 0:\\n f.write(\\\"FORMAT_NODE=NodeID,CoordX1,CoordY1,CoordX2,CoordY2,Width\\\\n\\\")\\n for bus_string in self.bus_string_list:\\n f.write(bus_string + \\\"\\\\n\\\")\\n\\n # Intermediate nodes\\n #\\n f.write(\\\"\\\\n[INTERMEDIATE NODES]\\\\n\\\")\\n f.write(\\\"FORMAT_INTERMEDIATENODE=SectionID,SeqNumber,CoordX,CoordY\\\\n\\\")\\n\\n for inter in intermediate_nodes:\\n f.write(\\n \\\"{SectionID},{SegNumber},{CoordX},{CoordY}\\\\n\\\".format(\\n SectionID=inter[0],\\n SegNumber=inter[1],\\n CoordX=inter[2],\\n CoordY=inter[3],\\n )\\n )\\n\\n # Sources\\n #\\n f.write(\\\"\\\\n[SOURCE]\\\\n\\\")\\n f.write(\\\"FORMAT_SOURCE=SourceID,DeviceNumber,NodeID,NetworkID\\\\n\\\")\\n k = 0\\n self.substation_IDs = {}\\n\\n for _source, _voltage in self.sources.items():\\n # _source should be the name of the headnode for one feeder_metadata object\\n # TODO: Find a better way to find it\\n for obj in model.models:\\n if isinstance(obj, Feeder_metadata) and obj.headnode == _source:\\n sourceID = obj.headnode + \\\"_src\\\"\\n nodeID = obj.headnode\\n NetworkID = obj.name\\n k += 1\\n for j, sub in enumerate(self.substations):\\n if sub[\\\"connecting_element\\\"] == _source:\\n self.substations[j][\\\"sub_ID\\\"] = \\\"sub_\\\" + str(k)\\n self.substation_IDs[_source] = \\\"sub{}\\\".format(k)\\n f.write(\\n \\\"sub_{k},sub_{k},{nodeID},{NetID}\\\\n\\\".format(\\n sourceID=sourceID, k=k, nodeID=nodeID, NetID=NetworkID\\n )\\n )\\n\\n f.write(\\\"\\\\n[HEADNODES]\\\\n\\\")\\n f.write(\\\"FORMAT_HEADNODES=NodeID,NetworkID\\\\n\\\")\\n # k=0\\n # for source_string in source_string_list:\\n # k+=1\\n # nodeID=source_string.split(',')[0]\\n # f.write('{nodeID},{NetID}\\\\n'.format(nodeID=nodeID, NetID=k))\\n for f_name, section_l in self.section_feeder_mapping.items():\\n # for kk in model.models:\\n # if isinstance(kk,Feeder_metadata):\\n # print(kk.name, kk.headnode)\\n # import pdb;pdb.set_trace()\\n if f_name != \\\"\\\":\\n head = model[\\n f_name\\n ].headnode # self.section_headnode_mapping[f_name]\\n f.write(\\\"{nodeID},{NetID}\\\\n\\\".format(nodeID=head, NetID=f_name))\\n\\n # Source equivalent\\n #\\n f.write(\\\"\\\\n[SOURCE EQUIVALENT]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_SOURCEEQUIVALENT=NodeID,Voltage,OperatingAngle1,OperatingAngle2,OperatingAngle3,PositiveSequenceResistance,PositiveSequenceReactance,ZeroSequenceResistance,ZeroSequenceReactance,NegativeSequenceResistance,NegativeSequenceReactance,OperatingVoltage1,OperatingVoltage2,OperatingVoltage3,ImpedanceUnit\\\\n\\\"\\n )\\n\\n id_from_source = []\\n for source_string in source_string_list:\\n id_from_source.append(source_string.split(\\\",\\\")[0])\\n f.write(source_string + \\\"\\\\n\\\")\\n\\n for f_name, section_l in self.section_line_feeder_mapping.items():\\n if f_name != \\\"subtransmission\\\" and \\\"substation\\\" not in f_name:\\n temp = model[f_name]\\n if (\\n hasattr(temp, \\\"nominal_voltage\\\")\\n and temp.nominal_voltage is not None\\n ):\\n volt = temp.nominal_voltage * 10 ** -3\\n else:\\n volt = model[temp.headnode].nominal_voltage * 10 ** -3\\n if temp.headnode not in id_from_source:\\n f.write(\\n \\\"{node_id},{voltage},{angle1},{angle2},{angle3},{R1},{X1},{R0},{X0},{R2},{X2},{voltage},{voltage},{voltage},0\\\\n\\\".format(\\n node_id=temp.headnode,\\n voltage=volt,\\n angle1=temp.operating_angle1,\\n angle2=temp.operating_angle2,\\n angle3=temp.operating_angle3,\\n R1=temp.positive_sequence_resistance,\\n X1=temp.positive_sequence_reactance,\\n R0=temp.zero_sequence_resistance,\\n X0=temp.zero_sequence_reactance,\\n R2=temp.negative_sequence_resistance,\\n X2=temp.negative_sequence_reactance,\\n )\\n )\\n\\n # Sections\\n #\\n f.write(\\\"\\\\n[SECTION]\\\\n\\\")\\n\\n # Always write the SECTION format\\n f.write(\\n \\\"FORMAT_SECTION=SectionID,FromNodeID,FromNodeIndex,ToNodeID,ToNodeIndex,Phase,SubNetworkId\\\\n\\\"\\n )\\n\\n # Always write the FEEDER format\\n f.write(\\\"FORMAT_FEEDER=NetworkID,HeadNodeID,CoordSet\\\\n\\\")\\n\\n # If we have subtransmission, then write the TRANSMISSIONLINE format\\n if \\\"subtransmission\\\" in self.section_line_feeder_mapping:\\n f.write(\\\"FORMAT_TRANSMISSIONLINE=NetworkID,HeadNodeID,CoordSet\\\\n\\\")\\n\\n # If we have a substation (have to have \\\"substation in the name...),\\n # then write the SUBSTATION format\\n if self.network_have_substations:\\n f.write(\\\"FORMAT_SUBSTATION=NetworkID,HeadNodeID,CoordSet\\\\n\\\")\\n\\n #####################################\\n # TO REMOVE ????????\\n ####################################\\n #\\n # k=0\\n # for source_string in source_string_list:\\n # k+=1\\n # f.write('FEEDER={NetID},{HeadNodeID},{coordset}\\\\n'.format(NetID=k,HeadNodeID=source_string.split(',')[0],coordset=0))\\n\\n # section_list=self.merge_regulators(self.section_line_list)\\n # for section_line in section_list:\\n # f.write(section_line+'\\\\n')\\n #######################################\\n\\n for f_name, section_l in self.section_line_feeder_mapping.items():\\n if \\\"substation\\\" in f_name:\\n head = \\\"\\\"\\n else:\\n head = model[\\n f_name\\n ].headnode # self.section_headnode_mapping[f_name]\\n # If we are considering the subtransmission network, use TRANSMISSIONLINE\\n if f_name == \\\"subtransmission\\\":\\n f.write(\\n \\\"TRANSMISSIONLINE={NetID},{HeadNodeID},{coordset}\\\\n\\\".format(\\n NetID=f_name, HeadNodeID=head, coordset=1\\n )\\n )\\n subnetID = \\\"\\\"\\n # If substation is in the name of the \\\"feeder\\\", then use SUBSTATION\\n elif \\\"substation\\\" in f_name:\\n f.write(\\n \\\"SUBSTATION={NetID},{HeadNodeID},{coordset}\\\\n\\\".format(\\n NetID=f_name.split(\\\"ation_\\\")[1], HeadNodeID=head, coordset=1\\n )\\n )\\n subnetID = f_name.split(\\\"ation_\\\")[1]\\n # Otherwise, it should be an actual feeder, so use FEEDER\\n else:\\n f.write(\\n \\\"FEEDER={NetID},{HeadNodeID},{coordset}\\\\n\\\".format(\\n NetID=f_name, HeadNodeID=head, coordset=1\\n )\\n )\\n subnetID = \\\"\\\"\\n # Then, write all the sections belonging to this subnetwork\\n for sec in section_l:\\n f.write(sec + \\\",{}\\\".format(subnetID) + \\\"\\\\n\\\")\\n\\n # Subnetworks\\n #\\n # Use subnetworks only for substations\\n # TODO: Let the user specify what should be subnetworked...\\n #\\n if self.network_have_substations:\\n f.write(\\\"\\\\n[SUBNETWORKS]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_SUBNETWORKS=SubNetID,Angle,X,Y,Height,Length,SymbolID,SubNetTypeID,Version,SymbolReferenceSize,TextReferenceSize,CoordSet\\\\n\\\"\\n )\\n for f_name, section_l in self.section_line_feeder_mapping.items():\\n if \\\"substation\\\" in f_name:\\n # We need to find the X,Y coordinates for the subnetwork\\n # (CASE 1) - First, we try setting these coordinates as the average of the LV elements.\\n # (CASE 2) - If this does not work, we try using the average of all the substation elements.\\n # (CASE 3) - If this does not work either, we try using the global average (all Nodes in the system), such that\\n # the subnetwork is more or less in the middle of the system.\\n # (CASE 4) - Finally, if nothing works, set the coordinates as (0,0)...\\n defaultX = []\\n defaultY = []\\n by_nominal_voltage_X = {}\\n by_nominal_voltage_Y = {}\\n all_coordsX = []\\n all_coordsY = []\\n #\\n # TODO: Better way to do this???\\n #\\n for obj in model.models:\\n # (CASE 3) - Just append all Node's valid coordinates to all_coordsX and all_coordsY\\n if (\\n isinstance(obj, Node)\\n and len(obj.positions) > 0\\n and obj.positions[0] is not None\\n and obj.positions[0].lat is not None\\n and obj.positions[0].long is not None\\n ):\\n all_coordsX.append(obj.positions[0].long)\\n all_coordsY.append(obj.positions[0].lat)\\n # (CASE 1) - Since we don't know what the LV value is beforehand, we store all coordinates by nominal voltage\\n # in the dictionaries by_nominal_voltage_X and by_nominal_voltage_Y.\\n if (\\n isinstance(obj, Node)\\n and obj.substation_name == f_name.split(\\\"ation_\\\")[1]\\n and obj.is_substation_connection == 1\\n ):\\n if obj.nominal_voltage is not None:\\n if (\\n len(obj.positions) > 0\\n and obj.positions[0] is not None\\n ):\\n if (\\n obj.positions[0].lat is not None\\n and obj.positions[0].long is not None\\n ):\\n if (\\n obj.nominal_voltage\\n in by_nominal_voltage_X\\n and obj.nominal_voltage\\n in by_nominal_voltage_Y\\n ):\\n by_nominal_voltage_X[\\n obj.nominal_voltage\\n ].append(obj.positions[0].long)\\n by_nominal_voltage_Y[\\n obj.nominal_voltage\\n ].append(obj.positions[0].lat)\\n else:\\n by_nominal_voltage_X[\\n obj.nominal_voltage\\n ] = [obj.positions[0].long]\\n by_nominal_voltage_Y[\\n obj.nominal_voltage\\n ] = [obj.positions[0].lat]\\n # (CASE 2) - If the nominal voltage was None, then add the coordinates to the default list\\n else:\\n if (\\n len(obj.positions) > 0\\n and obj.positions[0] is not None\\n ):\\n if (\\n obj.positions[0].lat is not None\\n and obj.positions[0].long is not None\\n ):\\n defaultX.append(obj.positions[0].long)\\n defaultY.append(obj.positions[0].lat)\\n # (CASE 1)\\n if len(list(by_nominal_voltage_X.keys())) > 0:\\n low_voltage = min(list(by_nominal_voltage_X.keys()))\\n Xs = by_nominal_voltage_X[low_voltage]\\n Ys = by_nominal_voltage_Y[low_voltage]\\n # (CASE 2)\\n else:\\n Xs = defaultX\\n Ys = defaultY\\n # If we were able to sample some coordinates, take the average\\n if len(Xs) > 0 and len(Ys) > 0:\\n X = np.mean(Xs)\\n Y = np.mean(Ys) + 50 / 2.0\\n # (CASE 3)\\n elif len(all_coordsX) > 0 and len(all_coordsY) > 0:\\n X = np.mean(all_coordsX)\\n Y = np.mean(all_coordsY)\\n # (CASE 4) - Otherwise, set to 0,0 (best effort...)\\n else:\\n logger.warning(\\n \\\"Could not find any coordinate for substation {s}. Setting the subnetwork coordinates to (0,0)...\\\".format(\\n s=f_name\\n )\\n )\\n X = 0\\n Y = 0\\n f.write(\\n \\\"{NetID},0,{X},{Y},{Height},{Length},-1,Geographically Referenced,-1,5,0.251957,1\\\\n\\\".format(\\n NetID=f_name.split(\\\"ation_\\\")[1],\\n X=X,\\n Y=Y,\\n Height=50.00,\\n Length=50.00,\\n )\\n )\\n\\n # Subnetwork Connections\\n #\\n # Use subnetwork connections only for substations\\n # TODO: Let the user specify what should be subnetworked\\n if self.network_have_substations:\\n f.write(\\\"\\\\n[SUBNETWORK CONNECTIONS]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_SUBNETWORKCONNECTIONS=SubNetID,NodeID,ConnectorCoordX,ConnectorCoordY\\\\n\\\"\\n )\\n for f_name, section_l in self.section_line_feeder_mapping.items():\\n if \\\"substation\\\" in f_name:\\n # We need to find all the connections between the subnetwork and the rest of the system\\n # Use the \\\"is_substation_connection\\\" attribute of Node objects\\n #\\n # TODO: Better way to do this???\\n for obj in model.models:\\n if (\\n isinstance(obj, Node)\\n and obj.is_substation_connection == 1\\n and obj.substation_name == f_name.split(\\\"ation_\\\")[1]\\n ):\\n # We also need the coordinates of this connection.\\n # Use the coordinates of the Node\\n if obj.positions is not None and len(obj.positions) > 0:\\n X = obj.positions[0].long\\n Y = obj.positions[0].lat\\n # If we don't have coordinates, then set to (0,0)....\\n else:\\n X = 0\\n Y = 0\\n f.write(\\n \\\"{NetID},{NodeID},{X},{Y}\\\\n\\\".format(\\n NetID=f_name.split(\\\"ation_\\\")[1],\\n NodeID=obj.name,\\n X=X,\\n Y=Y,\\n )\\n )\\n\\n # Overhead lines\\n #\\n if len(overhead_string_list) > 0:\\n f.write(\\\"\\\\n[OVERHEADLINE SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_OVERHEADLINESETTING=SectionID,LineCableID,Length,ConnectionStatus\\\\n\\\"\\n )\\n for overhead_string in overhead_string_list:\\n f.write(overhead_string + \\\"\\\\n\\\")\\n\\n # Overhead by phase lines\\n #\\n if len(overhead_byphase_string_list) > 0:\\n f.write(\\\"\\\\n[OVERHEAD BYPHASE SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_OVERHEADBYPHASESETTING=SectionID,DeviceNumber,CondID_A,CondID_B,CondID_C,CondID_N1,CondID_N2,SpacingID,Length,ConnectionStatus\\\\n\\\"\\n )\\n for overhead_byphase_string in overhead_byphase_string_list:\\n f.write(overhead_byphase_string + \\\"\\\\n\\\")\\n\\n # Underground lines\\n #\\n if len(underground_string_list) > 0:\\n f.write(\\\"\\\\n[UNDERGROUNDLINE SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_UNDERGROUNDLINESETTING=SectionID,LineCableID,Length,ConnectionStatus,DistanceBetweenConductors,CableConfiguration\\\\n\\\"\\n )\\n for underground_string in underground_string_list:\\n f.write(underground_string + \\\"\\\\n\\\")\\n\\n # Switches\\n #\\n if len(switch_string_list) > 0:\\n f.write(\\\"\\\\n[SWITCH SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_SWITCHSETTING=SectionID,EqID,Location,ClosedPhase,Locked,ConnectionStatus,DeviceNumber\\\\n\\\"\\n )\\n for switch_string in switch_string_list:\\n f.write(switch_string + \\\"\\\\n\\\")\\n\\n # Fuses\\n #\\n if len(fuse_string_list) > 0:\\n f.write(\\\"\\\\n[FUSE SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_FUSESETTING=SectionID,EqID,Location,ClosedPhase,Locked,ConnectionStatus,DeviceNumber\\\\n\\\"\\n )\\n for fuse_string in fuse_string_list:\\n f.write(fuse_string + \\\"\\\\n\\\")\\n\\n # Reclosers\\n #\\n if len(recloser_string_list) > 0:\\n f.write(\\\"\\\\n[RECLOSER SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_RECLOSERSETTING=SectionID,EqID,Location,ClosedPhase,Locked,ConnectionStatus,DeviceNumber\\\\n\\\"\\n )\\n for recloser_string in recloser_string_list:\\n f.write(recloser_string + \\\"\\\\n\\\")\\n\\n # Breakers\\n #\\n if len(breaker_string_list) > 0:\\n f.write(\\\"\\\\n[BREAKER SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_BREAKERSETTING=SectionID,EqID,Location,ClosedPhase,Locked,ConnectionStatus,DeviceNumber\\\\n\\\"\\n )\\n for breaker_string in breaker_string_list:\\n f.write(breaker_string + \\\"\\\\n\\\")\\n\\n # Capacitors\\n #\\n if len(capacitor_string_list) > 0:\\n f.write(\\\"\\\\n[SHUNT CAPACITOR SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_SHUNTCAPACITORSETTING=SectionID,Connection,SwitchedKVARA,SwitchedKVARB,SwitchedKVARC,KV,Control,OnValueA,OnValueB,OnValueC,OffValueA,OffValueB,OffValueC,DeviceNumber,ShuntCapacitorID,Location,ConnectionStatus\\\\n\\\"\\n )\\n for capacitor_string in capacitor_string_list:\\n f.write(capacitor_string + \\\"\\\\n\\\")\\n\\n # Transformers\\n #\\n # 2 WINDINGS\\n #\\n if len(two_windings_transformer_string_list) > 0:\\n f.write(\\\"\\\\n[TRANSFORMER SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_TRANSFORMERSETTING=SectionID,CoordX,CoordY,Conn,PhaseON,EqID,DeviceNumber,PhaseShiftType,Location,PrimTap,SecondaryTap,ODPrimPh,ConnectionStatus,Tap,SetPoint,ControlType,LowerBandwidth,UpperBandwidth,Maxbuck,Maxboost\\\\n\\\"\\n )\\n for transformer_string in two_windings_transformer_string_list:\\n f.write(transformer_string + \\\"\\\\n\\\")\\n\\n # 3 WINDINGS\\n #\\n if len(three_windings_transformer_string_list) > 0:\\n f.write(\\\"\\\\n[THREE WINDING TRANSFORMER SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_THREEWINDINGTRANSFORMERSETTING=SectionID,CoordX,CoordY,PrimaryBaseVoltage,SecondaryBaseVoltage,TertiaryBaseVoltage,EqID,DeviceNumber,Location,TertiaryNodeID,PrimaryFixedTapSetting,SecondaryFixedTapSetting,ConnectionStatus,Tap\\\\n\\\"\\n )\\n for transformer_string in three_windings_transformer_string_list:\\n f.write(transformer_string + \\\"\\\\n\\\")\\n\\n # Regulators\\n if len(regulator_string_list) > 0:\\n # Merge the Regulators\\n regulator_string_list_merged = self.merge_regulators(\\n regulator_string_list\\n )\\n f.write(\\\"\\\\n[REGULATOR SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_REGULATORSETTING=SectionID,CoordX,CoordY,PhaseON,BandWidth,CT,PT,VsetA,VsetB,VsetC,EqID,DeviceNumber,Location,MaxBuck,MaxBoost,SettingOption,RsetA,RsetB,RsetC,XsetA,XsetB,XsetC,TapA,TapB,TapC,ConnectionStatus\\\\n\\\"\\n )\\n for regulator_string in regulator_string_list_merged:\\n f.write(regulator_string + \\\"\\\\n\\\")\\n\\n if len(converter_string_list) > 0:\\n f.write(\\\"\\\\n[CONVERTER]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_CONVERTER=DeviceNumber,DeviceType,ConverterRating,ActivePowerRating,ReactivePowerRating,MinimumPowerFactor,PowerFallLimit,PowerRiseLimit,RiseFallUnit\\\\n\\\"\\n )\\n for i in converter_string_list:\\n f.write(i)\\n f.write(\\\"\\\\n\\\")\\n\\n if len(converter_control_string_list) > 0:\\n f.write(\\\"\\\\n[CONVERTER CONTROL SETTING]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_CONVERTERCONTROLSETTING=DeviceNumber,DeviceType,ControlIndex,TimeTriggerIndex,ControlType,FixedVarInjection,InjectionReference,ConverterControlID,PowerReference,PowerFactor\\\\n\\\"\\n )\\n for i in converter_control_string_list:\\n f.write(i)\\n f.write(\\\"\\\\n\\\")\\n\\n if len(pv_settings_string_list) > 0:\\n f.write(\\\"\\\\n[PHOTOVOLTAIC SETTINGS]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_PHOTOVOLTAICSETTING=SectionID,Location,DeviceNumber,EquipmentID,NS,NP,AmbientTemperature,Phase,ConstantInsolation,InsolationModelID\\\\n\\\"\\n )\\n for i in pv_settings_string_list:\\n f.write(i)\\n f.write(\\\"\\\\n\\\")\\n\\n if len(dg_generation_string_list) > 0:\\n f.write(\\\"\\\\n[DGGENERATIONMODEL]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_DGGENERATIONMODEL=DeviceNumber,DeviceType,LoadModelName,ActiveGeneration,PowerFactor\\\\n\\\"\\n )\\n for i in dg_generation_string_list:\\n f.write(i)\\n f.write(\\\"\\\\n\\\")\\n\\n if len(self.node_connector_string_list) > 0:\\n f.write(\\\"\\\\n[NODE CONNECTOR]\\\\n\\\")\\n f.write(\\\"FORMAT_NODECONNECTOR=NodeID,CoordX,CoordY,SectionID\\\\n\\\")\\n for i in self.node_connector_string_list:\\n f.write(i)\\n f.write(\\\"\\\\n\\\")\\n\\n if len(bess_settings_string_list) > 0:\\n f.write(\\\"\\\\n[BESS SETTINGS]\\\\n\\\")\\n f.write(\\n \\\"FORMAT_BESSSETTING=SectionID,Location,DeviceNumber,EquipmentID,Phase,InitialSOC\\\\n\\\"\\n )\\n for i in bess_settings_string_list:\\n f.write(i)\\n f.write(\\\"\\\\n\\\")\",\n \"def save_network(network, fpath):\\n\\twith open(fpath, \\\"wb\\\") as f:\\n\\t\\tpickle.dump(network, f)\",\n \"def save_utility_network(self,path_save):\\n print(\\\"Save the neural network to : \\\"+path_save)\\n self.nn.save_on_file(path_save)\",\n \"def _write_network_file(graph, out_name, out_format=None, data=False,weight=False):\\n\\n if out_format==None:\\n out_format=\\\"edges\\\"\\n os.makedirs(os.path.dirname(out_name), exist_ok=True)\\n #print(\\\"writing graph of format \\\" + out_format + \\\" at \\\" + out_name)\\n if out_format == 'edges':\\n nx.write_edgelist(graph, \\\"%s.edges\\\" % (out_name), data=data)\\n elif out_format == 'gefx':\\n nx.write_gexf(graph, \\\"%s.gefx\\\" % (out_name))\\n elif out_format == 'gml':\\n nx.write_gml(graph, \\\"%s.gml\\\" % (out_name))\\n elif out_format == 'pajek':\\n nx.write_pajek(graph, \\\"%s.pajek\\\" % (out_name))\\n elif out_format == 'ncol':\\n nx.write_edgelist(graph, \\\"%s.ncol\\\" % (out_name), delimiter='\\\\t',data=weight)\\n elif out_format == 'graphML' :\\n g = nx.write_graphml(graph, \\\"%s.graphml\\\" % (out_name))\\n else:\\n raise Exception(\\\"UNKNOWN FORMAT \\\" + out_format)\",\n \"def save_graph(graph, file_name):\\r\\n print \\\"Saving network into \\\"+file_name\\r\\n f = open(file_name, 'w')\\r\\n f.write(str(len(graph))+'\\\\n')\\r\\n for citizen in graph:\\r\\n f.write(str(citizen.id) + ';' + str(citizen.location) + ';' + str(citizen.influence_level) + ';' + \\\\\\r\\n str(citizen.proactivity_level) + '\\\\n')\\r\\n for op in citizen.opinions.keys():\\r\\n value = citizen.opinions[op].weight\\r\\n f.write(str(op)+':'+str(value)+';')\\r\\n f.write('\\\\n')\\r\\n for friend in citizen.friends:\\r\\n f.write(str(friend.id) + ';')\\r\\n f.write('\\\\n')\\r\\n f.close()\",\n \"def save_graph(self, filename, fileType):\\n if fileType == \\\"GML Format\\\":\\n nx.write_gml(self.graph, filename+\\\".gml\\\")\\n if fileType == \\\"Adjacency list\\\":\\n nx.write_adjlist(self.graph, filename+\\\".adjlist\\\")\\n if fileType == \\\"YAML\\\":\\n nx.write_yaml(self.graph, filename + \\\".yaml\\\")\",\n \"def save(self):\\n self.save_network_architecture( network_path=self.network_path )\\n self.save_network_parameters(\\n file_name='net_parameters', file_path=self.network_path )\",\n \"def dump_net_to_file(net_def, filename):\\n\\n print(\\\"DUMP TO FILE:\\\\n{}\\\\n\\\".format(net_def))\\n\\n with open(filename, \\\"w\\\") as fd:\\n line = json.dumps(net_def)\\n fd.write(\\\"{}\\\\n\\\".format(line))\\n\\n print(\\\"Wrote neural net to {}\\\".format(filename))\",\n \"def export_network(file_name, net) -> None:\\r\\n file = open(file_name, 'wb')\\r\\n file.write(pickle.dumps(net.__dict__))\\r\\n file.close()\",\n \"def to_net(self, filename):\\n if len(self.nodes1)>0:\\n h = open(filename, \\\"w\\\")\\n for n1,n2,s in zip(self.nodes1, self.nodes2, self.signs):\\n h.write(\\\"%s -> %s %s\\\\n\\\" % (n1, n2, s))\\n h.close()\",\n \"def save_nn(self, networkname= 'nn'):\\n np.save(f\\\"{networkname}_data.npy\\\", self.weights_and_biases)\\n print(f\\\"Data saved to {networkname}_data.npy\\\")\",\n \"def save_net(net, filepath):\\n\\twith open(filepath, 'wb+') as fh:\\n\\t\\tdump(obj = net, file = fh, protocol = -1)\",\n \"def but_save_net(self):\\n if isinstance(self.nn_obj, dict):\\n if platform == \\\"linux\\\" or platform == \\\"linux2\\\":\\n path=tk.filedialog.asksaveasfilename(filetypes = [('LM NN file','.csv')])\\n elif platform == \\\"win32\\\":\\n path=tk.filedialog.asksaveasfilename(filetypes = [('LM NN file','.csv')], defaultextension=\\\"*.*\\\")\\n else:\\n path=tk.filedialog.asksaveasfilename(filetypes = [('LM NN file','.csv')])\\n elif isinstance(self.nn_obj, Net_tr):\\n if platform == \\\"linux\\\" or platform == \\\"linux2\\\":\\n path=tk.filedialog.asksaveasfilename(filetypes = [(\\\"Torch NN file\\\",\\\".pt\\\")])\\n elif platform == \\\"win32\\\":\\n path=tk.filedialog.asksaveasfilename(filetypes = [(\\\"Torch NN file\\\",\\\".pt\\\")], defaultextension=\\\"*.*\\\")\\n else:\\n path=tk.filedialog.asksaveasfilename(filetypes = [(\\\"Torch NN file\\\",\\\".pt\\\")])\\n else:\\n tk.messagebox.showerror(\\\"Error\\\", \\\"Crete NN\\\")\\n return\\n save_nn(self.nn_obj, path)\",\n \"def save_network(nodes, edges, name, pid):\\n d = {'nodes': nodes, 'edges': edges, 'name': name, 'pid': pid}\\n\\n out_filename = \\\"{0}-{1}.pickle\\\".format(\\n datetime.datetime.now().strftime(\\\"%Y%m%d-%H%M%S\\\"),\\n pid\\n )\\n with open(out_filename, 'wb') as out_file:\\n pickle.dump(d, out_file)\",\n \"def save_state(self, path='/home/lukas/weights/'):\\r\\n stuff_in_path = os.listdir(path)\\r\\n counter = 0\\r\\n for i in stuff_in_path:\\r\\n if 'parameters' in i:\\r\\n counter += 1\\r\\n with open(path + 'info.txt', mode='a') as f:\\r\\n f.write('counter: %i \\\\taccuracy: %.8f%% \\\\tloss: %.8f\\\\n' % (counter, returnList(self.accuracy)[-1] * 100, returnList(self.loss)[-1]))\\r\\n\\r\\n parameters = [ self.batchsize_train,\\r\\n self.iterator,\\r\\n self.n_hidden_layers,\\r\\n self.n_hidden_neurons,\\r\\n self.n_input_neurons,\\r\\n self.n_output_neurons,\\r\\n self.hid_transfer.__name__,\\r\\n self.out_transfer.__name__]\\r\\n try:\\r\\n print '[Network] Saving network status ...'\\r\\n np.save(path + 'parameters' + str(counter), parameters)\\r\\n np.save(path + 'weights' + str(counter), self.weights)\\r\\n np.save(path + 'bias' + str(counter), self.bias)\\r\\n np.save(path + 'weights_gradient' + str(counter), self.weights_gradient)\\r\\n np.save(path + 'bias_gradient' + str(counter), self.bias_gradient)\\r\\n np.save(path + 'loss' + str(counter), self.loss)\\r\\n np.save(path + 'accuracy' + str(counter), self.accuracy)\\r\\n np.save(path + 'r_weights' + str(counter), self.r_weights)\\r\\n np.save(path + 'r_bias' + str(counter), self.r_bias)\\r\\n print '\\\\033[92m' + '[Network] Network status succesfully saved' + '\\\\033[0m'\\r\\n\\r\\n except Exception as e:\\r\\n print '\\\\033[1m' + '\\\\033[91m' + '[Network] Could not correctly save network status:' + '\\\\033[0m'\\r\\n print e.message\",\n \"def save_network(self, file_name):\\n data = {\\n \\\"layers_num\\\": self.layers_num,\\n \\\"weights\\\": [w.tolist() for w in self.weights],\\n \\\"biases\\\": [b.tolist() for b in self.biases],\\n \\\"act_func\\\": str(self.act_func.__name__),\\n \\\"cost_func\\\": str(self.cost_func.__name__),\\n \\\"metric\\\": str(self.metric.__name__)\\n }\\n\\n with open(file_name, 'w') as file:\\n json.dump(data, file)\",\n \"def save_network(self, **kwargs):\\n raise NotImplementedError\",\n \"def save(net, txt_dict, path):\\n dict_m = net.state_dict()\\n _ = txt_dict\\n torch.save(dict_m,path)\",\n \"def saveGraph(self, filename):\\n nx.write_yaml(self.G,filename)\",\n \"def save_network(save_file, training_round, digit):\\n with open(save_file, 'wb') as f:\\n np.save(f, S.w)\\n np.save(f, S.w_min)\\n np.save(f, S.w_max)\\n np.save(f, S.a_plus)\\n np.save(f, S.a_minus)\\n np.save(f, S.b_plus)\\n np.save(f, S.b_minus)\\n np.save(f, Output.v_th)\\n np.save(f, training_set.flatten())\\n np.save(f, training_round)\\n np.save(f, digit)\",\n \"def save_to_file(self, representation, filename) -> bool:\\n filename = \\\"data/\\\" + filename\\n output_matrix = self.get_graph(representation)\\n if isinstance(output_matrix, list):\\n with open(filename, \\\"w+\\\") as f:\\n for row in output_matrix:\\n f.write(\\\" \\\".join(str(item) for item in row))\\n f.write(\\\"\\\\n\\\")\\n return True\\n elif isinstance(output_matrix, np.ndarray):\\n with open(filename, \\\"w+\\\") as f:\\n np.savetxt(f, output_matrix, fmt=\\\"%i\\\")\\n return True\\n else:\\n return False\",\n \"def save(self, filename, path=\\\".\\\"):\\n if not self.trained:\\n if self.verbose:\\n print(\\\"Neural Network Model Class - Save Function: No trained model\\\")\\n return -1\\n\\n if filename is None:\\n if self.verbose:\\n print(\\\"Neural Network Model Class - Save Function: No file name\\\")\\n return -1\\n\\n #trn_params\\n self.trn_params.save('%s_trn_params.pickle'%(filename),path=path)\\n #model\\n # serialize model to JSON\\n model_json = self.model.to_json()\\n with open(\\\"%s/%s_model.json\\\"%(path,filename), \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n # serialize weights to HDF5\\n self.model.save_weights(\\\"%s/%s_model.h5\\\"%(path,filename))\\n\\n #trn_desc\\n pickle.dump([self.trn_desc], open(\\\"%s/%s_trn_desc.pickle\\\"%(path,filename), \\\"wb\\\"))\",\n \"def save_depfile(depdata,outname,is31=True): \\n\\n if outname==None:\\n print('save_depfile requires a filename to save.')\\n return\\n try:\\n fp=open(outname,'w')\\n except IOError:\\n print('save_depfile: invalid filename.')\\n return data\\n if is31:\\n fp.write('Node Number = %d\\\\n' % len(depdata['node_num']) )\\n for i in range(0,len(depdata['node_num'])):\\n fp.write('%f %f %f\\\\n'% (depdata['x'][i],depdata['y'][i],depdata['h'][i]))\\n fp.close()\\n \\n return\",\n \"def save_net(self, file_path):\\n \\tserialized_weights = [w.tolist() for w \\\\\\n in self.stacked_net.weights]\\n \\tserialized_biases = [b.tolist() for b \\\\\\n in self.stacked_net.biases]\\n \\tparams = {'weights':serialized_weights,\\\\\\n 'biases':serialized_biases}\\n \\twith open(file_path,'w') as f:\\n \\t\\tf.write(json.dumps(params))\",\n \"def save_model(self):\\n self.pred_net.save((self.save_path / \\\"iqn_pred_net\\\").absolute().as_posix())\\n self.target_net.save((self.save_path / \\\"iqn_target_net\\\").absolute().as_posix())\",\n \"def save_network(self, which_epoch):\\n save_filename = '%s_net.pkl' % (which_epoch)\\n save_path = os.path.join(self.save_dir, save_filename)\\n if len(self.gpu_ids) > 0 and torch.cuda.is_available():\\n torch.save(self.net.module.cpu().state_dict(), save_path)\\n self.net.cuda(self.gpu_ids[0])\\n else:\\n torch.save(self.net.cpu().state_dict(), save_path)\",\n \"def print_network(self, model, name):\\n num_params = 0\\n for p in model.parameters():\\n num_params += p.numel()\\n #print(model)\\n print(name)\\n print(\\\"The number of parameters: {}\\\".format(num_params))\\n\\n with open(os.path.join(self.train_dir,'model_arch.txt'), 'a') as fp:\\n print(model, file=fp)\\n print(name, file=fp)\\n print(\\\"The number of parameters: {}\\\".format(num_params),file=fp)\",\n \"def write_labels():\\n with open('../data/labels.txt', 'w') as labels_file:\\n labels = generate_labels()\\n labels_file.write('\\\\n'.join(labels))\",\n \"def save_network(self, sess, filename):\\n dir_path = os.path.dirname(os.path.realpath(__file__))\\n dir_path += '/Models/'\\n dir_path += filename\\n saver = tf.train.Saver()\\n saver.save(sess, dir_path)\",\n \"def Save2Pajek(filepath, adjmatrix, labels=[], directed=False, weighted=False):\\n # 0) SECURITY CHECK\\n N = len(adjmatrix)\\n if labels:\\n if len(labels) != N:\\n raise ValueError( \\\"List of labels not aligned with network size\\\" )\\n\\n # 1) OPEN THE TARGET FILE\\n outfile = open(filepath, 'w')\\n\\n # 2) SAVE INFORMATION OF THE NODES\\n print('*Vertices', N, file=outfile)\\n\\n # Wrie the list of nodes if labels have been given\\n if labels:\\n for i in range(N):\\n # line = '%d \\\"%s\\\"' %(i+1, labels[i])\\n line = '%d\\\\t\\\"%s\\\"' % (i + 1, labels[i])\\n print(line, file=outfile)\\n\\n # 3) SAVE THE LINKS\\n # Save the links AND their WEIGHTS\\n if weighted:\\n # 3.1) Find whether weights are integers or floats\\n if adjmatrix[0, 0].dtype in [np.uint8, np.uint, np.int8, np.int]:\\n formatstring = '%d %d %d'\\n elif adjmatrix[0, 0].dtype in [np.float16, np.float32, np.float, np.float64]:\\n formatstring = '%d %d %f'\\n\\n # 3.2) Save the ARCS if directed\\n if directed:\\n print('*Arcs', file=outfile)\\n for i in range(N):\\n neighbours = adjmatrix[i].nonzero()[0]\\n for j in neighbours:\\n line = formatstring % (i + 1, j + 1, adjmatrix[i, j])\\n print(line, file=outfile)\\n\\n # 3.2) Save the EDGES, if undirected\\n else:\\n print('*Edges', file=outfile)\\n for i in range(N):\\n neighbours = adjmatrix[i].nonzero()[0]\\n for j in neighbours:\\n if j > i:\\n line = formatstring % (i + 1, j + 1, adjmatrix[i, j])\\n print(line, file=outfile)\\n\\n # Save ONLY the adjacency list\\n else:\\n formatstring = '%d %d'\\n\\n # 3.1) Save the ARCS if directed\\n if directed:\\n print('*Arcs', file=outfile)\\n for i in range(N):\\n neighbours = adjmatrix[i].nonzero()[0]\\n for j in neighbours:\\n line = formatstring % (i + 1, j + 1)\\n print(line, file=outfile)\\n\\n # 3.1) Save the EDGES, if undirected\\n else:\\n print('*Edges', file=outfile)\\n for i in range(N):\\n neighbours = adjmatrix[i].nonzero()[0]\\n for j in neighbours:\\n if j > i:\\n line = formatstring % (i + 1, j + 1)\\n print(line, file=outfile)\\n\\n # 4) CLOSE FILE AND FINISH\\n outfile.close()\",\n \"def imwrite_architecture(layers, fpath, **kwargs):\\n pydot_graph = make_architecture_pydot_graph(layers, **kwargs)\\n\\n ext = fpath[fpath.rfind('.') + 1:]\\n with open(fpath, 'w') as fid:\\n fid.write(pydot_graph.create(format=ext))\",\n \"def save (self, filename) :\\n\\t\\tserialFile = open (filename, \\\"wb\\\")\\n\\t\\tpickle.dump (self.production_rules, serialFile)\\n\\t\\tpickle.dump (self.unitrelation, serialFile)\\n\\t\\tpickle.dump (self.labels, serialFile)\\n\\t\\tpickle.dump (self.keeper, serialFile)\\n\\t\\tpickle.dump (self.strnodes, serialFile)\\n\\t\\tpickle.dump (self.tokens, serialFile)\\n\\t\\tserialFile.close()\",\n \"def save(self, name, path=None):\\n if path is None:\\n path = '.'\\n if path[0] == '~':\\n path = os.getenv(\\\"HOME\\\") + path[1:]\\n\\n try:\\n with open(os.path.join(path, name), 'wb') as f:\\n pickle.dump(self, f)\\n except IOError as e:\\n msg = str(e) + '\\\\nNeuralNetwork.save failed.'\\n raise DNNetIOError(msg)\",\n \"def save2file(self):\\n ids_input = []\\n labels_input = []\\n ids_path = os.path.join(self.path, 'ids')\\n if not os.path.exists(ids_path):\\n os.makedirs(ids_path)\\n labels_path = os.path.join(self.path, 'labels')\\n if not os.path.exists(labels_path):\\n os.makedirs(labels_path)\\n ids_total = len(self.test)\\n for i in range(ids_total):\\n ids_input = self.test[i][0]\\n labels_input = self.test[i][1]\\n file_name = \\\"ids/\\\" + str(i) + \\\".bin\\\"\\n file_path = os.path.join(self.path, file_name)\\n np.array(ids_input, dtype=np.int32).tofile(file_path)\\n file_name = \\\"labels/\\\" + str(i) + \\\".bin\\\"\\n file_path = os.path.join(self.path, file_name)\\n np.array(labels_input, dtype=np.int32).tofile(file_path)\\n print(\\\"\\\\n ****** Success! ******\\\\n \\\")\",\n \"def save_network(session, tf_variables, file_path):\\n variable_values = session.run(tf_variables)\\n with open(file_path, mode='wb') as f:\\n pickle.dump(variable_values, f)\",\n \"def model_architecture_to_file(model, save_path, show_shapes=True):\\n plot_model(model, to_file=save_path + \\\"_model_architecture.png\\\", show_shapes=show_shapes)\",\n \"def save(nntagger, args):\\n outdir = args.save\\n modelname = outdir + \\\".model\\\"\\n nntagger.model.save(modelname)\\n import pickle\\n myparams = {\\\"num_words\\\": len(nntagger.w2i),\\n \\\"num_chars\\\": len(nntagger.c2i),\\n \\\"w2i\\\": nntagger.w2i,\\n \\\"c2i\\\": nntagger.c2i,\\n \\\"tag2idx\\\": nntagger.tag2idx,\\n \\\"activation\\\": nntagger.activation,\\n \\\"in_dim\\\": nntagger.in_dim,\\n \\\"h_dim\\\": nntagger.h_dim,\\n \\\"c_in_dim\\\": nntagger.c_in_dim,\\n \\\"h_layers\\\": nntagger.h_layers\\n }\\n pickle.dump(myparams, open( modelname+\\\".pickle\\\", \\\"wb\\\" ) )\\n print(\\\"model stored: {}\\\".format(modelname), file=sys.stderr)\",\n \"def save(uNetwork, uDir):\\n ## first of all, save the network spec\\n out = open(uDir + \\\"net_spec.py\\\", \\\"w\\\")\\n out.write(\\\"spec = \\\" + str(uNetwork.spec))\\n out.close()\\n \\n ## then, save the state of each layer\\n layers = uNetwork.layers\\n\\n for l in range(len(layers) - 1):\\n if layers[l].node_sharing:\\n ## save just one node\\n layers[l].pipes[0][0].send(\\\"clone_state\\\")\\n state = layers[l].pipes[0][0].recv()\\n \\n ## save coincidences and PCG\\n np.save(uDir + str(l) + \\\".0.0.coincidences\\\", state['coincidences'])\\n np.save(uDir + str(l) + \\\".0.0.PCG\\\", state['PCG'])\\n\\n else:\\n for i in range(len(layers[l].nodes)): \\n for j in range(len(layers[l].nodes[i])):\\n layers[l].pipes[i][j].send(\\\"clone_state\\\")\\n state = layers[l].pipes[i][j].recv()\\n\\n np.save(uDir + str(l) + \\\".\\\" + str(i) + \\\".\\\" + str(j) + \\\".coincidences\\\", state['coincidences'])\\n np.save(uDir + str(l) + \\\".\\\" + str(i) + \\\".\\\" + str(j) + \\\".PCG\\\", state['PCG'])\\n\\n ## then, save also the output layer\\n layers[-1].pipes[0][0].send(\\\"clone_state\\\")\\n state = layers[-1].pipes[0][0].recv()\\n np.save(uDir + str(len(layers) - 1) + \\\".0.0.coincidences\\\", state['coincidences'])\\n np.save(uDir + str(len(layers) - 1) + \\\".0.0.cls_prior_prob\\\", state['cls_prior_prob'])\\n np.save(uDir + str(len(layers) - 1) + \\\".0.0.PCW\\\", state['PCW'])\",\n \"def save_to_disk(self, file_name = \\\"vehicle_classifier.pkl\\\"):\\n self.classifier.save_to_disk(file_name)\",\n \"def save_port(self):\\n if self.instrument == Instruments.SERVER_LIDAR:\\n instrument_str = 'Lidar'\\n elif self.instrument == Instruments.SERVER_LSP:\\n instrument_str = 'LSP'\\n else:\\n print('Error!!! Instrument is not correctly defined')\\n return\\n\\n line = 'port=%i' % self.port\\n save_path = self.work_dir + ('network_%s.cfg' % instrument_str)\\n\\n with open(save_path, 'w') as f:\\n f.write(line)\",\n \"def save(self, step=None):\\n with self._graph.as_default():\\n path = os.path.join(self._save_path, 'model/weights.ckpt')\\n if step is not None:\\n self._saver.save(self.sess, path, global_step=step)\\n else:\\n self._saver.save(self.sess, path)\\n with open(os.path.join(self._save_path, 'LOG.txt'), 'a') as f:\\n f.write('Saving Model to: ' + path + '\\\\n')\\n\\n # Pickle network architecture into a file.\\n path = os.path.join(self._save_path, 'model/net_arch.pickle')\\n with open(path, 'wb') as handle:\\n pickle.dump(self.network_architecture, handle, protocol=pickle.HIGHEST_PROTOCOL)\",\n \"def output_classLabel_to_txt(save_path):\\n file_obj = open(save_path,'w')\\n length = len(class_label)\\n for i in range(0,length):\\n line = '%d:%s'%(i,class_label[i])\\n file_obj.writelines(line+'\\\\n')\\n return True\",\n \"def write_telluric_transmission_to_file(wls,T,outpath):\\n import pickle\\n print('------Saving teluric transmission to '+outpath)\\n with open(outpath, 'wb') as f: pickle.dump((wls,T),f)\",\n \"def save(self, folder):\\n try:\\n os.makedirs(folder)\\n print(\\\"Created directory for generated code.\\\")\\n except FileExistsError:\\n pass\\n\\n with open(os.path.join(folder, \\\"network.cpp\\\"), \\\"w\\\") as f:\\n f.write(self.network_code)\\n\\n with open(os.path.join(folder, \\\"network.h\\\"), \\\"w\\\") as f:\\n f.write(self.network_header)\\n\\n # with open(os.path.join(folder, \\\"network_initialization.cpp\\\"), \\\"w\\\") as f:\\n # f.write(self.constructor_code)\\n #\\n # with open(os.path.join(folder, \\\"network_initialization.h\\\"), \\\"w\\\") as f:\\n # f.write(self.buffer_declaration)\\n #\\n # with open(os.path.join(folder, \\\"network_cleanup.cpp\\\"), \\\"w\\\") as f:\\n # f.write(self.destructor_code)\\n #\\n # with open(os.path.join(folder, \\\"network_cleanup.h\\\"), \\\"w\\\") as f:\\n # f.write(self.cleanup_header)\\n\\n with open(os.path.join(folder, \\\"network.weights.bin\\\"), \\\"wb\\\") as f:\\n for packed_struct in self.packed_file:\\n f.write(packed_struct)\\n\\n with open(os.path.join(folder, \\\"Makefile\\\"), \\\"w\\\") as f:\\n f.write(self.makefile)\\n\\n with open(os.path.join(folder, \\\"dummy_input.cpp\\\"), \\\"w\\\") as f:\\n f.write(self.dummy_input)\\n\\n with open(os.path.join(folder, \\\"reference_input.cpp\\\"), \\\"w\\\") as f:\\n f.write(self.reference_input)\",\n \"def save(self, name, hide=False):\\n\\n save = [self.neurons, self.weights]\\n prefix = \\\"\\\"\\n if hide:\\n prefix = \\\".\\\"\\n np.save(str(prefix + name + \\\".npy\\\"), save)\\n\\n if not self.silent:\\n print(\\\"[NoxmainNetwork]: Network \\\\\\\"\\\" + str(name) + \\\"\\\\\\\" with neurons \\\" + str(self.neurons) + \\\" saved!\\\")\",\n \"def save_knowledge(net, filepath):\\n\\tknowledge = get_knowledge(net)\\n\\tsavez(filepath, *knowledge)\",\n \"def save_config(network, filename):\\n with open(filename, \\\"wt\\\") as my_file:\\n my_file.write(network.to_json())\\n return None\",\n \"def write_graph(g, filename):\\n with open(filename, 'w') as f:\\n f.write(repr(g))\",\n \"def model_architecture(self, filename=None):\\n list_summary = []\\n self.model.summary(print_fn=lambda x: list_summary.append(x))\\n summary = \\\"\\\\n\\\".join(list_summary)\\n\\n if filename:\\n with open(filename + '.txt', 'w') as f:\\n f.write(summary)\\n\\n from keras.utils import plot_model\\n plot_model(self.model, filename + '.jpg')\\n\\n return summary\",\n \"def save(self, current_epoch, path, file_type, save_weights=True):\\r\\n\\r\\n if (current_epoch == 0):\\r\\n # Saves the architecture\\r\\n architecture = {\\r\\n \\\"word_embedding_size\\\" : self._word_embedding_size,\\r\\n 'rels_descs_embed_type' : self._rels_descs_embed_type,\\r\\n 'rels_embedder_hidden_size': self._rels_embedder_hidden_size,\\r\\n }\\r\\n if (bool(self._mlp_params_dict)):\\r\\n architecture['mlp_params_dict'] = self._mlp_params_dict\\r\\n else:\\r\\n architecture['mlp_params_dict'] = {\\r\\n \\\"layers_sizes\\\" : self._mlp_layers,\\r\\n \\\"activation_functions\\\": self._mlp_activations,\\r\\n \\\"dropout_values\\\" : self._mlp_dropout_values,\\r\\n }\\r\\n torch.save(architecture, path + \\\"architecture.act\\\")\\r\\n\\r\\n # Saves the weights for the current_epoch, associated either with a checkpoint or the best performing model.\\r\\n if (save_weights):\\r\\n torch.save(self.state_dict(), path + \\\"weights\\\" + file_type)\",\n \"def save(self):\\n\\t\\tpath = input (\\\"To save ports scanned to file, please enter a filename, with or without path.\\\")\\n\\t\\tf = None\\n\\t\\tif not path.endswith('.txt'):\\n\\t\\t\\tpath+='.txt'\\n\\t\\ttry:\\n\\t\\t\\tf=open(path, 'w')\\n\\t\\texcept Exception as e:\\n\\t\\t\\tprint('file save failed, error from path')\\n\\t\\t\\tprint (e)\\n\\t\\t\\treturn\\n\\t\\ttry:\\n\\t\\t\\tfor host in self.host_and_ports.keys():\\n\\t\\t\\t\\tf.write(host + '\\\\n')\\n\\t\\t\\t\\tfor port in self.host_and_ports[host]:\\n\\t\\t\\t\\t\\tf.write(str(port) +'\\\\n')\\n\\t\\t\\t\\tf.write(\\\"\\\\n\\\")\\n\\t\\texcept Exception as e:\\n\\t\\t\\tprint(e)\",\n \"def save_network(self, expert_index, in_epoch):\\r\\n for i in range(self.layer_nums):\\r\\n for j in range(self.expert_nums):\\r\\n self.W[i][j, :, :].cpu().detach().numpy().tofile(\\r\\n os.path.join(\\\"C:/Users/rr/Desktop/sscc-main/model/nsm/model/part\\\", str(in_epoch)+'wc%0i%0i%0i_w.bin' % (expert_index, i, j)))\\r\\n self.B[i][j, :, :].cpu().detach().numpy().tofile(\\r\\n os.path.join(\\\"C:/Users/rr/Desktop/sscc-main/model/nsm/model/part\\\", str(in_epoch)+'wc%0i%0i%0i_b.bin' % (expert_index, i, j))\\r\\n )\",\n \"def export_topology(topology, filename='topology.gml'):\\n\\n nx.write_gml(topology, filename)\",\n \"def write(self, outfilename):\\n\\n nx.write_gpickle(self.graph, outfilename)\",\n \"def serialize(self, outputDataFile):\\n\\n print \\\"Serializing graph to {} ...\\\".format(outputDataFile)\\n fileWrite = open(outputDataFile, \\\"w\\\")\\n turtle = self.graph.serialize(None, format='n3')\\n fileWrite.writelines(turtle)\\n fileWrite.close()\\n print \\\"Serialization done.\\\"\",\n \"def to_file(self, fn):\\n store.store_dict(fn, 'trainalgorithm', self.to_dict())\",\n \"def save_graph(self, path):\\n if path.split('.')[-1]=='gexf':\\n nx.write_gexf(self.graph, path)\\n else:\\n nx.write_gpickle(self.graph, path)\",\n \"def writeDarknet(b, of):\\n with open(of, \\\"w\\\") as fh:\\n for r in b:\\n cx = (r[1]+r[3])*0.5*iw\\n cy = (r[2]+r[4])*0.5*ih\\n w = (r[3] - r[1])*iw\\n h = (r[4] - r[2])*ih\\n fh.write(\\\"%d %f %f %f %f\\\\n\\\" % ( labels[r[0]], cx*dw, cy*dh, w*dw, h*dh) )\",\n \"def store(self, path, time_step):\\n with self.graph.as_default():\\n file_name = os.path.join(path, \\\"network\\\")\\n print(\\\"Saving networks...\\\")\\n self.saver.save(self.sess, file_name, time_step)\\n print(\\\"Saved!\\\")\",\n \"def save_networks(self, which_epoch):\\n for name in self.model_names:\\n if isinstance(name, str):\\n save_filename = '%s_net_%s.pth' % (which_epoch, name)\\n save_path = os.path.join(self.save_dir, save_filename)\\n net = getattr(self, 'net_' + name)\\n torch.save(net.cpu().state_dict(), save_path)\\n if len(self.gpu_ids) > 0 and torch.cuda.is_available():\\n net.cuda()\",\n \"def display_network_architecture(self):\\n self.log(\\\"\\\\n-------- Network architecture --------\\\")\\n self.log(\\\"y_res: {}\\\".format(self.y_res))\\n self.log(\\\"x_res: {}\\\".format(self.x_res))\\n self.log(\\\"n_input_channels: {}\\\".format(self.n_input_channels))\\n self.log(\\\"n_output_classes: {}\\\".format(self.n_output_classes))\\n self.log(\\\"input_dropout: {}\\\".format(self.fc1_dropout))\\n self.log(\\\"alpha: {}\\\".format(self.alpha))\\n self.log(\\\"n_samples_trained: {}\\\".format(self.n_samples_trained))\\n for c in range(self.n_output_classes):\\n self.log( \\\" * Class {}, m = {}\\\".format( \\\\\\n c, self.n_class_samples_trained[c] ) )\",\n \"def write_graph(graph, filename):\\n with open(filename, 'w') as file: # open the file\\n # record the number of nodes and edges\\n num_nodes, num_edges = GraphProcessing.compute_num_nodes(graph), GraphProcessing.compute_num_edges(graph)\\n file.write(\\\" \\\".join(list([str(num_nodes), str(num_edges)])) + \\\"\\\\n\\\")\\n for source_node in graph.keys(): # for every node in the graph\\n # for every other node and corresponding weight\\n for terminal_node, weight in graph[source_node].items():\\n # write the edge to the file as the first node, second node and edge weight\\n file.write(\\\" \\\".join(list([str(source_node), str(terminal_node), str(weight)])) + \\\"\\\\n\\\")\",\n \"def save_model(net, path):\\n x_conv_weights = sess.run(net.parameters)\\n x_bn_params = sess.run(get_batch_norm_vars(net))\\n np.save(path, [x_conv_weights, x_bn_params])\\n print(\\\"\\\\x1b[35mSaved model to:\\\\x1b[0m\\\", path)\",\n \"def save(self, path):\\n torch.save({\\\"epoch\\\": self.epoch,\\n \\\"state_dict\\\": self.state_dict()}, path)\\n self.logger.info(\\\"Saved controller network to %s\\\", path)\",\n \"def save(self, filename):\\n with open(filename, 'wb') as f:\\n pickle.dump({'wi': self.W_input_to_hidden, 'wo': self.W_hidden_to_output}, f)\",\n \"def save_bin(words,data,fname):\\n\\n out=open(fname,\\\"wb\\\")\\n\\n rows,dims=data.shape\\n out.write(\\\"{} {}\\\\n\\\".format(rows,dims).encode(\\\"utf-8\\\"))\\n counter=0\\n\\n for i,w in enumerate(words):\\n out.write(w.encode(\\\"utf-8\\\"))\\n out.write(\\\" \\\".encode(\\\"utf-8\\\"))\\n out.write(struct.pack(\\\"{}f\\\".format(dims),*data[i,:]))\\n counter+=1\\n \\n out.close()\\n print(\\\"Model saved to\\\",fname,file=sys.stderr)\",\n \"def save(self):\\n filename = os.path.expanduser(\\\"~/\\\" + self.name)\\n print(filename)\\n np.savetxt(filename + \\\"_left.txt\\\", self.central)\\n np.savetxt(filename + \\\"_right.txt\\\", self.boundaries)\",\n \"def WriteSrnModelToFile(filename, model):\\n\\n # Write the .hpp file\\n WriteHeaderFileForSrnModel(filename, model)\\n\\n # Write the .cpp fil\\n WriteSourceFileForSrnModel(filename, model)\",\n \"def write_to_disk(self):\\n text_file = open(self.file_path, \\\"w\\\")\\n text_file.write(str(self))\\n text_file.close()\\n # dump to pickle\\n pickle.dump(self.blockchain, open(self.pickle_path, \\\"wb\\\"))\",\n \"def save_chain_to_file(config_dict, samplesOutlet, samplesInlet, samplesFD, logPostList, w_num):\\n outlet_path = f\\\"outputs/{config_dict['dir_name']}/AIES_LWR-outlet-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\\\"\\n inlet_path = f\\\"outputs/{config_dict['dir_name']}/AIES_LWR-inlet-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\\\"\\n FD_path = f\\\"outputs/{config_dict['dir_name']}/AIES_LWR-FD-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-walker{w_num}.txt\\\"\\n logPostList_path = f\\\"outputs/{config_dict['dir_name']}/AIES_LWR-FD-N_{config_dict['N_MCMC']}-L_{config_dict['Lwalkers']}-a_prop_{config_dict['a_prop']}-M_trunc_{config_dict['M_trunc']}-LogPostList.txt\\\"\\n np.savetxt(outlet_path, samplesOutlet)\\n np.savetxt(inlet_path, samplesInlet)\\n np.savetxt(FD_path, samplesFD)\\n np.savetxt(logPostList_path, logPostList)\\n\\n Run_settings = gen_run_setting_str(config_dict)\\n run_settings_path = f\\\"outputs/{config_dict['dir_name']}/run_settings.txt\\\"\\n with open(run_settings_path, 'w') as f:\\n f.write(Run_settings)\\n if config_dict[\\\"save_to_S3\\\"] == True:\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", outlet_path), local_path=outlet_path)\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", inlet_path), local_path=inlet_path)\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", FD_path), local_path=FD_path)\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", logPostList_path), local_path=logPostList_path)\\n upload_chain(s3_path=os.path.join(\\\"AIES_LWR\\\", run_settings_path), local_path=run_settings_path)\",\n \"def display_network_architecture(self):\\n self.log(\\\"\\\\n-------- Network architecture --------\\\")\\n self.log(\\\"y_res: {}\\\".format(self.y_res))\\n self.log(\\\"x_res: {}\\\".format(self.x_res))\\n self.log(\\\"n_input_channels: {}\\\".format(self.n_input_channels))\\n self.log(\\\"n_output_classes: {}\\\".format(self.n_output_classes))\\n self.log(\\\"fc1_n_chan: {}\\\".format(self.fc1_n_chan))\\n self.log(\\\"fc1_dropout: {}\\\".format(self.fc1_dropout))\\n self.log(\\\"alpha: {}\\\".format(self.alpha))\\n self.log(\\\"n_samples_trained: {}\\\".format(self.n_samples_trained))\\n for c in range(self.n_output_classes):\\n self.log( \\\" * Class {}, m = {}\\\".format( \\\\\\n c, self.n_class_samples_trained[c] ) )\",\n \"def matlab_export(self, filename):\\n\\n import scipy.io as sio\\n matdata = {}\\n for nn in range(self.num_networks):\\n for ll in range(len(self.networks[nn].layers)):\\n wstring = 'ws' + str(nn) + str(ll)\\n matdata[wstring] = self.networks[nn].layers[ll].weights\\n bstring = 'bs' + str(nn) + str(ll)\\n matdata[bstring] = self.networks[nn].layers[ll].biases\\n\\n sio.savemat(filename, matdata)\",\n \"def write_to_train_file(files: List, train_file_path: str) -> None:\\n f = open(train_file_path, \\\"w\\\")\\n text_to_save = \\\"\\\"\\n for i, img_path in enumerate(files):\\n img_path_stripped = img_path.replace(\\\"/darknet\\\", \\\"\\\")\\n if i == len(files) - 1:\\n text_to_save += img_path_stripped\\n else:\\n text_to_save += img_path_stripped + \\\"\\\\n\\\"\\n\\n f.write(text_to_save)\\n f.close()\",\n \"def save(self, filename):\\n hebbian_weights = open(filename, \\\"w\\\")\\n for i in xrange(self.hidden):\\n hebbian_weights.write(\\\"\\\\t\\\".join(self.vis_layer[i].get_weights()) + '\\\\n')\\n for i in xrange(self.layers):\\n for j in xrange(self.hidden):\\n hebbian_weights.write(\\\"\\\\t\\\".join(self.hidden_layers[i][j].get_weights()) + '\\\\n')\\n hebbian_weights.write(\\\"\\\\t\\\".join(self.output_neuron.get_weights()) + '\\\\n')\\n hebbian_weights.close()\",\n \"def save_model(self, model_file):\\n net_params = self.get_policy_param() # get model params\\n # torch.save(net, save_epoch + '.pkl') # 保存整个网络\\n torch.save(net_params, model_file)\",\n \"def generate_train_txt(name, path):\\n with open(path + '/test.txt', 'a') as file:\\n file.write('/content/YOLO_metric/data/obj/' + name + '\\\\n')\",\n \"def saveGraph (self, filename) :\\n\\t\\tss = \\\"digraph {\\\\n\\\"\\n\\t\\tfor key, rules in self.production_rules.items() :\\n\\t\\t\\tfor rule in rules :\\n\\t\\t\\t\\tr = [op.val for op in rule]\\n\\t\\t\\t\\tr = [i.replace (\\\"-\\\", \\\"\\\") for i in r]\\n\\t\\t\\t\\tr = [i.replace (\\\".\\\", \\\"\\\") for i in r]\\n\\t\\t\\t\\tr = [i.replace (\\\"\\\\'\\\\'\\\", \\\"eps\\\") for i in r]\\n\\t\\t\\t\\tr = [i.replace (\\\"\\\\\\\"\\\\\\\"\\\", \\\"eps\\\") for i in r]\\n\\t\\t\\t\\tr = [i.replace (\\\"/\\\", \\\"_\\\") for i in r]\\n\\t\\t\\t\\tk = key.replace (\\\"-\\\", \\\"\\\")\\n\\t\\t\\t\\tk = k.replace (\\\"/\\\", \\\"_\\\")\\n\\t\\t\\t\\tk = k.replace (\\\".\\\", \\\"_tok\\\")\\n\\t\\t\\t\\tss += \\\"\\\\t\\\" + k + \\\" -> \\\" \\n\\t\\t\\t\\tss += \\\" -> \\\".join (r)\\n\\t\\t\\t\\tss += \\\" ;\\\\n\\\"\\n\\t\\tss += \\\"}\\\"\\n\\t\\tfilestream = open (filename + '.dot', 'w') \\n\\t\\tfilestream.write(ss)\\n\\t\\tfilestream.close ()\\n\\t\\tcmd = 'dot -Tpng -o ' + filename + '.png ' + filename + '.dot'\\n\\t\\tos.system (cmd)\\n\\t\\tcmd = 'rm ' + filename + '.dot'\\n\\t\\tos.system (cmd)\",\n \"def display_network_architecture(self):\\n self.log(\\\"\\\\n-------- Network architecture --------\\\")\\n self.log(\\\"y_res: {}\\\".format(self.y_res))\\n self.log(\\\"x_res: {}\\\".format(self.x_res))\\n self.log(\\\"n_input_channels: {}\\\".format(self.n_input_channels))\\n self.log(\\\"n_output_classes: {}\\\".format(self.n_output_classes))\\n self.log(\\\"conv1_size: {}\\\".format(self.conv1_size))\\n self.log(\\\"conv1_n_chan: {}\\\".format(self.conv1_n_chan))\\n self.log(\\\"conv1_n_pool: {}\\\".format(self.conv1_n_pool))\\n self.log(\\\"conv2_size: {}\\\".format(self.conv2_size))\\n self.log(\\\"conv2_n_chan: {}\\\".format(self.conv2_n_chan))\\n self.log(\\\"conv2_n_pool: {}\\\".format(self.conv2_n_pool))\\n self.log(\\\"fc1_n_chan: {}\\\".format(self.fc1_n_chan))\\n self.log(\\\"fc1_dropout: {}\\\".format(self.fc1_dropout))\\n self.log(\\\"alpha: {}\\\".format(self.alpha))\\n self.log(\\\"n_samples_trained: {}\\\".format(self.n_samples_trained))\\n for c in range(self.n_output_classes):\\n self.log( \\\" * Class {}, m = {}\\\".format( \\\\\\n c, self.n_class_samples_trained[c] ) )\",\n \"def write_to_txt(batch, filepath, typ='vector', verbose ='dataset'):\\n if typ == 'params':\\n with open(filepath, \\\"w\\\") as txt:\\n for param_pack in batch:\\n txt.write(\\\"{} ; {} ; {} \\\\n\\\".format(param_pack.alphaL, \\n param_pack.alphaR, param_pack.label))\\n #txt.write(str(param_pack.alphaL) +\\\", \\\"+str(param_pack.alphaR) +\\\"\\\\n\\\")\\n elif typ == 'vector':\\n if verbose == 'human':\\n with open(filepath, \\\"w\\\") as txt:\\n for vector in batch:\\n txt.write(str(vector[0]) + \\\"\\\\n\\\")\\n txt.write(str(vector[1]) + \\\"\\\\n\\\")\\n elif verbose == 'dataset':\\n with open(filepath, \\\"w\\\") as txt:\\n for vector in batch:\\n #txt.write(str(vector[0].x) +\\\";\\\"+str(vector[0].y) +\\\";\\\"+ str(vector[0].angle) +\\\";\\\"+ str(vector[0].norm()) + \\\"\\\\n\\\")\\n txt.write(str(vector[1].x) +\\\";\\\"+ str(vector[1].angle) +\\\";\\\"+ str(vector[1].norm()) + \\\"\\\\n\\\")\",\n \"def SaveLabels(filepath, labels):\\n # 1) Create a string with all the text to be stored\\n text = '\\\\n'.join(labels)\\n\\n # 2) Open the datafile and save the text\\n with open(filepath, 'w') as outfile:\\n outfile.write(text)\",\n \"def save_networks(self, epoch):\\n for name in self.network_names:\\n if isinstance(name, str):\\n save_filename = '{0}_net_{1}.pth'.format(epoch, name)\\n save_path = os.path.join(self.save_dir, save_filename)\\n net = getattr(self, 'net')\\n\\n if self.use_cuda:\\n torch.save(net.cpu().state_dict(), save_path)\\n net.to(self.device)\\n else:\\n torch.save(net.cpu().state_dict(), save_path)\",\n \"def save(self, nodesName = False, edgesName = False, mode = \\\"authorities\\\"):\\n\\t\\tif nodesName:\\n\\t\\t\\tself.outputNodes = nodesName\\n\\t\\tif edgesName:\\n\\t\\t\\tself.outputEdges = edgesName\\n\\n\\t\\tif mode == \\\"authorities\\\":\\n\\t\\t\\tself.saveNodes()\\n\\t\\telif mode == \\\"cluster\\\":\\n\\t\\t\\tself.saveCluster()\",\n \"def export_to_file(self, path, graph_format):\\n try:\\n logging.info(\\\"Saving RDF data to \\\" + str(path))\\n with open(path, \\\"wb\\\") as out_file:\\n out_file.write(self.g.serialize(format=graph_format, encoding=\\\"UTF-8\\\"))\\n except Exception as e:\\n logging.error(\\\"Error while saving RDF results \\\"+str(e))\",\n \"def save_file(self, *args):\\n if args[0] == 'Save':\\n filename = args[0]\\n\\n # Checks if user input is valid or null for filename. if null, assigns a default filename\\n if args[1].text_field.text:\\n filename = args[1].text_field.text\\n\\n f = open('output/' + filename + '.txt', 'w')\\n f.write('\\\\nRegister Content: \\\\n')\\n for k, v in REGISTER.items():\\n f.write('\\\\n' + k.upper() + ':' + ' ' + v.upper() + '\\\\n')\\n\\n i = 0\\n f.write('\\\\nMemory Content: \\\\n')\\n while i < len(RAM):\\n f.write(f'\\\\n{RAM[i]} {RAM[i + 1]}')\\n i += 2\\n\\n toast('File saved in output folder as ' + filename + '.txt')\\n f.close()\\n\\n else:\\n toast('File save cancelled')\",\n \"def to_file(self, file_path, smirnoff_data):\\n pass\",\n \"def save_model(self, name: str):\\n\\n # Saving the current config\\n self.cM.create_config(name + \\\".cfg\\\")\\n\\n # Saving all Vocabs\\n pickle.dump(self.output_field.vocab, open(name + \\\".out_voc\\\", \\\"wb\\\"))\\n pickle.dump(self.input_field.vocab, open(name + \\\".in_voc\\\", \\\"wb\\\"))\\n\\n # Saving the actual network\\n if os.path.exists(name + \\\".auto\\\"):\\n # If auto saving found, simply rename it\\n logging.info(f\\\"Autostopper STOP\\\")\\n os.rename(name + \\\".auto\\\", name + \\\".ph\\\")\\n else:\\n self.network.save_model(name + \\\".ph\\\")\",\n \"def cmd_wq(self):\\n out_file = open(\\\"DoubleLinkedList.txt\\\", \\\"w\\\")\\n out_file.write(str(self.get_text()))\\n out_file.close()\\n print(\\\"File saved to DoubleLinkedList.txt\\\")\",\n \"def save_file():\\n filepath = asksaveasfilename(\\n defaultextension=\\\"txt\\\",\\n filetypes=[(\\\"Text Files\\\", \\\"*.txt\\\"), (\\\"All Files\\\", \\\"*.*\\\")],\\n )\\n if not filepath:\\n return\\n with open(filepath, \\\"w\\\") as output_file:\\n text = txt_edit.get(\\\"1.0\\\", tk.END)\\n output_file.write(text)\\n window.title(f\\\"Switch port Consolidation - {filepath}\\\")\",\n \"def Save(self, filename: str):\\n data_object = {\\n \\\"input_layer_count\\\" : self.input_layer_size,\\n \\\"hidden_layer_count\\\" : self.hidden_layer_size,\\n \\\"output_layer_count\\\" : self.output_layer_size,\\n\\n \\\"hidden_layer_biases\\\" : self.hidden_layer_biases.tolist(),\\n \\\"output_layer_biases\\\" : self.output_layer_biases.tolist(),\\n\\n \\\"input_to_hidden_weights\\\" : self.input_to_hidden_weights.tolist(),\\n \\\"hidden_to_output_weights\\\" : self.hidden_to_output_weights.tolist()\\n }\\n\\n with open(filename, \\\"w\\\") as f:\\n json.dump(data_object, f)\",\n \"def write_model_info(content=None):\\n _info_dir = os.path.join(CKPT_DIR, UNIQUE_NAME)\\n create_dir(_info_dir)\\n if content is None:\\n content = f\\\"Backbone: {BACKBONE}\\\\nLR: {LEARNING_RATE}\\\\n\\\" \\\\\\n f\\\"Resolution: {IMAGE_SIZE}\\\\nAugmentations: {AUG_PROBABILITY}\\\"\\n\\n with open(os.path.join(_info_dir, 'info.txt'), 'a') as fp:\\n fp.write(content + '\\\\n')\",\n \"def save(self, filename):\\n fptr = open(filename, 'w')\\n for node in self.val_l:\\n fptr.write(str(node) + \\\" \\\" + str(self.val_l[node]) +\\n \\\" \\\" + str(self.val_c[node]) + \\\"\\\\n\\\")\\n fptr.close()\",\n \"def save(self, filename):\\n with open(filename, 'wb') as f:\\n pickle.dump({'wi': self.W_input_to_hidden, 'wh':\\n self.W_hidden_to_hidden, 'wo': self.W_hidden_to_output}, f)\",\n \"def _createNetwork(self,verbose):\\n filename,n,rulesList = self.filename,self.n,self.rulesList\\n if self.verbose:\\n mult = 2\\n if self.MichaelisMenten:\\n mult = 4\\n start,startWall = cpuTime(),wallTime()\\n print(\\\"\\\")\\n print(\\\"Creating network with \\\"+str(n)+\\\" activation sites\\\")\\n print(\\\" and \\\"+str(len(rulesList))+\\\" additional rules (\\\" \\\\\\n +str(mult*(n+len(rulesList)))+\\\" parameters).\\\")\\n \\n namesList = writeBNGL.writeBNGLnetwork(n,rulesList,filename, \\\\\\n MichaelisMenten=self.MichaelisMenten)\\n self._runBNGLfile(filename)\\n \\n if self.verbose:\\n print(\\\"Network creation took \\\"+bothTimeStr(start,startWall))\\n \\n return namesList\",\n \"def save(model, save_name):\\n dirs = configparser.ConfigParser()\\n dirs.read(\\\"config/dir_config.ini\\\")\\n\\n save_name = os.path.splitext(save_name)[0]\\n path = os.path.join(dirs[\\\"save_dirs\\\"][\\\"models\\\"], save_name + \\\".h5\\\")\\n info = os.path.join(dirs[\\\"save_dirs\\\"][\\\"models\\\"], save_name + \\\"_info.txt\\\")\\n\\n with open(info, \\\"w\\\") as file:\\n model.summary(print_fn=lambda x: file.write(f\\\"{x}\\\\n\\\"))\\n model.save(path, overwrite=False)\",\n \"def to_file(self, file): \\n try:\\n import dill as pickle\\n except ImportError:\\n logger.error(\\\"Cannot write to file, dill not installed \\\\n\\\"\\n \\\"pip install dill\\\")\\n return\\n try:\\n logger.info('Writing GeologicalModel to: {}'.format(file))\\n pickle.dump(self,open(file,'wb'))\\n except pickle.PicklingError:\\n logger.error('Error saving file')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7442755","0.6993565","0.69844145","0.69380265","0.69357723","0.6913174","0.6849668","0.6798643","0.66806936","0.65847754","0.6535876","0.6521386","0.64706856","0.6424189","0.6404124","0.6398808","0.63774717","0.6374491","0.6335782","0.6327243","0.62925816","0.6291275","0.62752867","0.6273573","0.6271367","0.6259008","0.62510663","0.6229186","0.62275475","0.62126136","0.621142","0.61893314","0.6165754","0.61532134","0.6151619","0.6137878","0.61109316","0.6108655","0.61011046","0.6098445","0.6081042","0.60777885","0.60627097","0.60522217","0.60442585","0.60413","0.6028793","0.6023086","0.5994431","0.59666073","0.59544843","0.59448516","0.5936907","0.59224117","0.59176505","0.59120595","0.58850044","0.58523726","0.58393717","0.5809488","0.5808723","0.58068836","0.5784376","0.5763735","0.5751247","0.57299536","0.5718241","0.5715498","0.57077545","0.570579","0.5698782","0.5691482","0.5689005","0.5688078","0.56857044","0.5683277","0.5671934","0.56634164","0.5656698","0.56510913","0.5651062","0.5646372","0.56429017","0.56395715","0.56362927","0.563418","0.56293887","0.56269914","0.5620817","0.5615164","0.56111705","0.56015736","0.55975384","0.55960095","0.5589401","0.5585418","0.5580118","0.55736417","0.55728024","0.5572641"],"string":"[\n \"0.7442755\",\n \"0.6993565\",\n \"0.69844145\",\n \"0.69380265\",\n \"0.69357723\",\n \"0.6913174\",\n \"0.6849668\",\n \"0.6798643\",\n \"0.66806936\",\n \"0.65847754\",\n \"0.6535876\",\n \"0.6521386\",\n \"0.64706856\",\n \"0.6424189\",\n \"0.6404124\",\n \"0.6398808\",\n \"0.63774717\",\n \"0.6374491\",\n \"0.6335782\",\n \"0.6327243\",\n \"0.62925816\",\n \"0.6291275\",\n \"0.62752867\",\n \"0.6273573\",\n \"0.6271367\",\n \"0.6259008\",\n \"0.62510663\",\n \"0.6229186\",\n \"0.62275475\",\n \"0.62126136\",\n \"0.621142\",\n \"0.61893314\",\n \"0.6165754\",\n \"0.61532134\",\n \"0.6151619\",\n \"0.6137878\",\n \"0.61109316\",\n \"0.6108655\",\n \"0.61011046\",\n \"0.6098445\",\n \"0.6081042\",\n \"0.60777885\",\n \"0.60627097\",\n \"0.60522217\",\n \"0.60442585\",\n \"0.60413\",\n \"0.6028793\",\n \"0.6023086\",\n \"0.5994431\",\n \"0.59666073\",\n \"0.59544843\",\n \"0.59448516\",\n \"0.5936907\",\n \"0.59224117\",\n \"0.59176505\",\n \"0.59120595\",\n \"0.58850044\",\n \"0.58523726\",\n \"0.58393717\",\n \"0.5809488\",\n \"0.5808723\",\n \"0.58068836\",\n \"0.5784376\",\n \"0.5763735\",\n \"0.5751247\",\n \"0.57299536\",\n \"0.5718241\",\n \"0.5715498\",\n \"0.57077545\",\n \"0.570579\",\n \"0.5698782\",\n \"0.5691482\",\n \"0.5689005\",\n \"0.5688078\",\n \"0.56857044\",\n \"0.5683277\",\n \"0.5671934\",\n \"0.56634164\",\n \"0.5656698\",\n \"0.56510913\",\n \"0.5651062\",\n \"0.5646372\",\n \"0.56429017\",\n \"0.56395715\",\n \"0.56362927\",\n \"0.563418\",\n \"0.56293887\",\n \"0.56269914\",\n \"0.5620817\",\n \"0.5615164\",\n \"0.56111705\",\n \"0.56015736\",\n \"0.55975384\",\n \"0.55960095\",\n \"0.5589401\",\n \"0.5585418\",\n \"0.5580118\",\n \"0.55736417\",\n \"0.55728024\",\n \"0.5572641\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7138623"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":21492,"cells":{"query":{"kind":"string","value":"Reformat data into a suitable format. Arguments"},"document":{"kind":"string","value":"def reformat(dataset):\n x = dataset[:, 1] \n x = np.stack(x) # reshape to (n, mel bands, timesteps)\n x = np.expand_dims(np.moveaxis(x, 1, -1), axis=3) # reformat x to (n, timesteps, mel bands, 1) \n y = dataset[:, 2] \n y = np.moveaxis(np.stack(y), 1, -1) # reformat y to (n, timesteps, 8)\n return x, y"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def format_data(self, data):","def format(self, data):","def _normalize(self, data):\n norm_data = []\n\n for row in data:\n norm_row = []\n\n for column in row:\n # custom format strings for specific objects\n if isinstance(column, float):\n format_str = '{{:.{}f}}'.format(2)\n item = format_str.format(column)\n\n elif isinstance(column, datetime):\n item = column.strftime('%Y-%m-%d %H:%M')\n\n else:\n item = str(column)\n\n norm_row.append(item)\n\n norm_data.append(norm_row)\n\n return norm_data","def _format_data(self, data: np.ndarray) -> np.ndarray:\n if self._validate:\n if len(data.shape) <= 1:\n raise DataProcessorError(\n \"The data should be an array with at least two dimensions.\"\n )\n\n return data","def normalize_data(data):\n\n # 'alphanumeric' and 'description' use the empty string instead of None\n if 'alphanumeric' in data and data['alphanumeric'] is None:\n data['alphanumeric'] = \"\"\n if 'description' in data and data['description'] is None:\n data['description'] = \"\"\n\n # Values may be None to clear them or leave them blank.\n\n # Type is the one exception; it is required and may not be None.\n if 'type' in data:\n try:\n data['type'] = OdlcType.lookup(data['type'])\n except KeyError:\n raise ValueError('Unknown odlc type \"%s\"; known types %r' %\n (data['type'], OdlcType.names()))\n\n if 'latitude' in data and data['latitude'] is not None:\n try:\n data['latitude'] = float(data['latitude'])\n if data['latitude'] < -90 or data['latitude'] > 90:\n raise ValueError\n except ValueError:\n # Unable to convert to float or out-of-range\n raise ValueError('Invalid latitude \"%s\", must be -90 <= lat <= 90'\n % data['latitude'])\n\n if 'longitude' in data and data['longitude'] is not None:\n try:\n data['longitude'] = float(data['longitude'])\n if data['longitude'] < -180 or data['longitude'] > 180:\n raise ValueError\n except ValueError:\n # Unable to convert to float or out-of-range\n raise ValueError(\n 'Invalid longitude \"%s\", must be -180 <= lat <= 180' %\n (data['longitude']))\n\n if 'orientation' in data and data['orientation'] is not None:\n try:\n data['orientation'] = Orientation.lookup(data['orientation'])\n except KeyError:\n raise ValueError(\n 'Unknown orientation \"%s\"; known orientations %r' %\n (data['orientation'], Orientation.names()))\n\n if 'shape' in data and data['shape'] is not None:\n try:\n data['shape'] = Shape.lookup(data['shape'])\n except KeyError:\n raise ValueError('Unknown shape \"%s\"; known shapes %r' %\n (data['shape'], Shape.names()))\n\n if 'background_color' in data and data['background_color'] is not None:\n try:\n data['background_color'] = Color.lookup(data['background_color'])\n except KeyError:\n raise ValueError('Unknown color \"%s\"; known colors %r' %\n (data['background_color'], Color.names()))\n\n if 'alphanumeric_color' in data and data['alphanumeric_color'] is not None:\n try:\n data['alphanumeric_color'] = \\\n Color.lookup(data['alphanumeric_color'])\n except KeyError:\n raise ValueError('Unknown color \"%s\"; known colors %r' %\n (data['alphanumeric_color'], Color.names()))\n\n if 'autonomous' in data:\n if data['autonomous'] is not True and data['autonomous'] is not False:\n raise ValueError('\"autonmous\" must be true or false')\n\n if 'actionable_override' in data:\n if (data['actionable_override'] is not True and\n data['actionable_override'] is not False): # yapf: disable\n raise ValueError('\"actionable_override\" must be true or false')\n\n return data","def cleaning (data):","def _format_data(self, data: np.ndarray) -> np.ndarray:\n self._n_circs = 0\n self._n_shots = 0\n self._n_slots = 0\n self._n_iq = 0\n\n # identify shape\n try:\n # level1 single-shot data\n self._n_circs, self._n_shots, self._n_slots, self._n_iq = data.shape\n except ValueError:\n try:\n # level1 data averaged over shots\n self._n_circs, self._n_slots, self._n_iq = data.shape\n except ValueError as ex:\n raise DataProcessorError(\n f\"Data given to {self.__class__.__name__} is not likely level1 data.\"\n ) from ex\n\n if self._validate:\n if self._n_iq != 2:\n raise DataProcessorError(\n f\"IQ data given to {self.__class__.__name__} does not have two-dimensions \"\n f\"(I and Q). Instead, {self._n_iq} dimensions were found.\"\n )\n\n return data","def _formatData(self):\r\n assert self._runData is not None\r\n\r\n # Getting Axes data into separate lists\r\n x=[]; y=[]; z=[]\r\n for i in range(len(self._runData)):\r\n ySet = []; xSet = []; zSet = []\r\n for _ in range(len(self._runData[i][1][0])):\r\n ySet.append(self._runData[i][0])\r\n y.append(ySet)\r\n xSet.append(self._runData[i][1][0])\r\n x.append(xSet)\r\n zSet.append(self._runData[i][1][1])\r\n z.append(zSet)\r\n\r\n # Reduce extra brackets\r\n xnew = []; znew = []\r\n for i in range(len(x)):\r\n xnew.append(x[i][0])\r\n znew.append(z[i][0])\r\n x = xnew; z = znew\r\n\r\n self._frequency = x\r\n self._voltages = y\r\n self._intensity = z","def _format_data(self, data: np.ndarray) -> np.ndarray:\n\n self._n_shots = len(data[0])\n self._n_circuits = len(data)\n\n if self._validate:\n if data.shape[:2] != (self._n_circuits, self._n_shots):\n raise DataProcessorError(\n f\"The datum given to {self.__class__.__name__} does not convert \"\n \"of an array with dimension (number of circuit, number of shots).\"\n )\n\n return data","def _format_data(self) -> None:\n for row in self._db_data:\n if row['age_start'] is None:\n continue\n # entry = {'x': 'Celkem', 'y': int(row['count'])}\n elif row['age_start'] == 95:\n entry = {'x': f\"{int(row['age_start'])}+\", 'y': int(row['count'])}\n else:\n entry = {'x': f\"{int(row['age_start'])}-{int(row['age_start'])+4}\", 'y': int(row['count'])}\n self.return_data['data'].append(entry)","def normalizeData(self, data):\n return _normalizeData(data)","def normalizeData(self, data):\n return _normalizeData(data)","def format_data(self, raw_data):\n opz = raw_data.copy()\n opz['datetime'] = pd.to_datetime(opz['Datum-tijd'], format='%Y-%m-%dT%H:%M:%SZ')\n opz.drop(['Datum-tijd'],axis=1, inplace=True)\n opz['dag']=opz['datetime'].dt.day\n opz['tijd'] = opz['datetime'].dt.time\n #voeg open/dicht data toe en bepaal momenten waarop dit wisselt\n opz['Opzetstuk Noord (°)'] = opz['Opzetstuk Noord (°)'].str.replace(',', '.').astype(float)\n opz['Opzetstuk Zuid (°)'] = opz['Opzetstuk Zuid (°)'].str.replace(',', '.').astype(float)\n opz['Opzetstuk Noord (°)'].fillna(opz['Opzetstuk Zuid (°)'], inplace=True)\n opz['Opzetstuk Zuid (°)'].fillna(opz['Opzetstuk Noord (°)'], inplace=True)\n return opz","def transform(self, data):","def reformat():\n toolkit.reformat()","def _format_data(self, data: np.ndarray) -> np.ndarray:\n self._n_shots = 0\n\n # identify shape\n try:\n # level1 single-shot data\n self._n_circs, self._n_shots, self._n_slots, self._n_iq = data.shape\n except ValueError:\n try:\n # level1 data averaged over shots\n self._n_circs, self._n_slots, self._n_iq = data.shape\n except ValueError as ex:\n raise DataProcessorError(\n f\"Data given to {self.__class__.__name__} is not likely level1 data.\"\n ) from ex\n\n if self._validate:\n if data.shape[-1] != 2:\n raise DataProcessorError(\n f\"IQ data given to {self.__class__.__name__} must be a multi-dimensional array\"\n \"of dimension [d0, d1, ..., 2] in which the last dimension \"\n \"corresponds to IQ elements.\"\n f\"Input data contains element with length {data.shape[-1]} != 2.\"\n )\n\n return data","def prepare_data(self, data):\n for i, v in data.items():\n field_type = self.get_field_type(i)\n #log.info('i = %s, type = %s', i, field_type)\n if field_type == 'datetime' and isinstance(v, (str, unicode)):\n data[i] = datetime_from_string(v)\n return data","def _process_data(data):\n for array in data:\n # Check if time is inverted. If so, reverse array while keeping the time/data structure.\n if array and len(array) > 2 and array[0] > array[2]:\n buff_1 = array[::2][::-1]\n buff_2 = array[1::2][::-1]\n array[::2] = buff_1\n array[1::2] = buff_2\n return data","def format_data(data, is_feature1d=True, copy=False, make_float=True):\n if data is None or issparse(data):\n return data\n\n if make_float:\n data = asfloat(data)\n\n if not isinstance(data, np.ndarray) or copy:\n data = np.array(data, copy=copy)\n\n # Valid number of features for one or two dimensions\n n_features = data.shape[-1]\n\n if data.ndim == 1:\n data_shape = (n_features, 1) if is_feature1d else (1, n_features)\n data = data.reshape(data_shape)\n\n return data","def _format_data(self, data: np.ndarray) -> np.ndarray:\n if self._validate:\n if len(data.shape) <= self._axis:\n raise DataProcessorError(\n f\"Cannot average the {len(data.shape)} dimensional \"\n f\"array along axis {self._axis}.\"\n )\n\n return data","def convertData(data):\n\n return data","def from_multicsv(self,input_data):\n reformatted_data = []\n for (i,row) in enumerate(input_data):\n if i==0:\n headers = row\n else:\n data_row = {}\n for (j,h) in enumerate(headers):\n if j<len(row):\n data_row.update({h : row[j]})\n else:\n data_row.update({h : 0})\n reformatted_data.append(data_row)\n return reformatted_data","def preprocess(data):\n\tprint(\"\\n--------Data preview--------\\n{0}\".format(data.head()))\n\t# transform datatime columns to four columns includes the year、month、day、hour\n\tdata['year'] = pd.DatetimeIndex(data['datetime']).year\n\tdata['month'] = pd.DatetimeIndex(data['datetime']).month\n\tdata['day'] = pd.DatetimeIndex(data['datetime']).day\n\tdata['hour'] = pd.DatetimeIndex(data['datetime']).hour\n\n\tdata[\"date\"] = data.datetime.apply(lambda x : x.split()[0])\n\tdata[\"weekday\"] = data.date.apply(lambda dateString :\n\t calendar.day_name[datetime.strptime(dateString,\"%Y-%m-%d\").weekday()])\n\t# after transformed delete the 'datatime' column\n\tdataDroped = data.drop(['datetime'], axis=1)\n\tprint(\"\\n-------\\nAfter preprocess(transform time display format to avoid object data type)\\n-------\")\n\treturn dataDroped","def dataNormalize(data):\n tr = re.sub('<(.*)>|\\\\n', '', data.prettify())\n return re.sub(' +', ',', tr).split(',')","def _pre_process_record(self, data):\n result = []\n symbolic_split = \",\"\n if isinstance(data, dict):\n if self.measure is None:\n logging.error(\"Missing the name of keys pointing to values\")\n raise UnSADException.data_format_exception()\n if self.timestamp is not None:\n if self.timestamp in data:\n try:\n result.append(float(data[self.timestamp]))\n [result.append(data[measure])\n for measure in self.measure]\n except RuntimeError:\n logging.error(\"Invalid input data type, should be a numerical type\")\n logging.error(\"Input data should contain all the fields \"\n \"that are specified when initialize the detector: \" + str(self.measure))\n raise UnSADException.data_type_exception()\n else:\n logging.error(\"Input data should contain a timestamp field:\" + str(self.timestamp))\n raise UnSADException.data_format_exception()\n else:\n try:\n [result.append(data[measure]) for measure in self.measure]\n except RuntimeError:\n logging.error(\"Input data should contain all the fields \"\n \"that are specified when initialize the detector: \" + str(self.measure))\n raise UnSADException.data_format_exception()\n elif isinstance(data, Iterable) and not isinstance(data, str):\n if self.timestamp is not None:\n if len(data) == len(self.measure) + 1:\n try:\n result = list(data)\n result[0] = float(result[0])\n except RuntimeError as e:\n logging.error(\"Invalid input data type, timestamp should be a numerical type\")\n raise UnSADException.data_type_exception()\n else:\n logging.error(\"The number of input parameters:\" + str(\n len(data)) + \" does not match with this detectors:\" + str(len(self.measure) + 1))\n raise UnSADException.input_number_exception()\n else:\n if self.measure is None or len(data) == len(self.measure):\n result = data\n else:\n logging.error(\"The number of input parameters:\" + str(\n len(data)) + \" does not match with this detectors:\" + str(len(self.measure)))\n raise UnSADException.input_number_exception()\n else:\n if (self.measure is None or len(self.measure) == 1) and self.timestamp is None:\n if self.symbolic:\n return str(data)\n else:\n try:\n return float(data)\n except RuntimeError as e:\n logging.error(\"Invalid input data type, should be a numerical type\")\n raise UnSADException.data_type_exception()\n else:\n logging.error(\"This detector is not initialized properly\")\n raise UnSADException.not_proper_initialize_exception()\n\n if not self.symbolic:\n try:\n processed_result = [float(result[i])\n for i in range(len(result))]\n except RuntimeError as e:\n logging.error(\"Invalid input data type, should be a numerical type\")\n raise UnSADException.data_type_exception()\n\n return processed_result[0] if len(processed_result) == 1 else processed_result\n\n else:\n if self.timestamp is not None:\n return [result[0], symbolic_split.join([str(s) for s in result[1:]])]\n else:\n return symbolic_split.join([str(s) for s in result])","def _format_data(self):\n formatted_data = []\n\n for row in self._data_agg_by_mean_value.iterrows():\n \n car_make = row[0]\n mean_car_value = round(row[1][0], 2)\n formatted_data.append({'car_make': car_make, 'mean_car_value': mean_car_value})\n\n return formatted_data","def reformat(ctx):\n pass","def normalize_dataset(self):","def format_data(self)->float: \n try:\n formatted = chr(self.data[0])\n for i in range(1, len(self.data)): \n formatted = formatted + (chr(self.data[i])) \n return str(formatted)\n except ValueError as e:\n print(e)\n except TypeError as e:\n print(e)","def cleanData(data):\r\n \r\n indexes = data.index[pd.isnull(data[\"release date\"])]\r\n # data = data.drop(data.index[[2172, 3781, 7245, 12475, 14756, 15292, 49295, 93523, 99723]],axis=0,inplace=False)\r\n data = data.drop(indexes,axis=0,inplace=False)\r\n data = data.drop([\"video release date\", 'IMDb URL'],axis=1)\r\n \r\n \r\n data.gender = data.gender.astype(\"category\")\r\n data.occupation = data.occupation.astype(\"category\")\r\n \r\n categorical_variables = [\"gender\", \"occupation\"]\r\n for variable in categorical_variables:\r\n dummies = pd.get_dummies(data[variable], prefix=variable)\r\n data = pd.concat([data, dummies], axis=1)\r\n data.drop([variable], axis=1, inplace=True)\r\n data['movieID'] = data['movieID'].astype('int')\r\n data['userID'] = data['userID'].astype('int')\r\n \r\n\t#data = dateTime(data)\r\n \r\n return data","def prepareData(self, *data):\n arguments = 8\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\n self.model, self.annotations, self.args) = tuple(data[:arguments])\n \n self.width = self.args.beam_width\n self.mathType = self.args.mathType\n self.io_files = {\n 'input': self.args.intermediate_input_files,\n 'output': self.args.intermediate_output_files\n }\n self.repeat_width = self.args.repeat_width\n self.cons_count = self.args.cons_count\n self.posterior_processors = self.args.posterior_processors \n\n self.positionGenerator = \\\n list(AlignmentBeamGenerator(self.alignment, self.width))\n \n for i in range(len(self.model.states)):\n self.model.states[i].computeHints(self)\n\n return data[arguments:]","def _data_normalization(data: list) -> list:\n\n return [ \n [\n d[0], # IP\n d[1], # Port\n Froxy._split_proxy_info(\n d[2].strip(' ') # Proxy Info\n ) \n ]\n for d in data\n ]","def reformat_data(matlab_data) -> dict:\n data = dict()\n data[\"significant_ripples\"] = matlab_data.SignificantRipples - 1\n data[\"ripple_info\"] = matlab_data.RippleTimes\n data[\"inhibitory_neurons\"] = (\n np.array(matlab_data.InhibitoryNeurons) - 1\n ) # account for matlab indexing\n data[\"excitatory_neurons\"] = (\n matlab_data.ExcitatoryNeurons - 1\n ) # account for matlab indexing\n data[\"well_locations\"] = matlab_data.WellLocations\n data[\"well_sequence\"] = matlab_data.WellSequence\n data[\"spike_ids\"] = matlab_data.SpikeData[:, 1].astype(int) - 1\n data[\"spike_times_s\"] = matlab_data.SpikeData[:, 0]\n data[\"pos_times_s\"] = matlab_data.PositionData[:, 0]\n data[\"pos_xy_cm\"] = np.squeeze(matlab_data.PositionData[:, 1:-1])\n data[\"ripple_times_s\"] = data[\"ripple_info\"][:, :2]\n data[\"n_ripples\"] = len(data[\"ripple_times_s\"])\n data[\"n_cells\"] = np.max(data[\"spike_ids\"] + 1)\n return data","def format_rec_data(tr_data, village, HC, gs_pars, vfeatures, idx_pars=[]):\n\n print('\\nFormatting recorded data...')\n ret_list = []\n\n gs_xvec, gs_yvec = [utils.get_copy(gs_pars[v]) for v in ['xvec', 'yvec']]\n\n if 'anim_data' in tr_data:\n\n anim_data = pd.DataFrame(tr_data['anim_data']).T\n ret_list.append(anim_data)\n\n if 'stim_data' in tr_data:\n\n # Motor input.\n mot_keys = ['umot', 'vmot']\n mot_data = {i: pd.DataFrame({k: d[k] for k in mot_keys}).unstack()\n for i, d in tr_data['stim_data'].items() if d is not None}\n mot_data = pd.DataFrame(mot_data).T\n mot_data.columns.set_levels(['x', 'y'], level=1, inplace=True)\n ret_list.append(mot_data)\n\n # Visual input.\n vis_keys = ['ovis', 'vvis']\n vis_data = {i: pd.DataFrame({k: d[k] for k in vis_keys}).unstack()\n for i, d in tr_data['stim_data'].items() if d is not None}\n vis_data = pd.DataFrame(vis_data).T\n vis_data.columns.set_levels(vfeatures, level=1, inplace=True)\n ret_list.append(vis_data)\n\n if 'gs_state' in tr_data:\n\n gs_state = {k: pd.DataFrame(gs, columns=gs_xvec, index=gs_yvec)\n for k, gs in tr_data['gs_state'].items()}\n gs_state = pd.concat(gs_state)\n gs_state.columns.rename('x', inplace=True)\n gs_state.index.rename('y', level=-1, inplace=True)\n ret_list.append(gs_state)\n\n if 'hc_state' in tr_data:\n\n hc_state = {k: pd.DataFrame(hc, index=HC.s_names)\n for k, hc in tr_data['hc_state'].items()}\n hc_state = pd.concat(hc_state)\n hc_state.index.rename('loc', level=-1, inplace=True)\n hc_state = hc_state[HC.s_types] # reorder columns\n ret_list.append(hc_state)\n\n if 'vs_state' in tr_data:\n\n vs_state = {k: pd.Series(vc, index=HC.s_names)\n for k, vc in tr_data['vs_state'].items()}\n vs_state = pd.concat(vs_state)\n ret_list.append(vs_state)\n\n if 'dls_state' in tr_data:\n\n dls_state = {k: pd.DataFrame(dls, columns=HC.s_names, index=village.U)\n for k, dls in tr_data['dls_state'].items()}\n dls_state = pd.concat(dls_state)\n dls_state.columns.rename('s', inplace=True)\n dls_state.index.rename('u', level=-1, inplace=True)\n ret_list.append(dls_state)\n\n # Set index level names.\n idx_lvl_names = idx_pars + ['step']\n for df in ret_list:\n levels = (None if not isinstance(df.index, pd.core.index.MultiIndex)\n else list(range(len(idx_lvl_names))))\n df.index.set_names(idx_lvl_names, level=levels, inplace=True)\n\n return ret_list","def format_row(row):\n assert isinstance(row,list)\n \n data_row=[0]*len(header) #Formatted data row to be output and appeneded to 'data'\n \n for i in [0,1,11,13,14,15,16,17,19,20,21,28,31,45,46,47,48]: data_row[i]=row[i] #emptry string will NOT return None\n for i in [2,3,12,18]: data_row[i]=type_cast(lambda x: int(float(x)),row[i])\n for i in [6,7,8,9,10,23,24,25,26,27,29,30]: data_row[i]=type_cast(float,row[i])\n for i in [4,5,22]: data_row[i]=type_cast(datetime.strptime,row[i],'%Y-%m-%d %H:%M:%S')\n for i in range(32,45):\n if row[i]=='False': data_row[i]=False #bool('False') returns True!\n elif row[i]=='True': data_row[i]=True\n else: data_row[i]=None\n return data_row","def formatRecvdData(data_recvd):\n\n\t##############\tADD YOUR CODE HERE\t##############\n\t\n\tx = PrettyTable()\n\t\t\n\tdict2 = eval(data_recvd)\n\t\t\n\tx.field_names=[\"OPTION_NUMBER\",\"OPTIONS\",\"ADDITIONAL INFO\"]\n\tfor key,value in dict2.items():\n\t\tvalue = str(value)\n\t\tif '{' in value:\n\t\t\t\td = eval(value)\n\t\t\t\tfor i,j in d.items():\n\n\t\t\t\t\tx.add_row([key,i,j])\n\t\t\t\t\n\t\telse:\n\t\t\t\t\n\t\t\tx.add_row([key,value,\"-\"])\n\tprint(x)\n\t\n\n\t##################################################","def clean_data(data):\n \n cols = data.columns\n \n #these columns had some extra characters in the strings becuase of encoding issues\n list_to_strip=[\n 'attributes_alcohol',\n 'attributes_restaurantsattire',\n 'attributes_wifi',\n 'attributes_smoking',\n 'attributes_noiselevel',\n ]\n #this removes quotation marks and u's from strings\n \n for col in list_to_strip:\n data[col]=data[col].str.strip(\"u\\'\")\n \n #this replaces the strings None and none with Nan objects\n for col in cols:\n data[col]=data[col].where(data[col]!='None')\n data[col]=data[col].where(data[col]!='none')\n \n #this creates a list of categorical and numerical features\n categorical_features = cols.drop([\n 'review_count',\n 'restaurant',\n 'latitude',\n 'longitude',\n 'business_id',\n 'meanfunny',\n 'meanuseful',\n 'avgwordcount',\n 'maxwordcount',\n 'minwordcount',\n 'avgfunnywordcount',\n 'maxfunnywordcount',\n 'avgusefulwordcount',\n 'maxusefulwordcount',\n 'medianwordcount',\n 'upperquartilewordcount',\n 'lowerquartilewordcount',\n 'target'])\n \n \n numerical_features = [\n 'review_count',\n 'latitude',\n 'longitude',\n 'meanfunny',\n 'meanuseful',\n 'avgwordcount',\n 'maxwordcount',\n 'minwordcount',\n 'avgfunnywordcount',\n 'maxfunnywordcount',\n 'avgusefulwordcount',\n 'maxusefulwordcount',\n 'medianwordcount',\n 'upperquartilewordcount',\n 'lowerquartilewordcount']\n \n #this replaces the categorial nans with 9 as a placeholder and fills numerical nans with 0\n data[categorical_features]=data[categorical_features].fillna(9)\n data[numerical_features]=data[numerical_features].fillna(0)\n \n #this makes all the categorical columns strings\n data[categorical_features]=data[categorical_features].astype(str)\n data = data\n \n return data, numerical_features, categorical_features","def _prepare_and_validate_data(self,data_list):\n pos=0\n list_pos=0\n format=\"\"\n length=0\n value=\"\"\n\n #check number of items in data_list is as expected\n if(self.data_lookup.count()['type']!=len(data_list)):\n raise NumItemsError(\"Wrong number of items for the data type\")\n\n #loop over data from data_types.csv and populate\n for index,row in self.data_lookup.iterrows():\n length=int(row['Bytes'])\n\n #obtain format type\n if (row['Format']=='byte'):\n format=int\n elif (row['Format']=='string'):\n format=str\n\n #obtain limits\n try:\n min=int(row['Min'],16)\n max=int(row['Max'],16)\n except:\n min='*'\n max='*'\n\n #check format type\n if (isinstance(data_list[list_pos],format)):\n #correct format type\n if format==str:\n value=data_list[list_pos].encode()\n elif format==int:\n value=data_list[list_pos].to_bytes(length,'little')\n\n #check limits if int type\n if min=='*' or max == '*':\n pass\n elif int(data_list[list_pos]) >= min and int(data_list[list_pos]) <= max:\n pass\n else:\n raise ValueError(\"value\",int(value),\"is out of range, min:\",min,\"max:\",max)\n else:\n raise TypeError(\"Unknown type, can currently only handle string or integer types\")\n #populate data\n for n in range(0,length):\n self.data[pos+n]=value[n]\n pos=pos+length\n list_pos=list_pos+1\n else:\n raise TypeError(\"expected\",format,\"got\",type(data_list[list_pos]),\"at position\",list_pos)\n return True","def _format_data(self, data, charset):\n\n return self._encode_data(data) if data else u''","def preprocess(data):\n raise NotImplementedError","def _format_data(self, data: np.ndarray) -> np.ndarray:\n valid_count_type = int, np.integer\n\n if self._validate:\n for datum in data:\n if not isinstance(datum, dict):\n raise DataProcessorError(\n f\"Data entry must be dictionary of counts, received {type(datum)}.\"\n )\n for bit_str, count in datum.items():\n if not isinstance(bit_str, str):\n raise DataProcessorError(\n f\"Key {bit_str} is not a valid count key in {self.__class__.__name__}.\"\n )\n if not isinstance(count, valid_count_type):\n raise DataProcessorError(\n f\"Count {bit_str} is not a valid count for {self.__class__.__name__}. \"\n \"The uncertainty of probability is computed based on sampling error, \"\n \"thus the count should be an error-free discrete quantity \"\n \"representing the frequency of event.\"\n )\n\n return data","def format_data(self, data):\n # data or full_score is a list of tuples, here return just NPClassScore\n formatted_data = None # default when there is no score (missing class)\n if data:\n # there is a score\n formatted_data = f'{data[0][0]:.3f}'\n return formatted_data","def reformat_events(self, data, features):\n # Update alias\n if isinstance(features, list):\n [x.update(dict(alias=self.alias[(x[features[0]],\n x[features[1]])])) for x in data]\n else:\n [x.update(dict(alias=self.alias[x[features]])) for x in data]\n temp_data = list()\n # define ordering keys and columns\n if self.one_timestamp:\n columns = ['alias', 'duration', 'dur_act_norm']\n sort_key = 'end_timestamp'\n else:\n sort_key = 'start_timestamp'\n columns = ['alias', 'processing_time',\n 'proc_act_norm', 'waiting_time', 'wait_act_norm']\n data = sorted(data, key=lambda x: (x['caseid'], x[sort_key]))\n for key, group in itertools.groupby(data, key=lambda x: x['caseid']):\n trace = list(group)\n temp_dict = dict()\n for col in columns:\n serie = [y[col] for y in trace]\n if col == 'alias':\n temp_dict = {**{'profile': serie}, **temp_dict}\n else:\n serie = [y[col] for y in trace]\n temp_dict = {**{col: serie}, **temp_dict}\n temp_dict = {**{'caseid': key, 'start_time': trace[0][sort_key],\n 'end_time': trace[-1][sort_key]},\n **temp_dict}\n temp_data.append(temp_dict)\n return sorted(temp_data, key=itemgetter('start_time'))","def reformat(x):\n x = x.permute(0, 2, 3, 1)\n N, D1, D2, Feat = x.size()\n x = x.view(N, D1 * D2, Feat)\n return x","def reformat(x):\n x = x.permute(0, 2, 3, 1)\n N, D1, D2, Feat = x.size()\n x = x.view(N, D1 * D2, Feat)\n return x","def preprocess_data(data):\n def deal_line(line):\n pos, rating = line.split(',')\n row, col = pos.split(\"_\")\n row = row.replace(\"r\", \"\")\n col = col.replace(\"c\", \"\")\n return int(row), int(col), float(rating)\n\n def statistics(data):\n row = set([line[0] for line in data])\n col = set([line[1] for line in data])\n return min(row), max(row), min(col), max(col)\n\n # parse each line\n data = [deal_line(line) for line in data]\n\n # do statistics on the dataset.\n min_row, max_row, min_col, max_col = statistics(data)\n print(\"number of items: {}, number of users: {}\".format(max_row, max_col))\n\n # build rating matrix.\n ratings = sp.lil_matrix((max_row, max_col))\n for row, col, rating in data:\n ratings[row - 1, col - 1] = rating\n return ratings","def _separate_raw_data(self, raw_data):\n for key, value in raw_data.items():\n if type(value) == dict:\n self.data_dict[key] = value\n elif type(value) == list:\n self.data_list[key] = value","def FormatOutput( data ):\n nColumn = len(data[0])\n nRow = len(data)\n\n i = 0\n oData = []\n while i < nRow:\n tmp = ', '.join( str(x) for x in data[i] )\n oData.append(tmp)\n i += 1\n \n return oData","def _format_data(self, data: np.ndarray) -> np.ndarray:\n self._n_shots = 0\n\n # identify shape\n try:\n # level1 single-shot data\n self._n_circs, self._n_shots, self._n_slots, self._n_iq = data.shape\n except ValueError as ex:\n raise DataProcessorError(\n f\"The data given to {self.__class__.__name__} does not have the shape of \"\n \"single-shot IQ data; expecting a 4D array.\"\n ) from ex\n\n if self._validate:\n if data.shape[-1] != 2:\n raise DataProcessorError(\n f\"IQ data given to {self.__class__.__name__} must be a multi-dimensional array\"\n \"of dimension [d0, d1, ..., 2] in which the last dimension \"\n \"corresponds to IQ elements.\"\n f\"Input data contains element with length {data.shape[-1]} != 2.\"\n )\n\n if self._validate:\n if isinstance(self._discriminator, list):\n if self._n_slots != len(self._discriminator):\n raise DataProcessorError(\n f\"The Discriminator node has {len(self._discriminator)} which does \"\n f\"not match the {self._n_slots} slots in the data.\"\n )\n\n return unp.nominal_values(data)","def reformat_data(inp):\n lines = iter(inp)\n\n # First, find the start of the map records, which we assume for the moment\n # is the line that starts with 'CASEID'.\n for line in lines:\n if line.startswith('CASEID'):\n break\n else:\n print(\"CASEID record not found\")\n return\n\n while True:\n specline = line.strip()\n values = []\n for line in lines:\n if line[0].strip():\n # Start of next block.\n break\n values.append(line.strip())\n yield reformat_block(specline, values)\n if not line[0].strip() or line.startswith('-------------'):\n # End of data, because either we've seen the line introducing\n # the footer, or 'line' still has the last line in it, that\n # didn't have a non-blank first character.\n break","def reformat_chalendar(raw):\n # where we have variable (NG = net generation) and fuel type\n target_cols = [c for c in raw.columns if len(c.split(\".\")) == 5]\n logger.info(\"Filtering\")\n cleaned = (\n raw.loc[:, target_cols]\n .melt(ignore_index=False, value_name=\"generation\", var_name=\"variable\")\n .reset_index()\n )\n logger.info(\"Expanding cols\")\n cleaned[[\"dtype\", \"BA\", \"other BA\", \"var\", \"fuel\", \"interval\"]] = cleaned[\n \"variable\"\n ].str.split(r\"[.-]\", expand=True, regex=True)\n logger.info(\"Dropping and renaming\")\n cleaned = cleaned.drop(columns=[\"dtype\", \"var\", \"interval\", \"other BA\"])\n cleaned = cleaned.rename(columns={\"index\": \"datetime_utc\"})\n return cleaned","def preprocess_data(self, data, scale_data=True):\n print(\"preprocess_data not implemented\")\n return data","def _process_data(self):\r\n # Rename columns to match final feature class\r\n self._rename_columns()\r\n # Add point ID column\r\n self._add_pointid()\r\n # Sort rows by transect id and timestamp\r\n self._sort_rows()\r\n # Fill Null records with a value\r\n self._fill_nulls()\r\n # Set site_code to lower case\r\n self._lower_site_code()\r\n # Create survey_id\r\n self._calc_survey_id()\r\n # Calculate nativesg column if at least one of the veg columns is a Native seagrass type\r\n if set(self.veg_columns).intersection(set(NATIVESG_CODES)) > 0:\r\n self.nativesg_columns = list(set(self.veg_columns).intersection(set(NATIVESG_CODES)))\r\n self._calc_nativesg()\r\n #\r","def clean_data(data):\n # switch dict to flip the names of the RE data set to match SF\n col_switch = {'fund_id': 'project_id',\n 'gift_count': 'record_count.5',\n 'total': 'sum_of_amount.5'}\n\n # define package items\n dfs = data[0]\n args = data[1]\n\n # clean columns in dataframes\n for df in dfs:\n df.columns = [x.lower() for x in df.columns]\n if 'fund id' in df.columns:\n df.columns = [x.lower().replace(' ', '_') for x in df.columns]\n df['source'] = 'RE'\n df.rename(columns=col_switch, inplace=True)\n else:\n df.columns = [x.lower().replace(' ', '_') for x in df.columns]\n df['source'] = 'SF'\n df.drop(columns=['sum_of_amount', 'record_count', 'sum_of_amount.1', 'record_count.1', 'sum_of_amount.2',\n 'record_count.2', 'sum_of_amount.3',\n 'record_count.3', 'sum_of_amount.4', 'record_count.4'], inplace=True)\n\n # standardize project_IDs\n for df in dfs:\n df['project_id_new'] = df['project_id'].apply(lambda x: x.strip() if isinstance(x, str) else x)\n df['project_id_new'] = df['project_id_new'].apply(\n lambda x: x.replace(' - ', '-').lower() if isinstance(x, str) and '-' in x else x)\n df['project_id_new'] = df['project_id_new'].apply(\n lambda x: x.replace('- ', '-').lower() if isinstance(x, str) and '-' in x else x)\n df['project_id_new'] = df['project_id_new'].apply(\n lambda x: x.replace(' -', '-').lower() if isinstance(x, str) and '-' in x else x)\n df['project_id_new'] = df['project_id_new'].apply(\n lambda x: x.replace('-', '_').lower() if isinstance(x, str) and '-' in x else x)\n df['project_id_new'] = df['project_id_new'].apply(\n lambda x: x.replace(' ', '_').lower() if isinstance(x, str) and ' ' in x else x)\n df['project_id_new'] = df['project_id_new'].apply(lambda x: x.lower() if isinstance(x, str) else x)\n\n # standardize sum_of_amount\n for df in dfs:\n df['sum_of_amount_new'] = df['sum_of_amount.5'].apply(lambda x: x.strip() if isinstance(x, str) else x)\n df['sum_of_amount_new'] = df['sum_of_amount_new'].apply(\n lambda x: x.replace('USD', '').lower() if isinstance(x, str) and 'USD' in x else x)\n df['sum_of_amount_new'] = df['sum_of_amount_new'].apply(\n lambda x: x.replace('$', '').lower() if isinstance(x, str) and '$' in x else x)\n df['sum_of_amount_new'] = df['sum_of_amount_new'].apply(\n lambda x: x.replace(',', '').lower() if isinstance(x, str) and ',' in x else x)\n df['sum_of_amount_new'] = df['sum_of_amount_new'].apply(\n lambda x: float(\"{0:.2f}\".format(float(x))) if isinstance(x, str) else x)\n\n return dfs, args","def _format_data(self, data: CurveData) -> CurveData:\n # take average over the same x value by keeping sigma\n series, xdata, ydata, sigma, shots = multi_mean_xy_data(\n series=data.data_index,\n xdata=data.x,\n ydata=data.y,\n sigma=data.y_err,\n shots=data.shots,\n method=\"shots_weighted\",\n )\n\n # sort by x value in ascending order\n series, xdata, ydata, sigma, shots = data_sort(\n series=series,\n xdata=xdata,\n ydata=ydata,\n sigma=sigma,\n shots=shots,\n )\n\n return CurveData(\n label=\"fit_ready\",\n x=xdata,\n y=ydata,\n y_err=sigma,\n shots=shots,\n data_index=series,\n )","def processData (data, result):\n TITLE = 1\n YEAR = 2\n for d in data:\n # create key by using the given indices to find the title and year\n key = (d[TITLE].strip(), d[YEAR].strip())\n # create value from the remaining elements in the information list\n value = d[0:TITLE] + d[YEAR+1:]\n # add data to dictionary\n if key not in result:\n result[key] = []\n result[key] += value\n # OR:\n # result[key] = result.get(key, []) + value\n return result","def _transform_map_data(self):\n WARD_FMT = '%s-%s'\n self.map_data_trans = []\n lookup = {i.column: ''.join(filter(lambda x: x.isdigit(), i.value)) for i in self.sht[1]}\n\n #skip over header\n rs = iter(self.sht.rows)\n next(rs)\n next(rs)\n for r in rs:\n pka = r[0].value\n for c in r[1:]:\n if c.value is None:\n c.value = 0\n\n self.map_data_trans.append((WARD_FMT%(pka, lookup[c.column]), c.value))","def clean_data(data):\n src_list = []\n no_net_view = []\n for row in range(data.nrows):\n # Ignore header row.\n if row == 0:\n continue\n # Ignore blank row.\n if data.row_values(row)[1] == '' and \\\n data.row_values(row)[15] == '':\n continue\n # Capture lines that do not have a view listed.\n if data.row_values(row)[1] and not data.row_values(row)[15]:\n no_net_view.append(data.row_values(row))\n continue\n src_list.append(data.row_values(row))\n\n # Clean's src_list values.\n src_list = [[item.replace('\\t', '') for item in row\n if isinstance(item, str)]\n for row in src_list]\n src_list = [[item.replace('\\n', ', ') for item in row\n if isinstance(item, str)]\n for row in src_list]\n src_list = [[item.replace(', ,', ', ') for item in row\n if isinstance(item, str)]\n for row in src_list]\n src_list = [[item.strip() for item in row\n if isinstance(item, str)]\n for row in src_list]\n for enum, row in enumerate(src_list):\n row[0] = row[0].lower()\n src_list[enum] = row\n return src_list","def __call__(data, source_format, target_format):","def _format_data(data, block_numbers, one_hot_encode):\n\n X = []\n Y = []\n\n data = data.split(\"\\n\\n\")[:-1]\n\n block_cursor = 0\n speaker_cursor = 0\n for block in data:\n\n if block_cursor >= block_numbers[speaker_cursor]:\n block_cursor = 0\n speaker_cursor += 1\n\n X.append(np.loadtxt(io.StringIO(block)))\n\n if one_hot_encode:\n Y.append(ONE_HOT_SPEAKERS[speaker_cursor].reshape(1, -1))\n else:\n Y.append(np.array([SPEAKERS[speaker_cursor]]).reshape(1, 1))\n\n block_cursor += 1\n\n return X, Y","def normalize_values(self, data):\n\n df = pd.DataFrame(data[1:], columns = data[0]).astype(str)\n\n df = df.replace(ami_md_constants.NAS)\n\n df = df.replace(ami_md_constants.REGEX_REPLACE_DICT, regex=True)\n df = df.replace(ami_md_constants.STRING_REPLACE_DICT)\n df['source.object.format_type'] = df['source.object.format'].map(ami_md_constants.FORMAT_TYPE)\n\n for key in ami_md_constants.MEASURE_UNIT_MAPS.keys():\n value_map = ami_md_constants.MEASURE_UNIT_MAPS[key]\n df = self.map_value(df,\n value_map['from_column'],\n value_map['to_column'],\n value_map['constant_value'],\n value_map['values_map_column'],\n value_map['values_map'])\n\n #force all the numerics back to numeric, and drop all empty columns\n df = df.apply(pd.to_numeric, errors='ignore').dropna(axis=1, how = \"all\")\n\n vals = df.values.tolist()\n cols = df.columns.tolist()\n vals.insert(0, cols)\n\n return vals","def clean_recording_data(self, raw_data: dict) -> dict:\n (\n pos_xy_aligned,\n pos_times_aligned,\n spike_ids_aligned,\n spike_times_aligned,\n ) = self.align_spike_and_position_recording_data(\n raw_data[\"pos_xy_cm\"],\n raw_data[\"pos_times_s\"],\n raw_data[\"spike_ids\"],\n raw_data[\"spike_times_s\"],\n )\n (\n pos_xy_gaps_aligned_and_cleaned,\n large_position_gaps_inds,\n ) = self.clean_recording_gaps(pos_xy_aligned, pos_times_aligned)\n # store cleaned data in new dictionary\n cleaned_data = raw_data.copy()\n cleaned_data[\"pos_xy_cm\"] = pos_xy_gaps_aligned_and_cleaned\n cleaned_data[\"pos_times_s\"] = pos_times_aligned\n cleaned_data[\"spike_ids\"] = spike_ids_aligned\n cleaned_data[\"spike_times_s\"] = spike_times_aligned\n cleaned_data[\"large_position_gaps_inds\"] = large_position_gaps_inds\n return cleaned_data","def cleanData(rawData):\n\trawData = re.sub(r'R-LRB- \\(', r'R-LRB- -LRB-', rawData)\n\trawData = re.sub(r'R-RRB- \\)', r'R-RRB- -RRB-', rawData)\n\trawData = re.sub(r'R-RRB- \\(', r'R-RRB- -LRB-', rawData)\n\trawData = re.sub(r'-LRB- \\(', r'-LRB- -LRB-', rawData)\n\trawData = re.sub(r'-RRB- \\)', r'-RRB- -RRB-', rawData)\n\trawData = re.sub(r'PU \\(', r'PU -LRB-', rawData)\n\trawData = re.sub(r'PU \\)', r'PU -RRB-', rawData)\n\trawData = re.sub(r':-\\)', r'smileyface', rawData)\n\n\treturn rawData","def reformat(self, newformat):\n # check whether the column is defined\n if self._defined:\n # get the appropriate null-format\n nullformat = self._get_nullformat(newformat)\n # set the new formats\n self._format = [newformat, nullformat]\n else:\n # first the column type must be defined\n raise Exception('The data type of this column is not yet defined!')","def transform_data(redcap_data_json):\n redcap_data = pd.DataFrame(redcap_data_json)\n redcap_data.to_csv('data.csv')\n\n # Split data by event type\n enrollment_data = redcap_data[redcap_data['redcap_event_name']=='Enrollment']\n survey_data = redcap_data[redcap_data['redcap_event_name']!='Enrollment']\n survey_data['redcap_event_name'] = survey_data['redcap_event_name'].apply(lambda x: datetime.datetime(int(x[0:4]), int(x[5:7]), int(x[8:10]), 1, 0) if x[11:13] == \"AM\" else datetime.datetime(int(x[0:4]), int(x[5:7]), int(x[8:10]), 13, 0))\n\n # Exclude/Include relevant columns\n enrollment_data = enrollment_data[\n [\n 'record_id',\n 'redcap_event_name',\n 'ministry',\n 'facility',\n 'email',\n 'am_email_1',\n 'am_email_2',\n 'am_email_3',\n 'am_email_4',\n 'am_email_5',\n 'am_email_6',\n 'pm_email_1',\n 'pm_email_2',\n 'pm_email_3',\n 'pm_email_4',\n 'pm_email_5',\n 'pm_email_6',\n 'april_trigger',\n 'may_trigger',\n 'june_trigger',\n 'july_trigger',\n 'contact_market_facility_complete'\n ]\n ]\n\n survey_data = survey_data.drop(\n [\n 'email',\n 'am_email_1',\n 'am_email_2',\n 'am_email_3',\n 'am_email_4',\n 'am_email_5',\n 'am_email_6',\n 'pm_email_1',\n 'pm_email_2',\n 'pm_email_3',\n 'pm_email_4',\n 'pm_email_5',\n 'pm_email_6',\n 'april_trigger',\n 'may_trigger',\n 'june_trigger',\n 'july_trigger',\n 'contact_market_facility_complete'\n ], axis=1)\n\n # Fill Missing Data\n survey_data = survey_data.replace(\"\", np.nan) # Replace all empty strings with nan\n survey_data = survey_data.fillna(survey_data.groupby('record_id').ffill()) # Forward fill missing data\n survey_data = survey_data.fillna(survey_data.groupby('record_id').bfill()) # Backward fill missing data\n\n # Fill in survey data ministry and facility\n facility_params = {\n '40011': {'facility': 'StV Evansville Med Ctr', 'ministry': 'ININD'},\n '40017': {'facility': 'StV Warrick Hosp', 'ministry': 'ININD'},\n '46006': {'facility': 'StV Heart Ctr Indiana', 'ministry': 'ININD'},\n '46013': {'facility': 'St Vincent Seton Spec Hosp Indianapolis', 'ministry': 'ININD'},\n '46018': {'facility': 'StV Kokomo Hosp', 'ministry': 'ININD'},\n '46019': {'facility': 'StV Anderson Reg Hosp', 'ministry': 'ININD'},\n '46024': {'facility': 'StV Carmel Hosp', 'ministry': 'ININD'},\n '46029': {'facility': 'StV Indianapolis Hosp', 'ministry': 'ININD'},\n '46033': {'facility': 'StV Jennings Hosp', 'ministry': 'ININD'},\n '46036': {'facility': 'StV Mercy Hosp', 'ministry': 'ININD'},\n '46042': {'facility': 'StV Salem Hosp', 'ministry': 'ININD'},\n '46043': {'facility': 'StV Stress Ctr', 'ministry': 'ININD'},\n '46045': {'facility': 'StV Williamsport Hosp', 'ministry': 'ININD'},\n '46047': {'facility': 'StV Clay Hosp', 'ministry': 'ININD'},\n '46048': {'facility': 'StV Randolph Hosp', 'ministry': 'ININD'},\n '46052': {'facility': 'StV Dunn Hosp', 'ministry': 'ININD'},\n '46055': {'facility': 'StV Fishers', 'ministry': 'ININD'}\n }\n\n survey_data['ministry'] = survey_data.apply(lambda x: facility_params.get(x['record_id'], {}).get('ministry'), axis=1)\n survey_data['facility'] = survey_data.apply(lambda x: facility_params.get(x['record_id'], {}).get('facility'), axis=1)\n\n return enrollment_data, survey_data","def _process_stats_data(self, graph_rule, trans_stats_data):\n formatted_data = {}\n translation_data = {}\n if graph_rule:\n formatted_data['graph_rule'] = graph_rule\n if trans_stats_data.get('branch'):\n formatted_data['branch'] = trans_stats_data['branch']\n ticks = trans_stats_data.get('ticks')\n labels = {}\n [labels.update({index: val}) for index, val in ticks]\n graph_data = trans_stats_data.get('graph_data', {})\n for unit in graph_data:\n temp_stat = {}\n stat = unit.get('data', [])\n for index, val in stat:\n temp_stat.update({labels.get(index): val})\n translation_data[unit.get('label', 'label')] = temp_stat\n formatted_data['translation_stats'] = translation_data\n return formatted_data","def _process_stats_data(self, trans_stats_data):\n formatted_data = {}\n translation_data = {}\n if trans_stats_data.get('pkg_desc'):\n formatted_data['description'] = trans_stats_data['pkg_desc']\n ticks = trans_stats_data.get('ticks')\n labels = {}\n [labels.update({index: val}) for index, val in ticks]\n graph_data = trans_stats_data.get('graph_data', {})\n for branch, data in graph_data.items():\n new_trans_data = {}\n for index, stat in data:\n new_trans_data.update({labels.get(index): stat})\n translation_data[branch] = new_trans_data\n formatted_data['translation_stats'] = translation_data\n formatted_data['percentage_calculated_on'] = \"Messages\"\n return formatted_data","def parse_datum( self, data ):\n return data","def parse_datum( self, data ):\n return data","def format_data(arr, dimen, data_type):\n\tif type(dimen) != tuple:\n\t\tprint(\"Error: expected tuple type.\")\n\t\treturn None\n\tfactor = int(dimen[1] / dimen[0])\n\treturn {\n\t\t\"train\": [np.reshape(row, dimen) for row in arr],\n\t\t\"test\": [np.hsplit(row, factor) for row in arr]\n\t}.get(data_type)","def FixFloats(Data):\n\n if isinstance(Data, dict):\n return { k: FixFloats(v) for k, v in Data.items() }\n\n if isinstance(Data, list):\n return [ FixFloats(v) for v in Data ]\n\n if isinstance(Data, float): # Only floats being changed here\n return str(Data)\n\n return Data","def _normalize_data_to_send(info):\n # Remove the parts of the data that are unbounded in size.\n info = copy.deepcopy(info)\n for key in ['model_config', 'epoch_history']:\n if key in info:\n del info[key]\n return info","def preprocess(data):\n # Data Preprocessing\n data['GDP_scaled']=preprocessing.scale(data['GDP'])\n data['CLPRB_scaled']=preprocessing.scale(data['CLPRB'])\n data['EMFDB_scaled']=preprocessing.scale(data['EMFDB'])\n data['ENPRP_scaled']=preprocessing.scale(data['ENPRP'])\n data['NGMPB_scaled']=preprocessing.scale(data['NGMPB'])\n data['PAPRB_scaled']=preprocessing.scale(data['PAPRB'])\n data['PCP_scaled']=preprocessing.scale(data['PCP'])\n data['ZNDX_scaled']=preprocessing.scale(data['ZNDX'])\n data['OP_scaled']=preprocessing.scale(data['Nominal Price'])\n data['OP2_scaled']=preprocessing.scale(data['Inflation Adjusted Price'])\n\n return data","def reconstruct(self, data):\n self.recons = self.trf.reconstruct(data)","def preprocess_input(x, data_format=None): # pylint: disable=unused-argument\n return x","def data_preparation(self) -> None:\n self.logger.info('data cleaning')\n self.logger.info('num of secs: {}, num of ipo_dates: {}, num of secs with prices: {}'.format(\n len(self.data),\n len(self.ipo_dates),\n len(self.prices)\n ))\n excluded = []\n excluded = [i.lower() for i in excluded]\n self.logger.info(f'number of excluded: {len(excluded)}')\n for i in excluded:\n self.data.pop(i)\n for s in self.data:\n # columns with empty assets sum (empty columns and other situations)\n self.data[s].dropna(axis='columns', how='any', subset=['A_0'], inplace=True)\n # columns with descriptions (polish and english names of values)\n self.data[s].drop(self.data[s].columns[[0, 1]], inplace=True, axis=1)\n\n self.logger.info(f'number of secs after cleaning: {len(self.data)}')\n data_list = [k for k in self.data.values()]\n self.uber_data = pd.concat(data_list, ignore_index=True, axis=1)\n self.uber_data = self.uber_data.transpose()\n self.uber_data = self.uber_data.loc[:, pd.notnull(self.uber_data.columns)]","def unstructured_to_structured(data, indexes):\r\n header = data[0].tolist()\r\n dtype_lst = []\r\n for i in range(len(header)):\r\n if i in indexes:\r\n dtype_lst.append(tuple([header[i], \"<U30\"]))\r\n else:\r\n dtype_lst.append(tuple([header[i], \"float64\"]))\r\n updated = np.delete(data, 0, 0)\r\n tuple_lst = []\r\n for i in updated:\r\n tuple_lst.append(tuple(i))\r\n updated = np.array(tuple_lst, dtype=dtype_lst)\r\n return updated","def transform_data(data_orig):\n\tif isinstance(data_orig, str):\n\t\tdata_orig = pd.read_csv(data_orig)\n\n\tdata = data_orig\n\n\tnum_rows,num_variables = data.shape\n\tall_columns = data.columns.tolist()\n\tclean_data(data,all_columns,ignore_na=False,fill_mode=\"prob\")\n\texpand_features(data)\n\tvariables = ['Pclass','Sex',\"Fare\",\"Age\",\"SibSp\",\"Parch\",\"Embarked\",\"Fam_size\",\\\n\t\t\t\t \"cabin_no\",\"ticket_no\",\"friend\",\"Fare_person\",\"Child\"]\n\tX = pd.get_dummies(data[variables])\n\n\t## normalise features to zero man and unit variance\n\tscaler = preprocessing.StandardScaler().fit(X)\n\tX_scaled = scaler.transform(X)\n\tX = pd.DataFrame(X_scaled, columns=X.columns)\n\n\tif \"Survived\" in data.columns:\n\t\ty = data['Survived']\n\telse:\n\t\ty = None\n\n\treturn X, y","def _pack_data( self, data ) : \r\n \r\n # hints = self._translation_table.get( type(data), None )\r\n hints = self._get_hints( data ) \r\n \r\n if hints is None : \r\n \r\n ## #debug: \r\n ## print \"_pack_data(): no hints for data type %s (data repr: %s)\" % (type(data), repr(data))\r\n \r\n # \"one-level recursion\" : \r\n # return self._pack_data( repr(data) )\r\n return self._pack_data( str(data) )\r\n \r\n ## # our special case ( grep 'bugfix' to see why we want a zero block ) \r\n ## if data is None: data = 0\r\n \r\n # else ... \r\n \r\n # 'DescType' + 'length' + 'data'\r\n desctype = hints[0]\r\n if desctype == 'TEXT' : \r\n length = len(data)\r\n data_str = data \r\n else :\r\n length = struct.calcsize( hints[1] )\r\n data_str = struct.pack( hints[1], data )\r\n \r\n length_str = struct.pack('=H', length)\r\n \r\n \r\n return _cat(desctype, length_str, data_str)","def fix_corpus_format(corpus):\n import copy\n fixed_format = copy.copy(corpus)\n testing = corpus['testing']\n training = corpus['training']\n validation = corpus['validation']\n del fixed_format['testing']\n del fixed_format['training']\n del fixed_format['validation']\n fixed_format['partition'] = {\n \"testing\": testing,\n \"training\": training,\n \"validation\": validation,\n }\n return fixed_format","def _preprocess(self, data):\n\n # pipeline: first call the previous statistics:\n if self.previous_statistics is not None:\n data = self.previous_statistics.statistics(data)\n # the first of the statistics need to take list as input, in order to match the API. Then actually the\n # transformations work on np.arrays. In fact the first statistic transforms the list to array. Therefore, the\n # following code needs to be called only if the self statistic is the first, i.e. it does not have a\n # previous_statistic element.\n else:\n data = self._check_and_transform_input(data)\n\n return data","def preprocess_data(extracted_data: List[Tuple[str, str]]) -> List[str]:\n return [f'__label__{data[0]} {clean_formatting(data[1])}' for data in extracted_data]","def parseStructuredData( raw_data, format ):\n\tparsed_data = {}\n\n\tBEGIN = 0\n\tEND = 1\n\tCONV = 2\n\n\tfor key in format.keys():\n\t\tkey_format = format[key]\n\n\t\tif key_format[END] == \"\":\n\t\t\tkey_format[END] = key_format[BEGIN] + len(raw_data)\n\n\t\ttxt = raw_data[key_format[BEGIN]:key_format[END]]\n\n\t\tif len(key_format[CONV]) > 0:\n\t\t\tparsed_data[key] = struct.unpack(key_format[CONV], txt)[0]\n\t\telse:\n\t\t\tparsed_data[key] = txt\n\n\treturn parsed_data","def _transform_data(self, *args, **kwargs) -> None:\n raise NotImplementedError","def parse_data( self ):\n super( PivotGraph, self ).parse_data()\n new_parsed_data = {}\n parsed_data = getattr( self, 'parsed_data', self.results )\n for pivot, data in parsed_data.items():\n new_pivot = self.parse_pivot( pivot )\n data = self.parse_datum( data )\n if data != None:\n new_parsed_data[ new_pivot ] = data\n self.parsed_data = new_parsed_data","def normalize(data):\n data = lowercase(data)\n data = remove_punct(data)\n data = remove_apostrophes(data)\n data = remove_stopwords(data)\n data = num_to_words(data)\n data = lemmatize(data)\n data = stemming(data)\n data = remove_punct(data)\n data = num_to_words(data)\n data = lemmatize(data)\n data = stemming(data)\n data = remove_punct(data) #done again to remove hyphens produced by num2words\n data = remove_stopwords(data) #done agan to remove stopwords produced by num2words\n return data","def format_data(data):\n rules = []\n bags = []\n for bag_data in data:\n bag = bag_data.split('contain')\n bag_type = bag[0].replace('bags', '').strip().lower()\n bag_content = bag[1].replace('.', '')\n if 'no other bags' in bag_content:\n continue\n else:\n bags.append([bag_type, [[re.sub(r'bags?$', '', content).strip().lower()[2:], content[:2].strip()]\n for content in bag_content.split(',')]])\n rule = re.search(fr'\\d+ {BAG_TYPE}', bag_data)\n if rule:\n rules.append([bag_type, rule.group()[:1].strip()])\n # print(rules)\n return rules, bags","def _format_data(self, data):\n return json.dumps(data)","def reformat_file(inFile, outFile):\n \n with open(outFile, \"w\") as outHandle:\n \n\t\t# write header line\n\t\toutLine = [\"g1\", \"g2\", \"raw_count\", \"log(obs/exp)\"]\n\t\t\n\t\toutHandle.write(\"\\t\".join(outLine) + \"\\n\")\n\n\n\t\tfor i, line in enumerate(open(inFile)):\n\t\t\t\n\t\t\tif not i == 0:\n\t\t\t\t\n\t\t\t\tsp = line.strip().split(\"\\t\")\n\t\t\t\t\n\t\t\t\t# get row interaction counts and normalized obs/exp values\n\t\t\t\trawCount = sp[12]\n\t\t\t\tobsExp = sp[13]\n\t\t\t\t\n\t\t\t\tgenes1 = sp[4].split(\"|\")\n\t\t\t\tgenes2 = sp[10].split(\"|\")\n\t\t\t\t\n\t\t\t\t#~ print(g1, g2, rawCount)\n\t\t\t\t\n\t\t\t\t# iterate over all pairs\n\t\t\t\tfor g1 in genes1:\n\n\t\t\t\t\tfor g2 in genes2:\n\t\t\t\t\t\t\n\t\t\t\t\t\toutLine = [g1, g2, rawCount, obsExp]\n\t\t\t\t\t\t\n\t\t\t\t\t\toutHandle.write(\"\\t\".join(outLine) + \"\\n\")","def format_raw_data(data, indent=2*'\\t'):\n strings = [' '.join([('%.2x' % ord(x)) for x in data[i:i + DGTL_Decoder.__raw_data_chunk]])\n for i in xrange(0, len(data), DGTL_Decoder.__raw_data_chunk)]\n return ('\\n' + indent).join(strings)","def __format_it(self, data):\n\n for index, regex in self.regex_dates.items():\n matched = helpers.Regex(regex).match(data, return_match=True, rematch=True)\n\n if not matched:\n continue\n\n date = self.__format_management(index, matched)\n\n if not date: # pragma: no cover\n continue\n\n return \"-\".join(date)\n return None # pragma: no cover","def organize_data(self, data):\n presentation = \"\"\n\n offices = data['offices']\n living = data['living']\n\n presentation += \"OFFICE \\n\\n\"\n if len(offices) == 0:\n presentation += \"No Office allocations\\n\"\n\n else:\n presentation += \"Office Allocations\\n\"\n for office in offices:\n presentation += office['room'].capitalize() + \"\\n\"\n presentation += \"Members: \\n\"\n presentation += ','.join(office['names'])\n\n presentation += \"LIVING SPACES \\n\\n\"\n if len(offices) == 0:\n presentation += \"No Living space allocations\\n\"\n\n else:\n presentation += \"Office Allocations\\n\"\n for space in living:\n presentation += living['room'].capitalize() + \"\\n\"\n presentation += ','.join(living['names'])\n\n return presentation","def convertProfileData(data):\n actVer = Version(data.get('version', '0.0'))\n if actVer >= Version(profileVersion):\n return data\n if 'mainW' not in data:\n return data\n\n log.info(f'Conversion from [{data.get(\"version\")}] to [{profileVersion}]')\n watney = {\n 'deviceName': 'Watney',\n 'deviceList': ['Watney'],\n 'searchRadius': 10,\n 'timeout': 30,\n 'appPath': '',\n 'indexPath': '',\n }\n d = NestedDict(data)\n try:\n d['driversData'] = d['mainW', 'driversData']\n del d['mainW']['driversData']\n d['driversData', 'plateSolve'] = d['driversData', 'astrometry']\n del d['driversData']['astrometry']\n d['driversData', 'plateSolve', 'frameworks', 'watney'] = watney\n d['hemisphereW', 'horizonMaskFileName'] = d['mainW', 'horizonFileName']\n del d['mainW']['horizonFileName']\n t = d['driversData', 'directWeather', 'frameworks', 'internal']\n d['driversData', 'directWeather', 'frameworks', 'directWeather'] = t\n del d['driversData']['directWeather']['frameworks']['internal']\n d['driversData', 'directWeather', 'frameworks', 'directWeather',\n 'deviceName'] = 'On Mount'\n d['version'] = profileVersion\n except Exception as e:\n log.error(f'Failed conversion, keep old structure: {e}')\n else:\n data = d.to_dict()\n return data","def update_column_format(self):\n pass","def _normalize_layer_data(data: LayerData) -> FullLayerData:\n if not isinstance(data, tuple) and 0 < len(data) < 4:\n raise ValueError(\"LayerData must be a 1-, 2-, or 3-tuple\")\n _data = list(data)\n if len(_data) > 1:\n if not isinstance(_data[1], dict):\n raise ValueError(\n \"The second item in a LayerData tuple must be a dict\"\n )\n else:\n _data.append(dict())\n if len(_data) > 2:\n if _data[2] not in layers.NAMES:\n raise ValueError(\n \"The third item in a LayerData tuple must be one of: \"\n f\"{layers.NAMES!r}.\"\n )\n else:\n _data.append(guess_labels(_data[0]))\n return tuple(_data) # type: ignore","def formatAllToFloat(self):\n SectionList = [self.Accel[\"X\"], self.Accel[\"Y\"], self.Accel[\"Z\"], self.Gyro[\"X\"], self.Gyro[\"Y\"], self.Gyro[\"Z\"], self.Millis,self.GForce,self.Rot[\"X\"],self.Rot[\"Y\"],self.Rot[\"Z\"],self.DDMillis.Gyro,self.DDMillis.Accel,self.DDMillis.Rot,self.DDMillis.Mag,\n self.GPSDat[\"lng\"], self.GPSDat[\"lat\"], self.GPSDat[\"Speed\"], self.GPSDat[\"Altitude\"], self.GPSDat[\"Accuracy\"], self.GPSDat[\"Bearing\"],self.Mag[\"X\"],self.Mag[\"Y\"],self.Mag[\"Z\"]]\n\n for item in SectionList:\n if not len(item) == 0:\n GoToThisDangit = item[:]\n for SubItem in range(len(GoToThisDangit)):\n try:\n if SubItem > len(item):\n break\n else:\n item[SubItem] = float(item[SubItem])\n except ValueError:\n try:\n del item[SubItem]\n except IndexError:\n \"Slightly dangerous catch....\"\n except IndexError:\n \"yo\"","def OPCtimetransformOld(data, to):\n outtimes = []\n \n times = {\n 'ms':[],\n 'SS':[],\n 'MM':[],\n 'HH':[]\n }\n for i in range(0, len(data)):\n item = data[i]\n try: \n times['HH'].append(int(item[0:2]))\n times['MM'].append(int(item[2:4]))\n times['SS'].append(int(item[4:6]))\n times['ms'].append(int(item[7:9]))\n except ValueError:\n # strange value 2319010.00 in 201129 file...\n olditem = item\n newitem = item[:4] + item[4+1:]\n print( ('Repairing strange value %s into %s')%(olditem, newitem) )\n try:\n times['HH'].append(int(newitem[0:2]))\n times['MM'].append(int(newitem[2:4]))\n times['SS'].append(int(newitem[4:6]))\n times['ms'].append(int(newitem[7:9]))\n except ValueError:\n print(newitem)\n\n # OPC times go up to 60 minutes. This is corrected by moving one minute\n times['MM'] = [max(0,x-1) for x in times['MM']]\n times['SS'] = [max(0,x-1) for x in times['SS']]\n\n for i in range(0, len(data)):\n md = dt.datetime(1900,1,1,times['HH'][i], times['MM'][i], times['SS'][i]) \n outtimes.append( dt.datetime.strftime(md, to))\n\n return outtimes","def datamunge(cls, data):\n pass","def format_output(data: pd.DataFrame, source, col_maps=None) -> pd.DataFrame:\n if data.empty: return pd.DataFrame()\n if source == 'bdp': req_cols = ['ticker', 'field', 'value']\n else: req_cols = ['ticker', 'field', 'name', 'value', 'position']\n if any(col not in data for col in req_cols): return pd.DataFrame()\n if data.dropna(subset=['value']).empty: return pd.DataFrame()\n\n if source == 'bdp':\n res = pd.DataFrame(pd.concat([\n pd.Series({**{'ticker': t}, **grp.set_index('field').value.to_dict()})\n for t, grp in data.groupby('ticker')\n ], axis=1, sort=False)).transpose().set_index('ticker')\n else:\n res = pd.DataFrame(pd.concat([\n grp.loc[:, ['name', 'value']].set_index('name')\n .transpose().reset_index(drop=True).assign(ticker=t)\n for (t, _), grp in data.groupby(['ticker', 'position'])\n ], sort=False)).reset_index(drop=True).set_index('ticker')\n res.columns.name = None\n\n if col_maps is None: col_maps = dict()\n return res.rename(\n columns=lambda vv: col_maps.get(\n vv, vv.lower().replace(' ', '_').replace('-', '_')\n )\n ).apply(pd.to_numeric, errors='ignore', downcast='float')","def parse_data( self ):\n super( PivotGroupGraph, self ).parse_data()\n new_parsed_data = {}\n parsed_data = getattr( self, 'parsed_data', self.results )\n for pivot, groups in parsed_data.items():\n new_pivot = self.parse_pivot(pivot)\n if new_pivot == None:\n continue\n new_groups = {}\n new_parsed_data[ new_pivot ] = new_groups\n for group, data in groups.items():\n new_group = self.parse_group(group)\n new_datum = self.parse_datum(data)\n if new_group == None:\n continue\n new_groups[ new_group ] = new_datum\n if len(new_groups) == 0:\n del new_parsed_data[new_pivot]\n self.parsed_data = new_parsed_data"],"string":"[\n \"def format_data(self, data):\",\n \"def format(self, data):\",\n \"def _normalize(self, data):\\n norm_data = []\\n\\n for row in data:\\n norm_row = []\\n\\n for column in row:\\n # custom format strings for specific objects\\n if isinstance(column, float):\\n format_str = '{{:.{}f}}'.format(2)\\n item = format_str.format(column)\\n\\n elif isinstance(column, datetime):\\n item = column.strftime('%Y-%m-%d %H:%M')\\n\\n else:\\n item = str(column)\\n\\n norm_row.append(item)\\n\\n norm_data.append(norm_row)\\n\\n return norm_data\",\n \"def _format_data(self, data: np.ndarray) -> np.ndarray:\\n if self._validate:\\n if len(data.shape) <= 1:\\n raise DataProcessorError(\\n \\\"The data should be an array with at least two dimensions.\\\"\\n )\\n\\n return data\",\n \"def normalize_data(data):\\n\\n # 'alphanumeric' and 'description' use the empty string instead of None\\n if 'alphanumeric' in data and data['alphanumeric'] is None:\\n data['alphanumeric'] = \\\"\\\"\\n if 'description' in data and data['description'] is None:\\n data['description'] = \\\"\\\"\\n\\n # Values may be None to clear them or leave them blank.\\n\\n # Type is the one exception; it is required and may not be None.\\n if 'type' in data:\\n try:\\n data['type'] = OdlcType.lookup(data['type'])\\n except KeyError:\\n raise ValueError('Unknown odlc type \\\"%s\\\"; known types %r' %\\n (data['type'], OdlcType.names()))\\n\\n if 'latitude' in data and data['latitude'] is not None:\\n try:\\n data['latitude'] = float(data['latitude'])\\n if data['latitude'] < -90 or data['latitude'] > 90:\\n raise ValueError\\n except ValueError:\\n # Unable to convert to float or out-of-range\\n raise ValueError('Invalid latitude \\\"%s\\\", must be -90 <= lat <= 90'\\n % data['latitude'])\\n\\n if 'longitude' in data and data['longitude'] is not None:\\n try:\\n data['longitude'] = float(data['longitude'])\\n if data['longitude'] < -180 or data['longitude'] > 180:\\n raise ValueError\\n except ValueError:\\n # Unable to convert to float or out-of-range\\n raise ValueError(\\n 'Invalid longitude \\\"%s\\\", must be -180 <= lat <= 180' %\\n (data['longitude']))\\n\\n if 'orientation' in data and data['orientation'] is not None:\\n try:\\n data['orientation'] = Orientation.lookup(data['orientation'])\\n except KeyError:\\n raise ValueError(\\n 'Unknown orientation \\\"%s\\\"; known orientations %r' %\\n (data['orientation'], Orientation.names()))\\n\\n if 'shape' in data and data['shape'] is not None:\\n try:\\n data['shape'] = Shape.lookup(data['shape'])\\n except KeyError:\\n raise ValueError('Unknown shape \\\"%s\\\"; known shapes %r' %\\n (data['shape'], Shape.names()))\\n\\n if 'background_color' in data and data['background_color'] is not None:\\n try:\\n data['background_color'] = Color.lookup(data['background_color'])\\n except KeyError:\\n raise ValueError('Unknown color \\\"%s\\\"; known colors %r' %\\n (data['background_color'], Color.names()))\\n\\n if 'alphanumeric_color' in data and data['alphanumeric_color'] is not None:\\n try:\\n data['alphanumeric_color'] = \\\\\\n Color.lookup(data['alphanumeric_color'])\\n except KeyError:\\n raise ValueError('Unknown color \\\"%s\\\"; known colors %r' %\\n (data['alphanumeric_color'], Color.names()))\\n\\n if 'autonomous' in data:\\n if data['autonomous'] is not True and data['autonomous'] is not False:\\n raise ValueError('\\\"autonmous\\\" must be true or false')\\n\\n if 'actionable_override' in data:\\n if (data['actionable_override'] is not True and\\n data['actionable_override'] is not False): # yapf: disable\\n raise ValueError('\\\"actionable_override\\\" must be true or false')\\n\\n return data\",\n \"def cleaning (data):\",\n \"def _format_data(self, data: np.ndarray) -> np.ndarray:\\n self._n_circs = 0\\n self._n_shots = 0\\n self._n_slots = 0\\n self._n_iq = 0\\n\\n # identify shape\\n try:\\n # level1 single-shot data\\n self._n_circs, self._n_shots, self._n_slots, self._n_iq = data.shape\\n except ValueError:\\n try:\\n # level1 data averaged over shots\\n self._n_circs, self._n_slots, self._n_iq = data.shape\\n except ValueError as ex:\\n raise DataProcessorError(\\n f\\\"Data given to {self.__class__.__name__} is not likely level1 data.\\\"\\n ) from ex\\n\\n if self._validate:\\n if self._n_iq != 2:\\n raise DataProcessorError(\\n f\\\"IQ data given to {self.__class__.__name__} does not have two-dimensions \\\"\\n f\\\"(I and Q). Instead, {self._n_iq} dimensions were found.\\\"\\n )\\n\\n return data\",\n \"def _formatData(self):\\r\\n assert self._runData is not None\\r\\n\\r\\n # Getting Axes data into separate lists\\r\\n x=[]; y=[]; z=[]\\r\\n for i in range(len(self._runData)):\\r\\n ySet = []; xSet = []; zSet = []\\r\\n for _ in range(len(self._runData[i][1][0])):\\r\\n ySet.append(self._runData[i][0])\\r\\n y.append(ySet)\\r\\n xSet.append(self._runData[i][1][0])\\r\\n x.append(xSet)\\r\\n zSet.append(self._runData[i][1][1])\\r\\n z.append(zSet)\\r\\n\\r\\n # Reduce extra brackets\\r\\n xnew = []; znew = []\\r\\n for i in range(len(x)):\\r\\n xnew.append(x[i][0])\\r\\n znew.append(z[i][0])\\r\\n x = xnew; z = znew\\r\\n\\r\\n self._frequency = x\\r\\n self._voltages = y\\r\\n self._intensity = z\",\n \"def _format_data(self, data: np.ndarray) -> np.ndarray:\\n\\n self._n_shots = len(data[0])\\n self._n_circuits = len(data)\\n\\n if self._validate:\\n if data.shape[:2] != (self._n_circuits, self._n_shots):\\n raise DataProcessorError(\\n f\\\"The datum given to {self.__class__.__name__} does not convert \\\"\\n \\\"of an array with dimension (number of circuit, number of shots).\\\"\\n )\\n\\n return data\",\n \"def _format_data(self) -> None:\\n for row in self._db_data:\\n if row['age_start'] is None:\\n continue\\n # entry = {'x': 'Celkem', 'y': int(row['count'])}\\n elif row['age_start'] == 95:\\n entry = {'x': f\\\"{int(row['age_start'])}+\\\", 'y': int(row['count'])}\\n else:\\n entry = {'x': f\\\"{int(row['age_start'])}-{int(row['age_start'])+4}\\\", 'y': int(row['count'])}\\n self.return_data['data'].append(entry)\",\n \"def normalizeData(self, data):\\n return _normalizeData(data)\",\n \"def normalizeData(self, data):\\n return _normalizeData(data)\",\n \"def format_data(self, raw_data):\\n opz = raw_data.copy()\\n opz['datetime'] = pd.to_datetime(opz['Datum-tijd'], format='%Y-%m-%dT%H:%M:%SZ')\\n opz.drop(['Datum-tijd'],axis=1, inplace=True)\\n opz['dag']=opz['datetime'].dt.day\\n opz['tijd'] = opz['datetime'].dt.time\\n #voeg open/dicht data toe en bepaal momenten waarop dit wisselt\\n opz['Opzetstuk Noord (°)'] = opz['Opzetstuk Noord (°)'].str.replace(',', '.').astype(float)\\n opz['Opzetstuk Zuid (°)'] = opz['Opzetstuk Zuid (°)'].str.replace(',', '.').astype(float)\\n opz['Opzetstuk Noord (°)'].fillna(opz['Opzetstuk Zuid (°)'], inplace=True)\\n opz['Opzetstuk Zuid (°)'].fillna(opz['Opzetstuk Noord (°)'], inplace=True)\\n return opz\",\n \"def transform(self, data):\",\n \"def reformat():\\n toolkit.reformat()\",\n \"def _format_data(self, data: np.ndarray) -> np.ndarray:\\n self._n_shots = 0\\n\\n # identify shape\\n try:\\n # level1 single-shot data\\n self._n_circs, self._n_shots, self._n_slots, self._n_iq = data.shape\\n except ValueError:\\n try:\\n # level1 data averaged over shots\\n self._n_circs, self._n_slots, self._n_iq = data.shape\\n except ValueError as ex:\\n raise DataProcessorError(\\n f\\\"Data given to {self.__class__.__name__} is not likely level1 data.\\\"\\n ) from ex\\n\\n if self._validate:\\n if data.shape[-1] != 2:\\n raise DataProcessorError(\\n f\\\"IQ data given to {self.__class__.__name__} must be a multi-dimensional array\\\"\\n \\\"of dimension [d0, d1, ..., 2] in which the last dimension \\\"\\n \\\"corresponds to IQ elements.\\\"\\n f\\\"Input data contains element with length {data.shape[-1]} != 2.\\\"\\n )\\n\\n return data\",\n \"def prepare_data(self, data):\\n for i, v in data.items():\\n field_type = self.get_field_type(i)\\n #log.info('i = %s, type = %s', i, field_type)\\n if field_type == 'datetime' and isinstance(v, (str, unicode)):\\n data[i] = datetime_from_string(v)\\n return data\",\n \"def _process_data(data):\\n for array in data:\\n # Check if time is inverted. If so, reverse array while keeping the time/data structure.\\n if array and len(array) > 2 and array[0] > array[2]:\\n buff_1 = array[::2][::-1]\\n buff_2 = array[1::2][::-1]\\n array[::2] = buff_1\\n array[1::2] = buff_2\\n return data\",\n \"def format_data(data, is_feature1d=True, copy=False, make_float=True):\\n if data is None or issparse(data):\\n return data\\n\\n if make_float:\\n data = asfloat(data)\\n\\n if not isinstance(data, np.ndarray) or copy:\\n data = np.array(data, copy=copy)\\n\\n # Valid number of features for one or two dimensions\\n n_features = data.shape[-1]\\n\\n if data.ndim == 1:\\n data_shape = (n_features, 1) if is_feature1d else (1, n_features)\\n data = data.reshape(data_shape)\\n\\n return data\",\n \"def _format_data(self, data: np.ndarray) -> np.ndarray:\\n if self._validate:\\n if len(data.shape) <= self._axis:\\n raise DataProcessorError(\\n f\\\"Cannot average the {len(data.shape)} dimensional \\\"\\n f\\\"array along axis {self._axis}.\\\"\\n )\\n\\n return data\",\n \"def convertData(data):\\n\\n return data\",\n \"def from_multicsv(self,input_data):\\n reformatted_data = []\\n for (i,row) in enumerate(input_data):\\n if i==0:\\n headers = row\\n else:\\n data_row = {}\\n for (j,h) in enumerate(headers):\\n if j<len(row):\\n data_row.update({h : row[j]})\\n else:\\n data_row.update({h : 0})\\n reformatted_data.append(data_row)\\n return reformatted_data\",\n \"def preprocess(data):\\n\\tprint(\\\"\\\\n--------Data preview--------\\\\n{0}\\\".format(data.head()))\\n\\t# transform datatime columns to four columns includes the year、month、day、hour\\n\\tdata['year'] = pd.DatetimeIndex(data['datetime']).year\\n\\tdata['month'] = pd.DatetimeIndex(data['datetime']).month\\n\\tdata['day'] = pd.DatetimeIndex(data['datetime']).day\\n\\tdata['hour'] = pd.DatetimeIndex(data['datetime']).hour\\n\\n\\tdata[\\\"date\\\"] = data.datetime.apply(lambda x : x.split()[0])\\n\\tdata[\\\"weekday\\\"] = data.date.apply(lambda dateString :\\n\\t calendar.day_name[datetime.strptime(dateString,\\\"%Y-%m-%d\\\").weekday()])\\n\\t# after transformed delete the 'datatime' column\\n\\tdataDroped = data.drop(['datetime'], axis=1)\\n\\tprint(\\\"\\\\n-------\\\\nAfter preprocess(transform time display format to avoid object data type)\\\\n-------\\\")\\n\\treturn dataDroped\",\n \"def dataNormalize(data):\\n tr = re.sub('<(.*)>|\\\\\\\\n', '', data.prettify())\\n return re.sub(' +', ',', tr).split(',')\",\n \"def _pre_process_record(self, data):\\n result = []\\n symbolic_split = \\\",\\\"\\n if isinstance(data, dict):\\n if self.measure is None:\\n logging.error(\\\"Missing the name of keys pointing to values\\\")\\n raise UnSADException.data_format_exception()\\n if self.timestamp is not None:\\n if self.timestamp in data:\\n try:\\n result.append(float(data[self.timestamp]))\\n [result.append(data[measure])\\n for measure in self.measure]\\n except RuntimeError:\\n logging.error(\\\"Invalid input data type, should be a numerical type\\\")\\n logging.error(\\\"Input data should contain all the fields \\\"\\n \\\"that are specified when initialize the detector: \\\" + str(self.measure))\\n raise UnSADException.data_type_exception()\\n else:\\n logging.error(\\\"Input data should contain a timestamp field:\\\" + str(self.timestamp))\\n raise UnSADException.data_format_exception()\\n else:\\n try:\\n [result.append(data[measure]) for measure in self.measure]\\n except RuntimeError:\\n logging.error(\\\"Input data should contain all the fields \\\"\\n \\\"that are specified when initialize the detector: \\\" + str(self.measure))\\n raise UnSADException.data_format_exception()\\n elif isinstance(data, Iterable) and not isinstance(data, str):\\n if self.timestamp is not None:\\n if len(data) == len(self.measure) + 1:\\n try:\\n result = list(data)\\n result[0] = float(result[0])\\n except RuntimeError as e:\\n logging.error(\\\"Invalid input data type, timestamp should be a numerical type\\\")\\n raise UnSADException.data_type_exception()\\n else:\\n logging.error(\\\"The number of input parameters:\\\" + str(\\n len(data)) + \\\" does not match with this detectors:\\\" + str(len(self.measure) + 1))\\n raise UnSADException.input_number_exception()\\n else:\\n if self.measure is None or len(data) == len(self.measure):\\n result = data\\n else:\\n logging.error(\\\"The number of input parameters:\\\" + str(\\n len(data)) + \\\" does not match with this detectors:\\\" + str(len(self.measure)))\\n raise UnSADException.input_number_exception()\\n else:\\n if (self.measure is None or len(self.measure) == 1) and self.timestamp is None:\\n if self.symbolic:\\n return str(data)\\n else:\\n try:\\n return float(data)\\n except RuntimeError as e:\\n logging.error(\\\"Invalid input data type, should be a numerical type\\\")\\n raise UnSADException.data_type_exception()\\n else:\\n logging.error(\\\"This detector is not initialized properly\\\")\\n raise UnSADException.not_proper_initialize_exception()\\n\\n if not self.symbolic:\\n try:\\n processed_result = [float(result[i])\\n for i in range(len(result))]\\n except RuntimeError as e:\\n logging.error(\\\"Invalid input data type, should be a numerical type\\\")\\n raise UnSADException.data_type_exception()\\n\\n return processed_result[0] if len(processed_result) == 1 else processed_result\\n\\n else:\\n if self.timestamp is not None:\\n return [result[0], symbolic_split.join([str(s) for s in result[1:]])]\\n else:\\n return symbolic_split.join([str(s) for s in result])\",\n \"def _format_data(self):\\n formatted_data = []\\n\\n for row in self._data_agg_by_mean_value.iterrows():\\n \\n car_make = row[0]\\n mean_car_value = round(row[1][0], 2)\\n formatted_data.append({'car_make': car_make, 'mean_car_value': mean_car_value})\\n\\n return formatted_data\",\n \"def reformat(ctx):\\n pass\",\n \"def normalize_dataset(self):\",\n \"def format_data(self)->float: \\n try:\\n formatted = chr(self.data[0])\\n for i in range(1, len(self.data)): \\n formatted = formatted + (chr(self.data[i])) \\n return str(formatted)\\n except ValueError as e:\\n print(e)\\n except TypeError as e:\\n print(e)\",\n \"def cleanData(data):\\r\\n \\r\\n indexes = data.index[pd.isnull(data[\\\"release date\\\"])]\\r\\n # data = data.drop(data.index[[2172, 3781, 7245, 12475, 14756, 15292, 49295, 93523, 99723]],axis=0,inplace=False)\\r\\n data = data.drop(indexes,axis=0,inplace=False)\\r\\n data = data.drop([\\\"video release date\\\", 'IMDb URL'],axis=1)\\r\\n \\r\\n \\r\\n data.gender = data.gender.astype(\\\"category\\\")\\r\\n data.occupation = data.occupation.astype(\\\"category\\\")\\r\\n \\r\\n categorical_variables = [\\\"gender\\\", \\\"occupation\\\"]\\r\\n for variable in categorical_variables:\\r\\n dummies = pd.get_dummies(data[variable], prefix=variable)\\r\\n data = pd.concat([data, dummies], axis=1)\\r\\n data.drop([variable], axis=1, inplace=True)\\r\\n data['movieID'] = data['movieID'].astype('int')\\r\\n data['userID'] = data['userID'].astype('int')\\r\\n \\r\\n\\t#data = dateTime(data)\\r\\n \\r\\n return data\",\n \"def prepareData(self, *data):\\n arguments = 8\\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\\n self.model, self.annotations, self.args) = tuple(data[:arguments])\\n \\n self.width = self.args.beam_width\\n self.mathType = self.args.mathType\\n self.io_files = {\\n 'input': self.args.intermediate_input_files,\\n 'output': self.args.intermediate_output_files\\n }\\n self.repeat_width = self.args.repeat_width\\n self.cons_count = self.args.cons_count\\n self.posterior_processors = self.args.posterior_processors \\n\\n self.positionGenerator = \\\\\\n list(AlignmentBeamGenerator(self.alignment, self.width))\\n \\n for i in range(len(self.model.states)):\\n self.model.states[i].computeHints(self)\\n\\n return data[arguments:]\",\n \"def _data_normalization(data: list) -> list:\\n\\n return [ \\n [\\n d[0], # IP\\n d[1], # Port\\n Froxy._split_proxy_info(\\n d[2].strip(' ') # Proxy Info\\n ) \\n ]\\n for d in data\\n ]\",\n \"def reformat_data(matlab_data) -> dict:\\n data = dict()\\n data[\\\"significant_ripples\\\"] = matlab_data.SignificantRipples - 1\\n data[\\\"ripple_info\\\"] = matlab_data.RippleTimes\\n data[\\\"inhibitory_neurons\\\"] = (\\n np.array(matlab_data.InhibitoryNeurons) - 1\\n ) # account for matlab indexing\\n data[\\\"excitatory_neurons\\\"] = (\\n matlab_data.ExcitatoryNeurons - 1\\n ) # account for matlab indexing\\n data[\\\"well_locations\\\"] = matlab_data.WellLocations\\n data[\\\"well_sequence\\\"] = matlab_data.WellSequence\\n data[\\\"spike_ids\\\"] = matlab_data.SpikeData[:, 1].astype(int) - 1\\n data[\\\"spike_times_s\\\"] = matlab_data.SpikeData[:, 0]\\n data[\\\"pos_times_s\\\"] = matlab_data.PositionData[:, 0]\\n data[\\\"pos_xy_cm\\\"] = np.squeeze(matlab_data.PositionData[:, 1:-1])\\n data[\\\"ripple_times_s\\\"] = data[\\\"ripple_info\\\"][:, :2]\\n data[\\\"n_ripples\\\"] = len(data[\\\"ripple_times_s\\\"])\\n data[\\\"n_cells\\\"] = np.max(data[\\\"spike_ids\\\"] + 1)\\n return data\",\n \"def format_rec_data(tr_data, village, HC, gs_pars, vfeatures, idx_pars=[]):\\n\\n print('\\\\nFormatting recorded data...')\\n ret_list = []\\n\\n gs_xvec, gs_yvec = [utils.get_copy(gs_pars[v]) for v in ['xvec', 'yvec']]\\n\\n if 'anim_data' in tr_data:\\n\\n anim_data = pd.DataFrame(tr_data['anim_data']).T\\n ret_list.append(anim_data)\\n\\n if 'stim_data' in tr_data:\\n\\n # Motor input.\\n mot_keys = ['umot', 'vmot']\\n mot_data = {i: pd.DataFrame({k: d[k] for k in mot_keys}).unstack()\\n for i, d in tr_data['stim_data'].items() if d is not None}\\n mot_data = pd.DataFrame(mot_data).T\\n mot_data.columns.set_levels(['x', 'y'], level=1, inplace=True)\\n ret_list.append(mot_data)\\n\\n # Visual input.\\n vis_keys = ['ovis', 'vvis']\\n vis_data = {i: pd.DataFrame({k: d[k] for k in vis_keys}).unstack()\\n for i, d in tr_data['stim_data'].items() if d is not None}\\n vis_data = pd.DataFrame(vis_data).T\\n vis_data.columns.set_levels(vfeatures, level=1, inplace=True)\\n ret_list.append(vis_data)\\n\\n if 'gs_state' in tr_data:\\n\\n gs_state = {k: pd.DataFrame(gs, columns=gs_xvec, index=gs_yvec)\\n for k, gs in tr_data['gs_state'].items()}\\n gs_state = pd.concat(gs_state)\\n gs_state.columns.rename('x', inplace=True)\\n gs_state.index.rename('y', level=-1, inplace=True)\\n ret_list.append(gs_state)\\n\\n if 'hc_state' in tr_data:\\n\\n hc_state = {k: pd.DataFrame(hc, index=HC.s_names)\\n for k, hc in tr_data['hc_state'].items()}\\n hc_state = pd.concat(hc_state)\\n hc_state.index.rename('loc', level=-1, inplace=True)\\n hc_state = hc_state[HC.s_types] # reorder columns\\n ret_list.append(hc_state)\\n\\n if 'vs_state' in tr_data:\\n\\n vs_state = {k: pd.Series(vc, index=HC.s_names)\\n for k, vc in tr_data['vs_state'].items()}\\n vs_state = pd.concat(vs_state)\\n ret_list.append(vs_state)\\n\\n if 'dls_state' in tr_data:\\n\\n dls_state = {k: pd.DataFrame(dls, columns=HC.s_names, index=village.U)\\n for k, dls in tr_data['dls_state'].items()}\\n dls_state = pd.concat(dls_state)\\n dls_state.columns.rename('s', inplace=True)\\n dls_state.index.rename('u', level=-1, inplace=True)\\n ret_list.append(dls_state)\\n\\n # Set index level names.\\n idx_lvl_names = idx_pars + ['step']\\n for df in ret_list:\\n levels = (None if not isinstance(df.index, pd.core.index.MultiIndex)\\n else list(range(len(idx_lvl_names))))\\n df.index.set_names(idx_lvl_names, level=levels, inplace=True)\\n\\n return ret_list\",\n \"def format_row(row):\\n assert isinstance(row,list)\\n \\n data_row=[0]*len(header) #Formatted data row to be output and appeneded to 'data'\\n \\n for i in [0,1,11,13,14,15,16,17,19,20,21,28,31,45,46,47,48]: data_row[i]=row[i] #emptry string will NOT return None\\n for i in [2,3,12,18]: data_row[i]=type_cast(lambda x: int(float(x)),row[i])\\n for i in [6,7,8,9,10,23,24,25,26,27,29,30]: data_row[i]=type_cast(float,row[i])\\n for i in [4,5,22]: data_row[i]=type_cast(datetime.strptime,row[i],'%Y-%m-%d %H:%M:%S')\\n for i in range(32,45):\\n if row[i]=='False': data_row[i]=False #bool('False') returns True!\\n elif row[i]=='True': data_row[i]=True\\n else: data_row[i]=None\\n return data_row\",\n \"def formatRecvdData(data_recvd):\\n\\n\\t##############\\tADD YOUR CODE HERE\\t##############\\n\\t\\n\\tx = PrettyTable()\\n\\t\\t\\n\\tdict2 = eval(data_recvd)\\n\\t\\t\\n\\tx.field_names=[\\\"OPTION_NUMBER\\\",\\\"OPTIONS\\\",\\\"ADDITIONAL INFO\\\"]\\n\\tfor key,value in dict2.items():\\n\\t\\tvalue = str(value)\\n\\t\\tif '{' in value:\\n\\t\\t\\t\\td = eval(value)\\n\\t\\t\\t\\tfor i,j in d.items():\\n\\n\\t\\t\\t\\t\\tx.add_row([key,i,j])\\n\\t\\t\\t\\t\\n\\t\\telse:\\n\\t\\t\\t\\t\\n\\t\\t\\tx.add_row([key,value,\\\"-\\\"])\\n\\tprint(x)\\n\\t\\n\\n\\t##################################################\",\n \"def clean_data(data):\\n \\n cols = data.columns\\n \\n #these columns had some extra characters in the strings becuase of encoding issues\\n list_to_strip=[\\n 'attributes_alcohol',\\n 'attributes_restaurantsattire',\\n 'attributes_wifi',\\n 'attributes_smoking',\\n 'attributes_noiselevel',\\n ]\\n #this removes quotation marks and u's from strings\\n \\n for col in list_to_strip:\\n data[col]=data[col].str.strip(\\\"u\\\\'\\\")\\n \\n #this replaces the strings None and none with Nan objects\\n for col in cols:\\n data[col]=data[col].where(data[col]!='None')\\n data[col]=data[col].where(data[col]!='none')\\n \\n #this creates a list of categorical and numerical features\\n categorical_features = cols.drop([\\n 'review_count',\\n 'restaurant',\\n 'latitude',\\n 'longitude',\\n 'business_id',\\n 'meanfunny',\\n 'meanuseful',\\n 'avgwordcount',\\n 'maxwordcount',\\n 'minwordcount',\\n 'avgfunnywordcount',\\n 'maxfunnywordcount',\\n 'avgusefulwordcount',\\n 'maxusefulwordcount',\\n 'medianwordcount',\\n 'upperquartilewordcount',\\n 'lowerquartilewordcount',\\n 'target'])\\n \\n \\n numerical_features = [\\n 'review_count',\\n 'latitude',\\n 'longitude',\\n 'meanfunny',\\n 'meanuseful',\\n 'avgwordcount',\\n 'maxwordcount',\\n 'minwordcount',\\n 'avgfunnywordcount',\\n 'maxfunnywordcount',\\n 'avgusefulwordcount',\\n 'maxusefulwordcount',\\n 'medianwordcount',\\n 'upperquartilewordcount',\\n 'lowerquartilewordcount']\\n \\n #this replaces the categorial nans with 9 as a placeholder and fills numerical nans with 0\\n data[categorical_features]=data[categorical_features].fillna(9)\\n data[numerical_features]=data[numerical_features].fillna(0)\\n \\n #this makes all the categorical columns strings\\n data[categorical_features]=data[categorical_features].astype(str)\\n data = data\\n \\n return data, numerical_features, categorical_features\",\n \"def _prepare_and_validate_data(self,data_list):\\n pos=0\\n list_pos=0\\n format=\\\"\\\"\\n length=0\\n value=\\\"\\\"\\n\\n #check number of items in data_list is as expected\\n if(self.data_lookup.count()['type']!=len(data_list)):\\n raise NumItemsError(\\\"Wrong number of items for the data type\\\")\\n\\n #loop over data from data_types.csv and populate\\n for index,row in self.data_lookup.iterrows():\\n length=int(row['Bytes'])\\n\\n #obtain format type\\n if (row['Format']=='byte'):\\n format=int\\n elif (row['Format']=='string'):\\n format=str\\n\\n #obtain limits\\n try:\\n min=int(row['Min'],16)\\n max=int(row['Max'],16)\\n except:\\n min='*'\\n max='*'\\n\\n #check format type\\n if (isinstance(data_list[list_pos],format)):\\n #correct format type\\n if format==str:\\n value=data_list[list_pos].encode()\\n elif format==int:\\n value=data_list[list_pos].to_bytes(length,'little')\\n\\n #check limits if int type\\n if min=='*' or max == '*':\\n pass\\n elif int(data_list[list_pos]) >= min and int(data_list[list_pos]) <= max:\\n pass\\n else:\\n raise ValueError(\\\"value\\\",int(value),\\\"is out of range, min:\\\",min,\\\"max:\\\",max)\\n else:\\n raise TypeError(\\\"Unknown type, can currently only handle string or integer types\\\")\\n #populate data\\n for n in range(0,length):\\n self.data[pos+n]=value[n]\\n pos=pos+length\\n list_pos=list_pos+1\\n else:\\n raise TypeError(\\\"expected\\\",format,\\\"got\\\",type(data_list[list_pos]),\\\"at position\\\",list_pos)\\n return True\",\n \"def _format_data(self, data, charset):\\n\\n return self._encode_data(data) if data else u''\",\n \"def preprocess(data):\\n raise NotImplementedError\",\n \"def _format_data(self, data: np.ndarray) -> np.ndarray:\\n valid_count_type = int, np.integer\\n\\n if self._validate:\\n for datum in data:\\n if not isinstance(datum, dict):\\n raise DataProcessorError(\\n f\\\"Data entry must be dictionary of counts, received {type(datum)}.\\\"\\n )\\n for bit_str, count in datum.items():\\n if not isinstance(bit_str, str):\\n raise DataProcessorError(\\n f\\\"Key {bit_str} is not a valid count key in {self.__class__.__name__}.\\\"\\n )\\n if not isinstance(count, valid_count_type):\\n raise DataProcessorError(\\n f\\\"Count {bit_str} is not a valid count for {self.__class__.__name__}. \\\"\\n \\\"The uncertainty of probability is computed based on sampling error, \\\"\\n \\\"thus the count should be an error-free discrete quantity \\\"\\n \\\"representing the frequency of event.\\\"\\n )\\n\\n return data\",\n \"def format_data(self, data):\\n # data or full_score is a list of tuples, here return just NPClassScore\\n formatted_data = None # default when there is no score (missing class)\\n if data:\\n # there is a score\\n formatted_data = f'{data[0][0]:.3f}'\\n return formatted_data\",\n \"def reformat_events(self, data, features):\\n # Update alias\\n if isinstance(features, list):\\n [x.update(dict(alias=self.alias[(x[features[0]],\\n x[features[1]])])) for x in data]\\n else:\\n [x.update(dict(alias=self.alias[x[features]])) for x in data]\\n temp_data = list()\\n # define ordering keys and columns\\n if self.one_timestamp:\\n columns = ['alias', 'duration', 'dur_act_norm']\\n sort_key = 'end_timestamp'\\n else:\\n sort_key = 'start_timestamp'\\n columns = ['alias', 'processing_time',\\n 'proc_act_norm', 'waiting_time', 'wait_act_norm']\\n data = sorted(data, key=lambda x: (x['caseid'], x[sort_key]))\\n for key, group in itertools.groupby(data, key=lambda x: x['caseid']):\\n trace = list(group)\\n temp_dict = dict()\\n for col in columns:\\n serie = [y[col] for y in trace]\\n if col == 'alias':\\n temp_dict = {**{'profile': serie}, **temp_dict}\\n else:\\n serie = [y[col] for y in trace]\\n temp_dict = {**{col: serie}, **temp_dict}\\n temp_dict = {**{'caseid': key, 'start_time': trace[0][sort_key],\\n 'end_time': trace[-1][sort_key]},\\n **temp_dict}\\n temp_data.append(temp_dict)\\n return sorted(temp_data, key=itemgetter('start_time'))\",\n \"def reformat(x):\\n x = x.permute(0, 2, 3, 1)\\n N, D1, D2, Feat = x.size()\\n x = x.view(N, D1 * D2, Feat)\\n return x\",\n \"def reformat(x):\\n x = x.permute(0, 2, 3, 1)\\n N, D1, D2, Feat = x.size()\\n x = x.view(N, D1 * D2, Feat)\\n return x\",\n \"def preprocess_data(data):\\n def deal_line(line):\\n pos, rating = line.split(',')\\n row, col = pos.split(\\\"_\\\")\\n row = row.replace(\\\"r\\\", \\\"\\\")\\n col = col.replace(\\\"c\\\", \\\"\\\")\\n return int(row), int(col), float(rating)\\n\\n def statistics(data):\\n row = set([line[0] for line in data])\\n col = set([line[1] for line in data])\\n return min(row), max(row), min(col), max(col)\\n\\n # parse each line\\n data = [deal_line(line) for line in data]\\n\\n # do statistics on the dataset.\\n min_row, max_row, min_col, max_col = statistics(data)\\n print(\\\"number of items: {}, number of users: {}\\\".format(max_row, max_col))\\n\\n # build rating matrix.\\n ratings = sp.lil_matrix((max_row, max_col))\\n for row, col, rating in data:\\n ratings[row - 1, col - 1] = rating\\n return ratings\",\n \"def _separate_raw_data(self, raw_data):\\n for key, value in raw_data.items():\\n if type(value) == dict:\\n self.data_dict[key] = value\\n elif type(value) == list:\\n self.data_list[key] = value\",\n \"def FormatOutput( data ):\\n nColumn = len(data[0])\\n nRow = len(data)\\n\\n i = 0\\n oData = []\\n while i < nRow:\\n tmp = ', '.join( str(x) for x in data[i] )\\n oData.append(tmp)\\n i += 1\\n \\n return oData\",\n \"def _format_data(self, data: np.ndarray) -> np.ndarray:\\n self._n_shots = 0\\n\\n # identify shape\\n try:\\n # level1 single-shot data\\n self._n_circs, self._n_shots, self._n_slots, self._n_iq = data.shape\\n except ValueError as ex:\\n raise DataProcessorError(\\n f\\\"The data given to {self.__class__.__name__} does not have the shape of \\\"\\n \\\"single-shot IQ data; expecting a 4D array.\\\"\\n ) from ex\\n\\n if self._validate:\\n if data.shape[-1] != 2:\\n raise DataProcessorError(\\n f\\\"IQ data given to {self.__class__.__name__} must be a multi-dimensional array\\\"\\n \\\"of dimension [d0, d1, ..., 2] in which the last dimension \\\"\\n \\\"corresponds to IQ elements.\\\"\\n f\\\"Input data contains element with length {data.shape[-1]} != 2.\\\"\\n )\\n\\n if self._validate:\\n if isinstance(self._discriminator, list):\\n if self._n_slots != len(self._discriminator):\\n raise DataProcessorError(\\n f\\\"The Discriminator node has {len(self._discriminator)} which does \\\"\\n f\\\"not match the {self._n_slots} slots in the data.\\\"\\n )\\n\\n return unp.nominal_values(data)\",\n \"def reformat_data(inp):\\n lines = iter(inp)\\n\\n # First, find the start of the map records, which we assume for the moment\\n # is the line that starts with 'CASEID'.\\n for line in lines:\\n if line.startswith('CASEID'):\\n break\\n else:\\n print(\\\"CASEID record not found\\\")\\n return\\n\\n while True:\\n specline = line.strip()\\n values = []\\n for line in lines:\\n if line[0].strip():\\n # Start of next block.\\n break\\n values.append(line.strip())\\n yield reformat_block(specline, values)\\n if not line[0].strip() or line.startswith('-------------'):\\n # End of data, because either we've seen the line introducing\\n # the footer, or 'line' still has the last line in it, that\\n # didn't have a non-blank first character.\\n break\",\n \"def reformat_chalendar(raw):\\n # where we have variable (NG = net generation) and fuel type\\n target_cols = [c for c in raw.columns if len(c.split(\\\".\\\")) == 5]\\n logger.info(\\\"Filtering\\\")\\n cleaned = (\\n raw.loc[:, target_cols]\\n .melt(ignore_index=False, value_name=\\\"generation\\\", var_name=\\\"variable\\\")\\n .reset_index()\\n )\\n logger.info(\\\"Expanding cols\\\")\\n cleaned[[\\\"dtype\\\", \\\"BA\\\", \\\"other BA\\\", \\\"var\\\", \\\"fuel\\\", \\\"interval\\\"]] = cleaned[\\n \\\"variable\\\"\\n ].str.split(r\\\"[.-]\\\", expand=True, regex=True)\\n logger.info(\\\"Dropping and renaming\\\")\\n cleaned = cleaned.drop(columns=[\\\"dtype\\\", \\\"var\\\", \\\"interval\\\", \\\"other BA\\\"])\\n cleaned = cleaned.rename(columns={\\\"index\\\": \\\"datetime_utc\\\"})\\n return cleaned\",\n \"def preprocess_data(self, data, scale_data=True):\\n print(\\\"preprocess_data not implemented\\\")\\n return data\",\n \"def _process_data(self):\\r\\n # Rename columns to match final feature class\\r\\n self._rename_columns()\\r\\n # Add point ID column\\r\\n self._add_pointid()\\r\\n # Sort rows by transect id and timestamp\\r\\n self._sort_rows()\\r\\n # Fill Null records with a value\\r\\n self._fill_nulls()\\r\\n # Set site_code to lower case\\r\\n self._lower_site_code()\\r\\n # Create survey_id\\r\\n self._calc_survey_id()\\r\\n # Calculate nativesg column if at least one of the veg columns is a Native seagrass type\\r\\n if set(self.veg_columns).intersection(set(NATIVESG_CODES)) > 0:\\r\\n self.nativesg_columns = list(set(self.veg_columns).intersection(set(NATIVESG_CODES)))\\r\\n self._calc_nativesg()\\r\\n #\\r\",\n \"def clean_data(data):\\n # switch dict to flip the names of the RE data set to match SF\\n col_switch = {'fund_id': 'project_id',\\n 'gift_count': 'record_count.5',\\n 'total': 'sum_of_amount.5'}\\n\\n # define package items\\n dfs = data[0]\\n args = data[1]\\n\\n # clean columns in dataframes\\n for df in dfs:\\n df.columns = [x.lower() for x in df.columns]\\n if 'fund id' in df.columns:\\n df.columns = [x.lower().replace(' ', '_') for x in df.columns]\\n df['source'] = 'RE'\\n df.rename(columns=col_switch, inplace=True)\\n else:\\n df.columns = [x.lower().replace(' ', '_') for x in df.columns]\\n df['source'] = 'SF'\\n df.drop(columns=['sum_of_amount', 'record_count', 'sum_of_amount.1', 'record_count.1', 'sum_of_amount.2',\\n 'record_count.2', 'sum_of_amount.3',\\n 'record_count.3', 'sum_of_amount.4', 'record_count.4'], inplace=True)\\n\\n # standardize project_IDs\\n for df in dfs:\\n df['project_id_new'] = df['project_id'].apply(lambda x: x.strip() if isinstance(x, str) else x)\\n df['project_id_new'] = df['project_id_new'].apply(\\n lambda x: x.replace(' - ', '-').lower() if isinstance(x, str) and '-' in x else x)\\n df['project_id_new'] = df['project_id_new'].apply(\\n lambda x: x.replace('- ', '-').lower() if isinstance(x, str) and '-' in x else x)\\n df['project_id_new'] = df['project_id_new'].apply(\\n lambda x: x.replace(' -', '-').lower() if isinstance(x, str) and '-' in x else x)\\n df['project_id_new'] = df['project_id_new'].apply(\\n lambda x: x.replace('-', '_').lower() if isinstance(x, str) and '-' in x else x)\\n df['project_id_new'] = df['project_id_new'].apply(\\n lambda x: x.replace(' ', '_').lower() if isinstance(x, str) and ' ' in x else x)\\n df['project_id_new'] = df['project_id_new'].apply(lambda x: x.lower() if isinstance(x, str) else x)\\n\\n # standardize sum_of_amount\\n for df in dfs:\\n df['sum_of_amount_new'] = df['sum_of_amount.5'].apply(lambda x: x.strip() if isinstance(x, str) else x)\\n df['sum_of_amount_new'] = df['sum_of_amount_new'].apply(\\n lambda x: x.replace('USD', '').lower() if isinstance(x, str) and 'USD' in x else x)\\n df['sum_of_amount_new'] = df['sum_of_amount_new'].apply(\\n lambda x: x.replace('$', '').lower() if isinstance(x, str) and '$' in x else x)\\n df['sum_of_amount_new'] = df['sum_of_amount_new'].apply(\\n lambda x: x.replace(',', '').lower() if isinstance(x, str) and ',' in x else x)\\n df['sum_of_amount_new'] = df['sum_of_amount_new'].apply(\\n lambda x: float(\\\"{0:.2f}\\\".format(float(x))) if isinstance(x, str) else x)\\n\\n return dfs, args\",\n \"def _format_data(self, data: CurveData) -> CurveData:\\n # take average over the same x value by keeping sigma\\n series, xdata, ydata, sigma, shots = multi_mean_xy_data(\\n series=data.data_index,\\n xdata=data.x,\\n ydata=data.y,\\n sigma=data.y_err,\\n shots=data.shots,\\n method=\\\"shots_weighted\\\",\\n )\\n\\n # sort by x value in ascending order\\n series, xdata, ydata, sigma, shots = data_sort(\\n series=series,\\n xdata=xdata,\\n ydata=ydata,\\n sigma=sigma,\\n shots=shots,\\n )\\n\\n return CurveData(\\n label=\\\"fit_ready\\\",\\n x=xdata,\\n y=ydata,\\n y_err=sigma,\\n shots=shots,\\n data_index=series,\\n )\",\n \"def processData (data, result):\\n TITLE = 1\\n YEAR = 2\\n for d in data:\\n # create key by using the given indices to find the title and year\\n key = (d[TITLE].strip(), d[YEAR].strip())\\n # create value from the remaining elements in the information list\\n value = d[0:TITLE] + d[YEAR+1:]\\n # add data to dictionary\\n if key not in result:\\n result[key] = []\\n result[key] += value\\n # OR:\\n # result[key] = result.get(key, []) + value\\n return result\",\n \"def _transform_map_data(self):\\n WARD_FMT = '%s-%s'\\n self.map_data_trans = []\\n lookup = {i.column: ''.join(filter(lambda x: x.isdigit(), i.value)) for i in self.sht[1]}\\n\\n #skip over header\\n rs = iter(self.sht.rows)\\n next(rs)\\n next(rs)\\n for r in rs:\\n pka = r[0].value\\n for c in r[1:]:\\n if c.value is None:\\n c.value = 0\\n\\n self.map_data_trans.append((WARD_FMT%(pka, lookup[c.column]), c.value))\",\n \"def clean_data(data):\\n src_list = []\\n no_net_view = []\\n for row in range(data.nrows):\\n # Ignore header row.\\n if row == 0:\\n continue\\n # Ignore blank row.\\n if data.row_values(row)[1] == '' and \\\\\\n data.row_values(row)[15] == '':\\n continue\\n # Capture lines that do not have a view listed.\\n if data.row_values(row)[1] and not data.row_values(row)[15]:\\n no_net_view.append(data.row_values(row))\\n continue\\n src_list.append(data.row_values(row))\\n\\n # Clean's src_list values.\\n src_list = [[item.replace('\\\\t', '') for item in row\\n if isinstance(item, str)]\\n for row in src_list]\\n src_list = [[item.replace('\\\\n', ', ') for item in row\\n if isinstance(item, str)]\\n for row in src_list]\\n src_list = [[item.replace(', ,', ', ') for item in row\\n if isinstance(item, str)]\\n for row in src_list]\\n src_list = [[item.strip() for item in row\\n if isinstance(item, str)]\\n for row in src_list]\\n for enum, row in enumerate(src_list):\\n row[0] = row[0].lower()\\n src_list[enum] = row\\n return src_list\",\n \"def __call__(data, source_format, target_format):\",\n \"def _format_data(data, block_numbers, one_hot_encode):\\n\\n X = []\\n Y = []\\n\\n data = data.split(\\\"\\\\n\\\\n\\\")[:-1]\\n\\n block_cursor = 0\\n speaker_cursor = 0\\n for block in data:\\n\\n if block_cursor >= block_numbers[speaker_cursor]:\\n block_cursor = 0\\n speaker_cursor += 1\\n\\n X.append(np.loadtxt(io.StringIO(block)))\\n\\n if one_hot_encode:\\n Y.append(ONE_HOT_SPEAKERS[speaker_cursor].reshape(1, -1))\\n else:\\n Y.append(np.array([SPEAKERS[speaker_cursor]]).reshape(1, 1))\\n\\n block_cursor += 1\\n\\n return X, Y\",\n \"def normalize_values(self, data):\\n\\n df = pd.DataFrame(data[1:], columns = data[0]).astype(str)\\n\\n df = df.replace(ami_md_constants.NAS)\\n\\n df = df.replace(ami_md_constants.REGEX_REPLACE_DICT, regex=True)\\n df = df.replace(ami_md_constants.STRING_REPLACE_DICT)\\n df['source.object.format_type'] = df['source.object.format'].map(ami_md_constants.FORMAT_TYPE)\\n\\n for key in ami_md_constants.MEASURE_UNIT_MAPS.keys():\\n value_map = ami_md_constants.MEASURE_UNIT_MAPS[key]\\n df = self.map_value(df,\\n value_map['from_column'],\\n value_map['to_column'],\\n value_map['constant_value'],\\n value_map['values_map_column'],\\n value_map['values_map'])\\n\\n #force all the numerics back to numeric, and drop all empty columns\\n df = df.apply(pd.to_numeric, errors='ignore').dropna(axis=1, how = \\\"all\\\")\\n\\n vals = df.values.tolist()\\n cols = df.columns.tolist()\\n vals.insert(0, cols)\\n\\n return vals\",\n \"def clean_recording_data(self, raw_data: dict) -> dict:\\n (\\n pos_xy_aligned,\\n pos_times_aligned,\\n spike_ids_aligned,\\n spike_times_aligned,\\n ) = self.align_spike_and_position_recording_data(\\n raw_data[\\\"pos_xy_cm\\\"],\\n raw_data[\\\"pos_times_s\\\"],\\n raw_data[\\\"spike_ids\\\"],\\n raw_data[\\\"spike_times_s\\\"],\\n )\\n (\\n pos_xy_gaps_aligned_and_cleaned,\\n large_position_gaps_inds,\\n ) = self.clean_recording_gaps(pos_xy_aligned, pos_times_aligned)\\n # store cleaned data in new dictionary\\n cleaned_data = raw_data.copy()\\n cleaned_data[\\\"pos_xy_cm\\\"] = pos_xy_gaps_aligned_and_cleaned\\n cleaned_data[\\\"pos_times_s\\\"] = pos_times_aligned\\n cleaned_data[\\\"spike_ids\\\"] = spike_ids_aligned\\n cleaned_data[\\\"spike_times_s\\\"] = spike_times_aligned\\n cleaned_data[\\\"large_position_gaps_inds\\\"] = large_position_gaps_inds\\n return cleaned_data\",\n \"def cleanData(rawData):\\n\\trawData = re.sub(r'R-LRB- \\\\(', r'R-LRB- -LRB-', rawData)\\n\\trawData = re.sub(r'R-RRB- \\\\)', r'R-RRB- -RRB-', rawData)\\n\\trawData = re.sub(r'R-RRB- \\\\(', r'R-RRB- -LRB-', rawData)\\n\\trawData = re.sub(r'-LRB- \\\\(', r'-LRB- -LRB-', rawData)\\n\\trawData = re.sub(r'-RRB- \\\\)', r'-RRB- -RRB-', rawData)\\n\\trawData = re.sub(r'PU \\\\(', r'PU -LRB-', rawData)\\n\\trawData = re.sub(r'PU \\\\)', r'PU -RRB-', rawData)\\n\\trawData = re.sub(r':-\\\\)', r'smileyface', rawData)\\n\\n\\treturn rawData\",\n \"def reformat(self, newformat):\\n # check whether the column is defined\\n if self._defined:\\n # get the appropriate null-format\\n nullformat = self._get_nullformat(newformat)\\n # set the new formats\\n self._format = [newformat, nullformat]\\n else:\\n # first the column type must be defined\\n raise Exception('The data type of this column is not yet defined!')\",\n \"def transform_data(redcap_data_json):\\n redcap_data = pd.DataFrame(redcap_data_json)\\n redcap_data.to_csv('data.csv')\\n\\n # Split data by event type\\n enrollment_data = redcap_data[redcap_data['redcap_event_name']=='Enrollment']\\n survey_data = redcap_data[redcap_data['redcap_event_name']!='Enrollment']\\n survey_data['redcap_event_name'] = survey_data['redcap_event_name'].apply(lambda x: datetime.datetime(int(x[0:4]), int(x[5:7]), int(x[8:10]), 1, 0) if x[11:13] == \\\"AM\\\" else datetime.datetime(int(x[0:4]), int(x[5:7]), int(x[8:10]), 13, 0))\\n\\n # Exclude/Include relevant columns\\n enrollment_data = enrollment_data[\\n [\\n 'record_id',\\n 'redcap_event_name',\\n 'ministry',\\n 'facility',\\n 'email',\\n 'am_email_1',\\n 'am_email_2',\\n 'am_email_3',\\n 'am_email_4',\\n 'am_email_5',\\n 'am_email_6',\\n 'pm_email_1',\\n 'pm_email_2',\\n 'pm_email_3',\\n 'pm_email_4',\\n 'pm_email_5',\\n 'pm_email_6',\\n 'april_trigger',\\n 'may_trigger',\\n 'june_trigger',\\n 'july_trigger',\\n 'contact_market_facility_complete'\\n ]\\n ]\\n\\n survey_data = survey_data.drop(\\n [\\n 'email',\\n 'am_email_1',\\n 'am_email_2',\\n 'am_email_3',\\n 'am_email_4',\\n 'am_email_5',\\n 'am_email_6',\\n 'pm_email_1',\\n 'pm_email_2',\\n 'pm_email_3',\\n 'pm_email_4',\\n 'pm_email_5',\\n 'pm_email_6',\\n 'april_trigger',\\n 'may_trigger',\\n 'june_trigger',\\n 'july_trigger',\\n 'contact_market_facility_complete'\\n ], axis=1)\\n\\n # Fill Missing Data\\n survey_data = survey_data.replace(\\\"\\\", np.nan) # Replace all empty strings with nan\\n survey_data = survey_data.fillna(survey_data.groupby('record_id').ffill()) # Forward fill missing data\\n survey_data = survey_data.fillna(survey_data.groupby('record_id').bfill()) # Backward fill missing data\\n\\n # Fill in survey data ministry and facility\\n facility_params = {\\n '40011': {'facility': 'StV Evansville Med Ctr', 'ministry': 'ININD'},\\n '40017': {'facility': 'StV Warrick Hosp', 'ministry': 'ININD'},\\n '46006': {'facility': 'StV Heart Ctr Indiana', 'ministry': 'ININD'},\\n '46013': {'facility': 'St Vincent Seton Spec Hosp Indianapolis', 'ministry': 'ININD'},\\n '46018': {'facility': 'StV Kokomo Hosp', 'ministry': 'ININD'},\\n '46019': {'facility': 'StV Anderson Reg Hosp', 'ministry': 'ININD'},\\n '46024': {'facility': 'StV Carmel Hosp', 'ministry': 'ININD'},\\n '46029': {'facility': 'StV Indianapolis Hosp', 'ministry': 'ININD'},\\n '46033': {'facility': 'StV Jennings Hosp', 'ministry': 'ININD'},\\n '46036': {'facility': 'StV Mercy Hosp', 'ministry': 'ININD'},\\n '46042': {'facility': 'StV Salem Hosp', 'ministry': 'ININD'},\\n '46043': {'facility': 'StV Stress Ctr', 'ministry': 'ININD'},\\n '46045': {'facility': 'StV Williamsport Hosp', 'ministry': 'ININD'},\\n '46047': {'facility': 'StV Clay Hosp', 'ministry': 'ININD'},\\n '46048': {'facility': 'StV Randolph Hosp', 'ministry': 'ININD'},\\n '46052': {'facility': 'StV Dunn Hosp', 'ministry': 'ININD'},\\n '46055': {'facility': 'StV Fishers', 'ministry': 'ININD'}\\n }\\n\\n survey_data['ministry'] = survey_data.apply(lambda x: facility_params.get(x['record_id'], {}).get('ministry'), axis=1)\\n survey_data['facility'] = survey_data.apply(lambda x: facility_params.get(x['record_id'], {}).get('facility'), axis=1)\\n\\n return enrollment_data, survey_data\",\n \"def _process_stats_data(self, graph_rule, trans_stats_data):\\n formatted_data = {}\\n translation_data = {}\\n if graph_rule:\\n formatted_data['graph_rule'] = graph_rule\\n if trans_stats_data.get('branch'):\\n formatted_data['branch'] = trans_stats_data['branch']\\n ticks = trans_stats_data.get('ticks')\\n labels = {}\\n [labels.update({index: val}) for index, val in ticks]\\n graph_data = trans_stats_data.get('graph_data', {})\\n for unit in graph_data:\\n temp_stat = {}\\n stat = unit.get('data', [])\\n for index, val in stat:\\n temp_stat.update({labels.get(index): val})\\n translation_data[unit.get('label', 'label')] = temp_stat\\n formatted_data['translation_stats'] = translation_data\\n return formatted_data\",\n \"def _process_stats_data(self, trans_stats_data):\\n formatted_data = {}\\n translation_data = {}\\n if trans_stats_data.get('pkg_desc'):\\n formatted_data['description'] = trans_stats_data['pkg_desc']\\n ticks = trans_stats_data.get('ticks')\\n labels = {}\\n [labels.update({index: val}) for index, val in ticks]\\n graph_data = trans_stats_data.get('graph_data', {})\\n for branch, data in graph_data.items():\\n new_trans_data = {}\\n for index, stat in data:\\n new_trans_data.update({labels.get(index): stat})\\n translation_data[branch] = new_trans_data\\n formatted_data['translation_stats'] = translation_data\\n formatted_data['percentage_calculated_on'] = \\\"Messages\\\"\\n return formatted_data\",\n \"def parse_datum( self, data ):\\n return data\",\n \"def parse_datum( self, data ):\\n return data\",\n \"def format_data(arr, dimen, data_type):\\n\\tif type(dimen) != tuple:\\n\\t\\tprint(\\\"Error: expected tuple type.\\\")\\n\\t\\treturn None\\n\\tfactor = int(dimen[1] / dimen[0])\\n\\treturn {\\n\\t\\t\\\"train\\\": [np.reshape(row, dimen) for row in arr],\\n\\t\\t\\\"test\\\": [np.hsplit(row, factor) for row in arr]\\n\\t}.get(data_type)\",\n \"def FixFloats(Data):\\n\\n if isinstance(Data, dict):\\n return { k: FixFloats(v) for k, v in Data.items() }\\n\\n if isinstance(Data, list):\\n return [ FixFloats(v) for v in Data ]\\n\\n if isinstance(Data, float): # Only floats being changed here\\n return str(Data)\\n\\n return Data\",\n \"def _normalize_data_to_send(info):\\n # Remove the parts of the data that are unbounded in size.\\n info = copy.deepcopy(info)\\n for key in ['model_config', 'epoch_history']:\\n if key in info:\\n del info[key]\\n return info\",\n \"def preprocess(data):\\n # Data Preprocessing\\n data['GDP_scaled']=preprocessing.scale(data['GDP'])\\n data['CLPRB_scaled']=preprocessing.scale(data['CLPRB'])\\n data['EMFDB_scaled']=preprocessing.scale(data['EMFDB'])\\n data['ENPRP_scaled']=preprocessing.scale(data['ENPRP'])\\n data['NGMPB_scaled']=preprocessing.scale(data['NGMPB'])\\n data['PAPRB_scaled']=preprocessing.scale(data['PAPRB'])\\n data['PCP_scaled']=preprocessing.scale(data['PCP'])\\n data['ZNDX_scaled']=preprocessing.scale(data['ZNDX'])\\n data['OP_scaled']=preprocessing.scale(data['Nominal Price'])\\n data['OP2_scaled']=preprocessing.scale(data['Inflation Adjusted Price'])\\n\\n return data\",\n \"def reconstruct(self, data):\\n self.recons = self.trf.reconstruct(data)\",\n \"def preprocess_input(x, data_format=None): # pylint: disable=unused-argument\\n return x\",\n \"def data_preparation(self) -> None:\\n self.logger.info('data cleaning')\\n self.logger.info('num of secs: {}, num of ipo_dates: {}, num of secs with prices: {}'.format(\\n len(self.data),\\n len(self.ipo_dates),\\n len(self.prices)\\n ))\\n excluded = []\\n excluded = [i.lower() for i in excluded]\\n self.logger.info(f'number of excluded: {len(excluded)}')\\n for i in excluded:\\n self.data.pop(i)\\n for s in self.data:\\n # columns with empty assets sum (empty columns and other situations)\\n self.data[s].dropna(axis='columns', how='any', subset=['A_0'], inplace=True)\\n # columns with descriptions (polish and english names of values)\\n self.data[s].drop(self.data[s].columns[[0, 1]], inplace=True, axis=1)\\n\\n self.logger.info(f'number of secs after cleaning: {len(self.data)}')\\n data_list = [k for k in self.data.values()]\\n self.uber_data = pd.concat(data_list, ignore_index=True, axis=1)\\n self.uber_data = self.uber_data.transpose()\\n self.uber_data = self.uber_data.loc[:, pd.notnull(self.uber_data.columns)]\",\n \"def unstructured_to_structured(data, indexes):\\r\\n header = data[0].tolist()\\r\\n dtype_lst = []\\r\\n for i in range(len(header)):\\r\\n if i in indexes:\\r\\n dtype_lst.append(tuple([header[i], \\\"<U30\\\"]))\\r\\n else:\\r\\n dtype_lst.append(tuple([header[i], \\\"float64\\\"]))\\r\\n updated = np.delete(data, 0, 0)\\r\\n tuple_lst = []\\r\\n for i in updated:\\r\\n tuple_lst.append(tuple(i))\\r\\n updated = np.array(tuple_lst, dtype=dtype_lst)\\r\\n return updated\",\n \"def transform_data(data_orig):\\n\\tif isinstance(data_orig, str):\\n\\t\\tdata_orig = pd.read_csv(data_orig)\\n\\n\\tdata = data_orig\\n\\n\\tnum_rows,num_variables = data.shape\\n\\tall_columns = data.columns.tolist()\\n\\tclean_data(data,all_columns,ignore_na=False,fill_mode=\\\"prob\\\")\\n\\texpand_features(data)\\n\\tvariables = ['Pclass','Sex',\\\"Fare\\\",\\\"Age\\\",\\\"SibSp\\\",\\\"Parch\\\",\\\"Embarked\\\",\\\"Fam_size\\\",\\\\\\n\\t\\t\\t\\t \\\"cabin_no\\\",\\\"ticket_no\\\",\\\"friend\\\",\\\"Fare_person\\\",\\\"Child\\\"]\\n\\tX = pd.get_dummies(data[variables])\\n\\n\\t## normalise features to zero man and unit variance\\n\\tscaler = preprocessing.StandardScaler().fit(X)\\n\\tX_scaled = scaler.transform(X)\\n\\tX = pd.DataFrame(X_scaled, columns=X.columns)\\n\\n\\tif \\\"Survived\\\" in data.columns:\\n\\t\\ty = data['Survived']\\n\\telse:\\n\\t\\ty = None\\n\\n\\treturn X, y\",\n \"def _pack_data( self, data ) : \\r\\n \\r\\n # hints = self._translation_table.get( type(data), None )\\r\\n hints = self._get_hints( data ) \\r\\n \\r\\n if hints is None : \\r\\n \\r\\n ## #debug: \\r\\n ## print \\\"_pack_data(): no hints for data type %s (data repr: %s)\\\" % (type(data), repr(data))\\r\\n \\r\\n # \\\"one-level recursion\\\" : \\r\\n # return self._pack_data( repr(data) )\\r\\n return self._pack_data( str(data) )\\r\\n \\r\\n ## # our special case ( grep 'bugfix' to see why we want a zero block ) \\r\\n ## if data is None: data = 0\\r\\n \\r\\n # else ... \\r\\n \\r\\n # 'DescType' + 'length' + 'data'\\r\\n desctype = hints[0]\\r\\n if desctype == 'TEXT' : \\r\\n length = len(data)\\r\\n data_str = data \\r\\n else :\\r\\n length = struct.calcsize( hints[1] )\\r\\n data_str = struct.pack( hints[1], data )\\r\\n \\r\\n length_str = struct.pack('=H', length)\\r\\n \\r\\n \\r\\n return _cat(desctype, length_str, data_str)\",\n \"def fix_corpus_format(corpus):\\n import copy\\n fixed_format = copy.copy(corpus)\\n testing = corpus['testing']\\n training = corpus['training']\\n validation = corpus['validation']\\n del fixed_format['testing']\\n del fixed_format['training']\\n del fixed_format['validation']\\n fixed_format['partition'] = {\\n \\\"testing\\\": testing,\\n \\\"training\\\": training,\\n \\\"validation\\\": validation,\\n }\\n return fixed_format\",\n \"def _preprocess(self, data):\\n\\n # pipeline: first call the previous statistics:\\n if self.previous_statistics is not None:\\n data = self.previous_statistics.statistics(data)\\n # the first of the statistics need to take list as input, in order to match the API. Then actually the\\n # transformations work on np.arrays. In fact the first statistic transforms the list to array. Therefore, the\\n # following code needs to be called only if the self statistic is the first, i.e. it does not have a\\n # previous_statistic element.\\n else:\\n data = self._check_and_transform_input(data)\\n\\n return data\",\n \"def preprocess_data(extracted_data: List[Tuple[str, str]]) -> List[str]:\\n return [f'__label__{data[0]} {clean_formatting(data[1])}' for data in extracted_data]\",\n \"def parseStructuredData( raw_data, format ):\\n\\tparsed_data = {}\\n\\n\\tBEGIN = 0\\n\\tEND = 1\\n\\tCONV = 2\\n\\n\\tfor key in format.keys():\\n\\t\\tkey_format = format[key]\\n\\n\\t\\tif key_format[END] == \\\"\\\":\\n\\t\\t\\tkey_format[END] = key_format[BEGIN] + len(raw_data)\\n\\n\\t\\ttxt = raw_data[key_format[BEGIN]:key_format[END]]\\n\\n\\t\\tif len(key_format[CONV]) > 0:\\n\\t\\t\\tparsed_data[key] = struct.unpack(key_format[CONV], txt)[0]\\n\\t\\telse:\\n\\t\\t\\tparsed_data[key] = txt\\n\\n\\treturn parsed_data\",\n \"def _transform_data(self, *args, **kwargs) -> None:\\n raise NotImplementedError\",\n \"def parse_data( self ):\\n super( PivotGraph, self ).parse_data()\\n new_parsed_data = {}\\n parsed_data = getattr( self, 'parsed_data', self.results )\\n for pivot, data in parsed_data.items():\\n new_pivot = self.parse_pivot( pivot )\\n data = self.parse_datum( data )\\n if data != None:\\n new_parsed_data[ new_pivot ] = data\\n self.parsed_data = new_parsed_data\",\n \"def normalize(data):\\n data = lowercase(data)\\n data = remove_punct(data)\\n data = remove_apostrophes(data)\\n data = remove_stopwords(data)\\n data = num_to_words(data)\\n data = lemmatize(data)\\n data = stemming(data)\\n data = remove_punct(data)\\n data = num_to_words(data)\\n data = lemmatize(data)\\n data = stemming(data)\\n data = remove_punct(data) #done again to remove hyphens produced by num2words\\n data = remove_stopwords(data) #done agan to remove stopwords produced by num2words\\n return data\",\n \"def format_data(data):\\n rules = []\\n bags = []\\n for bag_data in data:\\n bag = bag_data.split('contain')\\n bag_type = bag[0].replace('bags', '').strip().lower()\\n bag_content = bag[1].replace('.', '')\\n if 'no other bags' in bag_content:\\n continue\\n else:\\n bags.append([bag_type, [[re.sub(r'bags?$', '', content).strip().lower()[2:], content[:2].strip()]\\n for content in bag_content.split(',')]])\\n rule = re.search(fr'\\\\d+ {BAG_TYPE}', bag_data)\\n if rule:\\n rules.append([bag_type, rule.group()[:1].strip()])\\n # print(rules)\\n return rules, bags\",\n \"def _format_data(self, data):\\n return json.dumps(data)\",\n \"def reformat_file(inFile, outFile):\\n \\n with open(outFile, \\\"w\\\") as outHandle:\\n \\n\\t\\t# write header line\\n\\t\\toutLine = [\\\"g1\\\", \\\"g2\\\", \\\"raw_count\\\", \\\"log(obs/exp)\\\"]\\n\\t\\t\\n\\t\\toutHandle.write(\\\"\\\\t\\\".join(outLine) + \\\"\\\\n\\\")\\n\\n\\n\\t\\tfor i, line in enumerate(open(inFile)):\\n\\t\\t\\t\\n\\t\\t\\tif not i == 0:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tsp = line.strip().split(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# get row interaction counts and normalized obs/exp values\\n\\t\\t\\t\\trawCount = sp[12]\\n\\t\\t\\t\\tobsExp = sp[13]\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tgenes1 = sp[4].split(\\\"|\\\")\\n\\t\\t\\t\\tgenes2 = sp[10].split(\\\"|\\\")\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t#~ print(g1, g2, rawCount)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# iterate over all pairs\\n\\t\\t\\t\\tfor g1 in genes1:\\n\\n\\t\\t\\t\\t\\tfor g2 in genes2:\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\toutLine = [g1, g2, rawCount, obsExp]\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\toutHandle.write(\\\"\\\\t\\\".join(outLine) + \\\"\\\\n\\\")\",\n \"def format_raw_data(data, indent=2*'\\\\t'):\\n strings = [' '.join([('%.2x' % ord(x)) for x in data[i:i + DGTL_Decoder.__raw_data_chunk]])\\n for i in xrange(0, len(data), DGTL_Decoder.__raw_data_chunk)]\\n return ('\\\\n' + indent).join(strings)\",\n \"def __format_it(self, data):\\n\\n for index, regex in self.regex_dates.items():\\n matched = helpers.Regex(regex).match(data, return_match=True, rematch=True)\\n\\n if not matched:\\n continue\\n\\n date = self.__format_management(index, matched)\\n\\n if not date: # pragma: no cover\\n continue\\n\\n return \\\"-\\\".join(date)\\n return None # pragma: no cover\",\n \"def organize_data(self, data):\\n presentation = \\\"\\\"\\n\\n offices = data['offices']\\n living = data['living']\\n\\n presentation += \\\"OFFICE \\\\n\\\\n\\\"\\n if len(offices) == 0:\\n presentation += \\\"No Office allocations\\\\n\\\"\\n\\n else:\\n presentation += \\\"Office Allocations\\\\n\\\"\\n for office in offices:\\n presentation += office['room'].capitalize() + \\\"\\\\n\\\"\\n presentation += \\\"Members: \\\\n\\\"\\n presentation += ','.join(office['names'])\\n\\n presentation += \\\"LIVING SPACES \\\\n\\\\n\\\"\\n if len(offices) == 0:\\n presentation += \\\"No Living space allocations\\\\n\\\"\\n\\n else:\\n presentation += \\\"Office Allocations\\\\n\\\"\\n for space in living:\\n presentation += living['room'].capitalize() + \\\"\\\\n\\\"\\n presentation += ','.join(living['names'])\\n\\n return presentation\",\n \"def convertProfileData(data):\\n actVer = Version(data.get('version', '0.0'))\\n if actVer >= Version(profileVersion):\\n return data\\n if 'mainW' not in data:\\n return data\\n\\n log.info(f'Conversion from [{data.get(\\\"version\\\")}] to [{profileVersion}]')\\n watney = {\\n 'deviceName': 'Watney',\\n 'deviceList': ['Watney'],\\n 'searchRadius': 10,\\n 'timeout': 30,\\n 'appPath': '',\\n 'indexPath': '',\\n }\\n d = NestedDict(data)\\n try:\\n d['driversData'] = d['mainW', 'driversData']\\n del d['mainW']['driversData']\\n d['driversData', 'plateSolve'] = d['driversData', 'astrometry']\\n del d['driversData']['astrometry']\\n d['driversData', 'plateSolve', 'frameworks', 'watney'] = watney\\n d['hemisphereW', 'horizonMaskFileName'] = d['mainW', 'horizonFileName']\\n del d['mainW']['horizonFileName']\\n t = d['driversData', 'directWeather', 'frameworks', 'internal']\\n d['driversData', 'directWeather', 'frameworks', 'directWeather'] = t\\n del d['driversData']['directWeather']['frameworks']['internal']\\n d['driversData', 'directWeather', 'frameworks', 'directWeather',\\n 'deviceName'] = 'On Mount'\\n d['version'] = profileVersion\\n except Exception as e:\\n log.error(f'Failed conversion, keep old structure: {e}')\\n else:\\n data = d.to_dict()\\n return data\",\n \"def update_column_format(self):\\n pass\",\n \"def _normalize_layer_data(data: LayerData) -> FullLayerData:\\n if not isinstance(data, tuple) and 0 < len(data) < 4:\\n raise ValueError(\\\"LayerData must be a 1-, 2-, or 3-tuple\\\")\\n _data = list(data)\\n if len(_data) > 1:\\n if not isinstance(_data[1], dict):\\n raise ValueError(\\n \\\"The second item in a LayerData tuple must be a dict\\\"\\n )\\n else:\\n _data.append(dict())\\n if len(_data) > 2:\\n if _data[2] not in layers.NAMES:\\n raise ValueError(\\n \\\"The third item in a LayerData tuple must be one of: \\\"\\n f\\\"{layers.NAMES!r}.\\\"\\n )\\n else:\\n _data.append(guess_labels(_data[0]))\\n return tuple(_data) # type: ignore\",\n \"def formatAllToFloat(self):\\n SectionList = [self.Accel[\\\"X\\\"], self.Accel[\\\"Y\\\"], self.Accel[\\\"Z\\\"], self.Gyro[\\\"X\\\"], self.Gyro[\\\"Y\\\"], self.Gyro[\\\"Z\\\"], self.Millis,self.GForce,self.Rot[\\\"X\\\"],self.Rot[\\\"Y\\\"],self.Rot[\\\"Z\\\"],self.DDMillis.Gyro,self.DDMillis.Accel,self.DDMillis.Rot,self.DDMillis.Mag,\\n self.GPSDat[\\\"lng\\\"], self.GPSDat[\\\"lat\\\"], self.GPSDat[\\\"Speed\\\"], self.GPSDat[\\\"Altitude\\\"], self.GPSDat[\\\"Accuracy\\\"], self.GPSDat[\\\"Bearing\\\"],self.Mag[\\\"X\\\"],self.Mag[\\\"Y\\\"],self.Mag[\\\"Z\\\"]]\\n\\n for item in SectionList:\\n if not len(item) == 0:\\n GoToThisDangit = item[:]\\n for SubItem in range(len(GoToThisDangit)):\\n try:\\n if SubItem > len(item):\\n break\\n else:\\n item[SubItem] = float(item[SubItem])\\n except ValueError:\\n try:\\n del item[SubItem]\\n except IndexError:\\n \\\"Slightly dangerous catch....\\\"\\n except IndexError:\\n \\\"yo\\\"\",\n \"def OPCtimetransformOld(data, to):\\n outtimes = []\\n \\n times = {\\n 'ms':[],\\n 'SS':[],\\n 'MM':[],\\n 'HH':[]\\n }\\n for i in range(0, len(data)):\\n item = data[i]\\n try: \\n times['HH'].append(int(item[0:2]))\\n times['MM'].append(int(item[2:4]))\\n times['SS'].append(int(item[4:6]))\\n times['ms'].append(int(item[7:9]))\\n except ValueError:\\n # strange value 2319010.00 in 201129 file...\\n olditem = item\\n newitem = item[:4] + item[4+1:]\\n print( ('Repairing strange value %s into %s')%(olditem, newitem) )\\n try:\\n times['HH'].append(int(newitem[0:2]))\\n times['MM'].append(int(newitem[2:4]))\\n times['SS'].append(int(newitem[4:6]))\\n times['ms'].append(int(newitem[7:9]))\\n except ValueError:\\n print(newitem)\\n\\n # OPC times go up to 60 minutes. This is corrected by moving one minute\\n times['MM'] = [max(0,x-1) for x in times['MM']]\\n times['SS'] = [max(0,x-1) for x in times['SS']]\\n\\n for i in range(0, len(data)):\\n md = dt.datetime(1900,1,1,times['HH'][i], times['MM'][i], times['SS'][i]) \\n outtimes.append( dt.datetime.strftime(md, to))\\n\\n return outtimes\",\n \"def datamunge(cls, data):\\n pass\",\n \"def format_output(data: pd.DataFrame, source, col_maps=None) -> pd.DataFrame:\\n if data.empty: return pd.DataFrame()\\n if source == 'bdp': req_cols = ['ticker', 'field', 'value']\\n else: req_cols = ['ticker', 'field', 'name', 'value', 'position']\\n if any(col not in data for col in req_cols): return pd.DataFrame()\\n if data.dropna(subset=['value']).empty: return pd.DataFrame()\\n\\n if source == 'bdp':\\n res = pd.DataFrame(pd.concat([\\n pd.Series({**{'ticker': t}, **grp.set_index('field').value.to_dict()})\\n for t, grp in data.groupby('ticker')\\n ], axis=1, sort=False)).transpose().set_index('ticker')\\n else:\\n res = pd.DataFrame(pd.concat([\\n grp.loc[:, ['name', 'value']].set_index('name')\\n .transpose().reset_index(drop=True).assign(ticker=t)\\n for (t, _), grp in data.groupby(['ticker', 'position'])\\n ], sort=False)).reset_index(drop=True).set_index('ticker')\\n res.columns.name = None\\n\\n if col_maps is None: col_maps = dict()\\n return res.rename(\\n columns=lambda vv: col_maps.get(\\n vv, vv.lower().replace(' ', '_').replace('-', '_')\\n )\\n ).apply(pd.to_numeric, errors='ignore', downcast='float')\",\n \"def parse_data( self ):\\n super( PivotGroupGraph, self ).parse_data()\\n new_parsed_data = {}\\n parsed_data = getattr( self, 'parsed_data', self.results )\\n for pivot, groups in parsed_data.items():\\n new_pivot = self.parse_pivot(pivot)\\n if new_pivot == None:\\n continue\\n new_groups = {}\\n new_parsed_data[ new_pivot ] = new_groups\\n for group, data in groups.items():\\n new_group = self.parse_group(group)\\n new_datum = self.parse_datum(data)\\n if new_group == None:\\n continue\\n new_groups[ new_group ] = new_datum\\n if len(new_groups) == 0:\\n del new_parsed_data[new_pivot]\\n self.parsed_data = new_parsed_data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7618255","0.7096688","0.6632938","0.6506588","0.6437094","0.63554853","0.6353619","0.63322175","0.6280301","0.6274984","0.626859","0.626859","0.6263245","0.624401","0.62409395","0.61382896","0.61014044","0.6049214","0.60481143","0.6002033","0.5962946","0.5951043","0.58999443","0.58917785","0.58881116","0.5875464","0.58426934","0.5790005","0.5787737","0.5780131","0.5720075","0.5712372","0.568794","0.56870604","0.56821185","0.5681258","0.56790483","0.56473607","0.56469226","0.56420475","0.56179076","0.5599724","0.5586397","0.55822647","0.55822647","0.5577499","0.5573564","0.5569925","0.55593646","0.555918","0.5541417","0.5534884","0.55097","0.55013406","0.54971355","0.5496634","0.5494691","0.5493506","0.5478081","0.5474955","0.5474316","0.5457411","0.54449767","0.5442427","0.54331696","0.54202914","0.5402715","0.5402272","0.5402272","0.5382676","0.53825355","0.5361151","0.5360086","0.5346165","0.5332458","0.53212523","0.53112054","0.53050786","0.5303167","0.530001","0.5294038","0.5292694","0.5284562","0.5283515","0.5275305","0.5268101","0.52525145","0.52480465","0.52471066","0.5244954","0.5235871","0.5232648","0.5220995","0.52126306","0.52107185","0.5209092","0.5205804","0.52048516","0.5201447","0.5194198"],"string":"[\n \"0.7618255\",\n \"0.7096688\",\n \"0.6632938\",\n \"0.6506588\",\n \"0.6437094\",\n \"0.63554853\",\n \"0.6353619\",\n \"0.63322175\",\n \"0.6280301\",\n \"0.6274984\",\n \"0.626859\",\n \"0.626859\",\n \"0.6263245\",\n \"0.624401\",\n \"0.62409395\",\n \"0.61382896\",\n \"0.61014044\",\n \"0.6049214\",\n \"0.60481143\",\n \"0.6002033\",\n \"0.5962946\",\n \"0.5951043\",\n \"0.58999443\",\n \"0.58917785\",\n \"0.58881116\",\n \"0.5875464\",\n \"0.58426934\",\n \"0.5790005\",\n \"0.5787737\",\n \"0.5780131\",\n \"0.5720075\",\n \"0.5712372\",\n \"0.568794\",\n \"0.56870604\",\n \"0.56821185\",\n \"0.5681258\",\n \"0.56790483\",\n \"0.56473607\",\n \"0.56469226\",\n \"0.56420475\",\n \"0.56179076\",\n \"0.5599724\",\n \"0.5586397\",\n \"0.55822647\",\n \"0.55822647\",\n \"0.5577499\",\n \"0.5573564\",\n \"0.5569925\",\n \"0.55593646\",\n \"0.555918\",\n \"0.5541417\",\n \"0.5534884\",\n \"0.55097\",\n \"0.55013406\",\n \"0.54971355\",\n \"0.5496634\",\n \"0.5494691\",\n \"0.5493506\",\n \"0.5478081\",\n \"0.5474955\",\n \"0.5474316\",\n \"0.5457411\",\n \"0.54449767\",\n \"0.5442427\",\n \"0.54331696\",\n \"0.54202914\",\n \"0.5402715\",\n \"0.5402272\",\n \"0.5402272\",\n \"0.5382676\",\n \"0.53825355\",\n \"0.5361151\",\n \"0.5360086\",\n \"0.5346165\",\n \"0.5332458\",\n \"0.53212523\",\n \"0.53112054\",\n \"0.53050786\",\n \"0.5303167\",\n \"0.530001\",\n \"0.5294038\",\n \"0.5292694\",\n \"0.5284562\",\n \"0.5283515\",\n \"0.5275305\",\n \"0.5268101\",\n \"0.52525145\",\n \"0.52480465\",\n \"0.52471066\",\n \"0.5244954\",\n \"0.5235871\",\n \"0.5232648\",\n \"0.5220995\",\n \"0.52126306\",\n \"0.52107185\",\n \"0.5209092\",\n \"0.5205804\",\n \"0.52048516\",\n \"0.5201447\",\n \"0.5194198\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56401306"},"document_rank":{"kind":"string","value":"40"}}},{"rowIdx":21493,"cells":{"query":{"kind":"string","value":"Find scaling value. Arguments"},"document":{"kind":"string","value":"def scale(original_train, new_train):\n # find magnitude original training data\n o_mag = np.linalg.norm(np.stack(original_train[:,1]))\n # find magnitude new data\n n_mag = np.linalg.norm(np.stack(new_train[:,1]))\n # scale new data\n scale = o_mag / n_mag\n return scale"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def GetScale(self):\n ...","def get_scale():\r\n\r\n \r\n return 0.5","def scale(self):\n return self.distribution.scale","def FindScale(self):\n\n ## 6 and from the cv code the distance is 6 then we are good\n print(\"TODO: Very hard\")","def get_scaled_value(self, value):\r\n raise NotImplementedError()","def scale(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"scale\")","def scale(self):\n return self._scale","def scaling(self):\n return self.__scaling","def scaling(self):\n return self._scaling","def scaling(self):\n return self._scaling","def scale(self) -> Optional[pulumi.Input['ScaleArgs']]:\n return pulumi.get(self, \"scale\")","def _call_scale(vecObj, sc):\n res = vecObj.scale(sc)\n return res","def scale(self):","def get_scaled_value_at(self, offset):\r\n return self.get_scaled_value(self.get_value_at(offset))","def scale(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"scale\")","def any_scale(scale):\n return scale","def get_scale_op(self):\n\t\treturn self.variables.get('scale')","def scale(self, value):\r\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0","def scale_value(self):\n return self._scale_value[2]","def get_scale_parameter(self):\r\n \r\n if self.scale_parameter == 0.0: \r\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\r\n gamma_func = special.gamma(shape_in_gamma_func)\r\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\r\n return self.scale_parameter\r\n else:\r\n return self.scale_parameter","def scale(self):\n return self._gev_bijector.scale","def scale(self, value):\n return (float(value) - float(self.minimum)) / \\\n float(self.maximum - self.minimum) * 2.0 - 1.0","def scale(self):\n return self._a","def getScale(self):\n \n dag_node = OpenMaya.MFnDagNode(self.thisObj)\n transform_node = OpenMaya.MFnTransform(dag_node.parent( 0 ))\n \n util = OpenMaya.MScriptUtil()\n util.createFromDouble(0.0, 0.0, 0.0)\n pointeur = util.asDoublePtr()\n transform_node.getScale(pointeur)\n \n sx = util.getDoubleArrayItem(pointeur, 0)\n sy = util.getDoubleArrayItem(pointeur, 1)\n sz = util.getDoubleArrayItem(pointeur, 2)\n\n return sx, sy, sz","def scale_parameter(self):\n return self._scale_parameter","def get_scale_parameter(self):\n\n if self.scale_parameter == 0.0:\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\n gamma_func = special.gamma(shape_in_gamma_func)\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\n return self.scale_parameter\n else:\n return self.scale_parameter","def scale(self) -> Tuple[float, float]:\n return self._scale","def scaling(self):\n return self.stacked._box_scaling[1]","def getScaleValues(a, x):\n raise NotImplementedError('getScaleValues not implemented')","def GetUserScale(*args, **kwargs):\n return _gdi_.DC_GetUserScale(*args, **kwargs)","def scale_it(val):\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])","def _get_scaling(root):\n dpi = root.winfo_fpixels(\"1i\")\n scaling = dpi / 72.0\n logger.debug(\"dpi: %s, scaling: %s'\", dpi, scaling)\n return scaling","def scale(input):\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))","def get_scale(self):\r\n try: return self.scale[0], self.scale[1], self.scale[2]\r\n except: return self.scale, self.scale, self.scale","def scale(self, value):\n\t\toldscale = self.oldmax - self.oldmin\n\t\tnewscale = self.newmax - self.newmin\n\t\treturn (newscale * (value - self.oldmin) / oldscale) + self.newmin","def freq_optimization(self):\n index = identify_scale(self.vz, True)\n # In case the patient is limping\n if index > 35:\n index = index / 2\n print(f\"Scale used is {index}\")","def get_scaling_factor(c, default=None, warning=False, exception=False, hint=None):\n try:\n sf = c.parent_block().scaling_factor[c]\n except (AttributeError, KeyError):\n if not isinstance(c, (pyo.Param, _ParamData)):\n if hint is None:\n h = \"\"\n else:\n h = f\", {hint}\"\n if warning:\n if hasattr(c, \"is_component_type\") and c.is_component_type():\n _log.warning(f\"Missing scaling factor for {c}{h}\")\n else:\n _log.warning(f\"Trying to get scaling factor for unnamed expr {h}\")\n if exception and default is None:\n if hasattr(c, \"is_component_type\") and c.is_component_type():\n _log.error(f\"Missing scaling factor for {c}{h}\")\n else:\n _log.error(f\"Trying to get scaling factor for unnamed expr {h}\")\n raise\n sf = default\n else:\n # Params can just use current value (as long it is not 0)\n val = pyo.value(c)\n if not val == 0:\n sf = abs(1 / pyo.value(c))\n else:\n sf = 1\n return sf","def _scale_param(self, resid_us):\n return((resid_us**2).sum().sum() / self.dof)","def scaling_object(self):\n return self.__scaling_object","def _scale(x):\n scaleFactor = 1\n _ret = int(x/scaleFactor)\n return _ret","def get_apply_scale(self, applyScaleFactor, scale_quality = 1.0):\n v = self.scale * self.scale_quality * scale_quality\n if applyScaleFactor:\n v *= self.scale_factor\n return v","def prescaler(self) -> int:","def getScale(self):\n return self.factor**self.turnOn","def get_scale_parameter(self):\n\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\n gamma_func = special.gamma(shape_in_gamma_func)\n self._scale_parameter = self._mean_fire_recurrence / gamma_func","def get_s( self ):\n\n # initialize scaling factor as unknown variable, assuming it's real and\n # greater than zero\n _s = Symbol( 's', real = True, positive = True )\n\n # solve for scaling factor (first argument is expression set equal to zero)\n s = solve( self.a * _s ** self.n + self.b * _s - 1, _s )\n\n # save result as float\n self.s = float( s[ 0 ] )","def xscale(value):\n impl.xscale(**locals())","def scale(val, src, dst):\r\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]","def scale(self):\n return self.scale_factor / CONSTANTS.AU","def scale(val, src, dst):\n try:\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\n except ZeroDivisionError:\n return 0.0","def scale_root(self) -> int:\r\n ...","def getScale(self):\n return _libsbml.Unit_getScale(self)","def set_and_get_scaling_factor(c, default, warning=False, exception=False, hint=None):\n if c.is_indexed():\n raise AttributeError(\n f\"Ambiguous which scaling factor to return for indexed component {c.name}.\"\n )\n sf = get_scaling_factor(c, warning=warning, exception=exception, hint=hint)\n if sf is None:\n sf = default\n set_scaling_factor(c, sf, data_objects=False)\n return sf","def simple_scaling(input_data):\n\n # Insert debugging assertions\n assert type(input_data) is np.ndarray, \"The 'input_data' must be numpy array.\"\n\n # Get the minimum values of the input numpy array along the axis \n Max = np.max(input_data, axis = 0)\n\n # Simple sclaing \n scaled_input_data = input_data / (Max + sys.float_info.min)\n\n # Return scaled input data\n return scaled_input_data","def getScale(self, mode='ACC'):\t#good\r\n\t\tif mode.upper() == 'ACC':\r\n\t\t\treg = 0x1C\r\n\t\telif mode.upper() == 'GYR':\r\n\t\t\treg = 0x1B\t\t\r\n\t\telse:\r\n\t\t\treturn False\r\n\t\tcurrentVal = self.read(reg)\r\n\t\tcurrentVal = self.dec2BinList(currentVal)\r\n\t\tscaleSetting = (currentVal[4]*2) + (currentVal[3]*1) \r\n\t\tif mode.upper() == 'ACC':\r\n\t\t\tscale = 2**(scaleSetting+1) \r\n\t\telif mode.upper() == 'GYR':\r\n\t\t\tscale = (2**(scaleSetting+1))*125\r\n\t\telse:\r\n\t\t\treturn False\r\n\t\treturn scale,scaleSetting","def get_scale_freq():\n return sf / 2 / (num_freq-1)","def prescaler(self, value: int, /) -> None:","def get_scale(self):\n\n if not hasattr(self, \"scale\"):\n raise NotImplementedError(\"\"\"All end-use subclasses of Color should define\n a get_scale method.\"\"\")\n\n return self.scale","def scale(self, axis, value):\r\n assert (axis < EventStream.numAxes), \"Axis number out of range\"\r\n if self.absInfo[axis]:\r\n return self.absInfo[axis].scale(value)\r\n else:\r\n return value","def scale(self, data: np.ndarray):\n if self.scale_type == \"min_max\":\n scaled_data = (data - self.predictor_min) / (\n self.predictor_max - self.predictor_mean\n )\n elif self.scale_type == \"normalize\":\n scaled_data = (data - self.predictor_mean) / (\n self.predictor_max - self.predictor_min\n )\n elif self.scale_type == \"standardize\":\n scaled_data = (data - self.predictor_mean) / self.predictor_std\n elif self.scale_type == \"scale\":\n scaled_data = data - self.predictor_mean\n else:\n scaled_data = data\n return scaled_data","def scale(x, minimum, maximum):\n return (x - minimum) / (maximum - minimum)","def scale(val, src, dst):\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]","def scaled_component(self, key):\n\n if key in self.components:\n dat = self.components[key] \n # Aliases\n elif key in component_from_alias:\n comp = component_from_alias[key]\n if comp in self.components:\n dat = self.components[comp] \n else:\n # Component not present, make zeros\n return np.zeros(self.shape)\n else:\n raise ValueError(f'Component not available: {key}')\n \n # Multiply by scale factor\n factor = self.factor \n \n if factor != 1:\n return factor*dat\n else:\n return dat","def Lookup(self, raw):\n return self.scale.Lookup(raw)","def test_scale_value(make_rampmodel):\n\n datmod = make_rampmodel(2, 2, 4, 2048, 2048)\n\n # Calculate the scale based off of the input.\n scale = datmod.meta.exposure.frame_divisor / datmod.meta.exposure.nframes\n\n output = GroupScaleStep.call(datmod)\n\n scale_from_data = np.unique(output.data / datmod.data)\n\n # Since the scale value is applied uniformly to the array, if we divide the output\n # by the input then we should get a single unique value (ie the scale) calculated\n # by the pipeline.\n assert len(scale_from_data) == 1\n\n # Make sure the scale calculated manually from the data model above matched what the\n # pipeline calculated.\n assert scale == scale_from_data[0]","def get_scaled_value(self, value):\r\n if self.logarithmic_factor != 1.0:\r\n exp_mult = exp(self.logarithmic_factor * value * 4.0) - 1\r\n exp_div = exp(self.logarithmic_factor * 4.0) - 1\r\n return exp_mult / exp_div * (self.maxvalue - self.minvalue) + self.minvalue\r\n else:\r\n return value * (self.maxvalue - self.minvalue) + self.minvalue","def scaling(self) -> Optional['outputs.AiFeatureStoreOnlineServingConfigScaling']:\n return pulumi.get(self, \"scaling\")","def scale(val, src, dst):\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]","def scale(val, src, dst):\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]","def point_scale_name(self):","def _eta_sfr_scaling(self,x,q):\n i = self.enum[q]\n A = self.scaling_params['A'][i]\n b = self.scaling_params['b'][i]\n return A*x**b","def scale(self, scale):\n\t\tself._current_score *= scale","def getscales(self):\n return self.scales","def rscale(mag=10.0):\n if mag > 11.5:\n return 0.5\n elif mag > 11.0:\n return 1.0\n elif mag > 10.5:\n return 1.5\n elif mag > 10.0:\n return 1.5\n elif mag > 9.5:\n return 2.0\n elif mag > 9.0:\n return 2.5\n elif mag > 8.5:\n return 3.0\n else:\n return 3.5","def scale(f, a, j=0):\n return f.per(dmp_scale_in(f.rep, f.dom.convert(a), j, f.lev, f.dom))","def quantify ( value, scale ):\r\n\r\n\r\n\tif value < scale[0] or value > scale[-1]: return value\r\n\tfor i in range (1, len(scale)):\r\n\t\tif value <= scale[i]:\r\n\t\t\tif scale[i] - value > value - scale[i-1]: return scale[i-1]\r\n\t\t\telse: return scale[i]","def setScale(self, *args):\n return _libsbml.Unit_setScale(self, *args)","def get_scaler(scaler):\n if scaler == 'standard':\n from sklearn.preprocessing import StandardScaler\n return StandardScaler()\n if scaler == 'minmax':\n from sklearn.preprocessing import MinMaxScaler\n return MinMaxScaler()","def get_constraint_transform_applied_scaling_factor(c, default=None):\n try:\n sf = c.parent_block().constraint_transformed_scaling_factor.get(c, default)\n except AttributeError:\n sf = default # when there is no suffix\n return sf","def apply(self, value):\n return (value - self._offset)/self._scale","def scale(self,s):\n return Vector(self.x * s, self.y * s, self.z * s)","def get_scale(self):\n\n scales = []\n for i in range(len(self.train_series)):\n series = self.train_series.iloc[i].values\n series = series[np.argmax(series != 0):]\n scale = ((series[1:] - series[:-1]) ** 2).mean()\n scales.append(scale)\n\n return np.array(scales)","def get_scale(units, compartmentId, volume, extracellularVolume):\r\n if compartmentId == 'c':\r\n V = volume\r\n else:\r\n V = extracellularVolume\r\n\r\n if units == 'uM':\r\n return 1. / N_AVOGADRO / V * 1e6\r\n elif units == 'mM':\r\n return 1. / N_AVOGADRO / V * 1e3\r\n elif units == 'molecules':\r\n return 1.\r\n else:\r\n raise Exception('Invalid units \"%s\"' % units)","def _hyperparam_to_scale(self, hyperparam):\n\n # If logscale is used, input hyperparam is log of the scale.\n if self.use_log_scale:\n scale = 10.0**hyperparam\n else:\n scale = numpy.abs(hyperparam)\n\n return scale","def scale_data(self, data):\n return (data - self.mean)/self.std","def task_scaling(input_array, scaling_factor):\n return(np.multiply(scaling_factor, input_array))","def scaleValues(values):\n\n values = values - values.min()\n return values/values.max()","def showscale(self):\n return self[\"showscale\"]","def scale(z,h=0.7,omegalambda=0.7,omegam=0.3,omegak=0.0):\n return distcalc(z,h,omegalambda,omegam,omegak)['scale']","def mapVal(inputPos, in_min, in_max, out_min, out_max):\n \n \n scale = ((out_max - out_min) / (in_max - in_min))\n return float(((inputPos - in_min) * scale) + out_min)","def get_scaled_weights(self):\n span = self.maxval-self.minval\n return (self.get_weights()-self.minval)/span","def scale_to_factor(scale):\n return (B.pi / 2) / (2 * scale**2)","def imageScale(scale):\n\t\treturn max(1, int(scale * (InterfaceTools.getCanvasSize()[0] / height)))","def get_scaling(self):\n if self.constrain_navigation:\n self.activate_navigation_constrain()\n return self.sx, self.sy","def GetLogicalScale(*args, **kwargs):\n return _gdi_.DC_GetLogicalScale(*args, **kwargs)","def scale(first,scalar):\n if isinstance(first,FreeCAD.Vector):\n return FreeCAD.Vector(first.x*scalar, first.y*scalar, first.z*scalar)","def loss_scale(self):\n return self._loss_scale","def freqscale(self):\n index = self._ordered_input_names.index('freqscale')\n return self._inputs[index]","def calc_scales(self, params_in):\n if self.use_scales:\n scale = params_in[0]\n B = params_in[1]\n sin_sq_theta = self.miller_array.two_theta(wavelength=self.wavelength) \\\n .sin_theta_over_lambda_sq().data()\n\n scales = scale * self.miller_array.data()\n exp_arg = flex.double(-2 * B * sin_sq_theta)\n return flex.double(flex.double(scales) * flex.exp(exp_arg))\n else:\n # Horrible way to get vector of ones...\n return flex.double(self.miller_array.data()/self.miller_array.data())","def select_range_and_scale(data, color_min, color_max, fac=1.0):\n scaled = ((data - color_min) * 1.0 / (color_max - color_min))\n scaled[scaled < 0.0] = 0.0\n scaled[scaled > 1.0] = 1.0\n if fac != 0.0:\n scaled = scaled * fac\n return scaled","def max_scale_image(self):\n maximum = np.argmax(self.transform, 0)\n return self.scale_array[maximum] * (self.support.sum(0) > 0)","def colorscale(self):\n return self[\"colorscale\"]"],"string":"[\n \"def GetScale(self):\\n ...\",\n \"def get_scale():\\r\\n\\r\\n \\r\\n return 0.5\",\n \"def scale(self):\\n return self.distribution.scale\",\n \"def FindScale(self):\\n\\n ## 6 and from the cv code the distance is 6 then we are good\\n print(\\\"TODO: Very hard\\\")\",\n \"def get_scaled_value(self, value):\\r\\n raise NotImplementedError()\",\n \"def scale(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def scale(self):\\n return self._scale\",\n \"def scaling(self):\\n return self.__scaling\",\n \"def scaling(self):\\n return self._scaling\",\n \"def scaling(self):\\n return self._scaling\",\n \"def scale(self) -> Optional[pulumi.Input['ScaleArgs']]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def _call_scale(vecObj, sc):\\n res = vecObj.scale(sc)\\n return res\",\n \"def scale(self):\",\n \"def get_scaled_value_at(self, offset):\\r\\n return self.get_scaled_value(self.get_value_at(offset))\",\n \"def scale(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def any_scale(scale):\\n return scale\",\n \"def get_scale_op(self):\\n\\t\\treturn self.variables.get('scale')\",\n \"def scale(self, value):\\r\\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0\",\n \"def scale_value(self):\\n return self._scale_value[2]\",\n \"def get_scale_parameter(self):\\r\\n \\r\\n if self.scale_parameter == 0.0: \\r\\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\\r\\n gamma_func = special.gamma(shape_in_gamma_func)\\r\\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\\r\\n return self.scale_parameter\\r\\n else:\\r\\n return self.scale_parameter\",\n \"def scale(self):\\n return self._gev_bijector.scale\",\n \"def scale(self, value):\\n return (float(value) - float(self.minimum)) / \\\\\\n float(self.maximum - self.minimum) * 2.0 - 1.0\",\n \"def scale(self):\\n return self._a\",\n \"def getScale(self):\\n \\n dag_node = OpenMaya.MFnDagNode(self.thisObj)\\n transform_node = OpenMaya.MFnTransform(dag_node.parent( 0 ))\\n \\n util = OpenMaya.MScriptUtil()\\n util.createFromDouble(0.0, 0.0, 0.0)\\n pointeur = util.asDoublePtr()\\n transform_node.getScale(pointeur)\\n \\n sx = util.getDoubleArrayItem(pointeur, 0)\\n sy = util.getDoubleArrayItem(pointeur, 1)\\n sz = util.getDoubleArrayItem(pointeur, 2)\\n\\n return sx, sy, sz\",\n \"def scale_parameter(self):\\n return self._scale_parameter\",\n \"def get_scale_parameter(self):\\n\\n if self.scale_parameter == 0.0:\\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\\n gamma_func = special.gamma(shape_in_gamma_func)\\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\\n return self.scale_parameter\\n else:\\n return self.scale_parameter\",\n \"def scale(self) -> Tuple[float, float]:\\n return self._scale\",\n \"def scaling(self):\\n return self.stacked._box_scaling[1]\",\n \"def getScaleValues(a, x):\\n raise NotImplementedError('getScaleValues not implemented')\",\n \"def GetUserScale(*args, **kwargs):\\n return _gdi_.DC_GetUserScale(*args, **kwargs)\",\n \"def scale_it(val):\\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])\",\n \"def _get_scaling(root):\\n dpi = root.winfo_fpixels(\\\"1i\\\")\\n scaling = dpi / 72.0\\n logger.debug(\\\"dpi: %s, scaling: %s'\\\", dpi, scaling)\\n return scaling\",\n \"def scale(input):\\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))\",\n \"def get_scale(self):\\r\\n try: return self.scale[0], self.scale[1], self.scale[2]\\r\\n except: return self.scale, self.scale, self.scale\",\n \"def scale(self, value):\\n\\t\\toldscale = self.oldmax - self.oldmin\\n\\t\\tnewscale = self.newmax - self.newmin\\n\\t\\treturn (newscale * (value - self.oldmin) / oldscale) + self.newmin\",\n \"def freq_optimization(self):\\n index = identify_scale(self.vz, True)\\n # In case the patient is limping\\n if index > 35:\\n index = index / 2\\n print(f\\\"Scale used is {index}\\\")\",\n \"def get_scaling_factor(c, default=None, warning=False, exception=False, hint=None):\\n try:\\n sf = c.parent_block().scaling_factor[c]\\n except (AttributeError, KeyError):\\n if not isinstance(c, (pyo.Param, _ParamData)):\\n if hint is None:\\n h = \\\"\\\"\\n else:\\n h = f\\\", {hint}\\\"\\n if warning:\\n if hasattr(c, \\\"is_component_type\\\") and c.is_component_type():\\n _log.warning(f\\\"Missing scaling factor for {c}{h}\\\")\\n else:\\n _log.warning(f\\\"Trying to get scaling factor for unnamed expr {h}\\\")\\n if exception and default is None:\\n if hasattr(c, \\\"is_component_type\\\") and c.is_component_type():\\n _log.error(f\\\"Missing scaling factor for {c}{h}\\\")\\n else:\\n _log.error(f\\\"Trying to get scaling factor for unnamed expr {h}\\\")\\n raise\\n sf = default\\n else:\\n # Params can just use current value (as long it is not 0)\\n val = pyo.value(c)\\n if not val == 0:\\n sf = abs(1 / pyo.value(c))\\n else:\\n sf = 1\\n return sf\",\n \"def _scale_param(self, resid_us):\\n return((resid_us**2).sum().sum() / self.dof)\",\n \"def scaling_object(self):\\n return self.__scaling_object\",\n \"def _scale(x):\\n scaleFactor = 1\\n _ret = int(x/scaleFactor)\\n return _ret\",\n \"def get_apply_scale(self, applyScaleFactor, scale_quality = 1.0):\\n v = self.scale * self.scale_quality * scale_quality\\n if applyScaleFactor:\\n v *= self.scale_factor\\n return v\",\n \"def prescaler(self) -> int:\",\n \"def getScale(self):\\n return self.factor**self.turnOn\",\n \"def get_scale_parameter(self):\\n\\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\\n gamma_func = special.gamma(shape_in_gamma_func)\\n self._scale_parameter = self._mean_fire_recurrence / gamma_func\",\n \"def get_s( self ):\\n\\n # initialize scaling factor as unknown variable, assuming it's real and\\n # greater than zero\\n _s = Symbol( 's', real = True, positive = True )\\n\\n # solve for scaling factor (first argument is expression set equal to zero)\\n s = solve( self.a * _s ** self.n + self.b * _s - 1, _s )\\n\\n # save result as float\\n self.s = float( s[ 0 ] )\",\n \"def xscale(value):\\n impl.xscale(**locals())\",\n \"def scale(val, src, dst):\\r\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\",\n \"def scale(self):\\n return self.scale_factor / CONSTANTS.AU\",\n \"def scale(val, src, dst):\\n try:\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\\n except ZeroDivisionError:\\n return 0.0\",\n \"def scale_root(self) -> int:\\r\\n ...\",\n \"def getScale(self):\\n return _libsbml.Unit_getScale(self)\",\n \"def set_and_get_scaling_factor(c, default, warning=False, exception=False, hint=None):\\n if c.is_indexed():\\n raise AttributeError(\\n f\\\"Ambiguous which scaling factor to return for indexed component {c.name}.\\\"\\n )\\n sf = get_scaling_factor(c, warning=warning, exception=exception, hint=hint)\\n if sf is None:\\n sf = default\\n set_scaling_factor(c, sf, data_objects=False)\\n return sf\",\n \"def simple_scaling(input_data):\\n\\n # Insert debugging assertions\\n assert type(input_data) is np.ndarray, \\\"The 'input_data' must be numpy array.\\\"\\n\\n # Get the minimum values of the input numpy array along the axis \\n Max = np.max(input_data, axis = 0)\\n\\n # Simple sclaing \\n scaled_input_data = input_data / (Max + sys.float_info.min)\\n\\n # Return scaled input data\\n return scaled_input_data\",\n \"def getScale(self, mode='ACC'):\\t#good\\r\\n\\t\\tif mode.upper() == 'ACC':\\r\\n\\t\\t\\treg = 0x1C\\r\\n\\t\\telif mode.upper() == 'GYR':\\r\\n\\t\\t\\treg = 0x1B\\t\\t\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn False\\r\\n\\t\\tcurrentVal = self.read(reg)\\r\\n\\t\\tcurrentVal = self.dec2BinList(currentVal)\\r\\n\\t\\tscaleSetting = (currentVal[4]*2) + (currentVal[3]*1) \\r\\n\\t\\tif mode.upper() == 'ACC':\\r\\n\\t\\t\\tscale = 2**(scaleSetting+1) \\r\\n\\t\\telif mode.upper() == 'GYR':\\r\\n\\t\\t\\tscale = (2**(scaleSetting+1))*125\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn False\\r\\n\\t\\treturn scale,scaleSetting\",\n \"def get_scale_freq():\\n return sf / 2 / (num_freq-1)\",\n \"def prescaler(self, value: int, /) -> None:\",\n \"def get_scale(self):\\n\\n if not hasattr(self, \\\"scale\\\"):\\n raise NotImplementedError(\\\"\\\"\\\"All end-use subclasses of Color should define\\n a get_scale method.\\\"\\\"\\\")\\n\\n return self.scale\",\n \"def scale(self, axis, value):\\r\\n assert (axis < EventStream.numAxes), \\\"Axis number out of range\\\"\\r\\n if self.absInfo[axis]:\\r\\n return self.absInfo[axis].scale(value)\\r\\n else:\\r\\n return value\",\n \"def scale(self, data: np.ndarray):\\n if self.scale_type == \\\"min_max\\\":\\n scaled_data = (data - self.predictor_min) / (\\n self.predictor_max - self.predictor_mean\\n )\\n elif self.scale_type == \\\"normalize\\\":\\n scaled_data = (data - self.predictor_mean) / (\\n self.predictor_max - self.predictor_min\\n )\\n elif self.scale_type == \\\"standardize\\\":\\n scaled_data = (data - self.predictor_mean) / self.predictor_std\\n elif self.scale_type == \\\"scale\\\":\\n scaled_data = data - self.predictor_mean\\n else:\\n scaled_data = data\\n return scaled_data\",\n \"def scale(x, minimum, maximum):\\n return (x - minimum) / (maximum - minimum)\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]\",\n \"def scaled_component(self, key):\\n\\n if key in self.components:\\n dat = self.components[key] \\n # Aliases\\n elif key in component_from_alias:\\n comp = component_from_alias[key]\\n if comp in self.components:\\n dat = self.components[comp] \\n else:\\n # Component not present, make zeros\\n return np.zeros(self.shape)\\n else:\\n raise ValueError(f'Component not available: {key}')\\n \\n # Multiply by scale factor\\n factor = self.factor \\n \\n if factor != 1:\\n return factor*dat\\n else:\\n return dat\",\n \"def Lookup(self, raw):\\n return self.scale.Lookup(raw)\",\n \"def test_scale_value(make_rampmodel):\\n\\n datmod = make_rampmodel(2, 2, 4, 2048, 2048)\\n\\n # Calculate the scale based off of the input.\\n scale = datmod.meta.exposure.frame_divisor / datmod.meta.exposure.nframes\\n\\n output = GroupScaleStep.call(datmod)\\n\\n scale_from_data = np.unique(output.data / datmod.data)\\n\\n # Since the scale value is applied uniformly to the array, if we divide the output\\n # by the input then we should get a single unique value (ie the scale) calculated\\n # by the pipeline.\\n assert len(scale_from_data) == 1\\n\\n # Make sure the scale calculated manually from the data model above matched what the\\n # pipeline calculated.\\n assert scale == scale_from_data[0]\",\n \"def get_scaled_value(self, value):\\r\\n if self.logarithmic_factor != 1.0:\\r\\n exp_mult = exp(self.logarithmic_factor * value * 4.0) - 1\\r\\n exp_div = exp(self.logarithmic_factor * 4.0) - 1\\r\\n return exp_mult / exp_div * (self.maxvalue - self.minvalue) + self.minvalue\\r\\n else:\\r\\n return value * (self.maxvalue - self.minvalue) + self.minvalue\",\n \"def scaling(self) -> Optional['outputs.AiFeatureStoreOnlineServingConfigScaling']:\\n return pulumi.get(self, \\\"scaling\\\")\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\",\n \"def point_scale_name(self):\",\n \"def _eta_sfr_scaling(self,x,q):\\n i = self.enum[q]\\n A = self.scaling_params['A'][i]\\n b = self.scaling_params['b'][i]\\n return A*x**b\",\n \"def scale(self, scale):\\n\\t\\tself._current_score *= scale\",\n \"def getscales(self):\\n return self.scales\",\n \"def rscale(mag=10.0):\\n if mag > 11.5:\\n return 0.5\\n elif mag > 11.0:\\n return 1.0\\n elif mag > 10.5:\\n return 1.5\\n elif mag > 10.0:\\n return 1.5\\n elif mag > 9.5:\\n return 2.0\\n elif mag > 9.0:\\n return 2.5\\n elif mag > 8.5:\\n return 3.0\\n else:\\n return 3.5\",\n \"def scale(f, a, j=0):\\n return f.per(dmp_scale_in(f.rep, f.dom.convert(a), j, f.lev, f.dom))\",\n \"def quantify ( value, scale ):\\r\\n\\r\\n\\r\\n\\tif value < scale[0] or value > scale[-1]: return value\\r\\n\\tfor i in range (1, len(scale)):\\r\\n\\t\\tif value <= scale[i]:\\r\\n\\t\\t\\tif scale[i] - value > value - scale[i-1]: return scale[i-1]\\r\\n\\t\\t\\telse: return scale[i]\",\n \"def setScale(self, *args):\\n return _libsbml.Unit_setScale(self, *args)\",\n \"def get_scaler(scaler):\\n if scaler == 'standard':\\n from sklearn.preprocessing import StandardScaler\\n return StandardScaler()\\n if scaler == 'minmax':\\n from sklearn.preprocessing import MinMaxScaler\\n return MinMaxScaler()\",\n \"def get_constraint_transform_applied_scaling_factor(c, default=None):\\n try:\\n sf = c.parent_block().constraint_transformed_scaling_factor.get(c, default)\\n except AttributeError:\\n sf = default # when there is no suffix\\n return sf\",\n \"def apply(self, value):\\n return (value - self._offset)/self._scale\",\n \"def scale(self,s):\\n return Vector(self.x * s, self.y * s, self.z * s)\",\n \"def get_scale(self):\\n\\n scales = []\\n for i in range(len(self.train_series)):\\n series = self.train_series.iloc[i].values\\n series = series[np.argmax(series != 0):]\\n scale = ((series[1:] - series[:-1]) ** 2).mean()\\n scales.append(scale)\\n\\n return np.array(scales)\",\n \"def get_scale(units, compartmentId, volume, extracellularVolume):\\r\\n if compartmentId == 'c':\\r\\n V = volume\\r\\n else:\\r\\n V = extracellularVolume\\r\\n\\r\\n if units == 'uM':\\r\\n return 1. / N_AVOGADRO / V * 1e6\\r\\n elif units == 'mM':\\r\\n return 1. / N_AVOGADRO / V * 1e3\\r\\n elif units == 'molecules':\\r\\n return 1.\\r\\n else:\\r\\n raise Exception('Invalid units \\\"%s\\\"' % units)\",\n \"def _hyperparam_to_scale(self, hyperparam):\\n\\n # If logscale is used, input hyperparam is log of the scale.\\n if self.use_log_scale:\\n scale = 10.0**hyperparam\\n else:\\n scale = numpy.abs(hyperparam)\\n\\n return scale\",\n \"def scale_data(self, data):\\n return (data - self.mean)/self.std\",\n \"def task_scaling(input_array, scaling_factor):\\n return(np.multiply(scaling_factor, input_array))\",\n \"def scaleValues(values):\\n\\n values = values - values.min()\\n return values/values.max()\",\n \"def showscale(self):\\n return self[\\\"showscale\\\"]\",\n \"def scale(z,h=0.7,omegalambda=0.7,omegam=0.3,omegak=0.0):\\n return distcalc(z,h,omegalambda,omegam,omegak)['scale']\",\n \"def mapVal(inputPos, in_min, in_max, out_min, out_max):\\n \\n \\n scale = ((out_max - out_min) / (in_max - in_min))\\n return float(((inputPos - in_min) * scale) + out_min)\",\n \"def get_scaled_weights(self):\\n span = self.maxval-self.minval\\n return (self.get_weights()-self.minval)/span\",\n \"def scale_to_factor(scale):\\n return (B.pi / 2) / (2 * scale**2)\",\n \"def imageScale(scale):\\n\\t\\treturn max(1, int(scale * (InterfaceTools.getCanvasSize()[0] / height)))\",\n \"def get_scaling(self):\\n if self.constrain_navigation:\\n self.activate_navigation_constrain()\\n return self.sx, self.sy\",\n \"def GetLogicalScale(*args, **kwargs):\\n return _gdi_.DC_GetLogicalScale(*args, **kwargs)\",\n \"def scale(first,scalar):\\n if isinstance(first,FreeCAD.Vector):\\n return FreeCAD.Vector(first.x*scalar, first.y*scalar, first.z*scalar)\",\n \"def loss_scale(self):\\n return self._loss_scale\",\n \"def freqscale(self):\\n index = self._ordered_input_names.index('freqscale')\\n return self._inputs[index]\",\n \"def calc_scales(self, params_in):\\n if self.use_scales:\\n scale = params_in[0]\\n B = params_in[1]\\n sin_sq_theta = self.miller_array.two_theta(wavelength=self.wavelength) \\\\\\n .sin_theta_over_lambda_sq().data()\\n\\n scales = scale * self.miller_array.data()\\n exp_arg = flex.double(-2 * B * sin_sq_theta)\\n return flex.double(flex.double(scales) * flex.exp(exp_arg))\\n else:\\n # Horrible way to get vector of ones...\\n return flex.double(self.miller_array.data()/self.miller_array.data())\",\n \"def select_range_and_scale(data, color_min, color_max, fac=1.0):\\n scaled = ((data - color_min) * 1.0 / (color_max - color_min))\\n scaled[scaled < 0.0] = 0.0\\n scaled[scaled > 1.0] = 1.0\\n if fac != 0.0:\\n scaled = scaled * fac\\n return scaled\",\n \"def max_scale_image(self):\\n maximum = np.argmax(self.transform, 0)\\n return self.scale_array[maximum] * (self.support.sum(0) > 0)\",\n \"def colorscale(self):\\n return self[\\\"colorscale\\\"]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7423413","0.73347855","0.73237866","0.73164004","0.7237661","0.71535647","0.71269476","0.70387477","0.7011061","0.7011061","0.6986615","0.6979968","0.6975686","0.695767","0.69401443","0.69075817","0.68978745","0.6861623","0.68483704","0.6829874","0.6802088","0.6780447","0.6778222","0.67607063","0.67532","0.67055094","0.6671363","0.66500187","0.6621191","0.66183776","0.6615346","0.65999806","0.64977086","0.6495174","0.64468324","0.64342695","0.64024055","0.6396536","0.63839245","0.6383135","0.63713753","0.6348068","0.63098645","0.62643343","0.6244955","0.62440854","0.6237093","0.62360203","0.62255585","0.61789864","0.6159179","0.615808","0.6157577","0.6152723","0.61485827","0.6142267","0.61406565","0.61404395","0.61263597","0.6116367","0.61127603","0.61096346","0.6103447","0.6092271","0.60842496","0.608367","0.6055937","0.6055937","0.60454637","0.6045013","0.6032693","0.60288066","0.6013431","0.6002282","0.5993054","0.5980722","0.5979196","0.597552","0.5974595","0.5973774","0.5964018","0.5956158","0.5947513","0.59370077","0.5927629","0.5918257","0.59144616","0.5903589","0.589495","0.5893805","0.5888154","0.5887852","0.58800703","0.5879292","0.5858978","0.5855334","0.5850887","0.58478504","0.5842365","0.58422047","0.5842018"],"string":"[\n \"0.7423413\",\n \"0.73347855\",\n \"0.73237866\",\n \"0.73164004\",\n \"0.7237661\",\n \"0.71535647\",\n \"0.71269476\",\n \"0.70387477\",\n \"0.7011061\",\n \"0.7011061\",\n \"0.6986615\",\n \"0.6979968\",\n \"0.6975686\",\n \"0.695767\",\n \"0.69401443\",\n \"0.69075817\",\n \"0.68978745\",\n \"0.6861623\",\n \"0.68483704\",\n \"0.6829874\",\n \"0.6802088\",\n \"0.6780447\",\n \"0.6778222\",\n \"0.67607063\",\n \"0.67532\",\n \"0.67055094\",\n \"0.6671363\",\n \"0.66500187\",\n \"0.6621191\",\n \"0.66183776\",\n \"0.6615346\",\n \"0.65999806\",\n \"0.64977086\",\n \"0.6495174\",\n \"0.64468324\",\n \"0.64342695\",\n \"0.64024055\",\n \"0.6396536\",\n \"0.63839245\",\n \"0.6383135\",\n \"0.63713753\",\n \"0.6348068\",\n \"0.63098645\",\n \"0.62643343\",\n \"0.6244955\",\n \"0.62440854\",\n \"0.6237093\",\n \"0.62360203\",\n \"0.62255585\",\n \"0.61789864\",\n \"0.6159179\",\n \"0.615808\",\n \"0.6157577\",\n \"0.6152723\",\n \"0.61485827\",\n \"0.6142267\",\n \"0.61406565\",\n \"0.61404395\",\n \"0.61263597\",\n \"0.6116367\",\n \"0.61127603\",\n \"0.61096346\",\n \"0.6103447\",\n \"0.6092271\",\n \"0.60842496\",\n \"0.608367\",\n \"0.6055937\",\n \"0.6055937\",\n \"0.60454637\",\n \"0.6045013\",\n \"0.6032693\",\n \"0.60288066\",\n \"0.6013431\",\n \"0.6002282\",\n \"0.5993054\",\n \"0.5980722\",\n \"0.5979196\",\n \"0.597552\",\n \"0.5974595\",\n \"0.5973774\",\n \"0.5964018\",\n \"0.5956158\",\n \"0.5947513\",\n \"0.59370077\",\n \"0.5927629\",\n \"0.5918257\",\n \"0.59144616\",\n \"0.5903589\",\n \"0.589495\",\n \"0.5893805\",\n \"0.5888154\",\n \"0.5887852\",\n \"0.58800703\",\n \"0.5879292\",\n \"0.5858978\",\n \"0.5855334\",\n \"0.5850887\",\n \"0.58478504\",\n \"0.5842365\",\n \"0.58422047\",\n \"0.5842018\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21494,"cells":{"query":{"kind":"string","value":"Computes the outcome of a single key by applying thresholding."},"document":{"kind":"string","value":"def _thresholding(qc_value, thresholds=None):\n MAX_BOUND, MIN_BOUND = (1, 0)\n if not thresholds:\n thresholds = TaskQC.criteria['default'].copy()\n if qc_value is None or np.isnan(qc_value):\n return int(-1)\n elif (qc_value > MAX_BOUND) or (qc_value < MIN_BOUND):\n raise ValueError(\"Values out of bound\")\n if 'PASS' in thresholds.keys() and qc_value >= thresholds['PASS']:\n return 0\n if 'WARNING' in thresholds.keys() and qc_value >= thresholds['WARNING']:\n return 1\n if 'FAIL' in thresholds and qc_value >= thresholds['FAIL']:\n return 2\n if 'NOT_SET' in thresholds and qc_value >= thresholds['NOT_SET']:\n return -1\n # if None of this applies, return 'NOT_SET'\n return -1"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def apply_thresholding(x):\n return x > threshold_otsu(x)","def global_threshold(img, threshold_method):\n pass","def binary_predict(probs, threshold = 0.5):\n return (probs >= threshold) * np.ones(len(probs))","def get_predict(prediction, threshold):\n\n prediction[prediction < threshold] = 0\n prediction[prediction >= threshold] = 1\n \n return prediction","def _check_threshold(threshold, value):\r\n return threshold[0](value, threshold[1])","def apply_thresholding_img(img, t1, t2):\n hist_threshold = np.where(img >= t1, img, 255)\n hist_threshold = np.where(hist_threshold < t2, 0, hist_threshold)\n return hist_threshold","def predict(self, key):\n return self.counts.get(key, 1.0)","def threshold(self,thresholdValue):\n # TO DO\n pass","def score_for_threshold(y, y_hat, score_func, threshold):\n y_rounded = np.where(y_hat >= threshold, 1, 0)\n return score_func(y, y_rounded)","def autothreshold(gray_im, method=\"otsu\"):\n if method == \"otsu\":\n t = otsu(gray_im)\n elif method == \"kmeans\":\n t = ave(kmeans(list(gray_im.getdata())))\n return gray_im.point(lambda x: 0 if x < t else 255) # < or <= ?","def evaluate(self, threshold=0.5):\n pass","def pure_pck(keys_pred, keys_gt, key_num_gt, image_scale, alpha):\n dif = keys_pred - keys_gt\n err = dif.norm(dim=2) / image_scale\n wrong = (err > alpha).sum(dim=1).float() # number of incorrect predictior\n pck = 1 - torch.div(wrong, key_num_gt)\n return pck","def thresh(self, thresh=25, total_ratings=False):\n before = self.item_count()\n\n if total_ratings: self.filter(self.n_per_item() >= thresh)\n else: self.filter(np.all(self.lam() >= thresh, axis=0))\n\n after = self.item_count()\n thresh_type = 'on each item total' if total_ratings else 'by each group' \n with msg(f'Applying threshold of {thresh} ratings {thresh_type} : {after} of {before}', done=False, enabled=self.output):pass","def discrete_potential(function, threshold):\n\n return np.where(function >= threshold, 1, 0)","def test_am_threshold(Simulator, plt, seed, rng):\n d = 64\n vocab = Vocabulary(d, pointer_gen=rng)\n vocab.populate('A; B; C; D')\n\n d2 = int(d / 2)\n vocab2 = Vocabulary(d2, pointer_gen=rng)\n vocab2.populate('A; B; C; D')\n\n def input_func(t):\n return '0.49 * A' if t < 0.1 else '0.8 * B'\n\n with spa.Network('model', seed=seed) as m:\n m.am = ThresholdingAssocMem(\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\n function=filtered_step_fn, mapping='by-key')\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\n m.stimulus >> m.am\n\n in_p = nengo.Probe(m.am.input)\n out_p = nengo.Probe(m.am.output, synapse=0.03)\n\n with Simulator(m) as sim:\n sim.run(0.3)\n t = sim.trange()\n below_th = t < 0.1\n above_th = t > 0.25\n\n plt.subplot(2, 1, 1)\n plt.plot(t, similarity(sim.data[in_p], vocab))\n plt.ylabel(\"Input\")\n plt.subplot(2, 1, 2)\n plt.plot(t, similarity(sim.data[out_p], vocab2))\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\n plt.ylabel(\"Output\")\n\n assert np.mean(sim.data[out_p][below_th]) < 0.01\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)","def anoise(this, *args, **kargs):\n\t\t\n\t\t# Arguments\n\t\tif not args: args = [50]\n\t\t\n\t\t# Kernel's retrieval\n\t\tanoisek = this._ANOISEK\n\t\tif anoisek is None: return None\n\t\t\n\t\t# More magic\n\t\tbin = this._BINARY\n\t\tfor thresh in args:\n\t\t\tbin[:,:] = (cv2.filter2D(bin, -1, anoisek) / 2.55 > thresh) * 255\n\t\treturn True","def pred_from_prob(a,threshold):\n bin_preds = np.zeros((np.size(a,0),))\n bin_preds[np.where(a[:,1]>threshold)]=1.0\n return bin_preds","def compute(self,filter_name):\n self.result = []\n for img in self.imgs:\n r = filters_dict[filter_name](img)\n if \"threshold\" in filter_name:\n r = img>r\n r = 1.0*r.copy()\n self.result.append(r)","def _get_pck(self, kp_id, threshold):\n if len(self.data[kp_id]) == 0:\n return None\n\n data = np.array(self.data[kp_id])\n pck = np.mean((data <= threshold).astype('float'))\n return pck","def apply_threshold(heatmap, threshold):\n heatmap_thresh = np.copy(heatmap)\n ind = np.where(np.logical_and(heatmap_thresh>1, heatmap_thresh<=threshold))\n heatmap_thresh[ind] = 0\n #heatmap_thresh[(heatmap_thresh <= threshold)] = 0\n return heatmap_thresh","def reward_threshold(self) -> Optional[float]:","def apply_threshold(heatmap, threshold):\n heatmap[heatmap <= threshold] = 0\n\n return heatmap","def testD():\n results = {}\n for threshold in ['volume', 25, 35,40, 20, ]: #adjust here\n print threshold\n results[threshold] = testC(threshold=threshold)\n return results","def keys_geq_threshold (Dict, threshold):\n for key, value in Dict.items ():\n if value >= threshold:\n yield key","def perform_thresholding(f,M,type):\n if type == \"largest\":\n a = np.sort(np.ravel(abs(f)))[::-1] #sort a 1D copy of F in descending order\n T = a[M]\n y = f*(abs(f) > T)\n elif type == \"soft\":\n s = abs(f) - M\n s = (s + abs(s))/2\n y = np.sign(f)*s\n elif type == \"hard\":\n y = f*(abs(f) > M)\n return y","def predict(self, X):\n z = self.transform(X)\n pred = z < self.threshold\n return pred","def _estimate_threshold(self, **kwargs):\n recompute_threshold = kwargs.pop('recompute_threshold', False)\n # if threshold is in table, then use it.\n current_setting = (self.beta, self.chi2dist.kwds['df'])\n threshold = None\n res = False\n if not recompute_threshold and current_setting in _gaussian_cusum_thresholds.keys():\n for e in _gaussian_cusum_thresholds[current_setting]:\n if e[0] == self.arl:\n threshold = np.array([e[1]])\n res = True\n # if threshold not is in table, estimate it\n if threshold is None:\n len_simulation = kwargs.pop('len_simulation', None)\n if len_simulation is None:\n len_simulation = 10 * self.arl\n self.log.info(\"estimating threshold...\")\n plain_cusum = Cusum(arl=self.arl, beta=self.beta)\n plain_cusum.gamma = self.gamma\n d2_training = self.chi2dist.rvs(size=(int(len_simulation), 1))\n kwargs.pop('x', None)\n res = plain_cusum._estimate_threshold(x=d2_training, dof=self.chi2dist.kwds['df'],\n **kwargs)\n threshold = plain_cusum.threshold\n self.threshold = threshold\n return res","def increase_dict_values_for_low_enough_keys(threshold, dictionary):\n\n dictionary = dictionary.update((x, y+1) for x, y in dictionary.items() if threshold >= x)\n return dictionary","def threshold(self, value):\r\n threshold = 0.5\r\n if value >= threshold:\r\n return 1\r\n else:\r\n return 0","def threshold_predict(X, w, theta):\n tmp = theta[:, None] - np.asarray(X.dot(w))\n pred = np.sum(tmp < 0, axis=0).astype(np.int)\n return pred","def soft_threshold(self, weight, lambd):\n if weight > lambd:\n result = weight - lambd\n elif abs(weight) <= lambd:\n result = 0\n else:\n result = weight + lambd\n return result","def hash_threshold(token_dict, fp_len):\n sum_hash = [0] * fp_len\n for _, token in token_dict.items():\n sum_hash = [ x + token.weight * y for x, y in zip(sum_hash, token.hash_list)]\n\n # apply binary threshold\n for i, ft in enumerate(sum_hash):\n if ft > 0:\n sum_hash[i] = 1\n else:\n sum_hash[i] = 0\n return sum_hash","def prepare_val_res(score, threshold):\n new_whale = 'new_whale'\n\n res ={}\n\n train_arr = np.array(train)\n\n for i,p in enumerate(val):\n t = []\n s = set()\n a = score[i,:]\n\n top_label_probs = {}\n cond = a > threshold\n cond_index = np.where(cond)[0]\n cond_images = train_arr[cond_index]\n for j, img in enumerate(cond_images):\n if tagged[img] in top_label_probs:\n top_label_probs[tagged[img]] += a[cond_index[j]]\n else:\n top_label_probs[tagged[img]] = a[cond_index[j]]\n\n sorted_top_label_probs = sort_dict_by_values(top_label_probs)\n\n t = []\n for lb, _ in sorted_top_label_probs:\n t.append(lb)\n\n if len(t) < 5:\n t.append(new_whale)\n\n for index in np.argsort(a)[::-1]:\n if tagged[train_arr[index]] not in t:\n t.append(tagged[train_arr[index]])\n if len(t) >= 5:\n break\n\n assert len(t) >= 5\n\n res[p[:-4]+'.jpg'] = t[:5]\n\n return res","def round_pred_at_threshold(squares_dict, threshold=THRESHOLD):\n for sq in squares_dict:\n predict = sq.predict\n if predict < threshold:\n sq.replace(pred_int = 0)\n else:\n sq.replace(pred_int = 1)\n return squares_dict","def compute_recall_at_k(self, gt: List[bool], result_dict: Dict) -> None:\n ks = self._hyper_params[\"recall_k\"]\n gt = gt[:ks[-1]]\n first_tp = np.where(gt)[0]\n if len(first_tp) == 0:\n return\n for k in ks:\n if k >= first_tp[0] + 1:\n result_dict[k] = result_dict[k] + 1","def current_threshold_hit(self):\n\n\t\tnew_current = self.robot.pdp.getCurrent(const.CARGO_PDP_ID)\n\n\t\tself._current_samples.append(new_current)\n\n\t\tif len(self._current_samples) > 10:\n\t\t\tself._current_samples.pop(0)\n\n\t\t# Calculate new running average\n\t\tnew_avg = sum(self._current_samples) / len(self._current_samples)\n\n\t\treturn new_avg > const.CARGO_INTAKE_THRESHOLD","def apply_hounsfield_thresholding(data_, threshold: tuple = (200, 600)):\n mask = np.ma.masked_inside(data_, threshold[0], threshold[1], ).mask\n thresholded = np.zeros_like(data_)\n thresholded[mask] = data_[mask]\n return thresholded","def overlay_thresholding_function(threshold, positive=True):\n # from the interface class definition above, there will be 3 values\n # for the thresh type: inactive, less than, greater than\n t = threshold[0]\n if threshold[-1] == 'inactive':\n if positive:\n return lambda x: np.ones(x.shape, 'B')\n return lambda x: np.zeros(x.shape, 'B')\n elif threshold[-1] == 'less than':\n if positive:\n return lambda x: np.less(x,t)\n return lambda x: np.greater_equal(x,t)\n elif threshold[-1] == 'greater than':\n if positive:\n return lambda x: np.greater(x,t)\n return lambda x: np.less_equal(x,t)\n else:\n print 'unrecognized thresholding parameters:', threshold","def apply_threshold(heatmap, threshold):\n # Zero out pixels below the threshold\n thresh_heatmap = np.copy(heatmap)\n thresh_heatmap[heatmap <= threshold] = 0\n # Return thresholded map\n return thresh_heatmap","def test_output_is_above_threshold_counterfactuals(self):\n threshold = 0.1\n self._config['Regression threshold'] = str(threshold)\n self._example = {'x_1': 0.0, 'x_2': -5.0}\n output = self._gen.generate(\n example=self._example,\n model=self._model,\n dataset=self._dataset,\n config=self._config)\n target_score = self._predict_and_return_score(self._example)\n self.assertLess(target_score, threshold)\n self.assertNotEmpty(output)\n for cf_example in output:\n cf_score = self._predict_and_return_score(cf_example)\n self.assertGreaterEqual(cf_score, threshold)","def threshold(img, thresh):\n return cv2.threshold(img, thresh, 255, cv2.THRESH_BINARY)[1]","def precision_threshold(predictions, targets, threshold=0.7):\n number_of_examples_meeting_threshold = 0\n\n for pred, targ in zip(predictions, targets):\n total_positive_guesses = sum(pred)\n correct_positive_guesses = 0\n\n for shift_pred, shift_targ in zip(pred, targ):\n if shift_pred == 1 and shift_targ == 1:\n correct_positive_guesses += 1\n\n example_precision = correct_positive_guesses / total_positive_guesses\n if example_precision > threshold:\n number_of_examples_meeting_threshold += 1\n\n print(number_of_examples_meeting_threshold)\n examples_meeting_threshold_ratio = number_of_examples_meeting_threshold / len(predictions)\n print(examples_meeting_threshold_ratio)","def _compute_sampling_threshold(global_step, k):\n return k / (k + math.exp(global_step / k))","def apply_threshold(heatmap, threshold):\n # Zero out pixels below the threshold\n heatmap[heatmap <= threshold] = 0\n # Return thresholded map\n return heatmap","def apply_threshold(heatmap, threshold):\n # Zero out pixels below the threshold\n heatmap[heatmap <= threshold] = 0\n # Return thresholded map\n return heatmap","def apply_threshold(heatmap, threshold):\n # Zero out pixels below the threshold\n heatmap[heatmap <= threshold] = 0\n # Return thresholded map\n return heatmap","def soft_thresholding(w, alpha):\n return np.sign(w) * np.clip(np.abs(w) - alpha, 0.0, np.inf)","def ap(gt, pred, k):\n if len(pred) > k:\n pred = pred[:k]\n\n score = 0.0\n num_hits = 0.0\n\n for i, p in enumerate(pred):\n if p in gt:\n num_hits += 1.0\n score += num_hits / (i + 1.0)\n\n if not gt:\n return 0.\n\n return score / min(len(gt), k)","def _compute_sampling_threshold(global_step, k):\n return tf.cast(k / (k + tf.exp(global_step / k)), tf.float32)","def conditional(self, func):\n out = Prob()\n for k, v in self.items():\n if func(k):\n out[k] = v\n out.normalize()\n return out","def infer_threshold(self, x: np.ndarray, fpr: float) -> None:\n self.backend.infer_threshold(self.backend._to_backend_dtype(x), fpr)","def test_key_predicate(datum):\n return 0 < datum","def threshold(activation):\n if activation >= 0.0:\n return 1\n else:\n return 0","def find_metric_threshold(self):\n logger.info(\"compute metric threshold\")\n\n ### Beaucoup trop lent quand on a beaucoup de models ###\n\n df_results_not_aggregated = self.result_reader.load_all_results(aggregate=False)\n\n if len(df_results_not_aggregated) == 0:\n logger.info(\"threshold = None\")\n return None\n\n main_scorer = \"test_%s\" % self.job_config.main_scorer\n (df_results_not_aggregated[main_scorer].fillna(df_results_not_aggregated[main_scorer].min(), inplace=True))\n min_cv = df_results_not_aggregated.groupby(\"job_id\")[main_scorer].min().values\n delta_min_max_cv = np.median(\n df_results_not_aggregated.groupby(\"job_id\")[main_scorer].apply(lambda x: x.max() - x.min())\n )\n\n if len(min_cv) <= self.min_nb_of_models:\n logger.info(\"threshold = None\")\n return None\n\n min_cv = -np.sort(-min_cv)\n result = min_cv[self.min_nb_of_models] - delta_min_max_cv\n\n # result = np.percentile( min_cv, self._get_quantile(len(min_cv)) * 100)\n # TODO : ici peut etre faire une estimation parametric du quantile avec un Kernel, plus smooth et moins sensible quand peu de valeurs\n\n logger.info(\"threshold : %2.2f\" % result)\n return result","def round_using_t(prediction, threshold):\n return (prediction >= threshold).astype('int')","def getThreshold(self): # real signature unknown; restored from __doc__\n pass","def test_output_is_below_threshold_counterfactuals(self):\n threshold = 2.8\n self._config['Regression threshold'] = str(threshold)\n self._example = {'x_1': 1.0, 'x_2': 1.0}\n output = self._gen.generate(\n example=self._example,\n model=self._model,\n dataset=self._dataset,\n config=self._config)\n target_score = self._predict_and_return_score(self._example)\n self.assertGreaterEqual(target_score, threshold)\n self.assertNotEmpty(output)\n for cf_example in output:\n cf_score = self._predict_and_return_score(cf_example)\n self.assertLess(cf_score, threshold)","def soft_threshold(X, threshold):\n X_thresholded = (np.abs(X) > threshold).astype('int')\n X_soft_threshold = np.sign(X) * (np.abs(X) - threshold) * X_thresholded\n return X_soft_threshold","def bin_thres_img(img, ksize=3):\n # Apply each of the thresholding functions\n gradx = abs_sobel_thresh(img, orient='x', sobel_kernel=ksize, thresh=(20, 100))\n grady = abs_sobel_thresh(img, orient='y', sobel_kernel=ksize, thresh=(20, 100))\n\n mag_binary = mag_thresh(img, sobel_kernel=ksize, mag_thresh=(30, 100))\n dir_binary = dir_threshold(img, sobel_kernel=ksize, thresh=(0.7, 1.3))\n\n hls_binary = hls_select(img, thresh=(170, 255))\n\n combined = np.zeros_like(dir_binary)\n combined[((gradx == 1) & (grady == 1)) | ((mag_binary == 1) & (dir_binary == 1)) | hls_binary == 1] = 1\n return combined","def predict_with_threshold(y_pred_proba, threshold):\n\n y_pred = [1 if x >= threshold else 0 for x in y_pred_proba]\n return pd.Series(data=y_pred, name='y_pred')","def sensitivity(\n targets: List[int], preds: List[float], threshold: float = 0.5\n) -> float:\n return recall(targets, preds, threshold)","def thresholding(pred,label,thres):\n \n conf =[]\n \n for i in thres:\n \n pr_th,lab_th = (pred>i),(label>i)\n conf += confusion(pr_th,lab_th)\n \n return np.array(conf).reshape(-1,4)","def compute_score(self, pred: Tensor, target: Tensor) -> Tensor:\n\t\tif self.threshold_input is not None:\n\t\t\tpred = pred.ge(self.threshold_input).float()\n\n\t\tif self.threshold_target is not None:\n\t\t\ttarget = target.ge(self.threshold_target).float()\n\n\t\trecall = self.recall(pred, target)\n\t\tprecision = self.precision(pred, target)\n\n\t\tscore = (1.0 + self.beta ** 2) * precision * recall / (self.beta ** 2 * precision + recall)\n\t\tscore[score.isnan()] = 0.0\n\n\t\tif self.reduce_fn is not None:\n\t\t\tscore = self.reduce_fn(score)\n\n\t\treturn score","def calculate(memory):\r\n dThthreshold = \r\n Ththreshold = f(memory['latitude'],memory['longitude'])\r\n \r\n dTh = sum(i > dThthreshold for i in memory['dTh'])\r\n \r\n return","def ks_test_function(dim, thresh):\n def ks_test(table1, table2):\n from scipy.stats import ks_2samp\n sample1 = table1.get_cols(dim)[0]\n sample2 = table2.get_cols(dim)[0]\n if thresh != None:\n sample1[sample1<thresh] = 0\n sample2[sample2<thresh] = 0\n ks, p_ks = ks_2samp(sample1, sample2)\n return ks\n return ks_test","def binary_accuracy(y_true, y_pred, threshold=0.5):\n assert y_true.shape == y_pred.shape\n y_pred_thresholded = (y_pred >= threshold).astype(float)\n correct_predictions = y_pred_thresholded == y_true \n return correct_predictions.mean()","def decision_threshold(x, y):\n \n model = DecisionTreeClassifier(max_depth=1, criterion='entropy')\n model.fit(x,y)\n print (\"-- Uncertainty Threshold: \", model.tree_.threshold[0])\n return model.tree_.threshold[0]","def test_check_single_threshold(self):\n data = np.array(\n [\n [[13.2, 8.0, 13.2], [-46.0, 8.0, -78.4], [-78.4, -86.5, -89.2]],\n [[34, 31.1111, 34.0], [27.5, 31.1111, 8.0], [8.0, -32.5, -46.0]],\n [[54.8, 54.2222, 54.8], [53.5, 54.2222, 49.6], [49.6, 34, -2.8]],\n ],\n dtype=np.float32,\n )\n\n threshold_coord = find_threshold_coordinate(self.cube)\n cube = next(self.cube.slices_over(threshold_coord))\n\n result = Plugin()._probabilities_to_percentiles(cube, self.percentiles)\n self.assertArrayAlmostEqual(result.data, data, decimal=4)","def test_soft_threshold():\n assert snet.soft_threshold(10, 100) == 0\n assert snet.soft_threshold(-10, 100) == 0\n assert snet.soft_threshold(10, 3) == 7\n assert snet.soft_threshold(-10, 3) == -7","def run_algo(self, th):\n p = self.run_proc(['threshold', str(th), 'input_0.png',\n 'output.png'])\n self.wait_proc(p, timeout=self.timeout)\n return","def threshold(X, thresh):\n Y = np.array(X)\n Y[Y >= thresh] = 1\n Y[Y < thresh] = 0\n return Y","def thresh_setup():\n pass","def _estimate_threshold(self, x=None, threshold_type='numerical', **kwargs):\n\n if threshold_type == \"data\":\n return super()._estimate_threshold(x)\n \n # if threshold is in table, then use it.\n current_setting = (self.beta, self._chi2dist.kwds['df'])\n threshold = None\n res = False\n # Whether to recompute thresholds\n recompute_threshold = kwargs.pop('recompute_threshold', False)\n if not recompute_threshold and current_setting in _gaussian_cusum_thresholds.keys():\n for e in _gaussian_cusum_thresholds[current_setting]:\n if e[0] == self.arl:\n threshold = np.array([e[1]])\n res = True\n\n # if threshold not is in table, estimate it\n if threshold is None:\n len_simulation = kwargs.pop('len_simulation', None)\n if len_simulation is None:\n len_simulation = 10 * self.arl\n self.log.info(\"estimating threshold...\")\n plain_cusum = Cusum(arl=self.arl, beta=self.beta)\n plain_cusum.gamma = self.gamma\n d2_training = self._chi2dist.rvs(size=(int(len_simulation), 1))\n kwargs.pop('x', None)\n res = plain_cusum._estimate_threshold(x=d2_training, dof=self._chi2dist.kwds['df'],\n **kwargs)\n threshold = plain_cusum.threshold\n \n # set threshold\n self.threshold = threshold\n return res","def test_soft_threshold_array():\n a = np.array([10, -10, 200, -200])\n np.testing.assert_allclose(snet.soft_threshold(a, 100),\n np.array([0, 0, 100, -100]))\n np.testing.assert_allclose(snet.soft_threshold(a, 3),\n np.array([7, -7, 197, -197]))","def bin_key(color_key, threshhold=0.2):\n bins = 1.0 / threshhold\n if int(bins) != bins:\n raise ValueError(\"threshhold must divide 1.0 evenly\")\n else:\n bins = int(bins)\n\n rounded_key = np.array(color_key)\n for i in xrange(color_key.shape[0]):\n bin = int(round(color_key[i] / threshhold))\n rounded_color = float(bin) / float(bins)\n rounded_key[i] = rounded_color\n return tuple(rounded_key)","def __call__(self, *args, **kwargs):\n out = super().__call__(*args, **kwargs)\n out **= 2\n self._debug.append(out)\n out = int(out > self.threshold_value)\n if out and self.since_last_peak > self._num_of_taps:\n self.since_last_peak = -1\n else:\n out = 0\n self.since_last_peak += 1\n return out","def adjusted_classes(pred_prob, threshold):\n return [1 if y >= threshold else 0 for y in pred_prob]","def nn_threshold_predict(X, nn, theta):\n tmp = theta.reshape((1, np.size(theta))) - nn.predict(X)\n pred = np.sum(tmp < 0, axis=1).astype(np.int)\n return np.array(pred)","def voxel_thresholded_ttest(x, threshold):\n t = ttest(x)\n return t > threshold","def scale(img):\n result = [[1 if x > BINARY_THRESHOLD else 0 for x in row] for row in img]\n return result","def thresholdClassify(sim_vec_dict, sim_thres):\n\n assert sim_thres >= 0.0 and sim_thres <= 1.0, sim_thres\n\n print('Similarity threshold based classification of %d record pairs' % \\\n (len(sim_vec_dict)))\n print(' Classification similarity threshold: %.3f' % (sim_thres))\n\n class_match_set = set()\n class_nonmatch_set = set()\n\n # Iterate over all record pairs\n #\n for (rec_id_tuple, sim_vec) in sim_vec_dict.items():\n # ********* Implement threshold based classification **********************\n\n pass # Add your code here\n\n # ************ End of your code *******************************************\n\n print(' Classified %d record pairs as matches and %d as non-matches' % \\\n (len(class_match_set), len(class_nonmatch_set)))\n print('')\n\n return class_match_set, class_nonmatch_set","def keypoint_loss(self, pred_keypoints_2d, gt_keypoints_2d, openpose_weight, gt_weight):\n conf = gt_keypoints_2d[:, :, -1].unsqueeze(-1).clone()\n conf[:, :25] *= openpose_weight\n conf[:, 25:] *= gt_weight\n loss = (conf * self.criterion_keypoints(pred_keypoints_2d, gt_keypoints_2d[:, :, :-1])).mean()\n return loss","def result(\n metrics: Dict[metric_types.MetricKey, float]\n ) -> Dict[metric_types.MetricKey, float]:\n output = {}\n for threshold in thresholds:\n ptn = flip_count_metric_key_by_name_by_threshold[threshold][\n 'positive_to_negative']\n ntp = flip_count_metric_key_by_name_by_threshold[threshold][\n 'negative_to_positive']\n pos_examples = flip_count_metric_key_by_name_by_threshold[threshold][\n 'positive_to_negative_examples_ids']\n neg_examples = flip_count_metric_key_by_name_by_threshold[threshold][\n 'negative_to_positive_examples_ids']\n pos = flip_count_metric_key_by_name_by_threshold[threshold][\n 'positive_examples_count']\n neg = flip_count_metric_key_by_name_by_threshold[threshold][\n 'negative_examples_count']\n output[metric_key_by_name_by_threshold[threshold]\n ['overall']] = (metrics[ntp] + metrics[ptn]) / (\n metrics[pos] + metrics[neg])\n output[metric_key_by_name_by_threshold[threshold]\n ['positive_to_negative']] = metrics[ptn] / metrics[pos]\n output[metric_key_by_name_by_threshold[threshold]\n ['negative_to_positive']] = metrics[ntp] / metrics[neg]\n output[metric_key_by_name_by_threshold[threshold]\n ['positive_to_negative_examples_ids']] = metrics[pos_examples]\n output[metric_key_by_name_by_threshold[threshold]\n ['negative_to_positive_examples_ids']] = metrics[neg_examples]\n\n return output","def thresholdfactor(self):\n return self.__thresholdfactor","def evaluateObjective(posts, threshold):\n partialSum = 0\n for post in posts:\n partialSum += max(np.sign(post[\"similarity\"] - threshold) * post[\"score\"], 0)\n return partialSum","def threshold(image, selem, out=None, mask=None, shift_x=False, shift_y=False):\n\n return _apply(_crank8.threshold, _crank16.threshold, image, selem, out=out,\n mask=mask, shift_x=shift_x, shift_y=shift_y)","def find_TPR_threshold(y, scores, desired_TPR):\n for threshold in np.arange(1,0,-0.01):\n y_hat = (scores>=threshold).astype(int)\n confusion = confusion_matrix(y, y_hat)\n TN, FP, FN, TP = confusion.flat\n TPR = TP / (TP + FN)\n FPR = FP / (FP + TN)\n if TPR >= desired_TPR:\n return threshold, FPR","def threshold(input_tensor, th, val, name):\n with tf.variable_scope(name) as scope:\n\n # First figure out where values are less than\n lessthan_tensor = tf.cast(tf.lesser(input_tensor, th), tf.int32)\n greaterthan_tensor = tf.cast(tf.greater(input_tensor, th), tf.int32)\n\n # Then make thresholded values equal to val and the rest are the same\n out_tensor = input_tensor * greaterthan_tensor + val * lessthan_tensor\n\n return out_tensor","def PT_loose_thresh(x, a, b, ma, mb):\n out = PT_indicator(x, a, b) * x + PT_indicator(x, b, None) * (b + mb * (x - b)) + PT_indicator(x, None, a) * (a + ma * (x-a))\n return out","def bin_thresh(img: np.ndarray, thresh: Number) -> np.ndarray:\n res = img >= thresh\n return res","def image_thresholding(image: np.ndarray):\n # Resize image to a shape of (48, 48)\n image = image_as_square(image)\n\n # Find threshold using Otsu filter\n threshold: float = filters.threshold_otsu(image)\n binary = image > threshold\n\n binary_image = np.where(image, binary, 0) * 255\n\n # Resize the iamge back to a shape of (2304, )\n return image_as_array(image)","def threshold_image(img, threshold=THRESHOLD):\n return cv2.threshold(img, threshold, MAX_GRAY_SCALE, cv2.THRESH_BINARY)","def precision(gt, pred, k):\n k = min(len(pred), k)\n den = min(len(gt), k)\n return sum([int(pred[i] in gt) for i in range(k)]) / den","def threshold_trec_run(run, fold, k):\n filtered_run = defaultdict(dict)\n # This is possible because best_search_run is an OrderedDict\n for qid, docs in run.items():\n if qid in fold[\"predict\"][\"test\"]:\n for idx, (docid, score) in enumerate(docs.items()):\n if idx >= k:\n break\n filtered_run[qid][docid] = score\n\n return filtered_run","def find_entropy(less_than_threshold,more_than_threshold):\n\n ''' Storing total number of records '''\n total_records = len(less_than_threshold) + len(more_than_threshold)\n\n ''' Calculating the probability '''\n less_than_probability = len(less_than_threshold) / total_records\n more_than_probability = len(more_than_threshold) / total_records\n\n ''' Converting the dataframe to numpy arrays '''\n less_than_threshold_values = less_than_threshold.values\n more_than_threshold_values = more_than_threshold.values\n\n ''' Storing the target attribute values (Muffin or Cupcake) for threshold values '''\n target_for_less_than = less_than_threshold_values[:, -1]\n target_for_more_than = more_than_threshold_values[:, -1]\n\n ''' Finding the counts of muffin and cupcake for values lower than and greater than threshold value '''\n recipe_type, less_than_cupcake_muffin_count = np.unique(target_for_less_than, return_counts=True)\n recipe_type, more_than_cupcake_muffin_count = np.unique(target_for_more_than, return_counts=True)\n\n # print(recipe_type, more_than_cupcake_muffin_count, len(more_than_cupcake_muffin_count))\n ''' To ensure there are at least 5 records in each node '''\n if less_than_cupcake_muffin_count.sum() < 5 or more_than_cupcake_muffin_count.sum() < 5:\n ''' Return horrible badness '''\n return math.inf\n else:\n ''' Find the entropies for less than threshold values and more than threshold values '''\n less_than_entropy = sum((less_than_cupcake_muffin_count / less_than_cupcake_muffin_count.sum()) * - np.log2(\n less_than_cupcake_muffin_count / less_than_cupcake_muffin_count.sum()))\n more_than_entropy = sum((more_than_cupcake_muffin_count / more_than_cupcake_muffin_count.sum()) * - np.log2(\n more_than_cupcake_muffin_count / more_than_cupcake_muffin_count.sum()))\n\n ''' Calculate the total weighted entropy '''\n total_weighted_entropy = less_than_probability * less_than_entropy + more_than_probability * more_than_entropy\n\n return total_weighted_entropy","def threshold(self) -> pulumi.Input[float]:\n return pulumi.get(self, \"threshold\")","def threshold(self) -> pulumi.Input[float]:\n return pulumi.get(self, \"threshold\")","def threshold(self) -> pulumi.Input[float]:\n return pulumi.get(self, \"threshold\")","def threshold(self) -> pulumi.Input[float]:\n return pulumi.get(self, \"threshold\")","def threshold(self) -> pulumi.Input[float]:\n return pulumi.get(self, \"threshold\")","def __cv_threshold(src, thresh, max_val, type):\n return cv2.threshold(src, thresh, max_val, type)[1]"],"string":"[\n \"def apply_thresholding(x):\\n return x > threshold_otsu(x)\",\n \"def global_threshold(img, threshold_method):\\n pass\",\n \"def binary_predict(probs, threshold = 0.5):\\n return (probs >= threshold) * np.ones(len(probs))\",\n \"def get_predict(prediction, threshold):\\n\\n prediction[prediction < threshold] = 0\\n prediction[prediction >= threshold] = 1\\n \\n return prediction\",\n \"def _check_threshold(threshold, value):\\r\\n return threshold[0](value, threshold[1])\",\n \"def apply_thresholding_img(img, t1, t2):\\n hist_threshold = np.where(img >= t1, img, 255)\\n hist_threshold = np.where(hist_threshold < t2, 0, hist_threshold)\\n return hist_threshold\",\n \"def predict(self, key):\\n return self.counts.get(key, 1.0)\",\n \"def threshold(self,thresholdValue):\\n # TO DO\\n pass\",\n \"def score_for_threshold(y, y_hat, score_func, threshold):\\n y_rounded = np.where(y_hat >= threshold, 1, 0)\\n return score_func(y, y_rounded)\",\n \"def autothreshold(gray_im, method=\\\"otsu\\\"):\\n if method == \\\"otsu\\\":\\n t = otsu(gray_im)\\n elif method == \\\"kmeans\\\":\\n t = ave(kmeans(list(gray_im.getdata())))\\n return gray_im.point(lambda x: 0 if x < t else 255) # < or <= ?\",\n \"def evaluate(self, threshold=0.5):\\n pass\",\n \"def pure_pck(keys_pred, keys_gt, key_num_gt, image_scale, alpha):\\n dif = keys_pred - keys_gt\\n err = dif.norm(dim=2) / image_scale\\n wrong = (err > alpha).sum(dim=1).float() # number of incorrect predictior\\n pck = 1 - torch.div(wrong, key_num_gt)\\n return pck\",\n \"def thresh(self, thresh=25, total_ratings=False):\\n before = self.item_count()\\n\\n if total_ratings: self.filter(self.n_per_item() >= thresh)\\n else: self.filter(np.all(self.lam() >= thresh, axis=0))\\n\\n after = self.item_count()\\n thresh_type = 'on each item total' if total_ratings else 'by each group' \\n with msg(f'Applying threshold of {thresh} ratings {thresh_type} : {after} of {before}', done=False, enabled=self.output):pass\",\n \"def discrete_potential(function, threshold):\\n\\n return np.where(function >= threshold, 1, 0)\",\n \"def test_am_threshold(Simulator, plt, seed, rng):\\n d = 64\\n vocab = Vocabulary(d, pointer_gen=rng)\\n vocab.populate('A; B; C; D')\\n\\n d2 = int(d / 2)\\n vocab2 = Vocabulary(d2, pointer_gen=rng)\\n vocab2.populate('A; B; C; D')\\n\\n def input_func(t):\\n return '0.49 * A' if t < 0.1 else '0.8 * B'\\n\\n with spa.Network('model', seed=seed) as m:\\n m.am = ThresholdingAssocMem(\\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\\n function=filtered_step_fn, mapping='by-key')\\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\\n m.stimulus >> m.am\\n\\n in_p = nengo.Probe(m.am.input)\\n out_p = nengo.Probe(m.am.output, synapse=0.03)\\n\\n with Simulator(m) as sim:\\n sim.run(0.3)\\n t = sim.trange()\\n below_th = t < 0.1\\n above_th = t > 0.25\\n\\n plt.subplot(2, 1, 1)\\n plt.plot(t, similarity(sim.data[in_p], vocab))\\n plt.ylabel(\\\"Input\\\")\\n plt.subplot(2, 1, 2)\\n plt.plot(t, similarity(sim.data[out_p], vocab2))\\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\\n plt.ylabel(\\\"Output\\\")\\n\\n assert np.mean(sim.data[out_p][below_th]) < 0.01\\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)\",\n \"def anoise(this, *args, **kargs):\\n\\t\\t\\n\\t\\t# Arguments\\n\\t\\tif not args: args = [50]\\n\\t\\t\\n\\t\\t# Kernel's retrieval\\n\\t\\tanoisek = this._ANOISEK\\n\\t\\tif anoisek is None: return None\\n\\t\\t\\n\\t\\t# More magic\\n\\t\\tbin = this._BINARY\\n\\t\\tfor thresh in args:\\n\\t\\t\\tbin[:,:] = (cv2.filter2D(bin, -1, anoisek) / 2.55 > thresh) * 255\\n\\t\\treturn True\",\n \"def pred_from_prob(a,threshold):\\n bin_preds = np.zeros((np.size(a,0),))\\n bin_preds[np.where(a[:,1]>threshold)]=1.0\\n return bin_preds\",\n \"def compute(self,filter_name):\\n self.result = []\\n for img in self.imgs:\\n r = filters_dict[filter_name](img)\\n if \\\"threshold\\\" in filter_name:\\n r = img>r\\n r = 1.0*r.copy()\\n self.result.append(r)\",\n \"def _get_pck(self, kp_id, threshold):\\n if len(self.data[kp_id]) == 0:\\n return None\\n\\n data = np.array(self.data[kp_id])\\n pck = np.mean((data <= threshold).astype('float'))\\n return pck\",\n \"def apply_threshold(heatmap, threshold):\\n heatmap_thresh = np.copy(heatmap)\\n ind = np.where(np.logical_and(heatmap_thresh>1, heatmap_thresh<=threshold))\\n heatmap_thresh[ind] = 0\\n #heatmap_thresh[(heatmap_thresh <= threshold)] = 0\\n return heatmap_thresh\",\n \"def reward_threshold(self) -> Optional[float]:\",\n \"def apply_threshold(heatmap, threshold):\\n heatmap[heatmap <= threshold] = 0\\n\\n return heatmap\",\n \"def testD():\\n results = {}\\n for threshold in ['volume', 25, 35,40, 20, ]: #adjust here\\n print threshold\\n results[threshold] = testC(threshold=threshold)\\n return results\",\n \"def keys_geq_threshold (Dict, threshold):\\n for key, value in Dict.items ():\\n if value >= threshold:\\n yield key\",\n \"def perform_thresholding(f,M,type):\\n if type == \\\"largest\\\":\\n a = np.sort(np.ravel(abs(f)))[::-1] #sort a 1D copy of F in descending order\\n T = a[M]\\n y = f*(abs(f) > T)\\n elif type == \\\"soft\\\":\\n s = abs(f) - M\\n s = (s + abs(s))/2\\n y = np.sign(f)*s\\n elif type == \\\"hard\\\":\\n y = f*(abs(f) > M)\\n return y\",\n \"def predict(self, X):\\n z = self.transform(X)\\n pred = z < self.threshold\\n return pred\",\n \"def _estimate_threshold(self, **kwargs):\\n recompute_threshold = kwargs.pop('recompute_threshold', False)\\n # if threshold is in table, then use it.\\n current_setting = (self.beta, self.chi2dist.kwds['df'])\\n threshold = None\\n res = False\\n if not recompute_threshold and current_setting in _gaussian_cusum_thresholds.keys():\\n for e in _gaussian_cusum_thresholds[current_setting]:\\n if e[0] == self.arl:\\n threshold = np.array([e[1]])\\n res = True\\n # if threshold not is in table, estimate it\\n if threshold is None:\\n len_simulation = kwargs.pop('len_simulation', None)\\n if len_simulation is None:\\n len_simulation = 10 * self.arl\\n self.log.info(\\\"estimating threshold...\\\")\\n plain_cusum = Cusum(arl=self.arl, beta=self.beta)\\n plain_cusum.gamma = self.gamma\\n d2_training = self.chi2dist.rvs(size=(int(len_simulation), 1))\\n kwargs.pop('x', None)\\n res = plain_cusum._estimate_threshold(x=d2_training, dof=self.chi2dist.kwds['df'],\\n **kwargs)\\n threshold = plain_cusum.threshold\\n self.threshold = threshold\\n return res\",\n \"def increase_dict_values_for_low_enough_keys(threshold, dictionary):\\n\\n dictionary = dictionary.update((x, y+1) for x, y in dictionary.items() if threshold >= x)\\n return dictionary\",\n \"def threshold(self, value):\\r\\n threshold = 0.5\\r\\n if value >= threshold:\\r\\n return 1\\r\\n else:\\r\\n return 0\",\n \"def threshold_predict(X, w, theta):\\n tmp = theta[:, None] - np.asarray(X.dot(w))\\n pred = np.sum(tmp < 0, axis=0).astype(np.int)\\n return pred\",\n \"def soft_threshold(self, weight, lambd):\\n if weight > lambd:\\n result = weight - lambd\\n elif abs(weight) <= lambd:\\n result = 0\\n else:\\n result = weight + lambd\\n return result\",\n \"def hash_threshold(token_dict, fp_len):\\n sum_hash = [0] * fp_len\\n for _, token in token_dict.items():\\n sum_hash = [ x + token.weight * y for x, y in zip(sum_hash, token.hash_list)]\\n\\n # apply binary threshold\\n for i, ft in enumerate(sum_hash):\\n if ft > 0:\\n sum_hash[i] = 1\\n else:\\n sum_hash[i] = 0\\n return sum_hash\",\n \"def prepare_val_res(score, threshold):\\n new_whale = 'new_whale'\\n\\n res ={}\\n\\n train_arr = np.array(train)\\n\\n for i,p in enumerate(val):\\n t = []\\n s = set()\\n a = score[i,:]\\n\\n top_label_probs = {}\\n cond = a > threshold\\n cond_index = np.where(cond)[0]\\n cond_images = train_arr[cond_index]\\n for j, img in enumerate(cond_images):\\n if tagged[img] in top_label_probs:\\n top_label_probs[tagged[img]] += a[cond_index[j]]\\n else:\\n top_label_probs[tagged[img]] = a[cond_index[j]]\\n\\n sorted_top_label_probs = sort_dict_by_values(top_label_probs)\\n\\n t = []\\n for lb, _ in sorted_top_label_probs:\\n t.append(lb)\\n\\n if len(t) < 5:\\n t.append(new_whale)\\n\\n for index in np.argsort(a)[::-1]:\\n if tagged[train_arr[index]] not in t:\\n t.append(tagged[train_arr[index]])\\n if len(t) >= 5:\\n break\\n\\n assert len(t) >= 5\\n\\n res[p[:-4]+'.jpg'] = t[:5]\\n\\n return res\",\n \"def round_pred_at_threshold(squares_dict, threshold=THRESHOLD):\\n for sq in squares_dict:\\n predict = sq.predict\\n if predict < threshold:\\n sq.replace(pred_int = 0)\\n else:\\n sq.replace(pred_int = 1)\\n return squares_dict\",\n \"def compute_recall_at_k(self, gt: List[bool], result_dict: Dict) -> None:\\n ks = self._hyper_params[\\\"recall_k\\\"]\\n gt = gt[:ks[-1]]\\n first_tp = np.where(gt)[0]\\n if len(first_tp) == 0:\\n return\\n for k in ks:\\n if k >= first_tp[0] + 1:\\n result_dict[k] = result_dict[k] + 1\",\n \"def current_threshold_hit(self):\\n\\n\\t\\tnew_current = self.robot.pdp.getCurrent(const.CARGO_PDP_ID)\\n\\n\\t\\tself._current_samples.append(new_current)\\n\\n\\t\\tif len(self._current_samples) > 10:\\n\\t\\t\\tself._current_samples.pop(0)\\n\\n\\t\\t# Calculate new running average\\n\\t\\tnew_avg = sum(self._current_samples) / len(self._current_samples)\\n\\n\\t\\treturn new_avg > const.CARGO_INTAKE_THRESHOLD\",\n \"def apply_hounsfield_thresholding(data_, threshold: tuple = (200, 600)):\\n mask = np.ma.masked_inside(data_, threshold[0], threshold[1], ).mask\\n thresholded = np.zeros_like(data_)\\n thresholded[mask] = data_[mask]\\n return thresholded\",\n \"def overlay_thresholding_function(threshold, positive=True):\\n # from the interface class definition above, there will be 3 values\\n # for the thresh type: inactive, less than, greater than\\n t = threshold[0]\\n if threshold[-1] == 'inactive':\\n if positive:\\n return lambda x: np.ones(x.shape, 'B')\\n return lambda x: np.zeros(x.shape, 'B')\\n elif threshold[-1] == 'less than':\\n if positive:\\n return lambda x: np.less(x,t)\\n return lambda x: np.greater_equal(x,t)\\n elif threshold[-1] == 'greater than':\\n if positive:\\n return lambda x: np.greater(x,t)\\n return lambda x: np.less_equal(x,t)\\n else:\\n print 'unrecognized thresholding parameters:', threshold\",\n \"def apply_threshold(heatmap, threshold):\\n # Zero out pixels below the threshold\\n thresh_heatmap = np.copy(heatmap)\\n thresh_heatmap[heatmap <= threshold] = 0\\n # Return thresholded map\\n return thresh_heatmap\",\n \"def test_output_is_above_threshold_counterfactuals(self):\\n threshold = 0.1\\n self._config['Regression threshold'] = str(threshold)\\n self._example = {'x_1': 0.0, 'x_2': -5.0}\\n output = self._gen.generate(\\n example=self._example,\\n model=self._model,\\n dataset=self._dataset,\\n config=self._config)\\n target_score = self._predict_and_return_score(self._example)\\n self.assertLess(target_score, threshold)\\n self.assertNotEmpty(output)\\n for cf_example in output:\\n cf_score = self._predict_and_return_score(cf_example)\\n self.assertGreaterEqual(cf_score, threshold)\",\n \"def threshold(img, thresh):\\n return cv2.threshold(img, thresh, 255, cv2.THRESH_BINARY)[1]\",\n \"def precision_threshold(predictions, targets, threshold=0.7):\\n number_of_examples_meeting_threshold = 0\\n\\n for pred, targ in zip(predictions, targets):\\n total_positive_guesses = sum(pred)\\n correct_positive_guesses = 0\\n\\n for shift_pred, shift_targ in zip(pred, targ):\\n if shift_pred == 1 and shift_targ == 1:\\n correct_positive_guesses += 1\\n\\n example_precision = correct_positive_guesses / total_positive_guesses\\n if example_precision > threshold:\\n number_of_examples_meeting_threshold += 1\\n\\n print(number_of_examples_meeting_threshold)\\n examples_meeting_threshold_ratio = number_of_examples_meeting_threshold / len(predictions)\\n print(examples_meeting_threshold_ratio)\",\n \"def _compute_sampling_threshold(global_step, k):\\n return k / (k + math.exp(global_step / k))\",\n \"def apply_threshold(heatmap, threshold):\\n # Zero out pixels below the threshold\\n heatmap[heatmap <= threshold] = 0\\n # Return thresholded map\\n return heatmap\",\n \"def apply_threshold(heatmap, threshold):\\n # Zero out pixels below the threshold\\n heatmap[heatmap <= threshold] = 0\\n # Return thresholded map\\n return heatmap\",\n \"def apply_threshold(heatmap, threshold):\\n # Zero out pixels below the threshold\\n heatmap[heatmap <= threshold] = 0\\n # Return thresholded map\\n return heatmap\",\n \"def soft_thresholding(w, alpha):\\n return np.sign(w) * np.clip(np.abs(w) - alpha, 0.0, np.inf)\",\n \"def ap(gt, pred, k):\\n if len(pred) > k:\\n pred = pred[:k]\\n\\n score = 0.0\\n num_hits = 0.0\\n\\n for i, p in enumerate(pred):\\n if p in gt:\\n num_hits += 1.0\\n score += num_hits / (i + 1.0)\\n\\n if not gt:\\n return 0.\\n\\n return score / min(len(gt), k)\",\n \"def _compute_sampling_threshold(global_step, k):\\n return tf.cast(k / (k + tf.exp(global_step / k)), tf.float32)\",\n \"def conditional(self, func):\\n out = Prob()\\n for k, v in self.items():\\n if func(k):\\n out[k] = v\\n out.normalize()\\n return out\",\n \"def infer_threshold(self, x: np.ndarray, fpr: float) -> None:\\n self.backend.infer_threshold(self.backend._to_backend_dtype(x), fpr)\",\n \"def test_key_predicate(datum):\\n return 0 < datum\",\n \"def threshold(activation):\\n if activation >= 0.0:\\n return 1\\n else:\\n return 0\",\n \"def find_metric_threshold(self):\\n logger.info(\\\"compute metric threshold\\\")\\n\\n ### Beaucoup trop lent quand on a beaucoup de models ###\\n\\n df_results_not_aggregated = self.result_reader.load_all_results(aggregate=False)\\n\\n if len(df_results_not_aggregated) == 0:\\n logger.info(\\\"threshold = None\\\")\\n return None\\n\\n main_scorer = \\\"test_%s\\\" % self.job_config.main_scorer\\n (df_results_not_aggregated[main_scorer].fillna(df_results_not_aggregated[main_scorer].min(), inplace=True))\\n min_cv = df_results_not_aggregated.groupby(\\\"job_id\\\")[main_scorer].min().values\\n delta_min_max_cv = np.median(\\n df_results_not_aggregated.groupby(\\\"job_id\\\")[main_scorer].apply(lambda x: x.max() - x.min())\\n )\\n\\n if len(min_cv) <= self.min_nb_of_models:\\n logger.info(\\\"threshold = None\\\")\\n return None\\n\\n min_cv = -np.sort(-min_cv)\\n result = min_cv[self.min_nb_of_models] - delta_min_max_cv\\n\\n # result = np.percentile( min_cv, self._get_quantile(len(min_cv)) * 100)\\n # TODO : ici peut etre faire une estimation parametric du quantile avec un Kernel, plus smooth et moins sensible quand peu de valeurs\\n\\n logger.info(\\\"threshold : %2.2f\\\" % result)\\n return result\",\n \"def round_using_t(prediction, threshold):\\n return (prediction >= threshold).astype('int')\",\n \"def getThreshold(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def test_output_is_below_threshold_counterfactuals(self):\\n threshold = 2.8\\n self._config['Regression threshold'] = str(threshold)\\n self._example = {'x_1': 1.0, 'x_2': 1.0}\\n output = self._gen.generate(\\n example=self._example,\\n model=self._model,\\n dataset=self._dataset,\\n config=self._config)\\n target_score = self._predict_and_return_score(self._example)\\n self.assertGreaterEqual(target_score, threshold)\\n self.assertNotEmpty(output)\\n for cf_example in output:\\n cf_score = self._predict_and_return_score(cf_example)\\n self.assertLess(cf_score, threshold)\",\n \"def soft_threshold(X, threshold):\\n X_thresholded = (np.abs(X) > threshold).astype('int')\\n X_soft_threshold = np.sign(X) * (np.abs(X) - threshold) * X_thresholded\\n return X_soft_threshold\",\n \"def bin_thres_img(img, ksize=3):\\n # Apply each of the thresholding functions\\n gradx = abs_sobel_thresh(img, orient='x', sobel_kernel=ksize, thresh=(20, 100))\\n grady = abs_sobel_thresh(img, orient='y', sobel_kernel=ksize, thresh=(20, 100))\\n\\n mag_binary = mag_thresh(img, sobel_kernel=ksize, mag_thresh=(30, 100))\\n dir_binary = dir_threshold(img, sobel_kernel=ksize, thresh=(0.7, 1.3))\\n\\n hls_binary = hls_select(img, thresh=(170, 255))\\n\\n combined = np.zeros_like(dir_binary)\\n combined[((gradx == 1) & (grady == 1)) | ((mag_binary == 1) & (dir_binary == 1)) | hls_binary == 1] = 1\\n return combined\",\n \"def predict_with_threshold(y_pred_proba, threshold):\\n\\n y_pred = [1 if x >= threshold else 0 for x in y_pred_proba]\\n return pd.Series(data=y_pred, name='y_pred')\",\n \"def sensitivity(\\n targets: List[int], preds: List[float], threshold: float = 0.5\\n) -> float:\\n return recall(targets, preds, threshold)\",\n \"def thresholding(pred,label,thres):\\n \\n conf =[]\\n \\n for i in thres:\\n \\n pr_th,lab_th = (pred>i),(label>i)\\n conf += confusion(pr_th,lab_th)\\n \\n return np.array(conf).reshape(-1,4)\",\n \"def compute_score(self, pred: Tensor, target: Tensor) -> Tensor:\\n\\t\\tif self.threshold_input is not None:\\n\\t\\t\\tpred = pred.ge(self.threshold_input).float()\\n\\n\\t\\tif self.threshold_target is not None:\\n\\t\\t\\ttarget = target.ge(self.threshold_target).float()\\n\\n\\t\\trecall = self.recall(pred, target)\\n\\t\\tprecision = self.precision(pred, target)\\n\\n\\t\\tscore = (1.0 + self.beta ** 2) * precision * recall / (self.beta ** 2 * precision + recall)\\n\\t\\tscore[score.isnan()] = 0.0\\n\\n\\t\\tif self.reduce_fn is not None:\\n\\t\\t\\tscore = self.reduce_fn(score)\\n\\n\\t\\treturn score\",\n \"def calculate(memory):\\r\\n dThthreshold = \\r\\n Ththreshold = f(memory['latitude'],memory['longitude'])\\r\\n \\r\\n dTh = sum(i > dThthreshold for i in memory['dTh'])\\r\\n \\r\\n return\",\n \"def ks_test_function(dim, thresh):\\n def ks_test(table1, table2):\\n from scipy.stats import ks_2samp\\n sample1 = table1.get_cols(dim)[0]\\n sample2 = table2.get_cols(dim)[0]\\n if thresh != None:\\n sample1[sample1<thresh] = 0\\n sample2[sample2<thresh] = 0\\n ks, p_ks = ks_2samp(sample1, sample2)\\n return ks\\n return ks_test\",\n \"def binary_accuracy(y_true, y_pred, threshold=0.5):\\n assert y_true.shape == y_pred.shape\\n y_pred_thresholded = (y_pred >= threshold).astype(float)\\n correct_predictions = y_pred_thresholded == y_true \\n return correct_predictions.mean()\",\n \"def decision_threshold(x, y):\\n \\n model = DecisionTreeClassifier(max_depth=1, criterion='entropy')\\n model.fit(x,y)\\n print (\\\"-- Uncertainty Threshold: \\\", model.tree_.threshold[0])\\n return model.tree_.threshold[0]\",\n \"def test_check_single_threshold(self):\\n data = np.array(\\n [\\n [[13.2, 8.0, 13.2], [-46.0, 8.0, -78.4], [-78.4, -86.5, -89.2]],\\n [[34, 31.1111, 34.0], [27.5, 31.1111, 8.0], [8.0, -32.5, -46.0]],\\n [[54.8, 54.2222, 54.8], [53.5, 54.2222, 49.6], [49.6, 34, -2.8]],\\n ],\\n dtype=np.float32,\\n )\\n\\n threshold_coord = find_threshold_coordinate(self.cube)\\n cube = next(self.cube.slices_over(threshold_coord))\\n\\n result = Plugin()._probabilities_to_percentiles(cube, self.percentiles)\\n self.assertArrayAlmostEqual(result.data, data, decimal=4)\",\n \"def test_soft_threshold():\\n assert snet.soft_threshold(10, 100) == 0\\n assert snet.soft_threshold(-10, 100) == 0\\n assert snet.soft_threshold(10, 3) == 7\\n assert snet.soft_threshold(-10, 3) == -7\",\n \"def run_algo(self, th):\\n p = self.run_proc(['threshold', str(th), 'input_0.png',\\n 'output.png'])\\n self.wait_proc(p, timeout=self.timeout)\\n return\",\n \"def threshold(X, thresh):\\n Y = np.array(X)\\n Y[Y >= thresh] = 1\\n Y[Y < thresh] = 0\\n return Y\",\n \"def thresh_setup():\\n pass\",\n \"def _estimate_threshold(self, x=None, threshold_type='numerical', **kwargs):\\n\\n if threshold_type == \\\"data\\\":\\n return super()._estimate_threshold(x)\\n \\n # if threshold is in table, then use it.\\n current_setting = (self.beta, self._chi2dist.kwds['df'])\\n threshold = None\\n res = False\\n # Whether to recompute thresholds\\n recompute_threshold = kwargs.pop('recompute_threshold', False)\\n if not recompute_threshold and current_setting in _gaussian_cusum_thresholds.keys():\\n for e in _gaussian_cusum_thresholds[current_setting]:\\n if e[0] == self.arl:\\n threshold = np.array([e[1]])\\n res = True\\n\\n # if threshold not is in table, estimate it\\n if threshold is None:\\n len_simulation = kwargs.pop('len_simulation', None)\\n if len_simulation is None:\\n len_simulation = 10 * self.arl\\n self.log.info(\\\"estimating threshold...\\\")\\n plain_cusum = Cusum(arl=self.arl, beta=self.beta)\\n plain_cusum.gamma = self.gamma\\n d2_training = self._chi2dist.rvs(size=(int(len_simulation), 1))\\n kwargs.pop('x', None)\\n res = plain_cusum._estimate_threshold(x=d2_training, dof=self._chi2dist.kwds['df'],\\n **kwargs)\\n threshold = plain_cusum.threshold\\n \\n # set threshold\\n self.threshold = threshold\\n return res\",\n \"def test_soft_threshold_array():\\n a = np.array([10, -10, 200, -200])\\n np.testing.assert_allclose(snet.soft_threshold(a, 100),\\n np.array([0, 0, 100, -100]))\\n np.testing.assert_allclose(snet.soft_threshold(a, 3),\\n np.array([7, -7, 197, -197]))\",\n \"def bin_key(color_key, threshhold=0.2):\\n bins = 1.0 / threshhold\\n if int(bins) != bins:\\n raise ValueError(\\\"threshhold must divide 1.0 evenly\\\")\\n else:\\n bins = int(bins)\\n\\n rounded_key = np.array(color_key)\\n for i in xrange(color_key.shape[0]):\\n bin = int(round(color_key[i] / threshhold))\\n rounded_color = float(bin) / float(bins)\\n rounded_key[i] = rounded_color\\n return tuple(rounded_key)\",\n \"def __call__(self, *args, **kwargs):\\n out = super().__call__(*args, **kwargs)\\n out **= 2\\n self._debug.append(out)\\n out = int(out > self.threshold_value)\\n if out and self.since_last_peak > self._num_of_taps:\\n self.since_last_peak = -1\\n else:\\n out = 0\\n self.since_last_peak += 1\\n return out\",\n \"def adjusted_classes(pred_prob, threshold):\\n return [1 if y >= threshold else 0 for y in pred_prob]\",\n \"def nn_threshold_predict(X, nn, theta):\\n tmp = theta.reshape((1, np.size(theta))) - nn.predict(X)\\n pred = np.sum(tmp < 0, axis=1).astype(np.int)\\n return np.array(pred)\",\n \"def voxel_thresholded_ttest(x, threshold):\\n t = ttest(x)\\n return t > threshold\",\n \"def scale(img):\\n result = [[1 if x > BINARY_THRESHOLD else 0 for x in row] for row in img]\\n return result\",\n \"def thresholdClassify(sim_vec_dict, sim_thres):\\n\\n assert sim_thres >= 0.0 and sim_thres <= 1.0, sim_thres\\n\\n print('Similarity threshold based classification of %d record pairs' % \\\\\\n (len(sim_vec_dict)))\\n print(' Classification similarity threshold: %.3f' % (sim_thres))\\n\\n class_match_set = set()\\n class_nonmatch_set = set()\\n\\n # Iterate over all record pairs\\n #\\n for (rec_id_tuple, sim_vec) in sim_vec_dict.items():\\n # ********* Implement threshold based classification **********************\\n\\n pass # Add your code here\\n\\n # ************ End of your code *******************************************\\n\\n print(' Classified %d record pairs as matches and %d as non-matches' % \\\\\\n (len(class_match_set), len(class_nonmatch_set)))\\n print('')\\n\\n return class_match_set, class_nonmatch_set\",\n \"def keypoint_loss(self, pred_keypoints_2d, gt_keypoints_2d, openpose_weight, gt_weight):\\n conf = gt_keypoints_2d[:, :, -1].unsqueeze(-1).clone()\\n conf[:, :25] *= openpose_weight\\n conf[:, 25:] *= gt_weight\\n loss = (conf * self.criterion_keypoints(pred_keypoints_2d, gt_keypoints_2d[:, :, :-1])).mean()\\n return loss\",\n \"def result(\\n metrics: Dict[metric_types.MetricKey, float]\\n ) -> Dict[metric_types.MetricKey, float]:\\n output = {}\\n for threshold in thresholds:\\n ptn = flip_count_metric_key_by_name_by_threshold[threshold][\\n 'positive_to_negative']\\n ntp = flip_count_metric_key_by_name_by_threshold[threshold][\\n 'negative_to_positive']\\n pos_examples = flip_count_metric_key_by_name_by_threshold[threshold][\\n 'positive_to_negative_examples_ids']\\n neg_examples = flip_count_metric_key_by_name_by_threshold[threshold][\\n 'negative_to_positive_examples_ids']\\n pos = flip_count_metric_key_by_name_by_threshold[threshold][\\n 'positive_examples_count']\\n neg = flip_count_metric_key_by_name_by_threshold[threshold][\\n 'negative_examples_count']\\n output[metric_key_by_name_by_threshold[threshold]\\n ['overall']] = (metrics[ntp] + metrics[ptn]) / (\\n metrics[pos] + metrics[neg])\\n output[metric_key_by_name_by_threshold[threshold]\\n ['positive_to_negative']] = metrics[ptn] / metrics[pos]\\n output[metric_key_by_name_by_threshold[threshold]\\n ['negative_to_positive']] = metrics[ntp] / metrics[neg]\\n output[metric_key_by_name_by_threshold[threshold]\\n ['positive_to_negative_examples_ids']] = metrics[pos_examples]\\n output[metric_key_by_name_by_threshold[threshold]\\n ['negative_to_positive_examples_ids']] = metrics[neg_examples]\\n\\n return output\",\n \"def thresholdfactor(self):\\n return self.__thresholdfactor\",\n \"def evaluateObjective(posts, threshold):\\n partialSum = 0\\n for post in posts:\\n partialSum += max(np.sign(post[\\\"similarity\\\"] - threshold) * post[\\\"score\\\"], 0)\\n return partialSum\",\n \"def threshold(image, selem, out=None, mask=None, shift_x=False, shift_y=False):\\n\\n return _apply(_crank8.threshold, _crank16.threshold, image, selem, out=out,\\n mask=mask, shift_x=shift_x, shift_y=shift_y)\",\n \"def find_TPR_threshold(y, scores, desired_TPR):\\n for threshold in np.arange(1,0,-0.01):\\n y_hat = (scores>=threshold).astype(int)\\n confusion = confusion_matrix(y, y_hat)\\n TN, FP, FN, TP = confusion.flat\\n TPR = TP / (TP + FN)\\n FPR = FP / (FP + TN)\\n if TPR >= desired_TPR:\\n return threshold, FPR\",\n \"def threshold(input_tensor, th, val, name):\\n with tf.variable_scope(name) as scope:\\n\\n # First figure out where values are less than\\n lessthan_tensor = tf.cast(tf.lesser(input_tensor, th), tf.int32)\\n greaterthan_tensor = tf.cast(tf.greater(input_tensor, th), tf.int32)\\n\\n # Then make thresholded values equal to val and the rest are the same\\n out_tensor = input_tensor * greaterthan_tensor + val * lessthan_tensor\\n\\n return out_tensor\",\n \"def PT_loose_thresh(x, a, b, ma, mb):\\n out = PT_indicator(x, a, b) * x + PT_indicator(x, b, None) * (b + mb * (x - b)) + PT_indicator(x, None, a) * (a + ma * (x-a))\\n return out\",\n \"def bin_thresh(img: np.ndarray, thresh: Number) -> np.ndarray:\\n res = img >= thresh\\n return res\",\n \"def image_thresholding(image: np.ndarray):\\n # Resize image to a shape of (48, 48)\\n image = image_as_square(image)\\n\\n # Find threshold using Otsu filter\\n threshold: float = filters.threshold_otsu(image)\\n binary = image > threshold\\n\\n binary_image = np.where(image, binary, 0) * 255\\n\\n # Resize the iamge back to a shape of (2304, )\\n return image_as_array(image)\",\n \"def threshold_image(img, threshold=THRESHOLD):\\n return cv2.threshold(img, threshold, MAX_GRAY_SCALE, cv2.THRESH_BINARY)\",\n \"def precision(gt, pred, k):\\n k = min(len(pred), k)\\n den = min(len(gt), k)\\n return sum([int(pred[i] in gt) for i in range(k)]) / den\",\n \"def threshold_trec_run(run, fold, k):\\n filtered_run = defaultdict(dict)\\n # This is possible because best_search_run is an OrderedDict\\n for qid, docs in run.items():\\n if qid in fold[\\\"predict\\\"][\\\"test\\\"]:\\n for idx, (docid, score) in enumerate(docs.items()):\\n if idx >= k:\\n break\\n filtered_run[qid][docid] = score\\n\\n return filtered_run\",\n \"def find_entropy(less_than_threshold,more_than_threshold):\\n\\n ''' Storing total number of records '''\\n total_records = len(less_than_threshold) + len(more_than_threshold)\\n\\n ''' Calculating the probability '''\\n less_than_probability = len(less_than_threshold) / total_records\\n more_than_probability = len(more_than_threshold) / total_records\\n\\n ''' Converting the dataframe to numpy arrays '''\\n less_than_threshold_values = less_than_threshold.values\\n more_than_threshold_values = more_than_threshold.values\\n\\n ''' Storing the target attribute values (Muffin or Cupcake) for threshold values '''\\n target_for_less_than = less_than_threshold_values[:, -1]\\n target_for_more_than = more_than_threshold_values[:, -1]\\n\\n ''' Finding the counts of muffin and cupcake for values lower than and greater than threshold value '''\\n recipe_type, less_than_cupcake_muffin_count = np.unique(target_for_less_than, return_counts=True)\\n recipe_type, more_than_cupcake_muffin_count = np.unique(target_for_more_than, return_counts=True)\\n\\n # print(recipe_type, more_than_cupcake_muffin_count, len(more_than_cupcake_muffin_count))\\n ''' To ensure there are at least 5 records in each node '''\\n if less_than_cupcake_muffin_count.sum() < 5 or more_than_cupcake_muffin_count.sum() < 5:\\n ''' Return horrible badness '''\\n return math.inf\\n else:\\n ''' Find the entropies for less than threshold values and more than threshold values '''\\n less_than_entropy = sum((less_than_cupcake_muffin_count / less_than_cupcake_muffin_count.sum()) * - np.log2(\\n less_than_cupcake_muffin_count / less_than_cupcake_muffin_count.sum()))\\n more_than_entropy = sum((more_than_cupcake_muffin_count / more_than_cupcake_muffin_count.sum()) * - np.log2(\\n more_than_cupcake_muffin_count / more_than_cupcake_muffin_count.sum()))\\n\\n ''' Calculate the total weighted entropy '''\\n total_weighted_entropy = less_than_probability * less_than_entropy + more_than_probability * more_than_entropy\\n\\n return total_weighted_entropy\",\n \"def threshold(self) -> pulumi.Input[float]:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def threshold(self) -> pulumi.Input[float]:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def threshold(self) -> pulumi.Input[float]:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def threshold(self) -> pulumi.Input[float]:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def threshold(self) -> pulumi.Input[float]:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def __cv_threshold(src, thresh, max_val, type):\\n return cv2.threshold(src, thresh, max_val, type)[1]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6783998","0.67353284","0.63087225","0.6274074","0.61894006","0.61030537","0.61008376","0.60762995","0.6047671","0.60170645","0.59696436","0.59311014","0.5793961","0.57806987","0.57802975","0.57697934","0.5745665","0.5731439","0.5718352","0.5692189","0.56847316","0.5678323","0.5676535","0.56732005","0.5660741","0.56559736","0.5653386","0.5613374","0.5604775","0.5587642","0.5584356","0.55837625","0.5579883","0.55613464","0.55516875","0.5546331","0.55319315","0.55305284","0.5526689","0.5517876","0.5506651","0.549613","0.5490721","0.5486672","0.5486672","0.5486672","0.54713464","0.54642844","0.5429959","0.5418588","0.54010415","0.5399449","0.53981423","0.53942513","0.53819877","0.53764135","0.5374235","0.5367461","0.53657347","0.5361177","0.53597116","0.53591585","0.53590435","0.5357391","0.5357005","0.53509593","0.53494966","0.53326255","0.5325977","0.53244144","0.5317508","0.5306946","0.53047544","0.5301807","0.5294887","0.52923304","0.5289601","0.5285158","0.52707267","0.5268324","0.52650845","0.5256277","0.52559036","0.5254841","0.5252773","0.52513003","0.5245026","0.5243976","0.52409214","0.5238714","0.5233965","0.52336085","0.5231742","0.5228881","0.52195597","0.52165467","0.52165467","0.52165467","0.52165467","0.52165467","0.5213116"],"string":"[\n \"0.6783998\",\n \"0.67353284\",\n \"0.63087225\",\n \"0.6274074\",\n \"0.61894006\",\n \"0.61030537\",\n \"0.61008376\",\n \"0.60762995\",\n \"0.6047671\",\n \"0.60170645\",\n \"0.59696436\",\n \"0.59311014\",\n \"0.5793961\",\n \"0.57806987\",\n \"0.57802975\",\n \"0.57697934\",\n \"0.5745665\",\n \"0.5731439\",\n \"0.5718352\",\n \"0.5692189\",\n \"0.56847316\",\n \"0.5678323\",\n \"0.5676535\",\n \"0.56732005\",\n \"0.5660741\",\n \"0.56559736\",\n \"0.5653386\",\n \"0.5613374\",\n \"0.5604775\",\n \"0.5587642\",\n \"0.5584356\",\n \"0.55837625\",\n \"0.5579883\",\n \"0.55613464\",\n \"0.55516875\",\n \"0.5546331\",\n \"0.55319315\",\n \"0.55305284\",\n \"0.5526689\",\n \"0.5517876\",\n \"0.5506651\",\n \"0.549613\",\n \"0.5490721\",\n \"0.5486672\",\n \"0.5486672\",\n \"0.5486672\",\n \"0.54713464\",\n \"0.54642844\",\n \"0.5429959\",\n \"0.5418588\",\n \"0.54010415\",\n \"0.5399449\",\n \"0.53981423\",\n \"0.53942513\",\n \"0.53819877\",\n \"0.53764135\",\n \"0.5374235\",\n \"0.5367461\",\n \"0.53657347\",\n \"0.5361177\",\n \"0.53597116\",\n \"0.53591585\",\n \"0.53590435\",\n \"0.5357391\",\n \"0.5357005\",\n \"0.53509593\",\n \"0.53494966\",\n \"0.53326255\",\n \"0.5325977\",\n \"0.53244144\",\n \"0.5317508\",\n \"0.5306946\",\n \"0.53047544\",\n \"0.5301807\",\n \"0.5294887\",\n \"0.52923304\",\n \"0.5289601\",\n \"0.5285158\",\n \"0.52707267\",\n \"0.5268324\",\n \"0.52650845\",\n \"0.5256277\",\n \"0.52559036\",\n \"0.5254841\",\n \"0.5252773\",\n \"0.52513003\",\n \"0.5245026\",\n \"0.5243976\",\n \"0.52409214\",\n \"0.5238714\",\n \"0.5233965\",\n \"0.52336085\",\n \"0.5231742\",\n \"0.5228881\",\n \"0.52195597\",\n \"0.52165467\",\n \"0.52165467\",\n \"0.52165467\",\n \"0.52165467\",\n \"0.52165467\",\n \"0.5213116\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21495,"cells":{"query":{"kind":"string","value":"Extract the data from raw data files Extracts all the required task data from the raw data files."},"document":{"kind":"string","value":"def load_data(self, bpod_only=False, download_data=True):\n self.extractor = TaskQCExtractor(\n self.session_path, one=self.one, download_data=download_data, bpod_only=bpod_only)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _extract(self):\r\n self._data = []\r\n for fname in self.files:\r\n meta = dict(filename=fname)\r\n\r\n # Perform the actual metadata extraction\r\n fname = os.path.splitext(self.filter_filename(fname))[0]\r\n values = fname.split(self.sep)\r\n\r\n # Handle the case where number of fields is less than the length\r\n # of the extracted values, ie cases where we only want to extract\r\n # a subset of available fields.\r\n if self.index:\r\n values = [val for i, val in enumerate(values) if i in self.index]\r\n\r\n meta.update(dict(zip(self.fields, values)))\r\n if self.split_by in self.fields:\r\n meta[self.split_by] = self._get_split_field_values(meta['filename'])\r\n self._data.append(meta)","def _extract_data(inputs):\n filename, split = inputs\n for name, fobj in tfds.download.iter_archive(\n filename, tfds.download.ExtractMethod.TAR_STREAM\n ):\n split_name = name.split(\"_\")\n if len(split_name) > 2 and split_name[2] == split:\n yield [name, fobj.read()]","def extract(self):\n self.build_path_pairs()\n self.extract_field_blocks()\n self.assert_filenames()","def runDataExtraction():\r\n config = CONFIG['steps']['DataExtraction']\r\n ci = config['inputs']\r\n co = config['outputs']\r\n columns = ci['columns']\r\n nrows = ci['nrows']\r\n input_bucket = ci['bucket']\r\n no_of_files = ci['no_of_files']\r\n\r\n output_bucket = co['bucket']\r\n csv_name_prefix = co['csv_name_prefix']\r\n\r\n minio_config = CONFIG['artifacts']['minio']\r\n minioClient = create_minio_client(minio_config[\"endpoint_url\"],\r\n access_key=minio_config[\"access_key\"],\r\n secret_key=minio_config[\"secret_key\"],\r\n secure=minio_config['secure'])\r\n\r\n boto_client = boto3.client(\"s3\",\r\n endpoint_url=minio_config[\"endpoint_url\"],\r\n aws_access_key_id=minio_config[\"access_key\"],\r\n aws_secret_access_key=minio_config[\"secret_key\"],\r\n region_name=minio_config[\"region_name\"])\r\n\r\n zip_files = get_files(input_bucket, boto_client, file_type='zip')\r\n\r\n no_of_files_to_process = no_of_files if no_of_files is not None else len(\r\n zip_files)\r\n for zip_file in tqdm(zip_files[:no_of_files_to_process], total=no_of_files_to_process):\r\n process_file(zip_file, input_bucket, output_bucket, minioClient, columns,\r\n nrows=nrows, output_csv_name_prefix=csv_name_prefix)","def extract(self):\n\n # print some infos about data\n print(\"\\n--extract batches from data:\\ntrain: {}\\nval: {}\\ntest: {}\\n\".format(self.data[0]['x'].shape, self.data[1]['x'].shape, self.data[2]['x'].shape))\n\n # create batches\n self.x_train, self.y_train, _ = self.create_batches(self.data[0], batch_size=self.batch_size)\n self.x_val, self.y_val, _ = self.create_batches(self.data[1], batch_size=self.batch_size_eval)\n self.x_test, self.y_test, _ = self.create_batches(self.data[2], batch_size=self.batch_size_eval)\n\n # my data\n if len(self.mfcc_data_files) == 4:\n self.x_my, self.y_my, self.z_my = self.create_batches(self.data[3], batch_size=1)","def read_parse_raw_data(path):\n file_list = TopologyHelper.get_file_list(path)\n print(\"Reading \" + str(len(file_list)) + \" files from \" + path)\n topology_info = []\n file_name = []\n for file in file_list:\n try:\n r = TopologyHelper.parse_file(file)\n tmp = (r[0])['Topology']\n topology_info.append(tmp)\n t = r[1]\n file_name.append(t)\n except:\n continue\n print(\"Parsing completed\")\n return file_name, topology_info","def process_raw_data(self):\n \n # Define some variables of interest.\n vor = [\"n_sentences\", \"n_correct\", \"p_correct\", \"median_RT\", \\\n \"mean_RT\", \"stdev_RT\", \"scaled_stdev_RT\"]\n \n # Get all participant names, or return straight away if no data was\n # loaded yet.\n if hasattr(self, \"raw\"):\n participants = self.raw.keys()\n participants.sort()\n else:\n self.data = None\n return\n\n # Count the number of participants.\n n = len(participants)\n \n # Create a data dict for each variable of interest.\n self.data = {}\n self.data[\"ppname\"] = []\n for var in vor:\n self.data[var] = numpy.zeros(n, dtype=float) * numpy.NaN\n \n # Loop through all participants.\n for i, ppname in enumerate(participants):\n # Add the participant name.\n self.data[\"ppname\"].append(copy.deepcopy(ppname))\n # Skip empty datasets.\n if self.raw[ppname] is None:\n continue\n # Compute stuff relevant to this task.\n self.data[\"n_sentences\"][i] = len(self.raw[ppname][\"Sentence\"])\n self.data[\"n_correct\"][i] = numpy.sum(self.raw[ppname][\"correct\"])\n self.data[\"p_correct\"][i] = float(self.data[\"n_correct\"][i]) \\\n / float(self.data[\"n_sentences\"][i])\n self.data[\"median_RT\"][i] = numpy.nanmedian(self.raw[ppname][\"RT\"])\n self.data[\"mean_RT\"][i] = numpy.nanmean(self.raw[ppname][\"RT\"])\n self.data[\"stdev_RT\"][i] = numpy.nanstd(self.raw[ppname][\"RT\"])\n # Compute a scaled standard deviation of the response time, scaled to the\n # median response time to remove the correlation between the two.\n self.data[\"scaled_stdev_RT\"] = self.data[\"stdev_RT\"] / self.data[\"median_RT\"]","def extract_all_lazy():\n\n\t#Construct filepaths: Data COMP_INFO_1\n\tdata_ci1_name = \"DATA_2016_COMP_INFO_1.csv\"\n\tdata_ci1_fullname = os.path.join(files_location, data_ci1_name)\n\t#Data COMP_INFO_2\n\tdata_ci2_name = \"DATA_2016_COMP_INFO_2.csv\"\n\tdata_ci2_fullname = os.path.join(files_location, data_ci2_name)\n\t#Data PROPERTY INFO\n\tdata_pi_name = \"DATA_2016_PROPERTY_INFO_ST.csv\"\n\tdata_pi_fullname = os.path.join(files_location, data_pi_name)\n\t#Data General Info\n\tdata_gi_name = \"DATA_2016_GENERAL_INFO.csv\"\n\tdata_gi_fullname = os.path.join(files_location, data_gi_name)\n\n\t#Read & Process COMP_INFO\n\tdata_ci1 = pd.read_csv(data_ci1_fullname, skiprows=2, usecols = constants.keep_columns_CI, encoding='ISO-8859-1')\n\tdata_ci2 = pd.read_csv(data_ci2_fullname, skiprows=2, usecols = constants.keep_columns_CI, encoding='ISO-8859-1')\n\n\tdata_ci = data_ci1.append(data_ci2)\n\tdata_ci['QUESTION'] = data_ci['QUESTION'].replace(constants.ci_mapping)\n\t# Take only the survey questions mapped\n\tdata_ci = data_ci[data_ci['QUESTION'].isin(constants.ci_mapping.values())]\n\tdata_ci = data_ci.set_index(['PROPERTY_CODE','PROPERTY_NAME','JOB_CODE','POSITION'])\n\tdata_ci = data_ci.pivot(columns=\"QUESTION\")\n\tdata_ci.columns = [\"_\".join(pair) for pair in data_ci.columns]\n\tdata_ci = data_ci.reset_index()\n\n\t#Read & Process Property Info data\n\tdata_pi = pd.read_csv(data_pi_fullname, usecols = constants.keep_columns_PI, encoding='ISO-8859-1')\n\t#survey_type_transformed = transform.surveytype_categorical(data_pi)\n\t#data_pi = pd.merge(data_pi, survey_type_transformed, on=['PROPERTY_CODE'])\n\n\t#Read & Process General Info\n\tdata_gi = pd.read_csv(data_gi_fullname, skiprows = 2, usecols = constants.keep_columns_GI, encoding='ISO-8859-1')\n\tdata_gi['QUESTION'] = data_gi['QUESTION'].replace(constants.gi_mapping)\n\t# Take onl the survey questions mapped\n\tdata_gi = data_gi[data_gi['QUESTION'].isin(constants.gi_mapping.values())]\n\tdata_gi = data_gi.set_index(['PROPERTY_CODE','PROPERTY_NAME'])\n\tdata_gi = data_gi.pivot(columns=\"QUESTION\")\n\tdata_gi.columns = [\"_\".join(pair) for pair in data_gi.columns]\n\tdata_gi = data_gi.reset_index()\n\n\t#This frame needs to be reworked\n\td_ci = pd.merge(data_gi, data_pi, on = ['PROPERTY_CODE','PROPERTY_NAME'])\n\td_ci = pd.merge(d_ci, data_ci, on = ['PROPERTY_CODE','PROPERTY_NAME'],suffixes= ['_ci','_gi'])\n\n\t#Observations by Dimensions to determine top X markets\n\t#Can this be in a better position?\n\td_ci = d_ci[~(d_ci['PROPERTY_NAME'].isin(constants.del_rows_property_name))]\n\td_ci['POSITION'] = d_ci['POSITION'].astype(str)\n\n\tpayload = {}\n\tpayload['gi'] = data_gi\n\tpayload['pi'] = data_pi\n\tpayload['ci'] = data_ci\n\tpayload['d_ci'] = d_ci\n\n\treturn payload","def _extract_raw_data(self, lines):\r\n\r\n i = self._find_first_data_point(lines)\r\n if self._lines_have_temperature(lines[i]):\r\n self._T = []\r\n\r\n if self._has_drift_points(lines):\r\n while i < len(lines) and lines[i][0] in ['+', '-']:\r\n self._extract_drift_point(lines[i])\r\n i += 2\r\n i += self._extract_next_forc(lines[i:])\r\n i += 1\r\n else:\r\n while i < len(lines) and lines[i][0]in ['+', '-']:\r\n i += self._extract_next_forc(lines[i:])\r\n self._extract_drift_point(lines[i-1])\r\n i += 1\r\n\r\n return","def process_raw_data(data_dir='/home/data/nbc/athena/athena-data/'):\n\n # Calls the process_corpus function, defined below\n # process_corpus reads in the text, performs abbreviation, spelling,\n # translation, and overall text Processing\n # process_corpus outputs the processed text for each file and the stemmed file\n for feature_source in ['abstract', 'full']:\n process_corpus(data_dir, feature_source)\n\n # Calls the label_data function, defined below\n # label_data reads in the metadata csv files, concatenates them, then\n # reads in the processed text files\n # label_data outputs a binary pmid by label metadata matrix\n label_data(data_dir)\n generate_gazetteer(data_dir)","def process_raw_data(self):\n \n # Get all participant names, or return straight away if no data was\n # loaded yet.\n if hasattr(self, \"raw\"):\n participants = self.raw.keys()\n participants.sort()\n else:\n self.data = None\n return\n\n # Count the number of participants.\n n = len(participants)\n \n # Find out how many questions there were.\n n_questions = 0\n for i, ppname in enumerate(participants):\n if self.raw[ppname] is None:\n continue\n if len(self.raw[ppname][\"QuestionNumber\"]) > n_questions:\n n_questions = len(self.raw[ppname][\"QuestionNumber\"])\n \n # Define some variables of interest.\n vor = []\n for i in range(n_questions):\n vor.append(\"Q%d_resp\" % (i+1))\n vor.append(\"Q%d_RT\" % (i+1))\n \n # Create a data dict for each variable of interest.\n self.data = {}\n self.data[\"ppname\"] = []\n for var in vor:\n self.data[var] = numpy.zeros(n, dtype=float) * numpy.NaN\n \n # Loop through all participants.\n for i, ppname in enumerate(participants):\n # Add the participant name.\n self.data[\"ppname\"].append(copy.deepcopy(ppname))\n # Skip empty datasets.\n if self.raw[ppname] is None:\n continue\n # Compute stuff relevant to this task.\n for j, qnr in enumerate(self.raw[ppname][\"QuestionNumber\"]):\n # Split Questionnaire 3, Q13 and Q14 into sub-questions\n if \"Q3\" in self._task_name and int(qnr) in [13,14]:\n # These questions split out into two parts: A description\n # of what each sub-part is, and a Boolean response for\n # each sub-part in the question. Example:\n # \"1_1_1_1_1_0//Television_VideogameConsole(suchas:WiiUPlayStationXboxorNintendoDS)_Tablet(likeanIPad)_Smartphone_LaptoporDesktopComputer_Noneofthese\"\n bool_resp, descr = self.raw[ppname][\"Response\"][j].split(\"//\")\n bool_resp = map(int, bool_resp.split(\"_\"))\n descr = descr.split(\"_\")\n # Store the data in the dict.\n for k, item in enumerate(descr):\n # Clean up the item name.\n if \"(\" in item:\n item = item[:item.find(\"(\")]\n var = \"Q%s_%s_resp\" % (int(qnr), item)\n # Create a new entry in the dict for this variable, if\n # one doesn't exist yet.\n if var not in self.data.keys():\n self.data[var] = numpy.zeros(n, dtype=float) * numpy.NaN\n # Store the data in the dict.\n self.data[var][i] = bool_resp[k]\n # Store response time for the whole item.\n self.data[\"Q%s_RT\" % (int(qnr))][i] = \\\n float(self.raw[ppname][\"TimeEndQuestion\"][j]) \\\n - float(self.raw[ppname][\"TimeStartQuestion\"][j])\n # All other questions are one-question one-response:\n else:\n # Store the data in the dict.\n self.data[\"Q%s_resp\" % (int(qnr))][i] = \\\n float(self.raw[ppname][\"Response\"][j])\n self.data[\"Q%s_RT\" % (int(qnr))][i] = \\\n self.raw[ppname][\"TimeEndQuestion\"][j] \\\n - self.raw[ppname][\"TimeStartQuestion\"][j]","def _extract_data(self):\n with open(self.file_path, \"rt\", encoding=self._encoding) as csv_file:\n raw_data = [row for row in csv.reader(csv_file)]\n\n # If we have read in a .txt, .tsv or .uniq file then we delimit our rows\n if self.file_path.suffix == \".txt\":\n raw_data = [row[0].split() for row in raw_data if len(row) == 1]\n\n elif (self.file_path.suffix == \".tsv\") or (self.file_path.suffix == \".tsv\"):\n raw_data = [re.split(r\"\\t+\", row[0]) for row in raw_data]\n\n # Csv files are the default so don't need handling\n elif self.file_path.suffix == \".csv\":\n pass\n\n # Warning users that a file has been loaded that we haven't build a capture for\n else:\n print(f\"Warning: {self.file_path.suffix} is not explicitly handled\")\n\n if self._file_headings:\n return raw_data[1:]\n else:\n return raw_data","def load_data(self):\n if self.use_files == True:\n if self.multi is True:\n self.star, self.data = [], []\n for fn in self.file:\n s = eleanor.Source(fn=fn, fn_dir=self.directory, tc=True)\n if self.do_corr == True or self.do_raw == True:\n d = eleanor.TargetData(s)\n else:\n d = eleanor.TargetData(s, do_psf=True)\n self.star.append(s)\n self.data.append(d)\n self.star = np.array(self.star)\n self.data = np.array(self.data)\n self.tic = self.star[0].tic\n self.coords = self.star[0].coords\n\n else:\n self.star = eleanor.Source(fn=self.file, fn_dir=self.directory, tc=True)\n if self.do_corr == True or self.do_raw == True:\n self.data = eleanor.TargetData(self.star)\n else:\n self.data = eleanor.TargetData(self.star, do_psf=True)\n self.tic = self.star.tic\n self.coords = self.star.coords\n\n else:\n if self.multi is True:\n self.star, self.data = [], []\n for s in self.star_results:\n self.star.append(s)\n if self.do_corr == True or self.do_raw == True:\n d = eleanor.TargetData(s)\n else:\n d = eleanor.TargetData(s, do_psf=True)\n self.data.append(d)\n\n else:\n self.star = self.star_results[0]\n if self.do_corr == True or self.do_raw == True:\n self.data = eleanor.TargetData(self.star)\n else:\n self.data = eleanor.TargetData(self.star, do_psf=True)\n\n return","def read_raw_data(self):\n dat_file = os.path.join(DATA_DIR, self.patient_number + '.txt')\n if not os.path.exists(dat_file):\n raise AssertionError(\"{} doesn't exist.\".format(dat_file))\n time = []\n voltage1 = []\n voltage2 = []\n with open(dat_file, 'r') as fd:\n for line in fd:\n line = line.split()\n time.append(line[0])\n voltage1.append(float(line[1]))\n voltage2.append(float(line[2]))\n\n tags_file = os.path.join(DATA_DIR, self.patient_number + '_tag.txt')\n if not os.path.exists(dat_file):\n raise AssertionError(\"{} doesn't exist.\".format(tags_file))\n tags_time = []\n tags = []\n r_peaks_indexes = []\n with open(tags_file, 'r') as fd:\n for line in fd:\n line = line.split()\n tags_time.append(line[0])\n tags.append(line[2])\n r_peaks_indexes.append(int(line[1]))\n return time, voltage1, voltage2, tags_time, tags, r_peaks_indexes","def get_data(self):\n \n with os.scandir(self.file_path) as collection_of_files:\n files_found = [file.name.split('.')[0] for file in collection_of_files \n if (file.name.split('.')[0].lower().strip() in self._data_requirements.required_file_names \n and file.name.endswith('.csv'))]\n\n self.check_missing_files(files_found)\n \n self._data = DictObjectView(self.read_in_files(files_found))","def data_extract(self, file):\n\n file_data = [row.strip().split() for row in open('data/{}'.format(file)).readlines()]\n return file_data","def extract_data(filename):\n if not os.path.exists(os.path.join(os.path.dirname(__file__), 'data2/')):\n with tarfile.open(filename, \"r\") as tarball:\n dir = os.path.dirname(__file__)\n tarball.extractall(os.path.join(dir, 'data2/'))\n return","def load_tasks(self):\n\n def _load_tasks(filename):\n filename = os.path.join(self.config['data']['location'], filename)\n filename = os.path.expanduser(filename)\n with open(filename, 'r') as f:\n lines = f.readlines()\n\n return list(map(taskw.utils.decode_task, lines))\n\n return dict(\n (db, _load_tasks('%s.data' % db))\n for db in ['completed', 'pending']\n )","def data_process(self):\n logging.info('Processing the data and split files')\n lines = Utility.file_len(self.fname)\n self.lines_to_be, self.split_files = Utility.split_files(self.fname, lines,\n cpu_count().real)","def main(input_path, output_path):\n logger.info('making final data set from raw data')\n\n index_path = 'data/raw/trec07p/full/index'\n index = getIndexMap(index_path, f'{input_path}/trec07p/data/')\n interim_path = 'data/interim'\n df = pd.DataFrame(columns=columns)\n\n count = 0\n if not path.exists(interim_path):\n logger.info(f'converting external txt files to trec07.csv in {interim_path}')\n mkdir(interim_path)\n for email in listdir(f'{input_path}/trec07p/data'):\n addEmailToDf(f'{input_path}/trec07p/data/{email}', index, df)\n count += 1\n if count % 1000 == 0:\n logger.info(f'conversion done for {count}/75000 files')\n df.to_csv(f'{interim_path}/trec07.csv', index=False)","def extract_dataset(filename):\n print(\"=\" * 40)\n print(\"Extracting dataset: \", filename)\n zipfile = ZipFile(os.path.join(DATA_DIR, filename))\n zipfile.extractall(DATA_DIR)","def InitDataset(self):\n train_txt = 'ImageSets/Main/train.txt'\n val_txt = 'ImageSets/Main/val.txt'\n annotations = \"Annotations\"\n jpegimages = \"JPEGImages\"\n images_path = train_txt if (self.is_train) else val_txt \n images_path = readTxt(os.path.join(self.path, images_path))\n images_path.pop(-1)\n # rawdata format: [path_2_image, path_2_xml]\n rawData = list()\n for each in images_path:\n xml = os.path.join(self.path, annotations, each + '.xml')\n jpeg = os.path.join(self.path, jpegimages, each + '.jpg')\n rawData.append([jpeg, xml])\n return rawData","def _read_data(self, \n data_path : str, \n bert : bool=False, \n mode : str=\"raw\", \n task : str=\"A\"\n ):\n print(f\"\\n[dataset]: Loading data from '{data_path}'...\")\n print(f\"[dataset]: performing task '{task}' preprocessing ...\")\n if task == \"A\":\n tokenizer = self._tokenize_line if mode == \"tokenize\" else self.bert_tokenizer\n return _read_data_taskA(data_path, tokenizer, bert, mode, tagger=self._tag_tokens, test=self.test)\n\n elif task == \"B\":\n return _read_data_taskB(data_path, test=False)\n \n elif task == \"C\":\n return _read_data_taskC(data_path, test=False)\n\n elif task == \"D\":\n return _read_data_taskD(data_path, test=False)","def load_data(self) -> tuple:\n label_num = {}\n data_set = pathlib.Path(self.path)\n data = []\n\n # create the label lookup dict for verifcation later\n for i, v in enumerate(data_set.iterdir()):\n label_num[v.name] = i\n self.labels[i] = v.name\n # end\n\n # read images\n for img_path in data_set.rglob(\"*.jpg\"):\n lbl = label_num[str(img_path.parent.stem)]\n img = cv2.imread(str(img_path))\n img = cv2.resize(img, self.dims, interpolation=cv2.INTER_AREA)\n\n # flatten RGB data into a vector\n # NOTE: NOT ACTUALLY NECESSARY! \n img.flatten()\n\n # label the sample and append to temp data list\n sample = np.append(lbl, img)\n data.append(sample)\n # end\n\n # partition and package the data (*_ ensures safe unpacking)\n train, test, validate, *_ = Data.partition(data, self.parts, 0.7, 0.2)\n self.train = Data(train)\n self.test = Data(test)\n self.validate = Data(validate)","def load_raw_data(self, input_files):\n\n log.debug(f\"Loading dataset {input_files}\") \n print(f\"Loading dataset\")\n\n # Load stroke information from XML files\n for file in input_files:\n new_strokeset = strokeset.StrokeSet(file)\n self.strokesets.append(new_strokeset)\n self.stroke_matrix.append(new_strokeset.as_delta_array())\n self.stroke_ascii.append(new_strokeset.get_text())\n\n done_msg = \"Finished parsing dataset. Imported {} lines\".format(len(self.get_strokesets()))\n print (done_msg)\n log.info(done_msg)","def prepare_data(self) -> None:\n if (self.root).is_dir():\n logger.info(\"Found the dataset.\")\n else:\n download_and_extract(self.root, DOWNLOAD_INFO)","def load_data(self) -> None:\n self.paths: List[str] = []\n self.durations: List[float] = []\n self.transcriptions: List[str] = []\n\n def raise_(err):\n \"\"\"raises error if problem during os.walk\"\"\"\n raise err\n\n for subset in self.subsets:\n subset_path = os.path.join(self.root, self.base_dir, subset)\n for root, dirs, files in os.walk(subset_path, onerror=raise_):\n if not files:\n continue\n matches = fnmatch.filter(files, \"*.trans.txt\")\n assert len(matches) == 1, \"> 1 transcription file found\"\n self._parse_transcription_file(root, matches[0])\n\n self._sort_by_duration()","def main(unused_argv):\n make_dir(FLAGS.raw_dir)\n\n # Get paths of download/extracted training and evaluation files.\n print(\"Downloading data from source\")\n train_files = get_raw_files(FLAGS.raw_dir, constants.TRAIN_DATA_SOURCES)\n eval_files = get_raw_files(FLAGS.raw_dir, constants.EVAL_DATA_SOURCES)","def get_additional_data_from_files(df, file_description): # file description one of [\"video\", \"eaf\", \"seg\", \"gentle\"]\n if file_description == \"gentle\":\n file_folder = FILE_BASE + \"/gentle/\"\n is_gentle_file = True\n else:\n file_folder = FILE_BASE + \"/original/\"\n is_gentle_file = False\n\n file_df = None\n\n if file_description not in list(FILE_DESCRIPTIONS_TO_EXT.keys()):\n print(\"Unknown file description! Don't know what to do with %s files...\" % file_description)\n return None\n\n else:\n print(\"Load and extract information from %s files...\" % file_description)\n #pbar = tqdm.tqdm(total = len(np.unique(df[\"source_file\"])),desc='Files', position=0,leave=True,file=sys.stdout)\n #file_log = tqdm.tqdm(total=0, position=1, bar_format='{desc}',leave=True,file=sys.stdout)\n print(\"Total files to laod and preprocess: \", len(np.unique(df[\"source_file\"])))\n \n for i,file in enumerate(np.unique(df[\"source_file\"])):\n if i%100 == 0:\n print(\"File: \",i)\n \n filepath = file_folder + get_file_path(file,is_gentle_file=is_gentle_file) + FILE_DESCRIPTIONS_TO_EXT[file_description]\n\n if file_description == \"video\":\n file_i_df = mp4_file_processing.get_word_video_snippet_size(df, filepath)\n elif file_description == \"eaf\":\n speech_annotation_eaf_data, gesture_eaf_data = eaf_file_processing.read_eaf(filepath)\n file_i_df = eaf_file_processing.map_gestures_to_annotation(speech_annotation_eaf_data, gesture_eaf_data, remove_pauses=False)\n file_i_df = eaf_file_processing.binary_encode_gestures(file_i_df, gesture_column=\"gesture\")\n\n elif file_description == \"seg\":\n file_i_df = seg_file_processing.get_seg_file_pos_info(filepath)\n\n elif file_description == \"gentle\":\n file_i_df = gentle_file_processing.get_gentle_file_transcripts(filepath)\n \n else:\n print(\"Unknown file format!!!\")\n return \n\n if file_df is None:\n file_df = file_i_df\n else:\n file_df = pd.concat([file_df, file_i_df], ignore_index=True)\n\n #file_log.set_description_str(f'Processed file: {file}')\n #pbar.update(1)\n #sleep(0.02)\n #file_log.close()\n #pbar.close()\n return file_df","def _read_data_taskD(data_path: str=\"path\", test: bool=False, test_samples=None):\n sentences = []\n labels = []\n targets_list = []\n\n data_dict = read_json_data(data_path) if not test else test_samples\n for entry in data_dict:\n text = entry[\"text\"]\n categories = entry[\"categories\"]\n\n sent_cats = []\n pol_labels = []\n cats_list = []\n for cat in categories:\n category = cat[0]\n sent_cats.append([text,cat])\n\n polarity = \"neutral\" if test else cat[1]\n pol_labels.append(POLARITY_2_TAGS[polarity])\n cats_list.append(category)\n\n sentences.append(sent_cats)\n labels.append(pol_labels)\n targets_list.append(cats_list)\n\n assert len(sentences) == len(labels)\n if not test:\n return sentences, labels, targets_list, None\n else:\n return list(zip(sentences,labels,targets_list))","def get_parsed_data():\n\n echonest_data_files = [f for f in os.listdir('.') if re.match(\"^echonest_[\\w]+.txt$\", f)]\n\n # Setting up header with user id and attributes\n header = ['user_id']\n header.extend(ATTRIBUTES)\n\n # printing header to standard out\n print \",\".join(header) \n\n # Processing each file to obtain parsed data\n for data_file in echonest_data_files:\n user_id = data_file[9:-4] # strip file prefix/suffix to get username/id\n parse_echonest_data_file(data_file, user_id)","def parsing(self, data_path, header=0):\n df_content = []\n csvfiles = glob.glob(data_path)\n selected_cols = list(self.data_features)\n selected_cols.append('workload.type')\n selected_cols.append('workload.appname')\n\n for csv in csvfiles:\n data = pd.read_csv(csv, index_col=None, header=header, usecols=selected_cols)\n data[self.data_features] = self.abnormal_detection(data[self.data_features])\n df_content.append(data.dropna(axis=0))\n self.dataset = pd.concat(df_content, sort=False)","def getInputFiles(self):\n taskname = self.cachedinfo['RequestName']\n\n #Get task status from the task DB\n self.logger.debug(\"Getting status from he DB\")\n server = self.crabserver\n crabDBInfo, _, _ = server.get(api='task', data={'subresource': 'search', 'workflow': taskname})\n status = getColumn(crabDBInfo, 'tm_task_status')\n self.destination = getColumn(crabDBInfo, 'tm_asyncdest')\n\n inputsFilename = os.path.join(os.getcwd(), 'InputFiles.tar.gz')\n if status == 'UPLOADED':\n raise ClientException('Currently crab upload only works for tasks successfully submitted')\n elif status == 'SUBMITTED':\n webdir = getProxiedWebDir(crabserver=self.crabserver, task=taskname,\n logFunction=self.logger.debug)\n if not webdir:\n webdir = getColumn(crabDBInfo, 'tm_user_webdir')\n self.logger.debug(\"Downloading 'InputFiles.tar.gz' from %s\" % webdir)\n httpCode = curlGetFileFromURL(webdir + '/InputFiles.tar.gz', inputsFilename, self.proxyfilename,\n logger=self.logger)\n if httpCode != 200:\n self.logger.errror(\"Failed to download 'InputFiles.tar.gz' from %s\", webdir)\n else:\n raise ClientException('Can only execute jobs from tasks in status SUBMITTED or UPLOADED. Current status is %s' % status)\n\n for name in [inputsFilename, 'CMSRunAnalysis.tar.gz', 'sandbox.tar.gz']:\n with tarfile.open(name) as tf:\n tf.extractall()","def load_file_data_from_db(self):\n\n file_objs = self.file_queryset.filter(sip=self.sip, removedtime__isnull=True)\n for file_obj in self._batch_query(file_objs):\n self.file_events = get_file_events(file_obj)\n if not self.file_events:\n return\n try:\n # merge the map_file_data dict with the map_av_data\n mapped_file_info = merge_file_data_dicts(\n map_file_data(file_obj, self.file_events), map_av_data(file_obj)\n )\n self.md_info[\"files\"].append(mapped_file_info)\n self.md_info[\"premis:size\"] = create_package_size(\n mapped_file_info[\"premis:size\"]\n )\n self.md_info[\"amount_of_files\"] += 1\n failed_virus_checks = get_failed_virus_checks(self.file_events)\n if failed_virus_checks:\n self.md_info[\"virus_scan_info\"][\"failed_virus_checks\"].append(\n failed_virus_checks\n )\n passed_virus_checks = get_passed_virus_checks(self.file_events)\n # add info virus_scan_tools if they passed and respect\n # different tools and versions if needed.\n if (\n passed_virus_checks\n and passed_virus_checks\n not in self.md_info[\"virus_scan_info\"][\"virus_scan_tools\"]\n ):\n self.md_info[\"virus_scan_info\"][\"virus_scan_tools\"].append(\n passed_virus_checks\n )\n except KeyError:\n logger.info(\n \"File is no longer present on the filesystem: %s\",\n file_obj.currentlocation,\n )\n continue","def unzip() -> None:\n logger = logging.getLogger(__name__)\n logger.info('Download the dataset')\n\n # define the destination\n destination = project_dir / 'data' / 'raw'\n\n # extract zip\n zip_file = ZipFile(destination / \"original.zip\")\n zip_file.extractall(destination)","def main(output_filepath):\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')\n\n baseurl = 'http://codeandbeer.org/virtual/BigData/Labs/'\n files = ['Booking-20151012-1322.csv', 'Booking-20181025-1232.csv']\n for filename in files:\n r = requests.get(baseurl+filename, stream=True)\n if r.status == 200:\n with open(output_filepath+\"/\"+filename, \"wb\") as f:\n f.raw.decode_content = True\n shutil.copyfileobj(r.raw, f)","def load_fullres_inputs(task, subdir='training'):\n tagged_paths = {\n 'gt': glob.glob(join(task.root, subdir, '*_GTL.tif')),\n 'im': glob.glob(join(task.root, subdir, '*_RGB.tif')),\n\n 'gti': glob.glob(join(task.root, subdir, '*_GTI.tif')),\n\n # digital terrain model\n 'dtm': glob.glob(join(task.root, subdir, '*_DTM.tif')),\n # digital surface model\n 'dsm': glob.glob(join(task.root, subdir, '*_DSM.tif')),\n }\n\n def extract_primary_key_info(paths, tag):\n if not paths:\n return pd.DataFrame()\n infos = [parse.parse('{site_id}_Tile_{N}_{type}.tif', p).named\n for p in map(basename, paths)]\n df = pd.DataFrame(infos)\n df = df.rename(columns={'type': tag + 'type'})\n df[tag] = paths\n df = df.set_index(['site_id', 'N'], drop=False).sort_index()\n return df\n\n train = pd.DataFrame()\n for tag, paths in tagged_paths.items():\n _df = extract_primary_key_info(paths, tag)\n if len(_df):\n for pk in ['N', 'site_id']:\n if pk not in train.columns:\n train[pk] = _df[pk]\n train[tag] = _df[tag]\n\n null_idxs = list(set(np.where(pd.isnull(train))[0]))\n if null_idxs:\n raise ValueError(('MISSING DATA FOR {}'.format(\n [train.index[i] for i in null_idxs])))\n\n for tag, paths in tagged_paths.items():\n pass\n\n metadata = train[['site_id', 'N']].reset_index(drop=True)\n dump_im_names = ['{site_id}_Tile_{N}.tif'.format(**d)\n for d in metadata.to_dict(orient='records')]\n\n # train_gts = list(train['gt'].values)\n # train_rgb = list(train['im'].values)\n # train_dtm = list(train['dtm'].values)\n # train_dsm = list(train['dsm'].values)\n\n # train_gts = sorted(train_gts)\n # train_rgb = fnameutil.align_paths(train_gts, train_rgb)\n # train_dtm = fnameutil.align_paths(train_gts, train_dtm)\n # train_dsm = fnameutil.align_paths(train_gts, train_dsm)\n # dump_im_names = ['{site_id}_Tile_{N}.tif'.format(**d) for d in infos]\n\n kw = train.drop(['N', 'site_id'], axis=1).to_dict(orient='list')\n fullres = inputs.Inputs.from_paths(**kw)\n\n # aux_paths = {'dtm': train_dtm, 'dsm': train_dsm}\n # fullres = {'im': train_rgb, 'gt': train_gts, 'aux': aux}\n\n fullres.dump_im_names = dump_im_names\n fullres.metadata = metadata\n\n # fullres.aux_paths = {}\n fullres.tag = 'fullres'\n return fullres","def get_raw_data():\n data_files = []\n for i, f in enumerate(os.listdir(config.RAW_DATA_DIR)):\n data_files.append(f)\n print i, \": \", f\n while True:\n try:\n index = int(raw_input(\"Type the index of the data file you'd like to import: \"))\n fn_raw_data = data_files[int(index)]\n break\n except ValueError:\n print(\"Not a valid index. Try again.\")\n except IndexError:\n print(\"Not a valid index. Try again.\")\n print \"Importing %s...\" % fn_raw_data\n with open(config.RAW_DATA_DIR + fn_raw_data) as infile:\n next(infile)\n raw_data = list(csv.DictReader(infile))\n return (fn_raw_data, raw_data)","def _process_data_file(self):\n \n with open(self.data_file, 'r') as f:\n self.description = f.readline().strip()\n data = np.loadtxt(self.data_file, skiprows=1)\n\n return data","def source_data_files(self, data_dir, tmp_dir, dataset_split):\n raise NotImplementedError()","def __load_data(self) -> np.array:\n with open('.'+os.sep+'ressources'+os.sep+self.path+os.sep+'capacity.txt','r') as fp:\n capacity = self.__parse_line(fp.readline())\n with open('.' + os.sep + 'ressources' + os.sep + self.path + os.sep + 'demand.txt', 'r') as fp:\n demand = self.__parse_line(fp.readline())\n with open('.' + os.sep + 'ressources' + os.sep + self.path + os.sep + 'distance.txt', 'r') as fp:\n distance_matrix = []\n for line in fp:\n row = self.__parse_line(line)\n distance_matrix.append(row)\n with open('.' + os.sep + 'ressources' + os.sep + self.path + os.sep + 'transportation_cost.txt', 'r') as fp:\n transportation_cost = self.__parse_line(fp.readline())\n return np.asarray(capacity), np.asarray(demand), np.asarray(distance_matrix), np.asarray(transportation_cost)","def parse(cls, raw_folder: str) -> Dict[str, Any]:\n folder_path = os.path.abspath(raw_folder)\n data = dict()\n files = os.listdir(folder_path)\n for file in files:\n if is_ignored(file):\n continue\n try:\n file = os.path.join(raw_folder, file)\n datum = cls.process_file(file)\n except FileNotCompatible:\n continue\n\n _, kwrd = os.path.split(file)\n kwrd = os.path.splitext(kwrd)[0]\n data[kwrd] = datum\n\n return data","def _load_data_worker(self,img_dir,lbl_dir):\n data = []\n\n for img,lbl in zip(glob(img_dir+\"/*.jpg\"),glob(lbl_dir+\"/*.txt\")):\n im = np.array(Image.open(img))\n im = make_square_image_with_padding(im, self.core_config.num_colors)\n lbl_fh = open(lbl,encoding='utf-8')\n\n objects = self._get_objects(lbl_fh)\n sorted_objects = sort_object_list(objects)\n object_class = self._get_object_classes(sorted_objects)\n \n image_with_objects = {\n 'img':im,\n 'objects':sorted_objects,\n 'object_class': object_class\n }\n\n image_with_mask = convert_to_mask(image_with_objects, self.core_config)\n\n data.append(image_with_mask)\n lbl_fh.close()\n\n return data","def import_data(self):\n\n # Import ordered names of origins\n origins_file = os.path.join(self.data_directory,'origins.txt')\n self.origins = np.loadtxt(origins_file,dtype=str,ndmin=1)\n\n # Import ordered names of destinations\n destinations_file = os.path.join(self.data_directory,'destinations.txt')\n self.destinations = np.loadtxt(destinations_file,dtype=str,ndmin=1)\n\n # Import origin supply\n originsupply_file = os.path.join(self.data_directory,'origin_supply.txt')\n self.origin_supply = np.loadtxt(originsupply_file,ndmin=1).astype('float64')\n\n # In case origin supply is not a list\n if not isinstance(self.origin_supply,(np.ndarray, np.generic)):\n self.origin_supply = np.array([self.origin_supply])\n\n # Import destination demand\n destinationdemand_file = os.path.join(self.data_directory,'destination_demand.txt')\n self.destination_demand = np.loadtxt(destinationdemand_file,ndmin=1).astype('float64')\n\n # In case destination demand is not a list\n if not isinstance(self.destination_demand,(np.ndarray, np.generic)):\n self.destination_demand = np.array([self.destination_demand])\n\n # Import origin locations\n originlocations_file = os.path.join(self.data_directory,'origin_locations.txt')\n self.origin_locations = np.loadtxt(originlocations_file,ndmin=1)\n\n # Import destination locations\n destinationlocations_file = os.path.join(self.data_directory,'destination_locations.txt')\n self.destination_locations = np.loadtxt(destinationlocations_file,ndmin=1)\n\n # Import initial and final destination sizes\n initialdestinationsizes_file = os.path.join(self.data_directory,'initial_destination_sizes.txt')\n self.initial_destination_sizes = np.loadtxt(initialdestinationsizes_file,ndmin=1)\n\n # In case destination sizes are not a list\n if not isinstance(self.initial_destination_sizes,(np.ndarray, np.generic)):\n self.initial_destination_sizes = np.array([self.initial_destination_sizes])\n\n # Import N,M\n self.N = self.origin_supply.shape[0]\n self.M = self.initial_destination_sizes.shape[0]\n\n # Import cost matrix\n costmatrix_file = os.path.join(self.data_directory,'cost_matrix.txt')\n self.cost_matrix = np.loadtxt(costmatrix_file).astype('float64')\n\n # Reshape cost matrix if necessary\n if self.N == 1:\n self.cost_matrix = np.reshape(self.cost_matrix[:,np.newaxis],(self.N,self.M))\n if self.M == 1:\n self.cost_matrix = np.reshape(self.cost_matrix[np.newaxis,:],(self.N,self.M))\n\n # Compute total initial and final destination sizes\n self.total_initial_sizes = np.sum(self.initial_destination_sizes)\n\n # Compute naive total cost\n self.total_cost = 0\n for i in range(self.N):\n for j in range(self.M):\n self.total_cost += self.cost_matrix[i,j]*(self.origin_supply[i]/self.N)","def extract(self, paths=None):\n\n all_files = self._get_package_files()\n if paths is None:\n extracted_files = all_files.values()\n else:\n extracted_files = [all_files[path] for path in paths]\n\n # filter already extracted file\n extracted_files = [pf for pf in extracted_files if not os.path.isfile(self.project.storage.fspath(pf.extract_path))]\n\n # group files by package\n files_by_package = defaultdict(list)\n for pf in extracted_files:\n files_by_package[pf.package].append(pf)\n\n package_files_path = f\"{self.path}/packages/files\"\n\n for package, files in files_by_package.items():\n with self.project.storage.stream(f\"{package_files_path}/{package}\") as reader:\n # sort files by offset to extract while streaming the bin file\n for pkgfile in sorted(files, key=lambda f: f.offset):\n logger.debug(f\"extracting {pkgfile.path}\")\n reader.skip_to(pkgfile.offset)\n fspath = self.project.storage.fspath(pkgfile.extract_path)\n with write_file_or_remove(fspath) as fout:\n if pkgfile.compressed:\n zobj = zlib.decompressobj(zlib.MAX_WBITS | 32)\n def writer(data):\n return fout.write(zobj.decompress(data))\n reader.copy(writer, pkgfile.size)\n fout.write(zobj.flush())\n else:\n reader.copy(fout.write, pkgfile.size)","def load_raw_data(self):\n if self.trendfile:\n self.raw_data = self.get_ap_file()\n else:\n report_params = self.format_api_request_params()\n report_params['test'] = self.testresults\n\n self.raw_data = self.get_ap_report(params=report_params)","def load_dataset(self):\n # Get all the files in the directory\n file_list = self.get_file_list()\n\n # Concatenate the data corresponding to a list of files\n data = self.concatenate_file_data(file_list)\n\n # Shuffle the data and create the training and the validation datasets\n data = self.shuffle_data_dictionary(data)\n self.training_dataset, self.validation_dataset = self.split_data_into_training_and_validation(data)","def perform_extraction(self) -> None:\n\n self._process_datasets_all_frames()","def __init__(self, raw_data_file,):\n self.raw_data_file = raw_data_file\n self.clean_data = self.cleanData()\n self.microtrip_data = []","def _extract_data(self, *args, **kwargs) -> None:\n raise NotImplementedError","def parse_main_tasks(self):\n # Need to determine the rolename per task somehow\n self.playbookparser = PlaybookParser(self.main_tasks, is_role=True)\n\n # Parse all main tasks\n self.playbookparser.parse_playbooks()\n self.parserdata = self.playbookparser.parserdata","def data_preprocessing():\n lineid_content = get_lineid_content()\n print('Read movie_lines.txt file complete...')\n convos = get_convos()\n print('Read movie_conversations.txt file complete...')\n print('Building dataset')\n get_data(lineid_content, convos)","def extract_files(self) -> list:\n pass","def extract(self, data):","def get_raw_files(raw_dir, data_source):\n raw_files = {\n \"inputs\": [],\n \"targets\": [],\n } # keys\n for d in data_source:\n if d[\"url\"].endswith(\"/\"): # the url is a dir and not a compressed file\n input_file = download_from_url(raw_dir, d[\"url\"] + d[\"input\"])\n target_file = download_from_url(raw_dir, d[\"url\"] + d[\"target\"])\n else:\n input_file, target_file = download_and_extract(\n raw_dir, d[\"url\"], d[\"input\"], d[\"target\"])\n raw_files[\"inputs\"].append(input_file)\n raw_files[\"targets\"].append(target_file)\n return raw_files","def extract(self):\n self.logger.info(f'Opening {self.file}')\n try:\n f = open(self.file, 'r')\n except FileNotFoundError:\n self.logger.info('Could not open the .vrt file')\n return\n\n result = {}\n self.logger.info('Extracting')\n for line in f:\n # Only attempt to extract if line is correct\n if self.is_target(line):\n # Add the closing text tag to make the line have proper XML\n xml_attributes = XML.fromstring(line.rstrip()+'</text>').attrib\n # Extract wanted parameters\n month = xml_attributes['date'][5:7] # Extract month\n # Add month to the keys\n if month not in result.keys():\n result[month] = []\n result[month].append({\n 'title': xml_attributes['title'], # Extract thread title\n 'thread_id': xml_attributes['thread_id'], # Extract thread id\n 'datetime': xml_attributes['datetime'] # Extract datetime\n })\n self.logger.info('Extraction complete')\n self.db = result\n # self.db[self.year] = result # Assign results to year\n self.save_result() # Save the results","def load_all_data() -> Tuple[pd.DataFrame, ...]:\n return tuple(\n pd.read_csv(path, sep='\\t') for path in (TARGETS_PATH, USER_INFO_PATH, INTERACTIONS_PATH, TRACK_INFO_PATH))","def cleanData(self):\n clean_data = []\n for file in self.raw_data_file:\n data = RawData(file)\n data.clean()\n data.prepare()\n clean_data.append(data)\n return clean_data","def unit_test_cal_extract_raw_spirou(p, rname, inputs):\n # define name and arguments\n name = 'cal_extract_RAW_spirou'\n arg_names = ['night_name', 'files']\n arg_types = [str, list]\n\n # get arguments\n args = get_args(p, name, rname, inputs, arg_names, arg_types)\n return args, name","def readFiles(trainFile, testFile):\r\n\r\n\t# Open both files and split into lines\r\n\twith open(trainFile) as f:\r\n\t\ttrainLines = f.read().splitlines()\r\n\r\n\twith open(testFile) as f:\r\n\t\ttestLines = f.read().splitlines()\r\n\r\n\t\t\r\n\t# Extract training data\r\n\tfor line in trainLines:\r\n\t\tline = line.split()\r\n\t\t\r\n\t\tid = line[0]\r\n\t\tclass_id = line[1]\r\n\t\twords = line[2:]\r\n\t\t\r\n\t\trow = [id, class_id, words]\r\n\t\t\r\n\t\ttrainingData.append(row)\r\n\t\t\r\n\t\t\r\n\t# Extract testing data\r\n\tfor line in testLines:\r\n\t\tline = line.split()\r\n\t\t\r\n\t\tid = line[0]\r\n\t\tclass_id = line[1]\r\n\t\twords = line[2:]\r\n\t\t\r\n\t\trow = [id, class_id, words]\r\n\t\t\r\n\t\ttestData.append(row)","def read_folder(self,sourceFolder):\n \n taskList = []\n for fileName in os.listdir(sourceFolder):\n if fileName.endswith(\".task\"):\n if 'HFODomain' in sourceFolder:\n taskList.append(HFOTask(sourceFolder+fileName,fileName.split('.')[0]))\n else:\n taskList.append(GridWorldTask(sourceFolder+fileName,fileName.split('.')[0]))\n return taskList","def get_data(output_dir: Path = Path(\"raw_data\")) -> None:\n\n files = [\n \"alignment.sorted.bam\",\n \"names-mdmg.dmp\",\n \"nodes-mdmg.dmp\",\n \"acc2taxid.map.gz\",\n ]\n\n for file in files:\n with resources.path(\"metaDMG.data\", file) as p:\n file_path = p\n\n target_path = Path(output_dir) / file\n target_path.parent.mkdir(parents=True, exist_ok=True)\n shutil.copy(file_path, target_path)","def _read_data_taskB(data_path: str=\"path\", test: bool=False, test_samples=None):\n sentences = []\n labels = []\n targets_list = []\n\n data_dict = read_json_data(data_path) if not test else test_samples\n for entry in data_dict:\n text = entry[\"text\"]\n targets = entry[\"targets\"]\n\n sent_term = []\n pol_labels = []\n term_list = []\n if len(targets) > 0:\n for tgt in targets:\n term = tgt[1]\n sent_term.append([text,term])\n term_list.append(term)\n\n polarity = \"un-polarized\" if test else tgt[2]\n pol_labels.append(POLARITY_TAGS[polarity])\n\n else:\n polarity = \"un-polarized\"\n sent_term.append([text,\"\"])\n pol_labels.append(POLARITY_TAGS[polarity])\n term_list.append(\"\")\n\n sentences.append(sent_term)\n labels.append(pol_labels)\n targets_list.append(term_list)\n\n assert len(sentences) == len(labels)\n if not test:\n return sentences, labels, targets_list, None\n else:\n return list(zip(sentences,labels,targets_list))","def _load_data(self):\n\n path_data_x = '/workspace/base-ml/data/dizzyreg/t%s_df.csv' % \\\n self.task_num\n path_data_y = '/workspace/base-ml/data/dizzyreg/label_df_t%s.csv' % self.task_num\n path_meta = '/workspace/base-ml/data/dizzyreg/meta_df_t%s.csv' % self.task_num\n path_numerical_columns = '/workspace/base-ml/data/dizzyreg/num_columns_v2.csv'\n path_nonnumerical_columns = '/workspace/base-ml/data/dizzyreg/non_num_columns_v2.csv'\n\n read_data_x = pd.read_csv(path_data_x)\n read_data_y = pd.read_csv(path_data_y)\n read_data_meta = pd.read_csv(path_meta)\n\n # Drop columns if it only contains 1 unique element\n read_data_x = pd.DataFrame(self.drop_one_elem_columns(read_data_x))\n\n num_col = pd.read_csv(path_numerical_columns)\n num_col = read_data_x.columns.isin(num_col['0'].values).nonzero()[0]\n col_idx = np.arange(read_data_x.shape[-1])\n non_num_col = np.setdiff1d(col_idx, num_col)\n\n # new_data_x = np.array(read_data_x).astype(np.float32)\n new_data_x = np.array(read_data_x)\n new_data_y = np.array(read_data_y).astype(np.float32)\n new_data_meta = np.array(read_data_meta).astype(np.float32)\n\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\n\n\n # Winsorize dataset\n len_feat = new_data_x.shape[-1]\n idx_list = list(num_col)\n for i in range(len_feat):\n if i in idx_list:\n cur_data = new_data_x[:, i]\n cur_data = np.array(cur_data)\n lower_p = np.percentile(cur_data, 5)\n higher_p = np.percentile(cur_data, 95)\n cur_data[cur_data < lower_p] = lower_p\n cur_data[cur_data > higher_p] = higher_p\n new_data_x[:, i] = cur_data\n\n # Make sure target data is one-hot encoded\n if new_data_y.shape[-1] == 1:\n num_class = len(np.unique(new_data_y))\n new_data_y = np.eye(num_class)[new_data_y.astype(int).reshape(-1)]\n new_data_y = new_data_y.astype('float32')\n self.orig_column_names = read_data_x.columns\n self.data_x = new_data_x # N x F\n self.data_y = new_data_y # N x C\n self.numerical_idx = num_col # list of idx\n self.non_num_idx = non_num_col # None\n\n # Calculate adjacency matrix\n self.meta_inf = new_data_meta.astype('float32') # N x 3\n if self.args.graph_type:\n self.adj = self.get_adjacency()","def loadFiles(root=\"data/TAIWAN_RAW_DATA/ADHD\"):\n\tdata_rt = [] # realtime.csv\n\tdata_trial = [] # trialdata.csv\n\tdata_id = [] # caseid/subjectid\n\tRealTime = \"A2RealTime_\"\n\tTrialData = \"A2TrialData_\"\n\tfolder_list = os.listdir(root) # list of subfolders in the root\n\tfor folders in folder_list:\n\t\tfolders_path = os.path.join(root,folders)\n\t\tif folders.find(\"pass\") != -1:\n\t\t\tcontinue\n\t\t\t\n\t\ttry:\n\t\t\tdata_rt.append(pd.read_csv(os.path.join\n\t\t\t\t\t\t\t\t (folders_path,\n\t\t\t\t\t\t\t\t RealTime+folders[3:]+\".csv\")))\n\t\t\tdata_trial.append(pd.read_csv(os.path.join\n\t\t\t\t\t\t\t\t\t (folders_path,\n\t\t\t\t\t\t\t\t\t TrialData+folders[3:]+\".csv\")))\n\t\t\tdata_id.append(int(folders.split('_')[1]))\n\t\texcept:\n\t\t\tprint(os.path.join(folders_path,TrialData+folders[3:]+\".csv\"))\n\t\t\t\n\treturn data_rt,data_trial,data_id,folder_list","def _load_processed_data(self):\n with open(os.path.join(self._data_root_path, self._processed_train_data_file_name),\n 'r') as f:\n train_examples = json.load(f)\n\n with open(os.path.join(self._data_root_path, self._processed_dev_data_file_name), 'r') as f:\n dev_examples = json.load(f)\n\n with open(os.path.join(self._data_root_path, self._word_vocab_file_name), 'r') as f:\n word_vocab = Vocab.from_json(json.load(f))\n\n with open(os.path.join(self._data_root_path, self._char_vocab_file_name), 'r') as f:\n char_vocab = Vocab.from_json(json.load(f))\n\n return train_examples, dev_examples, word_vocab, char_vocab","def process(self):\n # check already processed\n proc_dir = os.path.join(self.root, self.processed_dir)\n train_path = os.path.join(proc_dir, self.train_fn)\n test_path = os.path.join(proc_dir, self.test_fn)\n if os.path.exists(train_path) and os.path.exists(test_path):\n # already exists => load process file\n print(\"processed dataset already exists; load it\")\n self.train_data = torch.load(train_path)\n self.test_data = torch.load(test_path)\n return\n\n # read and process raw data\n print(\"read and process raw dataset ...\")\n label_path = os.path.join(self.root, self.raw_dir, \"labels.txt\")\n image_path_format = os.path.join(self.root, self.raw_dir, \"img_{}.png\")\n \n with open(label_path) as f:\n for line in f:\n if not line.strip():\n break\n \n idx, label = map(int, line.strip().split('\\t'))\n image_path = image_path_format.format(idx)\n image = load_image(image_path)\n \n if idx <= self.split:\n self.train_data.append((image, label))\n elif idx > self.split:\n self.test_data.append((image, label))\n\n # write processed file\n if not os.path.exists(proc_dir):\n os.mkdir(proc_dir)\n\n with open(train_path, 'wb') as f:\n torch.save(self.train_data, f)\n with open(test_path, 'wb') as f:\n torch.save(self.test_data, f)\n\n print(\"Done!\")","def get_processed_data(self, group_directory):\n processed_dir = [x for x in group_directory.iterdir()\n if x.is_dir() and 'processed' in x.name][0]\n\n task_dirs = [x for x in processed_dir.iterdir()\n if x.is_dir() and 'task' in x.name]\n\n files = dict()\n for task in task_dirs:\n task_camera_dirs = [x for x in task.iterdir()\n if x.is_dir() and 'pc' in x.name]\n\n task_frame_files = list()\n if task_camera_dirs:\n task_frame_files = dict()\n for camera_dir in task_camera_dirs:\n task_frame_files[camera_dir.name] = [x for x in camera_dir.iterdir()\n if not x.is_dir() and x.suffix in VALID_OUTPUT_FILE_TYPES]\n\n for camera, frame_files in task_frame_files.items():\n for frame_file in frame_files:\n frame = int(re.search(r'(?<=_)(\\d{12})(?=_)',\n frame_file.name).group(0))\n if task.name not in files:\n files[task.name] = dict()\n\n if frame not in files[task.name]:\n files[task.name][frame] = dict()\n\n files[task.name][frame][camera] = frame_file\n\n else:\n task_frame_files = [x for x in task.iterdir()\n if not x.is_dir()\n and x.suffix in VALID_OUTPUT_FILE_TYPES]\n\n for frame_file in task_frame_files:\n frame = int(re.search(r'(?<=_)(\\d{12})(?=_)',\n frame_file.name).group(0))\n if task.name not in files:\n files[task.name] = dict()\n files[task.name][frame] = frame_file\n\n return files","def read_data(args):\n\n print(\"Start read_data\")\n t_tot = 0 # sum of times for the all dataset\n date_dirs = os.listdir(args.path_data_base)\n for n_iter, date_dir in enumerate(date_dirs):\n # get access to each sequence\n path1 = os.path.join(args.path_data_base, date_dir)\n if not os.path.isdir(path1):\n continue\n date_dirs2 = os.listdir(path1)\n\n for date_dir2 in date_dirs2:\n path2 = os.path.join(path1, date_dir2)\n if not os.path.isdir(path2):\n continue\n # read data\n oxts_files = sorted(glob.glob(os.path.join(path2, 'oxts', 'data', '*.txt')))\n oxts = KITTIDataset.load_oxts_packets_and_poses(oxts_files)\n\n \"\"\" Note on difference between ground truth and oxts solution:\n - orientation is the same\n - north and east axis are inverted\n - position are closed to but different\n => oxts solution is not loaded\n \"\"\"\n\n print(\"\\n Sequence name : \" + date_dir2)\n if len(oxts) < KITTIDataset.min_seq_dim: # sequence shorter than 30 s are rejected\n cprint(\"Dataset is too short ({:.2f} s)\".format(len(oxts) / 100), 'yellow')\n continue\n lat_oxts = np.zeros(len(oxts))\n lon_oxts = np.zeros(len(oxts))\n alt_oxts = np.zeros(len(oxts))\n roll_oxts = np.zeros(len(oxts))\n pitch_oxts = np.zeros(len(oxts))\n yaw_oxts = np.zeros(len(oxts))\n roll_gt = np.zeros(len(oxts))\n pitch_gt = np.zeros(len(oxts))\n yaw_gt = np.zeros(len(oxts))\n t = KITTIDataset.load_timestamps(path2)\n acc = np.zeros((len(oxts), 3))\n acc_bis = np.zeros((len(oxts), 3))\n gyro = np.zeros((len(oxts), 3))\n gyro_bis = np.zeros((len(oxts), 3))\n p_gt = np.zeros((len(oxts), 3))\n v_gt = np.zeros((len(oxts), 3))\n v_rob_gt = np.zeros((len(oxts), 3))\n\n k_max = len(oxts)\n for k in range(k_max):\n oxts_k = oxts[k]\n t[k] = 3600 * t[k].hour + 60 * t[k].minute + t[k].second + t[\n k].microsecond / 1e6\n lat_oxts[k] = oxts_k[0].lat\n lon_oxts[k] = oxts_k[0].lon\n alt_oxts[k] = oxts_k[0].alt\n acc[k, 0] = oxts_k[0].af\n acc[k, 1] = oxts_k[0].al\n acc[k, 2] = oxts_k[0].au\n acc_bis[k, 0] = oxts_k[0].ax\n acc_bis[k, 1] = oxts_k[0].ay\n acc_bis[k, 2] = oxts_k[0].az\n gyro[k, 0] = oxts_k[0].wf\n gyro[k, 1] = oxts_k[0].wl\n gyro[k, 2] = oxts_k[0].wu\n gyro_bis[k, 0] = oxts_k[0].wx\n gyro_bis[k, 1] = oxts_k[0].wy\n gyro_bis[k, 2] = oxts_k[0].wz\n roll_oxts[k] = oxts_k[0].roll\n pitch_oxts[k] = oxts_k[0].pitch\n yaw_oxts[k] = oxts_k[0].yaw\n v_gt[k, 0] = oxts_k[0].ve\n v_gt[k, 1] = oxts_k[0].vn\n v_gt[k, 2] = oxts_k[0].vu\n v_rob_gt[k, 0] = oxts_k[0].vf\n v_rob_gt[k, 1] = oxts_k[0].vl\n v_rob_gt[k, 2] = oxts_k[0].vu\n p_gt[k] = oxts_k[1][:3, 3]\n Rot_gt_k = oxts_k[1][:3, :3]\n roll_gt[k], pitch_gt[k], yaw_gt[k] = IEKF.to_rpy(Rot_gt_k)\n\n t0 = t[0]\n t = np.array(t) - t[0]\n # some data can have gps out\n if np.max(t[:-1] - t[1:]) > 0.1:\n cprint(date_dir2 + \" has time problem\", 'yellow')\n ang_gt = np.zeros((roll_gt.shape[0], 3))\n ang_gt[:, 0] = roll_gt\n ang_gt[:, 1] = pitch_gt\n ang_gt[:, 2] = yaw_gt\n\n p_oxts = lla2ned(lat_oxts, lon_oxts, alt_oxts, lat_oxts[0], lon_oxts[0],\n alt_oxts[0], latlon_unit='deg', alt_unit='m', model='wgs84')\n p_oxts[:, [0, 1]] = p_oxts[:, [1, 0]] # see note\n\n # take correct imu measurements\n u = np.concatenate((gyro_bis, acc_bis), -1)\n # convert from numpy\n t = torch.from_numpy(t)\n p_gt = torch.from_numpy(p_gt)\n v_gt = torch.from_numpy(v_gt)\n ang_gt = torch.from_numpy(ang_gt)\n u = torch.from_numpy(u)\n\n # convert to float\n t = t.float()\n u = u.float()\n p_gt = p_gt.float()\n ang_gt = ang_gt.float()\n v_gt = v_gt.float()\n\n mondict = {\n 't': t, 'p_gt': p_gt, 'ang_gt': ang_gt, 'v_gt': v_gt,\n 'u': u, 'name': date_dir2, 't0': t0\n }\n\n t_tot += t[-1] - t[0]\n KITTIDataset.dump(mondict, args.path_data_save, date_dir2)\n print(\"\\n Total dataset duration : {:.2f} s\".format(t_tot))","def main(input_filepath, output_filepath):\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')","def main(input_filepath, output_filepath):\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')","def extractor_multiprocess(self):\n pool = multiprocessing.Pool()\n queue = multiprocessing.Queue()\n queue.put(\"safe\")\n end = len(next(os.walk(self.datadir))[2])\n error = 0\n\n extractor_iterator = ((directory)\n for directory in os.listdir(self.datadir))\n with jsonlines.open(self.output, \"w\") as f:\n for x in tqdm.tqdm(\n pool.imap_unordered(self.extract_unpack, extractor_iterator), total=end\n ):\n if not x:\n \"\"\"\n To input error class or function\n \"\"\"\n error += 1\n continue\n msg = queue.get()\n if msg == \"safe\":\n f.write(x)\n queue.put(\"safe\")\n\n pool.close()","def _load(self, data):\n raise NotImplementedError(\"Don't know how to load the task\")","def extract_from_file(self, data_file, data_path):\n with open(data_file, \"r\") as f:\n lines = f.readlines()\n\n data_paths = [os.path.join(data_path, line) for line in lines]\n return data_paths","def get_data_gen_datasets(raw_data,normalize_data=True):\n\n training_set,validation_set,test_set,class_labels = raw_data\n print \"Loading data succeeded\"\n\n if normalize_data:\n training_set_samples = normalize(training_set[:,0:-1])\n validation_set_samples = normalize(validation_set[:,0:-1])\n testing_set_samples = normalize(test_set[:,0:-1])\n\n print \"Normalized data\"\n\n # assume square patches\n inp_shape = int(numpy.sqrt(training_set_samples.shape[1]))\n\n training_set_samples = theano.shared(training_set_samples.astype(theano.config.floatX))\n validation_set_samples = theano.shared(validation_set_samples.astype(theano.config.floatX))\n test_set_samples = theano.shared(testing_set_samples.astype(theano.config.floatX))\n\n training_set_labels = theano.shared(training_set[:,-1].astype('int32')) # FIXME: uint8 should be sufficient\n validation_set_labels = theano.shared(validation_set[:,-1].astype('int32'))\n test_set_labels = theano.shared(test_set[:,-1].astype('int32'))\n\n print \"Unpacked data\"\n\n return ((training_set_samples, training_set_labels), \\\n (validation_set_samples, validation_set_labels), \\\n (test_set_samples, test_set_labels), \\\n inp_shape,class_labels)","def read_unlabeled(data_loc, dname):\n data = []\n fnames = []\n raw_fnames = os.listdir(data_loc + dname)\n for raw_fname in raw_fnames:\n fname = dname + '/' + raw_fname\n content = read_instance(data_loc, fname)\n data.append(content)\n fnames.append(fname)\n return data, fnames","def __init__(self, data_dir, output_path=None, task_name=\"Q1_Questions\"):\n \n # Remember the task name.\n self._task_name = task_name\n # Load all data.\n self.load_from_directory(data_dir, task_name)\n self.process_raw_data()\n if not (output_path is None):\n self.write_processed_data_to_file(output_path)","def doImport(self, params):\n #logging.info(params.filename)\n raw_data = self.open_filename(params.filename)\n #logging.info('file open ok')\n data = self.split_to_blocks(raw_data)\n #logging.info('splitting ok')\n chromatograms = self.process_data_to_chromatograms(data)\n #logging.info('extract ok')\n \n processed_data = []\n \n zero = params.field_results[\"zero\"]\n MIC = params.field_results[\"MIC\"]\n TIC = params.field_results[\"TIC\"]\n round_MZ = params.field_results[\"round_MZ\"]\n \n for chrom in chromatograms:\n \n prefix = chrom['short_title']\n if (\".\" in prefix) and round_MZ:\n first,last = prefix.split('.')\n prefix = first\n \n if (\"MIC\" in prefix) and (not MIC):\n pass\n elif (\"TIC\" in prefix) and (not TIC):\n pass\n else:\n x = ImportDataset1D(name=prefix+'_time',data = chrom['time'])\n if zero:\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal_zero'])\n else:\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal'])\n processed_data.append(x)\n processed_data.append(y)\n \n return processed_data","def get_data(n = None):\n files = download_data()\n for path in files.values():\n extract_data(path)\n class_fnames, labelmap = explore_data()\n X, y = load_data(class_fnames)\n return prepare_data(X, y, n = n)","def download_and_extract_data(tmp_dir, dataset):\n url = dataset[0]\n print(dataset)\n compressed_filename = os.path.basename(url)\n compressed_file = generator_utils.maybe_download(\n tmp_dir, compressed_filename, url)\n\n for file in dataset[1]:\n tf.logging.info(\"Reading file: %s\" % file)\n filepath = os.path.join(tmp_dir, file)\n\n # Extract from tar if needed.\n if not tf.gfile.Exists(filepath):\n with tarfile.open(compressed_file, \"r:gz\") as corpus_tar:\n corpus_tar.extractall(tmp_dir)\n\n documents_filename, labels_filename = dataset[1]\n documents_filepath = os.path.join(tmp_dir, documents_filename)\n labels_filepath = os.path.join(tmp_dir, labels_filename)\n return documents_filepath, labels_filepath","def load_data_part(fname):\n if \"_data\" not in fname:\n return None\n # Read data\n data = pd.read_csv(fname)\n # events file\n events_fname = fname.replace('_data', '_events')\n # read event file\n labels = pd.read_csv(events_fname)\n clean = data.drop(['id'], axis=1) # remove id\n labels = labels.drop(['id'], axis=1) # remove id\n return clean, labels","def extract_data(input_file):\n input_zip = client.file(input_file).getFile().name\n # Create directory to unzip model files into\n if os.path.exists(\"/tmp/unzipped_file/\"):\n rmtree('unzipped_file',ignore_errors=True)\n else:\n os.mkdir(\"/tmp/unzipped_file/\")\n zipped_file = zipfile.ZipFile(input_zip)\n # Extract unzipped files into directory created earlier returns none\n file_path = \"/tmp/unzipped_file/\"\n return zipped_file.extract(\"test_keras_data.csv\", file_path)","def process_data(self) -> Tuple[list, List[Sequence[int]]]:\n features, labels = self.load_files()\n x = [self.process_text(f, self.max_length) for f in features]\n y = [self._convert_labels(l, self.max_length) for l in labels]\n return x, y","def process(self):\n self.extract()\n self.transform()\n self.load()","def load_data(self, task):\n params = self.params\n data = {splt: {} for splt in ['train', 'valid', 'test']}\n dpath = os.path.join(params.data_path, 'eval', task)\n\n self.n_sent = 1 if task in ['SST-2', 'CoLA'] else 2\n\n for splt in ['train', 'valid', 'test']:\n\n # load data and dictionary\n data1 = load_binarized(os.path.join(dpath, '%s.s1.pth' % splt), params)\n data2 = load_binarized(os.path.join(dpath, '%s.s2.pth' % splt), params) if self.n_sent == 2 else None\n data['dico'] = data.get('dico', data1['dico'])\n\n # set dictionary parameters\n set_dico_parameters(params, data, data1['dico'])\n if self.n_sent == 2:\n set_dico_parameters(params, data, data2['dico'])\n\n # create dataset\n if self.n_sent == 1:\n data[splt]['x'] = Dataset(data1['sentences'], data1['positions'], params)\n else:\n data[splt]['x'] = ParallelDataset(\n data1['sentences'], data1['positions'],\n data2['sentences'], data2['positions'],\n params\n )\n\n # load labels\n if splt != 'test' or task in ['MRPC']:\n # read labels from file\n with open(os.path.join(dpath, '%s.label' % splt), 'r') as f:\n lines = [l.rstrip() for l in f]\n # STS-B task\n if task == 'STS-B':\n assert all(0 <= float(x) <= 5 for x in lines)\n y = [float(l) for l in lines]\n # QQP\n elif task == 'QQP':\n UNK_LABEL = 0\n lab2id = {x: i for i, x in enumerate(sorted(set(lines) - set([''])))}\n y = [lab2id.get(x, UNK_LABEL) for x in lines]\n # other tasks\n else:\n lab2id = {x: i for i, x in enumerate(sorted(set(lines)))}\n y = [lab2id[x] for x in lines]\n data[splt]['y'] = torch.LongTensor(y)\n assert len(data[splt]['x']) == len(data[splt]['y'])\n\n # compute weights for weighted training\n if task != 'STS-B' and params.weighted_training:\n weights = torch.FloatTensor([\n 1.0 / (data['train']['y'] == i).sum().item()\n for i in range(len(lab2id))\n ]).npu()\n self.weights = weights / weights.sum()\n else:\n self.weights = None\n\n return data","def readDataFromFile():\n image_size = 28 # each image is 28x28\n\n num_images = 60000 # there are 60k images\n with gzip.open(r'train-images-idx3-ubyte.gz', 'r') as f: # 60k train & valid\n f.read(16) # reading by 16-byte double\n buffer_Train_Images = f.read(image_size * image_size * num_images)\n f.close()\n data_Train_Images = np.frombuffer(buffer_Train_Images, dtype=np.uint8).astype(\n np.int32) # translating into 0 to 255\n data_Train_Images = data_Train_Images.reshape(num_images,\n image_size * image_size) # Data = 60k x 28 x 28 with 1 value in it\n\n with gzip.open('train-labels-idx1-ubyte.gz', 'r') as f: # 60k train & valid - labels\n f.read(8) # reading by 16-byte double\n buffer_Train_Labels = f.read(num_images)\n data_Train_Labels = np.frombuffer(buffer_Train_Labels, dtype=np.uint8).astype(\n np.int32) # translating into 0 to 255\n\n num_images = 10000 # there are 10k images\n with gzip.open('t10k-images-idx3-ubyte.gz', 'r') as f: # 10k tests\n f.read(16) # reading by 16-byte double\n buffer_Test_Image = f.read(image_size * image_size * num_images)\n data_Test_Image = np.frombuffer(buffer_Test_Image, dtype=np.uint8).astype(\n np.uint8) # translating into 0 to 255\n data_Test_Image = data_Test_Image.reshape(num_images, image_size * image_size) # Data = 60k x 28 x 28 with\n\n with gzip.open('t10k-labels-idx1-ubyte.gz', 'r') as f: # 10k tests - lbles\n f.read(8) # reading by 16-byte double\n buffer_Test_Label = f.read(num_images)\n data_Test_Labels = np.frombuffer(buffer_Test_Label, dtype=np.uint8).astype(\n np.int32) # translating into 0 to 255\n\n return data_Train_Images, data_Train_Labels, data_Test_Image, data_Test_Labels","def grab_data_chunk(self, filenames):\n \n filenames = [join(self.kwargs[\"data_dir\"],f) for f in filenames]\n\n\n dataset=MFDataset(filenames)\n \n tensor = convert_nc_data_to_tensor(dataset,self.kwargs)\n \n return tensor","def _read_data(self) -> MMD:\n\t\tif self.config.source_type == SourceType.LOCAL_FILE:\n\t\t\treturn self._read_files()\n\t\telif self.config.source_type == SourceType.HDFS:\n\t\t\treturn self._read_hdfs()\n\t\telif self.config.source_type == SourceType.NEO4J:\n\t\t\treturn self._read_neo4j(self.config.graph_db)\n\n\t\telse:\n\t\t\traise NotImplementedError(\"The source type {} has not been implemented yet.\".format(loader_config.source_type))","def _get_data(\n self,\n vis_hdu,\n antenna_nums,\n antenna_names,\n ant_str,\n bls,\n frequencies,\n freq_chans,\n times,\n time_range,\n polarizations,\n blt_inds,\n read_metadata,\n keep_all_metadata,\n run_check,\n check_extra,\n run_check_acceptability,\n strict_uvw_antpos_check,\n ):\n # figure out what data to read in\n blt_inds, freq_inds, pol_inds, history_update_string = self._select_preprocess(\n antenna_nums,\n antenna_names,\n ant_str,\n bls,\n frequencies,\n freq_chans,\n times,\n time_range,\n polarizations,\n blt_inds,\n )\n\n if blt_inds is not None:\n blt_frac = len(blt_inds) / float(self.Nblts)\n else:\n blt_frac = 1\n\n if freq_inds is not None:\n freq_frac = len(freq_inds) / float(self.Nfreqs)\n else:\n freq_frac = 1\n\n if pol_inds is not None:\n pol_frac = len(pol_inds) / float(self.Npols)\n else:\n pol_frac = 1\n\n min_frac = np.min([blt_frac, freq_frac, pol_frac])\n\n if min_frac == 1:\n # no select, read in all the data\n if vis_hdu.header[\"NAXIS\"] == 7:\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :, :]\n assert self.Nspws == raw_data_array.shape[1]\n\n else:\n # in many uvfits files the spw axis is left out,\n # here we put it back in so the dimensionality stays the same\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :]\n raw_data_array = raw_data_array[:, np.newaxis, :, :]\n else:\n # do select operations on everything except data_array, flag_array\n # and nsample_array\n self._select_metadata(\n blt_inds, freq_inds, pol_inds, history_update_string, keep_all_metadata\n )\n\n # just read in the right portions of the data and flag arrays\n if blt_frac == min_frac:\n if vis_hdu.header[\"NAXIS\"] == 7:\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\n assert self.Nspws == raw_data_array.shape[1]\n else:\n # in many uvfits files the spw axis is left out,\n # here we put it back in so the dimensionality stays the same\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\n if freq_frac < 1:\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\n if pol_frac < 1:\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\n elif freq_frac == min_frac:\n if vis_hdu.header[\"NAXIS\"] == 7:\n raw_data_array = vis_hdu.data.data[:, :, :, :, freq_inds, :, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\n assert self.Nspws == raw_data_array.shape[1]\n else:\n # in many uvfits files the spw axis is left out,\n # here we put it back in so the dimensionality stays the same\n raw_data_array = vis_hdu.data.data[:, :, :, freq_inds, :, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\n\n if blt_frac < 1:\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\n if pol_frac < 1:\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\n else:\n if vis_hdu.header[\"NAXIS\"] == 7:\n raw_data_array = vis_hdu.data.data[:, :, :, :, :, pol_inds, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\n assert self.Nspws == raw_data_array.shape[1]\n else:\n # in many uvfits files the spw axis is left out,\n # here we put it back in so the dimensionality stays the same\n raw_data_array = vis_hdu.data.data[:, :, :, :, pol_inds, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\n\n if blt_frac < 1:\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\n if freq_frac < 1:\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\n\n assert len(raw_data_array.shape) == 5\n # FITS uvw direction convention is opposite ours and Miriad's.\n # So conjugate the visibilities and flip the uvws:\n self.data_array = (\n raw_data_array[:, :, :, :, 0] - 1j * raw_data_array[:, :, :, :, 1]\n )\n self.flag_array = raw_data_array[:, :, :, :, 2] <= 0\n self.nsample_array = np.abs(raw_data_array[:, :, :, :, 2])\n\n # check if object has all required UVParameters set\n if run_check:\n self.check(\n check_extra=check_extra,\n run_check_acceptability=run_check_acceptability,\n strict_uvw_antpos_check=strict_uvw_antpos_check,\n )","def import_raw(self,read_teff=False,**kwargs):\n \n #build dirs\n self._build_em_dirs()\n\n for tn in self.Tn:\n #initialize counter and flag\n counter=0\n #build wait-time specific path\n tn_path = self.root_path%tn\n #create em results dir if needed\n em_res_tn_dir=os.path.join(self.em_res_top_dir,'tn%d'%tn)\n if not os.path.exists(em_res_tn_dir):\n os.makedirs(em_res_tn_dir)\n for pfile in os.listdir(tn_path):\n if 'heat_amp' not in pfile and 'dem' not in pfile:\n self.logger.debug(\"Reading %s\"%pfile)\n data = np.loadtxt(os.path.join(tn_path,pfile))\n n_index = 2\n t_index = 1\n if 'electron' in tn_path or 'ion' in tn_path: n_index += 1\n if read_teff:\n n_index = 3\n t_index = 2\n t,T,n = data[:,0],data[:,t_index],data[:,n_index]\n #calculate emission measure distribution\n self.binner.set_data(t,T,n)\n self.binner.build_em_dist()\n #save data\n with open(os.path.join(em_res_tn_dir,os.path.splitext(pfile)[0]+'.pickle'),'wb') as f:\n pickle.dump({'T':self.binner.T_em_flat, 'em':self.binner.em_flat/self.aspect_ratio_factor, 'bins':self.binner.T_em_histo_bins},f)\n #increment counter\n counter += 1\n else:\n continue\n\n #Estimate percentage of files read\n self.logger.info(\"Tn = %d s finished, Estimated total # of events simulated: %.2f %%\"%(tn, counter*int(np.ceil(t[-1]/(self.tpulse+tn)))))","def prep_data(self, num_processes):\n filenames = os.listdir(self.beatmaps_root)\n processes = []\n for i in range(num_processes):\n start = i * (len(filenames) // num_processes)\n end = None\n if i != num_processes - 1:\n end = (i + 1) * (len(filenames) // num_processes)\n else:\n end = len(filenames)\n processes.append(Process(target=self._prep_data_worker,\n args=(start, end, filenames)))\n for p in processes:\n p.start()\n for p in processes:\n p.join()","def load(fnames, tag=None, inst_id=None):\n\n all_data = []\n\n # Dst data is actually stored by year but users can load by day.\n # Extract the actual dates from the input list of filenames as\n # well as the names of the actual files.\n fdates = []\n ufnames = []\n for filename in fnames:\n fdates.append(dt.datetime.strptime(filename[-10:], '%Y-%m-%d'))\n ufnames.append(filename[0:-11])\n\n # Get unique filenames that map to actual data\n ufnames = np.unique(ufnames).tolist()\n\n # Load unique files\n for fname in ufnames:\n with open(fname) as open_f:\n lines = open_f.readlines()\n idx = 0\n\n # Check if all lines are good\n max_lines = 0\n for line in lines:\n if len(line) > 1:\n max_lines += 1\n\n # Prep memory\n yr = np.zeros(max_lines * 24, dtype=int)\n mo = np.zeros(max_lines * 24, dtype=int)\n day = np.zeros(max_lines * 24, dtype=int)\n ut = np.zeros(max_lines * 24, dtype=int)\n dst = np.zeros(max_lines * 24, dtype=int)\n\n # Read data\n for line in lines:\n if len(line) > 1:\n temp_year = int(line[14:16] + line[3:5])\n if temp_year > 57:\n temp_year += 1900\n else:\n temp_year += 2000\n\n yr[idx:idx + 24] = temp_year\n mo[idx:idx + 24] = int(line[5:7])\n day[idx:idx + 24] = int(line[8:10])\n ut[idx:idx + 24] = np.arange(24)\n temp = line.strip()[20:-4]\n temp2 = [temp[4 * i:4 * (i + 1)] for i in np.arange(24)]\n dst[idx:idx + 24] = temp2\n idx += 24\n\n # Prep datetime index for the data and create DataFrame\n start = dt.datetime(yr[0], mo[0], day[0], ut[0])\n stop = dt.datetime(yr[-1], mo[-1], day[-1], ut[-1])\n dates = pds.date_range(start, stop, freq='H')\n new_data = pds.DataFrame(dst, index=dates, columns=['dst'])\n\n # Add to all data loaded for filenames\n all_data.append(new_data)\n\n # Combine data together\n data = pds.concat(all_data, sort=True, axis=0)\n\n # Pull out requested days\n data = data.iloc[data.index >= fdates[0], :]\n data = data.iloc[data.index < fdates[-1] + pds.DateOffset(days=1), :]\n\n # Create metadata\n meta = pysat.Meta()\n meta['dst'] = {meta.labels.units: 'nT',\n meta.labels.name: 'Dst',\n meta.labels.notes: tags[tag],\n meta.labels.desc: 'Disturbance storm-time index',\n meta.labels.fill_val: np.nan,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n\n return data, meta","def copy_raw_data(spark, input_data, output_data):\n # load smaller test table from parquet files\n immigration_data_small = os.path.join(input_data, 'sas_data/')\n immigration_small_df = spark.read.parquet(immigration_data_small)\n \n # load full table from sas files \n immigration_data_path = os.path.join(input_data, 'data/18-83510-I94-Data-2016/*.sas7bdat')\n immigration_data = [f for f in glob.glob(immigration_data_path)]\n\n for file in immigration_data:\n if file == immigration_data[0]:\n immigration_df = spark.read.format('com.github.saurfang.sas.spark').load(file)\n else:\n new_df = spark.read.format('com.github.saurfang.sas.spark').load(file)\n immigration_df = outter_union(immigration_df, new_df)\n \n temp_data = os.path.join(input_data, 'GlobalLandTemperaturesByState.csv')\n temp_df = spark.read.csv(temp_data, header=True)\n logging.info('Temperature data successfully loaded')\n\n cities_data = os.path.join(input_data, 'us-cities-demographics.csv')\n cities_df = spark.read.csv(cities_data, header=True, sep=';')\n logging.info('Cities data successfully loaded')\n\n airports_data = os.path.join(input_data, 'airport-codes_csv.csv')\n airports_df = spark.read.csv(airports_data, header=True)\n logging.info('Airports data successfully loaded')\n\n\n # put all tables into one dictionary\n df_raw_all = {#'immigration_data': immigration_small_df, # activate for using small test dataset\n 'immigration_data': immigration_df, # activate for using full dataset\n 'temp_data': temp_df, \n 'cities_data': cities_df,\n 'airport_data': airports_df\n }\n\n for file, df in df_raw_all.items():\n # remove spaces and minus in column-names of dataframes\n df = df.select([F.col(col).alias(col.replace(' ', '_').replace('-', '_')) for col in df.columns])\n # write parquet files to raw path\n path = os.path.join(output_data, 'raw', file)\n df.write.parquet(path)\n logging.info(f'All tables copied to {output_data} as parquet')","def load_data(self):\n for set_name in self.image_dir_path:\n if self.verbose:\n print('\\n> Loading data files for the set: ' + set_name)\n\n # image dir\n image_dir = os.path.join(self.data_path, self.image_dir_path[set_name])\n\n # annotation file path\n annot_filepath = os.path.join(self.data_path, self.annotation_path[set_name])\n\n if 'test' in set_name:\n yield load_data_test(set_name, image_dir, annot_filepath, self.verbose)\n else:\n yield self.load_data_trainval(set_name, image_dir, annot_filepath)","def prepareData(args):\n print(\"Starting preprocessing\")\n\n # params\n max_midi = args['max_midi']\n min_midi = args['min_midi']\n note_range = args['note_range']\n window_size = args['window_size']\n sr = args['sr']\n hop_length = args['hop_length']\n wav_dir = args['wav_dir']\n\n datapath = os.path.join(args['proj_root'], 'Features')\n bin_multiple = int(args['bin_multiple'])\n\n framecnt = 0\n maxFramesPerFile = args['maxFramesPerFile']\n maxFrames = args['maxFrames']\n\n fileappend = str(maxFramesPerFile) + 'pf_max' + str(maxFrames) + '.dat'\n\n filenameIN = os.path.join(datapath, 'input_' + fileappend)\n filenameOUT = os.path.join(datapath, 'output_' + fileappend)\n\n if os.path.isfile(filenameIN) and os.path.isfile(filenameOUT):\n n_bins = note_range * bin_multiple\n print('loading precomputed data from ' + filenameIN)\n mmi = np.memmap(filenameIN, mode='r', dtype=\"float64\")\n inputs = np.reshape(mmi, (-1, window_size, n_bins))\n\n mmo = np.memmap(filenameOUT, mode='r', dtype=\"float64\")\n outputs = np.reshape(mmo, (-1, note_range))\n\n return inputs, outputs, datapath\n\n inputs, outputs = [], []\n addCnt, errCnt = 0, 0\n\n # hack to deal with high PPQ from MAPS\n # https://github.com/craffel/pretty-midi/issues/112\n pretty_midi.pretty_midi.MAX_TICK = 1e10\n\n for s in os.listdir(wav_dir):\n subdir = os.path.join(wav_dir, s)\n if not os.path.isdir(subdir):\n continue\n # recursively search in subdir\n print(subdir)\n for dp, dn, filenames in os.walk(subdir):\n # in each level of the directory, look at filenames ending with .mid\n for f in filenames:\n # if there exists a .wav file and .midi file with the same name\n\n if f.endswith('.wav'):\n audio_filename = f\n fprefix = audio_filename.split('.wav')[0]\n mid_fn = fprefix + '.mid'\n txt_fn = fprefix + '.txt'\n print(\"Handling files {}\".format(fprefix))\n if mid_fn in filenames:\n # extract_features\n audio_filename = os.path.join(dp, audio_filename)\n inputnp = extract_features(audio_filename, args)\n times = librosa.frames_to_time(np.arange(inputnp.shape[0]), sr=sr, hop_length=hop_length)\n # mid2outputnp\n mid_fn = os.path.join(dp, mid_fn)\n pm_mid = pretty_midi.PrettyMIDI(mid_fn)\n\n outputnp = mid2outputnp(pm_mid, times, args)\n\n # check that num onsets is equal\n if inputnp.shape[0] == outputnp.shape[0]:\n # Some filtering highly pragmatic filtering on the data!!\n # take only frames that are \"sufficiently loud\", ...\n good2take = np.array(inputnp.max(axis=(1, 2)) > 0.05)\n # ... and always omit the last frame as this has been padded ...\n good2take[-1] = False # omit last\n # ... and only take frames with at least one true label (i.e. some tone is played)\n good2take = good2take & (outputnp.max(axis=1) > 0)\n outputnp = outputnp[good2take, ]\n inputnp = inputnp[good2take, ]\n\n addCnt += 1\n if inputnp.shape[0] > maxFramesPerFile > 0:\n inputnp = inputnp[:maxFramesPerFile]\n outputnp = outputnp[:maxFramesPerFile]\n framecnt += inputnp.shape[0]\n print(\"framecnt is {}\".format(framecnt))\n inputs.append(inputnp)\n outputs.append(outputnp)\n else:\n print(\"error for fprefix {}\".format(fprefix))\n errCnt += 1\n print(inputnp.shape)\n print(outputnp.shape)\n\n if framecnt > maxFrames > 0:\n print(\"have enought frames, leaving {}\".format(subdir))\n break\n if framecnt > maxFrames > 0:\n print(\"have enought frames, leaving {}\".format(wav_dir))\n break\n\n if framecnt > maxFrames > 0:\n print(\"have enought frames, leaving {}\".format(wav_dir))\n break\n\n print(\"{} examples in dataset\".format(addCnt))\n print(\"{} examples couldnt be processed\".format(errCnt))\n\n # concatenate dynamic list to numpy list of example\n if addCnt:\n inputs = np.concatenate(inputs)\n outputs = np.concatenate(outputs)\n\n print(\"inputs.shape\")\n print(inputs.shape)\n print(\"outputs.shape\")\n print(outputs.shape)\n mmi = np.memmap(filename=filenameIN, mode='w+', shape=inputs.shape, dtype=\"float64\")\n mmi[:] = inputs[:]\n mmo = np.memmap(filename=filenameOUT, mode='w+', shape=outputs.shape, dtype=\"float64\")\n mmo[:] = outputs[:]\n del mmi\n del mmo\n\n return inputs, outputs, datapath","def load_all_data(self):\n layers, layers_fnames = [], []\n # TODO: add multiprocessing\n for i in range(len(self.infiles)):\n fname = self.infiles[i]\n self.logger.info(\n \"#Loading file: {} {}\".format(fname, \"(text file)\" if pathlib.Path(fname).suffix == \"\" else \"\"))\n\n # load text file\n data = load_data_text(file_path=fname, sample_names=self.sn, feature_names=self.fn, drop_features=self.df,\n drop_samples=self.ds)\n layers.append(data)\n layers_fnames.append(fname)\n\n return list(zip(layers_fnames, layers))","def extractData():\n for line in src:\n line = str(line) # now each line is a string\n line = line.rstrip()\n if '%%' in line: #header\n yield line\n for desired in desStr:\n if desired in line:\n yield line","def load_data(self) -> None:","def lfp_extract(files):\r\n \r\n if 'lfpdata' in locals():\r\n del lfpdata\r\n \r\n for i, file in enumerate(files):\r\n \r\n ### load data\r\n matdat = sio.loadmat(file, variable_names = ['lfpsegs', 'lfpdata', 'fs', 'chnAreas'], \r\n struct_as_record = False, squeeze_me = True) \r\n \r\n \r\n \r\n ### extract the noused channels, only calculate once\r\n if i == 0:\r\n \r\n # chnAreas\r\n chnAreas = matdat['chnAreas'].tolist()\r\n \r\n # fs: sample rate\r\n fs = matdat['fs'] \r\n \r\n \r\n\r\n ### dealing lfp data\r\n \r\n # lfp (np.ndarray): nareas * ntemp * ntrials or ntemp * nareas * ntrials\r\n if 'lfpdata' in matdat.keys():\r\n lfpdata_1file = matdat['lfpdata']\r\n elif 'lfpsegs' in matdat.keys():\r\n lfpdata_1file = matdat['lfpsegs']\r\n\r\n n1, n2, n3 = lfpdata_1file.shape\r\n if n1 > n2: # ntemp * nareas * ntrials\r\n lfpdata_1file = np.transpose(lfpdata_1file, (1, 0, 2))\r\n \r\n # concatenate to lfpdata for all files\r\n if 'lfpdata' not in locals():\r\n lfpdata = lfpdata_1file\r\n else:\r\n lfpdata = np.concatenate((lfpdata, lfpdata_1file), axis = 2)\r\n \r\n \r\n return lfpdata, chnAreas, fs","def prepare_data(raw=False, round_ratings=False):\n print('Downloading input data...')\n if raw:\n # read data\n review = get_input(\n 'https://www.dropbox.com/s/mtln9b6udoydn2h/yelp_academic \\\n _dataset_review_sample.csv?dl=1')\n user = get_input(\n 'https://www.dropbox.com/s/pngrptljotqm4ds/yelp_academic \\\n _dataset_user.json?dl=1')\n business = get_input(\n 'https://www.dropbox.com/s/w0wy854u5swrhmc/yelp_academic \\\n _dataset_business.json?dl=1')\n\n # join datasets\n review_user = pd.merge(\n review, user, on=\"user_id\",\n how=\"left\", suffixes=(\"\", \"_user\"))\n review_user_business = pd.merge(\n review_user, business, on=\"business_id\",\n how=\"left\", suffixes=(\"\", \"_business\"))\n review_user_business = review_user_business[[\n 'user_id', 'business_id',\n 'stars', 'text',\n 'name', 'average_stars',\n 'name_business', 'stars_business',\n 'categories', 'state', 'city']]\n else:\n review_user_business = get_input(\n 'https://www.dropbox.com/s/sj445d95lljuc4p/small_sample.parquet?dl=1'\n )\n if round_ratings:\n # bucketize numeric features to reduce dimensions\n review_user_business['average_stars'] = review_user_business[\n 'average_stars'].apply(lambda x: round_of_rating(x))\n review_user_business['stars_business'] = review_user_business[\n 'stars_business'].apply(lambda x: round_of_rating(x))\n return review_user_business","def get_examples(data_dir, mode, task_id, shard_id):\n file_path = get_full_filename(data_dir, mode, task_id, shard_id)\n relative_path = \"/\".join(file_path.split(\"/\")[3:])\n tf.logging.info(\"Reading file: %s\" % (file_path))\n print(relative_path)\n #client = storage.Client(projectname, credentials=credentials)\n #bucket = client.get_bucket(bucket_name)\n blob = storage_bucket.blob(relative_path)\n if not blob.exists():\n tf.logging.info(\"Path doesn't exist\")\n return None\n nq_data = extract_nq_data(file_path)\n tf.logging.info(\"NQ data Size: \" + str(len(nq_data.keys())))\n\n tf.logging.info(\"Performing entity extraction\")\n fact_extracted_data = entity_link_nq(nq_data)\n return fact_extracted_data"],"string":"[\n \"def _extract(self):\\r\\n self._data = []\\r\\n for fname in self.files:\\r\\n meta = dict(filename=fname)\\r\\n\\r\\n # Perform the actual metadata extraction\\r\\n fname = os.path.splitext(self.filter_filename(fname))[0]\\r\\n values = fname.split(self.sep)\\r\\n\\r\\n # Handle the case where number of fields is less than the length\\r\\n # of the extracted values, ie cases where we only want to extract\\r\\n # a subset of available fields.\\r\\n if self.index:\\r\\n values = [val for i, val in enumerate(values) if i in self.index]\\r\\n\\r\\n meta.update(dict(zip(self.fields, values)))\\r\\n if self.split_by in self.fields:\\r\\n meta[self.split_by] = self._get_split_field_values(meta['filename'])\\r\\n self._data.append(meta)\",\n \"def _extract_data(inputs):\\n filename, split = inputs\\n for name, fobj in tfds.download.iter_archive(\\n filename, tfds.download.ExtractMethod.TAR_STREAM\\n ):\\n split_name = name.split(\\\"_\\\")\\n if len(split_name) > 2 and split_name[2] == split:\\n yield [name, fobj.read()]\",\n \"def extract(self):\\n self.build_path_pairs()\\n self.extract_field_blocks()\\n self.assert_filenames()\",\n \"def runDataExtraction():\\r\\n config = CONFIG['steps']['DataExtraction']\\r\\n ci = config['inputs']\\r\\n co = config['outputs']\\r\\n columns = ci['columns']\\r\\n nrows = ci['nrows']\\r\\n input_bucket = ci['bucket']\\r\\n no_of_files = ci['no_of_files']\\r\\n\\r\\n output_bucket = co['bucket']\\r\\n csv_name_prefix = co['csv_name_prefix']\\r\\n\\r\\n minio_config = CONFIG['artifacts']['minio']\\r\\n minioClient = create_minio_client(minio_config[\\\"endpoint_url\\\"],\\r\\n access_key=minio_config[\\\"access_key\\\"],\\r\\n secret_key=minio_config[\\\"secret_key\\\"],\\r\\n secure=minio_config['secure'])\\r\\n\\r\\n boto_client = boto3.client(\\\"s3\\\",\\r\\n endpoint_url=minio_config[\\\"endpoint_url\\\"],\\r\\n aws_access_key_id=minio_config[\\\"access_key\\\"],\\r\\n aws_secret_access_key=minio_config[\\\"secret_key\\\"],\\r\\n region_name=minio_config[\\\"region_name\\\"])\\r\\n\\r\\n zip_files = get_files(input_bucket, boto_client, file_type='zip')\\r\\n\\r\\n no_of_files_to_process = no_of_files if no_of_files is not None else len(\\r\\n zip_files)\\r\\n for zip_file in tqdm(zip_files[:no_of_files_to_process], total=no_of_files_to_process):\\r\\n process_file(zip_file, input_bucket, output_bucket, minioClient, columns,\\r\\n nrows=nrows, output_csv_name_prefix=csv_name_prefix)\",\n \"def extract(self):\\n\\n # print some infos about data\\n print(\\\"\\\\n--extract batches from data:\\\\ntrain: {}\\\\nval: {}\\\\ntest: {}\\\\n\\\".format(self.data[0]['x'].shape, self.data[1]['x'].shape, self.data[2]['x'].shape))\\n\\n # create batches\\n self.x_train, self.y_train, _ = self.create_batches(self.data[0], batch_size=self.batch_size)\\n self.x_val, self.y_val, _ = self.create_batches(self.data[1], batch_size=self.batch_size_eval)\\n self.x_test, self.y_test, _ = self.create_batches(self.data[2], batch_size=self.batch_size_eval)\\n\\n # my data\\n if len(self.mfcc_data_files) == 4:\\n self.x_my, self.y_my, self.z_my = self.create_batches(self.data[3], batch_size=1)\",\n \"def read_parse_raw_data(path):\\n file_list = TopologyHelper.get_file_list(path)\\n print(\\\"Reading \\\" + str(len(file_list)) + \\\" files from \\\" + path)\\n topology_info = []\\n file_name = []\\n for file in file_list:\\n try:\\n r = TopologyHelper.parse_file(file)\\n tmp = (r[0])['Topology']\\n topology_info.append(tmp)\\n t = r[1]\\n file_name.append(t)\\n except:\\n continue\\n print(\\\"Parsing completed\\\")\\n return file_name, topology_info\",\n \"def process_raw_data(self):\\n \\n # Define some variables of interest.\\n vor = [\\\"n_sentences\\\", \\\"n_correct\\\", \\\"p_correct\\\", \\\"median_RT\\\", \\\\\\n \\\"mean_RT\\\", \\\"stdev_RT\\\", \\\"scaled_stdev_RT\\\"]\\n \\n # Get all participant names, or return straight away if no data was\\n # loaded yet.\\n if hasattr(self, \\\"raw\\\"):\\n participants = self.raw.keys()\\n participants.sort()\\n else:\\n self.data = None\\n return\\n\\n # Count the number of participants.\\n n = len(participants)\\n \\n # Create a data dict for each variable of interest.\\n self.data = {}\\n self.data[\\\"ppname\\\"] = []\\n for var in vor:\\n self.data[var] = numpy.zeros(n, dtype=float) * numpy.NaN\\n \\n # Loop through all participants.\\n for i, ppname in enumerate(participants):\\n # Add the participant name.\\n self.data[\\\"ppname\\\"].append(copy.deepcopy(ppname))\\n # Skip empty datasets.\\n if self.raw[ppname] is None:\\n continue\\n # Compute stuff relevant to this task.\\n self.data[\\\"n_sentences\\\"][i] = len(self.raw[ppname][\\\"Sentence\\\"])\\n self.data[\\\"n_correct\\\"][i] = numpy.sum(self.raw[ppname][\\\"correct\\\"])\\n self.data[\\\"p_correct\\\"][i] = float(self.data[\\\"n_correct\\\"][i]) \\\\\\n / float(self.data[\\\"n_sentences\\\"][i])\\n self.data[\\\"median_RT\\\"][i] = numpy.nanmedian(self.raw[ppname][\\\"RT\\\"])\\n self.data[\\\"mean_RT\\\"][i] = numpy.nanmean(self.raw[ppname][\\\"RT\\\"])\\n self.data[\\\"stdev_RT\\\"][i] = numpy.nanstd(self.raw[ppname][\\\"RT\\\"])\\n # Compute a scaled standard deviation of the response time, scaled to the\\n # median response time to remove the correlation between the two.\\n self.data[\\\"scaled_stdev_RT\\\"] = self.data[\\\"stdev_RT\\\"] / self.data[\\\"median_RT\\\"]\",\n \"def extract_all_lazy():\\n\\n\\t#Construct filepaths: Data COMP_INFO_1\\n\\tdata_ci1_name = \\\"DATA_2016_COMP_INFO_1.csv\\\"\\n\\tdata_ci1_fullname = os.path.join(files_location, data_ci1_name)\\n\\t#Data COMP_INFO_2\\n\\tdata_ci2_name = \\\"DATA_2016_COMP_INFO_2.csv\\\"\\n\\tdata_ci2_fullname = os.path.join(files_location, data_ci2_name)\\n\\t#Data PROPERTY INFO\\n\\tdata_pi_name = \\\"DATA_2016_PROPERTY_INFO_ST.csv\\\"\\n\\tdata_pi_fullname = os.path.join(files_location, data_pi_name)\\n\\t#Data General Info\\n\\tdata_gi_name = \\\"DATA_2016_GENERAL_INFO.csv\\\"\\n\\tdata_gi_fullname = os.path.join(files_location, data_gi_name)\\n\\n\\t#Read & Process COMP_INFO\\n\\tdata_ci1 = pd.read_csv(data_ci1_fullname, skiprows=2, usecols = constants.keep_columns_CI, encoding='ISO-8859-1')\\n\\tdata_ci2 = pd.read_csv(data_ci2_fullname, skiprows=2, usecols = constants.keep_columns_CI, encoding='ISO-8859-1')\\n\\n\\tdata_ci = data_ci1.append(data_ci2)\\n\\tdata_ci['QUESTION'] = data_ci['QUESTION'].replace(constants.ci_mapping)\\n\\t# Take only the survey questions mapped\\n\\tdata_ci = data_ci[data_ci['QUESTION'].isin(constants.ci_mapping.values())]\\n\\tdata_ci = data_ci.set_index(['PROPERTY_CODE','PROPERTY_NAME','JOB_CODE','POSITION'])\\n\\tdata_ci = data_ci.pivot(columns=\\\"QUESTION\\\")\\n\\tdata_ci.columns = [\\\"_\\\".join(pair) for pair in data_ci.columns]\\n\\tdata_ci = data_ci.reset_index()\\n\\n\\t#Read & Process Property Info data\\n\\tdata_pi = pd.read_csv(data_pi_fullname, usecols = constants.keep_columns_PI, encoding='ISO-8859-1')\\n\\t#survey_type_transformed = transform.surveytype_categorical(data_pi)\\n\\t#data_pi = pd.merge(data_pi, survey_type_transformed, on=['PROPERTY_CODE'])\\n\\n\\t#Read & Process General Info\\n\\tdata_gi = pd.read_csv(data_gi_fullname, skiprows = 2, usecols = constants.keep_columns_GI, encoding='ISO-8859-1')\\n\\tdata_gi['QUESTION'] = data_gi['QUESTION'].replace(constants.gi_mapping)\\n\\t# Take onl the survey questions mapped\\n\\tdata_gi = data_gi[data_gi['QUESTION'].isin(constants.gi_mapping.values())]\\n\\tdata_gi = data_gi.set_index(['PROPERTY_CODE','PROPERTY_NAME'])\\n\\tdata_gi = data_gi.pivot(columns=\\\"QUESTION\\\")\\n\\tdata_gi.columns = [\\\"_\\\".join(pair) for pair in data_gi.columns]\\n\\tdata_gi = data_gi.reset_index()\\n\\n\\t#This frame needs to be reworked\\n\\td_ci = pd.merge(data_gi, data_pi, on = ['PROPERTY_CODE','PROPERTY_NAME'])\\n\\td_ci = pd.merge(d_ci, data_ci, on = ['PROPERTY_CODE','PROPERTY_NAME'],suffixes= ['_ci','_gi'])\\n\\n\\t#Observations by Dimensions to determine top X markets\\n\\t#Can this be in a better position?\\n\\td_ci = d_ci[~(d_ci['PROPERTY_NAME'].isin(constants.del_rows_property_name))]\\n\\td_ci['POSITION'] = d_ci['POSITION'].astype(str)\\n\\n\\tpayload = {}\\n\\tpayload['gi'] = data_gi\\n\\tpayload['pi'] = data_pi\\n\\tpayload['ci'] = data_ci\\n\\tpayload['d_ci'] = d_ci\\n\\n\\treturn payload\",\n \"def _extract_raw_data(self, lines):\\r\\n\\r\\n i = self._find_first_data_point(lines)\\r\\n if self._lines_have_temperature(lines[i]):\\r\\n self._T = []\\r\\n\\r\\n if self._has_drift_points(lines):\\r\\n while i < len(lines) and lines[i][0] in ['+', '-']:\\r\\n self._extract_drift_point(lines[i])\\r\\n i += 2\\r\\n i += self._extract_next_forc(lines[i:])\\r\\n i += 1\\r\\n else:\\r\\n while i < len(lines) and lines[i][0]in ['+', '-']:\\r\\n i += self._extract_next_forc(lines[i:])\\r\\n self._extract_drift_point(lines[i-1])\\r\\n i += 1\\r\\n\\r\\n return\",\n \"def process_raw_data(data_dir='/home/data/nbc/athena/athena-data/'):\\n\\n # Calls the process_corpus function, defined below\\n # process_corpus reads in the text, performs abbreviation, spelling,\\n # translation, and overall text Processing\\n # process_corpus outputs the processed text for each file and the stemmed file\\n for feature_source in ['abstract', 'full']:\\n process_corpus(data_dir, feature_source)\\n\\n # Calls the label_data function, defined below\\n # label_data reads in the metadata csv files, concatenates them, then\\n # reads in the processed text files\\n # label_data outputs a binary pmid by label metadata matrix\\n label_data(data_dir)\\n generate_gazetteer(data_dir)\",\n \"def process_raw_data(self):\\n \\n # Get all participant names, or return straight away if no data was\\n # loaded yet.\\n if hasattr(self, \\\"raw\\\"):\\n participants = self.raw.keys()\\n participants.sort()\\n else:\\n self.data = None\\n return\\n\\n # Count the number of participants.\\n n = len(participants)\\n \\n # Find out how many questions there were.\\n n_questions = 0\\n for i, ppname in enumerate(participants):\\n if self.raw[ppname] is None:\\n continue\\n if len(self.raw[ppname][\\\"QuestionNumber\\\"]) > n_questions:\\n n_questions = len(self.raw[ppname][\\\"QuestionNumber\\\"])\\n \\n # Define some variables of interest.\\n vor = []\\n for i in range(n_questions):\\n vor.append(\\\"Q%d_resp\\\" % (i+1))\\n vor.append(\\\"Q%d_RT\\\" % (i+1))\\n \\n # Create a data dict for each variable of interest.\\n self.data = {}\\n self.data[\\\"ppname\\\"] = []\\n for var in vor:\\n self.data[var] = numpy.zeros(n, dtype=float) * numpy.NaN\\n \\n # Loop through all participants.\\n for i, ppname in enumerate(participants):\\n # Add the participant name.\\n self.data[\\\"ppname\\\"].append(copy.deepcopy(ppname))\\n # Skip empty datasets.\\n if self.raw[ppname] is None:\\n continue\\n # Compute stuff relevant to this task.\\n for j, qnr in enumerate(self.raw[ppname][\\\"QuestionNumber\\\"]):\\n # Split Questionnaire 3, Q13 and Q14 into sub-questions\\n if \\\"Q3\\\" in self._task_name and int(qnr) in [13,14]:\\n # These questions split out into two parts: A description\\n # of what each sub-part is, and a Boolean response for\\n # each sub-part in the question. Example:\\n # \\\"1_1_1_1_1_0//Television_VideogameConsole(suchas:WiiUPlayStationXboxorNintendoDS)_Tablet(likeanIPad)_Smartphone_LaptoporDesktopComputer_Noneofthese\\\"\\n bool_resp, descr = self.raw[ppname][\\\"Response\\\"][j].split(\\\"//\\\")\\n bool_resp = map(int, bool_resp.split(\\\"_\\\"))\\n descr = descr.split(\\\"_\\\")\\n # Store the data in the dict.\\n for k, item in enumerate(descr):\\n # Clean up the item name.\\n if \\\"(\\\" in item:\\n item = item[:item.find(\\\"(\\\")]\\n var = \\\"Q%s_%s_resp\\\" % (int(qnr), item)\\n # Create a new entry in the dict for this variable, if\\n # one doesn't exist yet.\\n if var not in self.data.keys():\\n self.data[var] = numpy.zeros(n, dtype=float) * numpy.NaN\\n # Store the data in the dict.\\n self.data[var][i] = bool_resp[k]\\n # Store response time for the whole item.\\n self.data[\\\"Q%s_RT\\\" % (int(qnr))][i] = \\\\\\n float(self.raw[ppname][\\\"TimeEndQuestion\\\"][j]) \\\\\\n - float(self.raw[ppname][\\\"TimeStartQuestion\\\"][j])\\n # All other questions are one-question one-response:\\n else:\\n # Store the data in the dict.\\n self.data[\\\"Q%s_resp\\\" % (int(qnr))][i] = \\\\\\n float(self.raw[ppname][\\\"Response\\\"][j])\\n self.data[\\\"Q%s_RT\\\" % (int(qnr))][i] = \\\\\\n self.raw[ppname][\\\"TimeEndQuestion\\\"][j] \\\\\\n - self.raw[ppname][\\\"TimeStartQuestion\\\"][j]\",\n \"def _extract_data(self):\\n with open(self.file_path, \\\"rt\\\", encoding=self._encoding) as csv_file:\\n raw_data = [row for row in csv.reader(csv_file)]\\n\\n # If we have read in a .txt, .tsv or .uniq file then we delimit our rows\\n if self.file_path.suffix == \\\".txt\\\":\\n raw_data = [row[0].split() for row in raw_data if len(row) == 1]\\n\\n elif (self.file_path.suffix == \\\".tsv\\\") or (self.file_path.suffix == \\\".tsv\\\"):\\n raw_data = [re.split(r\\\"\\\\t+\\\", row[0]) for row in raw_data]\\n\\n # Csv files are the default so don't need handling\\n elif self.file_path.suffix == \\\".csv\\\":\\n pass\\n\\n # Warning users that a file has been loaded that we haven't build a capture for\\n else:\\n print(f\\\"Warning: {self.file_path.suffix} is not explicitly handled\\\")\\n\\n if self._file_headings:\\n return raw_data[1:]\\n else:\\n return raw_data\",\n \"def load_data(self):\\n if self.use_files == True:\\n if self.multi is True:\\n self.star, self.data = [], []\\n for fn in self.file:\\n s = eleanor.Source(fn=fn, fn_dir=self.directory, tc=True)\\n if self.do_corr == True or self.do_raw == True:\\n d = eleanor.TargetData(s)\\n else:\\n d = eleanor.TargetData(s, do_psf=True)\\n self.star.append(s)\\n self.data.append(d)\\n self.star = np.array(self.star)\\n self.data = np.array(self.data)\\n self.tic = self.star[0].tic\\n self.coords = self.star[0].coords\\n\\n else:\\n self.star = eleanor.Source(fn=self.file, fn_dir=self.directory, tc=True)\\n if self.do_corr == True or self.do_raw == True:\\n self.data = eleanor.TargetData(self.star)\\n else:\\n self.data = eleanor.TargetData(self.star, do_psf=True)\\n self.tic = self.star.tic\\n self.coords = self.star.coords\\n\\n else:\\n if self.multi is True:\\n self.star, self.data = [], []\\n for s in self.star_results:\\n self.star.append(s)\\n if self.do_corr == True or self.do_raw == True:\\n d = eleanor.TargetData(s)\\n else:\\n d = eleanor.TargetData(s, do_psf=True)\\n self.data.append(d)\\n\\n else:\\n self.star = self.star_results[0]\\n if self.do_corr == True or self.do_raw == True:\\n self.data = eleanor.TargetData(self.star)\\n else:\\n self.data = eleanor.TargetData(self.star, do_psf=True)\\n\\n return\",\n \"def read_raw_data(self):\\n dat_file = os.path.join(DATA_DIR, self.patient_number + '.txt')\\n if not os.path.exists(dat_file):\\n raise AssertionError(\\\"{} doesn't exist.\\\".format(dat_file))\\n time = []\\n voltage1 = []\\n voltage2 = []\\n with open(dat_file, 'r') as fd:\\n for line in fd:\\n line = line.split()\\n time.append(line[0])\\n voltage1.append(float(line[1]))\\n voltage2.append(float(line[2]))\\n\\n tags_file = os.path.join(DATA_DIR, self.patient_number + '_tag.txt')\\n if not os.path.exists(dat_file):\\n raise AssertionError(\\\"{} doesn't exist.\\\".format(tags_file))\\n tags_time = []\\n tags = []\\n r_peaks_indexes = []\\n with open(tags_file, 'r') as fd:\\n for line in fd:\\n line = line.split()\\n tags_time.append(line[0])\\n tags.append(line[2])\\n r_peaks_indexes.append(int(line[1]))\\n return time, voltage1, voltage2, tags_time, tags, r_peaks_indexes\",\n \"def get_data(self):\\n \\n with os.scandir(self.file_path) as collection_of_files:\\n files_found = [file.name.split('.')[0] for file in collection_of_files \\n if (file.name.split('.')[0].lower().strip() in self._data_requirements.required_file_names \\n and file.name.endswith('.csv'))]\\n\\n self.check_missing_files(files_found)\\n \\n self._data = DictObjectView(self.read_in_files(files_found))\",\n \"def data_extract(self, file):\\n\\n file_data = [row.strip().split() for row in open('data/{}'.format(file)).readlines()]\\n return file_data\",\n \"def extract_data(filename):\\n if not os.path.exists(os.path.join(os.path.dirname(__file__), 'data2/')):\\n with tarfile.open(filename, \\\"r\\\") as tarball:\\n dir = os.path.dirname(__file__)\\n tarball.extractall(os.path.join(dir, 'data2/'))\\n return\",\n \"def load_tasks(self):\\n\\n def _load_tasks(filename):\\n filename = os.path.join(self.config['data']['location'], filename)\\n filename = os.path.expanduser(filename)\\n with open(filename, 'r') as f:\\n lines = f.readlines()\\n\\n return list(map(taskw.utils.decode_task, lines))\\n\\n return dict(\\n (db, _load_tasks('%s.data' % db))\\n for db in ['completed', 'pending']\\n )\",\n \"def data_process(self):\\n logging.info('Processing the data and split files')\\n lines = Utility.file_len(self.fname)\\n self.lines_to_be, self.split_files = Utility.split_files(self.fname, lines,\\n cpu_count().real)\",\n \"def main(input_path, output_path):\\n logger.info('making final data set from raw data')\\n\\n index_path = 'data/raw/trec07p/full/index'\\n index = getIndexMap(index_path, f'{input_path}/trec07p/data/')\\n interim_path = 'data/interim'\\n df = pd.DataFrame(columns=columns)\\n\\n count = 0\\n if not path.exists(interim_path):\\n logger.info(f'converting external txt files to trec07.csv in {interim_path}')\\n mkdir(interim_path)\\n for email in listdir(f'{input_path}/trec07p/data'):\\n addEmailToDf(f'{input_path}/trec07p/data/{email}', index, df)\\n count += 1\\n if count % 1000 == 0:\\n logger.info(f'conversion done for {count}/75000 files')\\n df.to_csv(f'{interim_path}/trec07.csv', index=False)\",\n \"def extract_dataset(filename):\\n print(\\\"=\\\" * 40)\\n print(\\\"Extracting dataset: \\\", filename)\\n zipfile = ZipFile(os.path.join(DATA_DIR, filename))\\n zipfile.extractall(DATA_DIR)\",\n \"def InitDataset(self):\\n train_txt = 'ImageSets/Main/train.txt'\\n val_txt = 'ImageSets/Main/val.txt'\\n annotations = \\\"Annotations\\\"\\n jpegimages = \\\"JPEGImages\\\"\\n images_path = train_txt if (self.is_train) else val_txt \\n images_path = readTxt(os.path.join(self.path, images_path))\\n images_path.pop(-1)\\n # rawdata format: [path_2_image, path_2_xml]\\n rawData = list()\\n for each in images_path:\\n xml = os.path.join(self.path, annotations, each + '.xml')\\n jpeg = os.path.join(self.path, jpegimages, each + '.jpg')\\n rawData.append([jpeg, xml])\\n return rawData\",\n \"def _read_data(self, \\n data_path : str, \\n bert : bool=False, \\n mode : str=\\\"raw\\\", \\n task : str=\\\"A\\\"\\n ):\\n print(f\\\"\\\\n[dataset]: Loading data from '{data_path}'...\\\")\\n print(f\\\"[dataset]: performing task '{task}' preprocessing ...\\\")\\n if task == \\\"A\\\":\\n tokenizer = self._tokenize_line if mode == \\\"tokenize\\\" else self.bert_tokenizer\\n return _read_data_taskA(data_path, tokenizer, bert, mode, tagger=self._tag_tokens, test=self.test)\\n\\n elif task == \\\"B\\\":\\n return _read_data_taskB(data_path, test=False)\\n \\n elif task == \\\"C\\\":\\n return _read_data_taskC(data_path, test=False)\\n\\n elif task == \\\"D\\\":\\n return _read_data_taskD(data_path, test=False)\",\n \"def load_data(self) -> tuple:\\n label_num = {}\\n data_set = pathlib.Path(self.path)\\n data = []\\n\\n # create the label lookup dict for verifcation later\\n for i, v in enumerate(data_set.iterdir()):\\n label_num[v.name] = i\\n self.labels[i] = v.name\\n # end\\n\\n # read images\\n for img_path in data_set.rglob(\\\"*.jpg\\\"):\\n lbl = label_num[str(img_path.parent.stem)]\\n img = cv2.imread(str(img_path))\\n img = cv2.resize(img, self.dims, interpolation=cv2.INTER_AREA)\\n\\n # flatten RGB data into a vector\\n # NOTE: NOT ACTUALLY NECESSARY! \\n img.flatten()\\n\\n # label the sample and append to temp data list\\n sample = np.append(lbl, img)\\n data.append(sample)\\n # end\\n\\n # partition and package the data (*_ ensures safe unpacking)\\n train, test, validate, *_ = Data.partition(data, self.parts, 0.7, 0.2)\\n self.train = Data(train)\\n self.test = Data(test)\\n self.validate = Data(validate)\",\n \"def load_raw_data(self, input_files):\\n\\n log.debug(f\\\"Loading dataset {input_files}\\\") \\n print(f\\\"Loading dataset\\\")\\n\\n # Load stroke information from XML files\\n for file in input_files:\\n new_strokeset = strokeset.StrokeSet(file)\\n self.strokesets.append(new_strokeset)\\n self.stroke_matrix.append(new_strokeset.as_delta_array())\\n self.stroke_ascii.append(new_strokeset.get_text())\\n\\n done_msg = \\\"Finished parsing dataset. Imported {} lines\\\".format(len(self.get_strokesets()))\\n print (done_msg)\\n log.info(done_msg)\",\n \"def prepare_data(self) -> None:\\n if (self.root).is_dir():\\n logger.info(\\\"Found the dataset.\\\")\\n else:\\n download_and_extract(self.root, DOWNLOAD_INFO)\",\n \"def load_data(self) -> None:\\n self.paths: List[str] = []\\n self.durations: List[float] = []\\n self.transcriptions: List[str] = []\\n\\n def raise_(err):\\n \\\"\\\"\\\"raises error if problem during os.walk\\\"\\\"\\\"\\n raise err\\n\\n for subset in self.subsets:\\n subset_path = os.path.join(self.root, self.base_dir, subset)\\n for root, dirs, files in os.walk(subset_path, onerror=raise_):\\n if not files:\\n continue\\n matches = fnmatch.filter(files, \\\"*.trans.txt\\\")\\n assert len(matches) == 1, \\\"> 1 transcription file found\\\"\\n self._parse_transcription_file(root, matches[0])\\n\\n self._sort_by_duration()\",\n \"def main(unused_argv):\\n make_dir(FLAGS.raw_dir)\\n\\n # Get paths of download/extracted training and evaluation files.\\n print(\\\"Downloading data from source\\\")\\n train_files = get_raw_files(FLAGS.raw_dir, constants.TRAIN_DATA_SOURCES)\\n eval_files = get_raw_files(FLAGS.raw_dir, constants.EVAL_DATA_SOURCES)\",\n \"def get_additional_data_from_files(df, file_description): # file description one of [\\\"video\\\", \\\"eaf\\\", \\\"seg\\\", \\\"gentle\\\"]\\n if file_description == \\\"gentle\\\":\\n file_folder = FILE_BASE + \\\"/gentle/\\\"\\n is_gentle_file = True\\n else:\\n file_folder = FILE_BASE + \\\"/original/\\\"\\n is_gentle_file = False\\n\\n file_df = None\\n\\n if file_description not in list(FILE_DESCRIPTIONS_TO_EXT.keys()):\\n print(\\\"Unknown file description! Don't know what to do with %s files...\\\" % file_description)\\n return None\\n\\n else:\\n print(\\\"Load and extract information from %s files...\\\" % file_description)\\n #pbar = tqdm.tqdm(total = len(np.unique(df[\\\"source_file\\\"])),desc='Files', position=0,leave=True,file=sys.stdout)\\n #file_log = tqdm.tqdm(total=0, position=1, bar_format='{desc}',leave=True,file=sys.stdout)\\n print(\\\"Total files to laod and preprocess: \\\", len(np.unique(df[\\\"source_file\\\"])))\\n \\n for i,file in enumerate(np.unique(df[\\\"source_file\\\"])):\\n if i%100 == 0:\\n print(\\\"File: \\\",i)\\n \\n filepath = file_folder + get_file_path(file,is_gentle_file=is_gentle_file) + FILE_DESCRIPTIONS_TO_EXT[file_description]\\n\\n if file_description == \\\"video\\\":\\n file_i_df = mp4_file_processing.get_word_video_snippet_size(df, filepath)\\n elif file_description == \\\"eaf\\\":\\n speech_annotation_eaf_data, gesture_eaf_data = eaf_file_processing.read_eaf(filepath)\\n file_i_df = eaf_file_processing.map_gestures_to_annotation(speech_annotation_eaf_data, gesture_eaf_data, remove_pauses=False)\\n file_i_df = eaf_file_processing.binary_encode_gestures(file_i_df, gesture_column=\\\"gesture\\\")\\n\\n elif file_description == \\\"seg\\\":\\n file_i_df = seg_file_processing.get_seg_file_pos_info(filepath)\\n\\n elif file_description == \\\"gentle\\\":\\n file_i_df = gentle_file_processing.get_gentle_file_transcripts(filepath)\\n \\n else:\\n print(\\\"Unknown file format!!!\\\")\\n return \\n\\n if file_df is None:\\n file_df = file_i_df\\n else:\\n file_df = pd.concat([file_df, file_i_df], ignore_index=True)\\n\\n #file_log.set_description_str(f'Processed file: {file}')\\n #pbar.update(1)\\n #sleep(0.02)\\n #file_log.close()\\n #pbar.close()\\n return file_df\",\n \"def _read_data_taskD(data_path: str=\\\"path\\\", test: bool=False, test_samples=None):\\n sentences = []\\n labels = []\\n targets_list = []\\n\\n data_dict = read_json_data(data_path) if not test else test_samples\\n for entry in data_dict:\\n text = entry[\\\"text\\\"]\\n categories = entry[\\\"categories\\\"]\\n\\n sent_cats = []\\n pol_labels = []\\n cats_list = []\\n for cat in categories:\\n category = cat[0]\\n sent_cats.append([text,cat])\\n\\n polarity = \\\"neutral\\\" if test else cat[1]\\n pol_labels.append(POLARITY_2_TAGS[polarity])\\n cats_list.append(category)\\n\\n sentences.append(sent_cats)\\n labels.append(pol_labels)\\n targets_list.append(cats_list)\\n\\n assert len(sentences) == len(labels)\\n if not test:\\n return sentences, labels, targets_list, None\\n else:\\n return list(zip(sentences,labels,targets_list))\",\n \"def get_parsed_data():\\n\\n echonest_data_files = [f for f in os.listdir('.') if re.match(\\\"^echonest_[\\\\w]+.txt$\\\", f)]\\n\\n # Setting up header with user id and attributes\\n header = ['user_id']\\n header.extend(ATTRIBUTES)\\n\\n # printing header to standard out\\n print \\\",\\\".join(header) \\n\\n # Processing each file to obtain parsed data\\n for data_file in echonest_data_files:\\n user_id = data_file[9:-4] # strip file prefix/suffix to get username/id\\n parse_echonest_data_file(data_file, user_id)\",\n \"def parsing(self, data_path, header=0):\\n df_content = []\\n csvfiles = glob.glob(data_path)\\n selected_cols = list(self.data_features)\\n selected_cols.append('workload.type')\\n selected_cols.append('workload.appname')\\n\\n for csv in csvfiles:\\n data = pd.read_csv(csv, index_col=None, header=header, usecols=selected_cols)\\n data[self.data_features] = self.abnormal_detection(data[self.data_features])\\n df_content.append(data.dropna(axis=0))\\n self.dataset = pd.concat(df_content, sort=False)\",\n \"def getInputFiles(self):\\n taskname = self.cachedinfo['RequestName']\\n\\n #Get task status from the task DB\\n self.logger.debug(\\\"Getting status from he DB\\\")\\n server = self.crabserver\\n crabDBInfo, _, _ = server.get(api='task', data={'subresource': 'search', 'workflow': taskname})\\n status = getColumn(crabDBInfo, 'tm_task_status')\\n self.destination = getColumn(crabDBInfo, 'tm_asyncdest')\\n\\n inputsFilename = os.path.join(os.getcwd(), 'InputFiles.tar.gz')\\n if status == 'UPLOADED':\\n raise ClientException('Currently crab upload only works for tasks successfully submitted')\\n elif status == 'SUBMITTED':\\n webdir = getProxiedWebDir(crabserver=self.crabserver, task=taskname,\\n logFunction=self.logger.debug)\\n if not webdir:\\n webdir = getColumn(crabDBInfo, 'tm_user_webdir')\\n self.logger.debug(\\\"Downloading 'InputFiles.tar.gz' from %s\\\" % webdir)\\n httpCode = curlGetFileFromURL(webdir + '/InputFiles.tar.gz', inputsFilename, self.proxyfilename,\\n logger=self.logger)\\n if httpCode != 200:\\n self.logger.errror(\\\"Failed to download 'InputFiles.tar.gz' from %s\\\", webdir)\\n else:\\n raise ClientException('Can only execute jobs from tasks in status SUBMITTED or UPLOADED. Current status is %s' % status)\\n\\n for name in [inputsFilename, 'CMSRunAnalysis.tar.gz', 'sandbox.tar.gz']:\\n with tarfile.open(name) as tf:\\n tf.extractall()\",\n \"def load_file_data_from_db(self):\\n\\n file_objs = self.file_queryset.filter(sip=self.sip, removedtime__isnull=True)\\n for file_obj in self._batch_query(file_objs):\\n self.file_events = get_file_events(file_obj)\\n if not self.file_events:\\n return\\n try:\\n # merge the map_file_data dict with the map_av_data\\n mapped_file_info = merge_file_data_dicts(\\n map_file_data(file_obj, self.file_events), map_av_data(file_obj)\\n )\\n self.md_info[\\\"files\\\"].append(mapped_file_info)\\n self.md_info[\\\"premis:size\\\"] = create_package_size(\\n mapped_file_info[\\\"premis:size\\\"]\\n )\\n self.md_info[\\\"amount_of_files\\\"] += 1\\n failed_virus_checks = get_failed_virus_checks(self.file_events)\\n if failed_virus_checks:\\n self.md_info[\\\"virus_scan_info\\\"][\\\"failed_virus_checks\\\"].append(\\n failed_virus_checks\\n )\\n passed_virus_checks = get_passed_virus_checks(self.file_events)\\n # add info virus_scan_tools if they passed and respect\\n # different tools and versions if needed.\\n if (\\n passed_virus_checks\\n and passed_virus_checks\\n not in self.md_info[\\\"virus_scan_info\\\"][\\\"virus_scan_tools\\\"]\\n ):\\n self.md_info[\\\"virus_scan_info\\\"][\\\"virus_scan_tools\\\"].append(\\n passed_virus_checks\\n )\\n except KeyError:\\n logger.info(\\n \\\"File is no longer present on the filesystem: %s\\\",\\n file_obj.currentlocation,\\n )\\n continue\",\n \"def unzip() -> None:\\n logger = logging.getLogger(__name__)\\n logger.info('Download the dataset')\\n\\n # define the destination\\n destination = project_dir / 'data' / 'raw'\\n\\n # extract zip\\n zip_file = ZipFile(destination / \\\"original.zip\\\")\\n zip_file.extractall(destination)\",\n \"def main(output_filepath):\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\\n\\n baseurl = 'http://codeandbeer.org/virtual/BigData/Labs/'\\n files = ['Booking-20151012-1322.csv', 'Booking-20181025-1232.csv']\\n for filename in files:\\n r = requests.get(baseurl+filename, stream=True)\\n if r.status == 200:\\n with open(output_filepath+\\\"/\\\"+filename, \\\"wb\\\") as f:\\n f.raw.decode_content = True\\n shutil.copyfileobj(r.raw, f)\",\n \"def load_fullres_inputs(task, subdir='training'):\\n tagged_paths = {\\n 'gt': glob.glob(join(task.root, subdir, '*_GTL.tif')),\\n 'im': glob.glob(join(task.root, subdir, '*_RGB.tif')),\\n\\n 'gti': glob.glob(join(task.root, subdir, '*_GTI.tif')),\\n\\n # digital terrain model\\n 'dtm': glob.glob(join(task.root, subdir, '*_DTM.tif')),\\n # digital surface model\\n 'dsm': glob.glob(join(task.root, subdir, '*_DSM.tif')),\\n }\\n\\n def extract_primary_key_info(paths, tag):\\n if not paths:\\n return pd.DataFrame()\\n infos = [parse.parse('{site_id}_Tile_{N}_{type}.tif', p).named\\n for p in map(basename, paths)]\\n df = pd.DataFrame(infos)\\n df = df.rename(columns={'type': tag + 'type'})\\n df[tag] = paths\\n df = df.set_index(['site_id', 'N'], drop=False).sort_index()\\n return df\\n\\n train = pd.DataFrame()\\n for tag, paths in tagged_paths.items():\\n _df = extract_primary_key_info(paths, tag)\\n if len(_df):\\n for pk in ['N', 'site_id']:\\n if pk not in train.columns:\\n train[pk] = _df[pk]\\n train[tag] = _df[tag]\\n\\n null_idxs = list(set(np.where(pd.isnull(train))[0]))\\n if null_idxs:\\n raise ValueError(('MISSING DATA FOR {}'.format(\\n [train.index[i] for i in null_idxs])))\\n\\n for tag, paths in tagged_paths.items():\\n pass\\n\\n metadata = train[['site_id', 'N']].reset_index(drop=True)\\n dump_im_names = ['{site_id}_Tile_{N}.tif'.format(**d)\\n for d in metadata.to_dict(orient='records')]\\n\\n # train_gts = list(train['gt'].values)\\n # train_rgb = list(train['im'].values)\\n # train_dtm = list(train['dtm'].values)\\n # train_dsm = list(train['dsm'].values)\\n\\n # train_gts = sorted(train_gts)\\n # train_rgb = fnameutil.align_paths(train_gts, train_rgb)\\n # train_dtm = fnameutil.align_paths(train_gts, train_dtm)\\n # train_dsm = fnameutil.align_paths(train_gts, train_dsm)\\n # dump_im_names = ['{site_id}_Tile_{N}.tif'.format(**d) for d in infos]\\n\\n kw = train.drop(['N', 'site_id'], axis=1).to_dict(orient='list')\\n fullres = inputs.Inputs.from_paths(**kw)\\n\\n # aux_paths = {'dtm': train_dtm, 'dsm': train_dsm}\\n # fullres = {'im': train_rgb, 'gt': train_gts, 'aux': aux}\\n\\n fullres.dump_im_names = dump_im_names\\n fullres.metadata = metadata\\n\\n # fullres.aux_paths = {}\\n fullres.tag = 'fullres'\\n return fullres\",\n \"def get_raw_data():\\n data_files = []\\n for i, f in enumerate(os.listdir(config.RAW_DATA_DIR)):\\n data_files.append(f)\\n print i, \\\": \\\", f\\n while True:\\n try:\\n index = int(raw_input(\\\"Type the index of the data file you'd like to import: \\\"))\\n fn_raw_data = data_files[int(index)]\\n break\\n except ValueError:\\n print(\\\"Not a valid index. Try again.\\\")\\n except IndexError:\\n print(\\\"Not a valid index. Try again.\\\")\\n print \\\"Importing %s...\\\" % fn_raw_data\\n with open(config.RAW_DATA_DIR + fn_raw_data) as infile:\\n next(infile)\\n raw_data = list(csv.DictReader(infile))\\n return (fn_raw_data, raw_data)\",\n \"def _process_data_file(self):\\n \\n with open(self.data_file, 'r') as f:\\n self.description = f.readline().strip()\\n data = np.loadtxt(self.data_file, skiprows=1)\\n\\n return data\",\n \"def source_data_files(self, data_dir, tmp_dir, dataset_split):\\n raise NotImplementedError()\",\n \"def __load_data(self) -> np.array:\\n with open('.'+os.sep+'ressources'+os.sep+self.path+os.sep+'capacity.txt','r') as fp:\\n capacity = self.__parse_line(fp.readline())\\n with open('.' + os.sep + 'ressources' + os.sep + self.path + os.sep + 'demand.txt', 'r') as fp:\\n demand = self.__parse_line(fp.readline())\\n with open('.' + os.sep + 'ressources' + os.sep + self.path + os.sep + 'distance.txt', 'r') as fp:\\n distance_matrix = []\\n for line in fp:\\n row = self.__parse_line(line)\\n distance_matrix.append(row)\\n with open('.' + os.sep + 'ressources' + os.sep + self.path + os.sep + 'transportation_cost.txt', 'r') as fp:\\n transportation_cost = self.__parse_line(fp.readline())\\n return np.asarray(capacity), np.asarray(demand), np.asarray(distance_matrix), np.asarray(transportation_cost)\",\n \"def parse(cls, raw_folder: str) -> Dict[str, Any]:\\n folder_path = os.path.abspath(raw_folder)\\n data = dict()\\n files = os.listdir(folder_path)\\n for file in files:\\n if is_ignored(file):\\n continue\\n try:\\n file = os.path.join(raw_folder, file)\\n datum = cls.process_file(file)\\n except FileNotCompatible:\\n continue\\n\\n _, kwrd = os.path.split(file)\\n kwrd = os.path.splitext(kwrd)[0]\\n data[kwrd] = datum\\n\\n return data\",\n \"def _load_data_worker(self,img_dir,lbl_dir):\\n data = []\\n\\n for img,lbl in zip(glob(img_dir+\\\"/*.jpg\\\"),glob(lbl_dir+\\\"/*.txt\\\")):\\n im = np.array(Image.open(img))\\n im = make_square_image_with_padding(im, self.core_config.num_colors)\\n lbl_fh = open(lbl,encoding='utf-8')\\n\\n objects = self._get_objects(lbl_fh)\\n sorted_objects = sort_object_list(objects)\\n object_class = self._get_object_classes(sorted_objects)\\n \\n image_with_objects = {\\n 'img':im,\\n 'objects':sorted_objects,\\n 'object_class': object_class\\n }\\n\\n image_with_mask = convert_to_mask(image_with_objects, self.core_config)\\n\\n data.append(image_with_mask)\\n lbl_fh.close()\\n\\n return data\",\n \"def import_data(self):\\n\\n # Import ordered names of origins\\n origins_file = os.path.join(self.data_directory,'origins.txt')\\n self.origins = np.loadtxt(origins_file,dtype=str,ndmin=1)\\n\\n # Import ordered names of destinations\\n destinations_file = os.path.join(self.data_directory,'destinations.txt')\\n self.destinations = np.loadtxt(destinations_file,dtype=str,ndmin=1)\\n\\n # Import origin supply\\n originsupply_file = os.path.join(self.data_directory,'origin_supply.txt')\\n self.origin_supply = np.loadtxt(originsupply_file,ndmin=1).astype('float64')\\n\\n # In case origin supply is not a list\\n if not isinstance(self.origin_supply,(np.ndarray, np.generic)):\\n self.origin_supply = np.array([self.origin_supply])\\n\\n # Import destination demand\\n destinationdemand_file = os.path.join(self.data_directory,'destination_demand.txt')\\n self.destination_demand = np.loadtxt(destinationdemand_file,ndmin=1).astype('float64')\\n\\n # In case destination demand is not a list\\n if not isinstance(self.destination_demand,(np.ndarray, np.generic)):\\n self.destination_demand = np.array([self.destination_demand])\\n\\n # Import origin locations\\n originlocations_file = os.path.join(self.data_directory,'origin_locations.txt')\\n self.origin_locations = np.loadtxt(originlocations_file,ndmin=1)\\n\\n # Import destination locations\\n destinationlocations_file = os.path.join(self.data_directory,'destination_locations.txt')\\n self.destination_locations = np.loadtxt(destinationlocations_file,ndmin=1)\\n\\n # Import initial and final destination sizes\\n initialdestinationsizes_file = os.path.join(self.data_directory,'initial_destination_sizes.txt')\\n self.initial_destination_sizes = np.loadtxt(initialdestinationsizes_file,ndmin=1)\\n\\n # In case destination sizes are not a list\\n if not isinstance(self.initial_destination_sizes,(np.ndarray, np.generic)):\\n self.initial_destination_sizes = np.array([self.initial_destination_sizes])\\n\\n # Import N,M\\n self.N = self.origin_supply.shape[0]\\n self.M = self.initial_destination_sizes.shape[0]\\n\\n # Import cost matrix\\n costmatrix_file = os.path.join(self.data_directory,'cost_matrix.txt')\\n self.cost_matrix = np.loadtxt(costmatrix_file).astype('float64')\\n\\n # Reshape cost matrix if necessary\\n if self.N == 1:\\n self.cost_matrix = np.reshape(self.cost_matrix[:,np.newaxis],(self.N,self.M))\\n if self.M == 1:\\n self.cost_matrix = np.reshape(self.cost_matrix[np.newaxis,:],(self.N,self.M))\\n\\n # Compute total initial and final destination sizes\\n self.total_initial_sizes = np.sum(self.initial_destination_sizes)\\n\\n # Compute naive total cost\\n self.total_cost = 0\\n for i in range(self.N):\\n for j in range(self.M):\\n self.total_cost += self.cost_matrix[i,j]*(self.origin_supply[i]/self.N)\",\n \"def extract(self, paths=None):\\n\\n all_files = self._get_package_files()\\n if paths is None:\\n extracted_files = all_files.values()\\n else:\\n extracted_files = [all_files[path] for path in paths]\\n\\n # filter already extracted file\\n extracted_files = [pf for pf in extracted_files if not os.path.isfile(self.project.storage.fspath(pf.extract_path))]\\n\\n # group files by package\\n files_by_package = defaultdict(list)\\n for pf in extracted_files:\\n files_by_package[pf.package].append(pf)\\n\\n package_files_path = f\\\"{self.path}/packages/files\\\"\\n\\n for package, files in files_by_package.items():\\n with self.project.storage.stream(f\\\"{package_files_path}/{package}\\\") as reader:\\n # sort files by offset to extract while streaming the bin file\\n for pkgfile in sorted(files, key=lambda f: f.offset):\\n logger.debug(f\\\"extracting {pkgfile.path}\\\")\\n reader.skip_to(pkgfile.offset)\\n fspath = self.project.storage.fspath(pkgfile.extract_path)\\n with write_file_or_remove(fspath) as fout:\\n if pkgfile.compressed:\\n zobj = zlib.decompressobj(zlib.MAX_WBITS | 32)\\n def writer(data):\\n return fout.write(zobj.decompress(data))\\n reader.copy(writer, pkgfile.size)\\n fout.write(zobj.flush())\\n else:\\n reader.copy(fout.write, pkgfile.size)\",\n \"def load_raw_data(self):\\n if self.trendfile:\\n self.raw_data = self.get_ap_file()\\n else:\\n report_params = self.format_api_request_params()\\n report_params['test'] = self.testresults\\n\\n self.raw_data = self.get_ap_report(params=report_params)\",\n \"def load_dataset(self):\\n # Get all the files in the directory\\n file_list = self.get_file_list()\\n\\n # Concatenate the data corresponding to a list of files\\n data = self.concatenate_file_data(file_list)\\n\\n # Shuffle the data and create the training and the validation datasets\\n data = self.shuffle_data_dictionary(data)\\n self.training_dataset, self.validation_dataset = self.split_data_into_training_and_validation(data)\",\n \"def perform_extraction(self) -> None:\\n\\n self._process_datasets_all_frames()\",\n \"def __init__(self, raw_data_file,):\\n self.raw_data_file = raw_data_file\\n self.clean_data = self.cleanData()\\n self.microtrip_data = []\",\n \"def _extract_data(self, *args, **kwargs) -> None:\\n raise NotImplementedError\",\n \"def parse_main_tasks(self):\\n # Need to determine the rolename per task somehow\\n self.playbookparser = PlaybookParser(self.main_tasks, is_role=True)\\n\\n # Parse all main tasks\\n self.playbookparser.parse_playbooks()\\n self.parserdata = self.playbookparser.parserdata\",\n \"def data_preprocessing():\\n lineid_content = get_lineid_content()\\n print('Read movie_lines.txt file complete...')\\n convos = get_convos()\\n print('Read movie_conversations.txt file complete...')\\n print('Building dataset')\\n get_data(lineid_content, convos)\",\n \"def extract_files(self) -> list:\\n pass\",\n \"def extract(self, data):\",\n \"def get_raw_files(raw_dir, data_source):\\n raw_files = {\\n \\\"inputs\\\": [],\\n \\\"targets\\\": [],\\n } # keys\\n for d in data_source:\\n if d[\\\"url\\\"].endswith(\\\"/\\\"): # the url is a dir and not a compressed file\\n input_file = download_from_url(raw_dir, d[\\\"url\\\"] + d[\\\"input\\\"])\\n target_file = download_from_url(raw_dir, d[\\\"url\\\"] + d[\\\"target\\\"])\\n else:\\n input_file, target_file = download_and_extract(\\n raw_dir, d[\\\"url\\\"], d[\\\"input\\\"], d[\\\"target\\\"])\\n raw_files[\\\"inputs\\\"].append(input_file)\\n raw_files[\\\"targets\\\"].append(target_file)\\n return raw_files\",\n \"def extract(self):\\n self.logger.info(f'Opening {self.file}')\\n try:\\n f = open(self.file, 'r')\\n except FileNotFoundError:\\n self.logger.info('Could not open the .vrt file')\\n return\\n\\n result = {}\\n self.logger.info('Extracting')\\n for line in f:\\n # Only attempt to extract if line is correct\\n if self.is_target(line):\\n # Add the closing text tag to make the line have proper XML\\n xml_attributes = XML.fromstring(line.rstrip()+'</text>').attrib\\n # Extract wanted parameters\\n month = xml_attributes['date'][5:7] # Extract month\\n # Add month to the keys\\n if month not in result.keys():\\n result[month] = []\\n result[month].append({\\n 'title': xml_attributes['title'], # Extract thread title\\n 'thread_id': xml_attributes['thread_id'], # Extract thread id\\n 'datetime': xml_attributes['datetime'] # Extract datetime\\n })\\n self.logger.info('Extraction complete')\\n self.db = result\\n # self.db[self.year] = result # Assign results to year\\n self.save_result() # Save the results\",\n \"def load_all_data() -> Tuple[pd.DataFrame, ...]:\\n return tuple(\\n pd.read_csv(path, sep='\\\\t') for path in (TARGETS_PATH, USER_INFO_PATH, INTERACTIONS_PATH, TRACK_INFO_PATH))\",\n \"def cleanData(self):\\n clean_data = []\\n for file in self.raw_data_file:\\n data = RawData(file)\\n data.clean()\\n data.prepare()\\n clean_data.append(data)\\n return clean_data\",\n \"def unit_test_cal_extract_raw_spirou(p, rname, inputs):\\n # define name and arguments\\n name = 'cal_extract_RAW_spirou'\\n arg_names = ['night_name', 'files']\\n arg_types = [str, list]\\n\\n # get arguments\\n args = get_args(p, name, rname, inputs, arg_names, arg_types)\\n return args, name\",\n \"def readFiles(trainFile, testFile):\\r\\n\\r\\n\\t# Open both files and split into lines\\r\\n\\twith open(trainFile) as f:\\r\\n\\t\\ttrainLines = f.read().splitlines()\\r\\n\\r\\n\\twith open(testFile) as f:\\r\\n\\t\\ttestLines = f.read().splitlines()\\r\\n\\r\\n\\t\\t\\r\\n\\t# Extract training data\\r\\n\\tfor line in trainLines:\\r\\n\\t\\tline = line.split()\\r\\n\\t\\t\\r\\n\\t\\tid = line[0]\\r\\n\\t\\tclass_id = line[1]\\r\\n\\t\\twords = line[2:]\\r\\n\\t\\t\\r\\n\\t\\trow = [id, class_id, words]\\r\\n\\t\\t\\r\\n\\t\\ttrainingData.append(row)\\r\\n\\t\\t\\r\\n\\t\\t\\r\\n\\t# Extract testing data\\r\\n\\tfor line in testLines:\\r\\n\\t\\tline = line.split()\\r\\n\\t\\t\\r\\n\\t\\tid = line[0]\\r\\n\\t\\tclass_id = line[1]\\r\\n\\t\\twords = line[2:]\\r\\n\\t\\t\\r\\n\\t\\trow = [id, class_id, words]\\r\\n\\t\\t\\r\\n\\t\\ttestData.append(row)\",\n \"def read_folder(self,sourceFolder):\\n \\n taskList = []\\n for fileName in os.listdir(sourceFolder):\\n if fileName.endswith(\\\".task\\\"):\\n if 'HFODomain' in sourceFolder:\\n taskList.append(HFOTask(sourceFolder+fileName,fileName.split('.')[0]))\\n else:\\n taskList.append(GridWorldTask(sourceFolder+fileName,fileName.split('.')[0]))\\n return taskList\",\n \"def get_data(output_dir: Path = Path(\\\"raw_data\\\")) -> None:\\n\\n files = [\\n \\\"alignment.sorted.bam\\\",\\n \\\"names-mdmg.dmp\\\",\\n \\\"nodes-mdmg.dmp\\\",\\n \\\"acc2taxid.map.gz\\\",\\n ]\\n\\n for file in files:\\n with resources.path(\\\"metaDMG.data\\\", file) as p:\\n file_path = p\\n\\n target_path = Path(output_dir) / file\\n target_path.parent.mkdir(parents=True, exist_ok=True)\\n shutil.copy(file_path, target_path)\",\n \"def _read_data_taskB(data_path: str=\\\"path\\\", test: bool=False, test_samples=None):\\n sentences = []\\n labels = []\\n targets_list = []\\n\\n data_dict = read_json_data(data_path) if not test else test_samples\\n for entry in data_dict:\\n text = entry[\\\"text\\\"]\\n targets = entry[\\\"targets\\\"]\\n\\n sent_term = []\\n pol_labels = []\\n term_list = []\\n if len(targets) > 0:\\n for tgt in targets:\\n term = tgt[1]\\n sent_term.append([text,term])\\n term_list.append(term)\\n\\n polarity = \\\"un-polarized\\\" if test else tgt[2]\\n pol_labels.append(POLARITY_TAGS[polarity])\\n\\n else:\\n polarity = \\\"un-polarized\\\"\\n sent_term.append([text,\\\"\\\"])\\n pol_labels.append(POLARITY_TAGS[polarity])\\n term_list.append(\\\"\\\")\\n\\n sentences.append(sent_term)\\n labels.append(pol_labels)\\n targets_list.append(term_list)\\n\\n assert len(sentences) == len(labels)\\n if not test:\\n return sentences, labels, targets_list, None\\n else:\\n return list(zip(sentences,labels,targets_list))\",\n \"def _load_data(self):\\n\\n path_data_x = '/workspace/base-ml/data/dizzyreg/t%s_df.csv' % \\\\\\n self.task_num\\n path_data_y = '/workspace/base-ml/data/dizzyreg/label_df_t%s.csv' % self.task_num\\n path_meta = '/workspace/base-ml/data/dizzyreg/meta_df_t%s.csv' % self.task_num\\n path_numerical_columns = '/workspace/base-ml/data/dizzyreg/num_columns_v2.csv'\\n path_nonnumerical_columns = '/workspace/base-ml/data/dizzyreg/non_num_columns_v2.csv'\\n\\n read_data_x = pd.read_csv(path_data_x)\\n read_data_y = pd.read_csv(path_data_y)\\n read_data_meta = pd.read_csv(path_meta)\\n\\n # Drop columns if it only contains 1 unique element\\n read_data_x = pd.DataFrame(self.drop_one_elem_columns(read_data_x))\\n\\n num_col = pd.read_csv(path_numerical_columns)\\n num_col = read_data_x.columns.isin(num_col['0'].values).nonzero()[0]\\n col_idx = np.arange(read_data_x.shape[-1])\\n non_num_col = np.setdiff1d(col_idx, num_col)\\n\\n # new_data_x = np.array(read_data_x).astype(np.float32)\\n new_data_x = np.array(read_data_x)\\n new_data_y = np.array(read_data_y).astype(np.float32)\\n new_data_meta = np.array(read_data_meta).astype(np.float32)\\n\\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\\n\\n\\n # Winsorize dataset\\n len_feat = new_data_x.shape[-1]\\n idx_list = list(num_col)\\n for i in range(len_feat):\\n if i in idx_list:\\n cur_data = new_data_x[:, i]\\n cur_data = np.array(cur_data)\\n lower_p = np.percentile(cur_data, 5)\\n higher_p = np.percentile(cur_data, 95)\\n cur_data[cur_data < lower_p] = lower_p\\n cur_data[cur_data > higher_p] = higher_p\\n new_data_x[:, i] = cur_data\\n\\n # Make sure target data is one-hot encoded\\n if new_data_y.shape[-1] == 1:\\n num_class = len(np.unique(new_data_y))\\n new_data_y = np.eye(num_class)[new_data_y.astype(int).reshape(-1)]\\n new_data_y = new_data_y.astype('float32')\\n self.orig_column_names = read_data_x.columns\\n self.data_x = new_data_x # N x F\\n self.data_y = new_data_y # N x C\\n self.numerical_idx = num_col # list of idx\\n self.non_num_idx = non_num_col # None\\n\\n # Calculate adjacency matrix\\n self.meta_inf = new_data_meta.astype('float32') # N x 3\\n if self.args.graph_type:\\n self.adj = self.get_adjacency()\",\n \"def loadFiles(root=\\\"data/TAIWAN_RAW_DATA/ADHD\\\"):\\n\\tdata_rt = [] # realtime.csv\\n\\tdata_trial = [] # trialdata.csv\\n\\tdata_id = [] # caseid/subjectid\\n\\tRealTime = \\\"A2RealTime_\\\"\\n\\tTrialData = \\\"A2TrialData_\\\"\\n\\tfolder_list = os.listdir(root) # list of subfolders in the root\\n\\tfor folders in folder_list:\\n\\t\\tfolders_path = os.path.join(root,folders)\\n\\t\\tif folders.find(\\\"pass\\\") != -1:\\n\\t\\t\\tcontinue\\n\\t\\t\\t\\n\\t\\ttry:\\n\\t\\t\\tdata_rt.append(pd.read_csv(os.path.join\\n\\t\\t\\t\\t\\t\\t\\t\\t (folders_path,\\n\\t\\t\\t\\t\\t\\t\\t\\t RealTime+folders[3:]+\\\".csv\\\")))\\n\\t\\t\\tdata_trial.append(pd.read_csv(os.path.join\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t (folders_path,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t TrialData+folders[3:]+\\\".csv\\\")))\\n\\t\\t\\tdata_id.append(int(folders.split('_')[1]))\\n\\t\\texcept:\\n\\t\\t\\tprint(os.path.join(folders_path,TrialData+folders[3:]+\\\".csv\\\"))\\n\\t\\t\\t\\n\\treturn data_rt,data_trial,data_id,folder_list\",\n \"def _load_processed_data(self):\\n with open(os.path.join(self._data_root_path, self._processed_train_data_file_name),\\n 'r') as f:\\n train_examples = json.load(f)\\n\\n with open(os.path.join(self._data_root_path, self._processed_dev_data_file_name), 'r') as f:\\n dev_examples = json.load(f)\\n\\n with open(os.path.join(self._data_root_path, self._word_vocab_file_name), 'r') as f:\\n word_vocab = Vocab.from_json(json.load(f))\\n\\n with open(os.path.join(self._data_root_path, self._char_vocab_file_name), 'r') as f:\\n char_vocab = Vocab.from_json(json.load(f))\\n\\n return train_examples, dev_examples, word_vocab, char_vocab\",\n \"def process(self):\\n # check already processed\\n proc_dir = os.path.join(self.root, self.processed_dir)\\n train_path = os.path.join(proc_dir, self.train_fn)\\n test_path = os.path.join(proc_dir, self.test_fn)\\n if os.path.exists(train_path) and os.path.exists(test_path):\\n # already exists => load process file\\n print(\\\"processed dataset already exists; load it\\\")\\n self.train_data = torch.load(train_path)\\n self.test_data = torch.load(test_path)\\n return\\n\\n # read and process raw data\\n print(\\\"read and process raw dataset ...\\\")\\n label_path = os.path.join(self.root, self.raw_dir, \\\"labels.txt\\\")\\n image_path_format = os.path.join(self.root, self.raw_dir, \\\"img_{}.png\\\")\\n \\n with open(label_path) as f:\\n for line in f:\\n if not line.strip():\\n break\\n \\n idx, label = map(int, line.strip().split('\\\\t'))\\n image_path = image_path_format.format(idx)\\n image = load_image(image_path)\\n \\n if idx <= self.split:\\n self.train_data.append((image, label))\\n elif idx > self.split:\\n self.test_data.append((image, label))\\n\\n # write processed file\\n if not os.path.exists(proc_dir):\\n os.mkdir(proc_dir)\\n\\n with open(train_path, 'wb') as f:\\n torch.save(self.train_data, f)\\n with open(test_path, 'wb') as f:\\n torch.save(self.test_data, f)\\n\\n print(\\\"Done!\\\")\",\n \"def get_processed_data(self, group_directory):\\n processed_dir = [x for x in group_directory.iterdir()\\n if x.is_dir() and 'processed' in x.name][0]\\n\\n task_dirs = [x for x in processed_dir.iterdir()\\n if x.is_dir() and 'task' in x.name]\\n\\n files = dict()\\n for task in task_dirs:\\n task_camera_dirs = [x for x in task.iterdir()\\n if x.is_dir() and 'pc' in x.name]\\n\\n task_frame_files = list()\\n if task_camera_dirs:\\n task_frame_files = dict()\\n for camera_dir in task_camera_dirs:\\n task_frame_files[camera_dir.name] = [x for x in camera_dir.iterdir()\\n if not x.is_dir() and x.suffix in VALID_OUTPUT_FILE_TYPES]\\n\\n for camera, frame_files in task_frame_files.items():\\n for frame_file in frame_files:\\n frame = int(re.search(r'(?<=_)(\\\\d{12})(?=_)',\\n frame_file.name).group(0))\\n if task.name not in files:\\n files[task.name] = dict()\\n\\n if frame not in files[task.name]:\\n files[task.name][frame] = dict()\\n\\n files[task.name][frame][camera] = frame_file\\n\\n else:\\n task_frame_files = [x for x in task.iterdir()\\n if not x.is_dir()\\n and x.suffix in VALID_OUTPUT_FILE_TYPES]\\n\\n for frame_file in task_frame_files:\\n frame = int(re.search(r'(?<=_)(\\\\d{12})(?=_)',\\n frame_file.name).group(0))\\n if task.name not in files:\\n files[task.name] = dict()\\n files[task.name][frame] = frame_file\\n\\n return files\",\n \"def read_data(args):\\n\\n print(\\\"Start read_data\\\")\\n t_tot = 0 # sum of times for the all dataset\\n date_dirs = os.listdir(args.path_data_base)\\n for n_iter, date_dir in enumerate(date_dirs):\\n # get access to each sequence\\n path1 = os.path.join(args.path_data_base, date_dir)\\n if not os.path.isdir(path1):\\n continue\\n date_dirs2 = os.listdir(path1)\\n\\n for date_dir2 in date_dirs2:\\n path2 = os.path.join(path1, date_dir2)\\n if not os.path.isdir(path2):\\n continue\\n # read data\\n oxts_files = sorted(glob.glob(os.path.join(path2, 'oxts', 'data', '*.txt')))\\n oxts = KITTIDataset.load_oxts_packets_and_poses(oxts_files)\\n\\n \\\"\\\"\\\" Note on difference between ground truth and oxts solution:\\n - orientation is the same\\n - north and east axis are inverted\\n - position are closed to but different\\n => oxts solution is not loaded\\n \\\"\\\"\\\"\\n\\n print(\\\"\\\\n Sequence name : \\\" + date_dir2)\\n if len(oxts) < KITTIDataset.min_seq_dim: # sequence shorter than 30 s are rejected\\n cprint(\\\"Dataset is too short ({:.2f} s)\\\".format(len(oxts) / 100), 'yellow')\\n continue\\n lat_oxts = np.zeros(len(oxts))\\n lon_oxts = np.zeros(len(oxts))\\n alt_oxts = np.zeros(len(oxts))\\n roll_oxts = np.zeros(len(oxts))\\n pitch_oxts = np.zeros(len(oxts))\\n yaw_oxts = np.zeros(len(oxts))\\n roll_gt = np.zeros(len(oxts))\\n pitch_gt = np.zeros(len(oxts))\\n yaw_gt = np.zeros(len(oxts))\\n t = KITTIDataset.load_timestamps(path2)\\n acc = np.zeros((len(oxts), 3))\\n acc_bis = np.zeros((len(oxts), 3))\\n gyro = np.zeros((len(oxts), 3))\\n gyro_bis = np.zeros((len(oxts), 3))\\n p_gt = np.zeros((len(oxts), 3))\\n v_gt = np.zeros((len(oxts), 3))\\n v_rob_gt = np.zeros((len(oxts), 3))\\n\\n k_max = len(oxts)\\n for k in range(k_max):\\n oxts_k = oxts[k]\\n t[k] = 3600 * t[k].hour + 60 * t[k].minute + t[k].second + t[\\n k].microsecond / 1e6\\n lat_oxts[k] = oxts_k[0].lat\\n lon_oxts[k] = oxts_k[0].lon\\n alt_oxts[k] = oxts_k[0].alt\\n acc[k, 0] = oxts_k[0].af\\n acc[k, 1] = oxts_k[0].al\\n acc[k, 2] = oxts_k[0].au\\n acc_bis[k, 0] = oxts_k[0].ax\\n acc_bis[k, 1] = oxts_k[0].ay\\n acc_bis[k, 2] = oxts_k[0].az\\n gyro[k, 0] = oxts_k[0].wf\\n gyro[k, 1] = oxts_k[0].wl\\n gyro[k, 2] = oxts_k[0].wu\\n gyro_bis[k, 0] = oxts_k[0].wx\\n gyro_bis[k, 1] = oxts_k[0].wy\\n gyro_bis[k, 2] = oxts_k[0].wz\\n roll_oxts[k] = oxts_k[0].roll\\n pitch_oxts[k] = oxts_k[0].pitch\\n yaw_oxts[k] = oxts_k[0].yaw\\n v_gt[k, 0] = oxts_k[0].ve\\n v_gt[k, 1] = oxts_k[0].vn\\n v_gt[k, 2] = oxts_k[0].vu\\n v_rob_gt[k, 0] = oxts_k[0].vf\\n v_rob_gt[k, 1] = oxts_k[0].vl\\n v_rob_gt[k, 2] = oxts_k[0].vu\\n p_gt[k] = oxts_k[1][:3, 3]\\n Rot_gt_k = oxts_k[1][:3, :3]\\n roll_gt[k], pitch_gt[k], yaw_gt[k] = IEKF.to_rpy(Rot_gt_k)\\n\\n t0 = t[0]\\n t = np.array(t) - t[0]\\n # some data can have gps out\\n if np.max(t[:-1] - t[1:]) > 0.1:\\n cprint(date_dir2 + \\\" has time problem\\\", 'yellow')\\n ang_gt = np.zeros((roll_gt.shape[0], 3))\\n ang_gt[:, 0] = roll_gt\\n ang_gt[:, 1] = pitch_gt\\n ang_gt[:, 2] = yaw_gt\\n\\n p_oxts = lla2ned(lat_oxts, lon_oxts, alt_oxts, lat_oxts[0], lon_oxts[0],\\n alt_oxts[0], latlon_unit='deg', alt_unit='m', model='wgs84')\\n p_oxts[:, [0, 1]] = p_oxts[:, [1, 0]] # see note\\n\\n # take correct imu measurements\\n u = np.concatenate((gyro_bis, acc_bis), -1)\\n # convert from numpy\\n t = torch.from_numpy(t)\\n p_gt = torch.from_numpy(p_gt)\\n v_gt = torch.from_numpy(v_gt)\\n ang_gt = torch.from_numpy(ang_gt)\\n u = torch.from_numpy(u)\\n\\n # convert to float\\n t = t.float()\\n u = u.float()\\n p_gt = p_gt.float()\\n ang_gt = ang_gt.float()\\n v_gt = v_gt.float()\\n\\n mondict = {\\n 't': t, 'p_gt': p_gt, 'ang_gt': ang_gt, 'v_gt': v_gt,\\n 'u': u, 'name': date_dir2, 't0': t0\\n }\\n\\n t_tot += t[-1] - t[0]\\n KITTIDataset.dump(mondict, args.path_data_save, date_dir2)\\n print(\\\"\\\\n Total dataset duration : {:.2f} s\\\".format(t_tot))\",\n \"def main(input_filepath, output_filepath):\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\",\n \"def main(input_filepath, output_filepath):\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\",\n \"def extractor_multiprocess(self):\\n pool = multiprocessing.Pool()\\n queue = multiprocessing.Queue()\\n queue.put(\\\"safe\\\")\\n end = len(next(os.walk(self.datadir))[2])\\n error = 0\\n\\n extractor_iterator = ((directory)\\n for directory in os.listdir(self.datadir))\\n with jsonlines.open(self.output, \\\"w\\\") as f:\\n for x in tqdm.tqdm(\\n pool.imap_unordered(self.extract_unpack, extractor_iterator), total=end\\n ):\\n if not x:\\n \\\"\\\"\\\"\\n To input error class or function\\n \\\"\\\"\\\"\\n error += 1\\n continue\\n msg = queue.get()\\n if msg == \\\"safe\\\":\\n f.write(x)\\n queue.put(\\\"safe\\\")\\n\\n pool.close()\",\n \"def _load(self, data):\\n raise NotImplementedError(\\\"Don't know how to load the task\\\")\",\n \"def extract_from_file(self, data_file, data_path):\\n with open(data_file, \\\"r\\\") as f:\\n lines = f.readlines()\\n\\n data_paths = [os.path.join(data_path, line) for line in lines]\\n return data_paths\",\n \"def get_data_gen_datasets(raw_data,normalize_data=True):\\n\\n training_set,validation_set,test_set,class_labels = raw_data\\n print \\\"Loading data succeeded\\\"\\n\\n if normalize_data:\\n training_set_samples = normalize(training_set[:,0:-1])\\n validation_set_samples = normalize(validation_set[:,0:-1])\\n testing_set_samples = normalize(test_set[:,0:-1])\\n\\n print \\\"Normalized data\\\"\\n\\n # assume square patches\\n inp_shape = int(numpy.sqrt(training_set_samples.shape[1]))\\n\\n training_set_samples = theano.shared(training_set_samples.astype(theano.config.floatX))\\n validation_set_samples = theano.shared(validation_set_samples.astype(theano.config.floatX))\\n test_set_samples = theano.shared(testing_set_samples.astype(theano.config.floatX))\\n\\n training_set_labels = theano.shared(training_set[:,-1].astype('int32')) # FIXME: uint8 should be sufficient\\n validation_set_labels = theano.shared(validation_set[:,-1].astype('int32'))\\n test_set_labels = theano.shared(test_set[:,-1].astype('int32'))\\n\\n print \\\"Unpacked data\\\"\\n\\n return ((training_set_samples, training_set_labels), \\\\\\n (validation_set_samples, validation_set_labels), \\\\\\n (test_set_samples, test_set_labels), \\\\\\n inp_shape,class_labels)\",\n \"def read_unlabeled(data_loc, dname):\\n data = []\\n fnames = []\\n raw_fnames = os.listdir(data_loc + dname)\\n for raw_fname in raw_fnames:\\n fname = dname + '/' + raw_fname\\n content = read_instance(data_loc, fname)\\n data.append(content)\\n fnames.append(fname)\\n return data, fnames\",\n \"def __init__(self, data_dir, output_path=None, task_name=\\\"Q1_Questions\\\"):\\n \\n # Remember the task name.\\n self._task_name = task_name\\n # Load all data.\\n self.load_from_directory(data_dir, task_name)\\n self.process_raw_data()\\n if not (output_path is None):\\n self.write_processed_data_to_file(output_path)\",\n \"def doImport(self, params):\\n #logging.info(params.filename)\\n raw_data = self.open_filename(params.filename)\\n #logging.info('file open ok')\\n data = self.split_to_blocks(raw_data)\\n #logging.info('splitting ok')\\n chromatograms = self.process_data_to_chromatograms(data)\\n #logging.info('extract ok')\\n \\n processed_data = []\\n \\n zero = params.field_results[\\\"zero\\\"]\\n MIC = params.field_results[\\\"MIC\\\"]\\n TIC = params.field_results[\\\"TIC\\\"]\\n round_MZ = params.field_results[\\\"round_MZ\\\"]\\n \\n for chrom in chromatograms:\\n \\n prefix = chrom['short_title']\\n if (\\\".\\\" in prefix) and round_MZ:\\n first,last = prefix.split('.')\\n prefix = first\\n \\n if (\\\"MIC\\\" in prefix) and (not MIC):\\n pass\\n elif (\\\"TIC\\\" in prefix) and (not TIC):\\n pass\\n else:\\n x = ImportDataset1D(name=prefix+'_time',data = chrom['time'])\\n if zero:\\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal_zero'])\\n else:\\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal'])\\n processed_data.append(x)\\n processed_data.append(y)\\n \\n return processed_data\",\n \"def get_data(n = None):\\n files = download_data()\\n for path in files.values():\\n extract_data(path)\\n class_fnames, labelmap = explore_data()\\n X, y = load_data(class_fnames)\\n return prepare_data(X, y, n = n)\",\n \"def download_and_extract_data(tmp_dir, dataset):\\n url = dataset[0]\\n print(dataset)\\n compressed_filename = os.path.basename(url)\\n compressed_file = generator_utils.maybe_download(\\n tmp_dir, compressed_filename, url)\\n\\n for file in dataset[1]:\\n tf.logging.info(\\\"Reading file: %s\\\" % file)\\n filepath = os.path.join(tmp_dir, file)\\n\\n # Extract from tar if needed.\\n if not tf.gfile.Exists(filepath):\\n with tarfile.open(compressed_file, \\\"r:gz\\\") as corpus_tar:\\n corpus_tar.extractall(tmp_dir)\\n\\n documents_filename, labels_filename = dataset[1]\\n documents_filepath = os.path.join(tmp_dir, documents_filename)\\n labels_filepath = os.path.join(tmp_dir, labels_filename)\\n return documents_filepath, labels_filepath\",\n \"def load_data_part(fname):\\n if \\\"_data\\\" not in fname:\\n return None\\n # Read data\\n data = pd.read_csv(fname)\\n # events file\\n events_fname = fname.replace('_data', '_events')\\n # read event file\\n labels = pd.read_csv(events_fname)\\n clean = data.drop(['id'], axis=1) # remove id\\n labels = labels.drop(['id'], axis=1) # remove id\\n return clean, labels\",\n \"def extract_data(input_file):\\n input_zip = client.file(input_file).getFile().name\\n # Create directory to unzip model files into\\n if os.path.exists(\\\"/tmp/unzipped_file/\\\"):\\n rmtree('unzipped_file',ignore_errors=True)\\n else:\\n os.mkdir(\\\"/tmp/unzipped_file/\\\")\\n zipped_file = zipfile.ZipFile(input_zip)\\n # Extract unzipped files into directory created earlier returns none\\n file_path = \\\"/tmp/unzipped_file/\\\"\\n return zipped_file.extract(\\\"test_keras_data.csv\\\", file_path)\",\n \"def process_data(self) -> Tuple[list, List[Sequence[int]]]:\\n features, labels = self.load_files()\\n x = [self.process_text(f, self.max_length) for f in features]\\n y = [self._convert_labels(l, self.max_length) for l in labels]\\n return x, y\",\n \"def process(self):\\n self.extract()\\n self.transform()\\n self.load()\",\n \"def load_data(self, task):\\n params = self.params\\n data = {splt: {} for splt in ['train', 'valid', 'test']}\\n dpath = os.path.join(params.data_path, 'eval', task)\\n\\n self.n_sent = 1 if task in ['SST-2', 'CoLA'] else 2\\n\\n for splt in ['train', 'valid', 'test']:\\n\\n # load data and dictionary\\n data1 = load_binarized(os.path.join(dpath, '%s.s1.pth' % splt), params)\\n data2 = load_binarized(os.path.join(dpath, '%s.s2.pth' % splt), params) if self.n_sent == 2 else None\\n data['dico'] = data.get('dico', data1['dico'])\\n\\n # set dictionary parameters\\n set_dico_parameters(params, data, data1['dico'])\\n if self.n_sent == 2:\\n set_dico_parameters(params, data, data2['dico'])\\n\\n # create dataset\\n if self.n_sent == 1:\\n data[splt]['x'] = Dataset(data1['sentences'], data1['positions'], params)\\n else:\\n data[splt]['x'] = ParallelDataset(\\n data1['sentences'], data1['positions'],\\n data2['sentences'], data2['positions'],\\n params\\n )\\n\\n # load labels\\n if splt != 'test' or task in ['MRPC']:\\n # read labels from file\\n with open(os.path.join(dpath, '%s.label' % splt), 'r') as f:\\n lines = [l.rstrip() for l in f]\\n # STS-B task\\n if task == 'STS-B':\\n assert all(0 <= float(x) <= 5 for x in lines)\\n y = [float(l) for l in lines]\\n # QQP\\n elif task == 'QQP':\\n UNK_LABEL = 0\\n lab2id = {x: i for i, x in enumerate(sorted(set(lines) - set([''])))}\\n y = [lab2id.get(x, UNK_LABEL) for x in lines]\\n # other tasks\\n else:\\n lab2id = {x: i for i, x in enumerate(sorted(set(lines)))}\\n y = [lab2id[x] for x in lines]\\n data[splt]['y'] = torch.LongTensor(y)\\n assert len(data[splt]['x']) == len(data[splt]['y'])\\n\\n # compute weights for weighted training\\n if task != 'STS-B' and params.weighted_training:\\n weights = torch.FloatTensor([\\n 1.0 / (data['train']['y'] == i).sum().item()\\n for i in range(len(lab2id))\\n ]).npu()\\n self.weights = weights / weights.sum()\\n else:\\n self.weights = None\\n\\n return data\",\n \"def readDataFromFile():\\n image_size = 28 # each image is 28x28\\n\\n num_images = 60000 # there are 60k images\\n with gzip.open(r'train-images-idx3-ubyte.gz', 'r') as f: # 60k train & valid\\n f.read(16) # reading by 16-byte double\\n buffer_Train_Images = f.read(image_size * image_size * num_images)\\n f.close()\\n data_Train_Images = np.frombuffer(buffer_Train_Images, dtype=np.uint8).astype(\\n np.int32) # translating into 0 to 255\\n data_Train_Images = data_Train_Images.reshape(num_images,\\n image_size * image_size) # Data = 60k x 28 x 28 with 1 value in it\\n\\n with gzip.open('train-labels-idx1-ubyte.gz', 'r') as f: # 60k train & valid - labels\\n f.read(8) # reading by 16-byte double\\n buffer_Train_Labels = f.read(num_images)\\n data_Train_Labels = np.frombuffer(buffer_Train_Labels, dtype=np.uint8).astype(\\n np.int32) # translating into 0 to 255\\n\\n num_images = 10000 # there are 10k images\\n with gzip.open('t10k-images-idx3-ubyte.gz', 'r') as f: # 10k tests\\n f.read(16) # reading by 16-byte double\\n buffer_Test_Image = f.read(image_size * image_size * num_images)\\n data_Test_Image = np.frombuffer(buffer_Test_Image, dtype=np.uint8).astype(\\n np.uint8) # translating into 0 to 255\\n data_Test_Image = data_Test_Image.reshape(num_images, image_size * image_size) # Data = 60k x 28 x 28 with\\n\\n with gzip.open('t10k-labels-idx1-ubyte.gz', 'r') as f: # 10k tests - lbles\\n f.read(8) # reading by 16-byte double\\n buffer_Test_Label = f.read(num_images)\\n data_Test_Labels = np.frombuffer(buffer_Test_Label, dtype=np.uint8).astype(\\n np.int32) # translating into 0 to 255\\n\\n return data_Train_Images, data_Train_Labels, data_Test_Image, data_Test_Labels\",\n \"def grab_data_chunk(self, filenames):\\n \\n filenames = [join(self.kwargs[\\\"data_dir\\\"],f) for f in filenames]\\n\\n\\n dataset=MFDataset(filenames)\\n \\n tensor = convert_nc_data_to_tensor(dataset,self.kwargs)\\n \\n return tensor\",\n \"def _read_data(self) -> MMD:\\n\\t\\tif self.config.source_type == SourceType.LOCAL_FILE:\\n\\t\\t\\treturn self._read_files()\\n\\t\\telif self.config.source_type == SourceType.HDFS:\\n\\t\\t\\treturn self._read_hdfs()\\n\\t\\telif self.config.source_type == SourceType.NEO4J:\\n\\t\\t\\treturn self._read_neo4j(self.config.graph_db)\\n\\n\\t\\telse:\\n\\t\\t\\traise NotImplementedError(\\\"The source type {} has not been implemented yet.\\\".format(loader_config.source_type))\",\n \"def _get_data(\\n self,\\n vis_hdu,\\n antenna_nums,\\n antenna_names,\\n ant_str,\\n bls,\\n frequencies,\\n freq_chans,\\n times,\\n time_range,\\n polarizations,\\n blt_inds,\\n read_metadata,\\n keep_all_metadata,\\n run_check,\\n check_extra,\\n run_check_acceptability,\\n strict_uvw_antpos_check,\\n ):\\n # figure out what data to read in\\n blt_inds, freq_inds, pol_inds, history_update_string = self._select_preprocess(\\n antenna_nums,\\n antenna_names,\\n ant_str,\\n bls,\\n frequencies,\\n freq_chans,\\n times,\\n time_range,\\n polarizations,\\n blt_inds,\\n )\\n\\n if blt_inds is not None:\\n blt_frac = len(blt_inds) / float(self.Nblts)\\n else:\\n blt_frac = 1\\n\\n if freq_inds is not None:\\n freq_frac = len(freq_inds) / float(self.Nfreqs)\\n else:\\n freq_frac = 1\\n\\n if pol_inds is not None:\\n pol_frac = len(pol_inds) / float(self.Npols)\\n else:\\n pol_frac = 1\\n\\n min_frac = np.min([blt_frac, freq_frac, pol_frac])\\n\\n if min_frac == 1:\\n # no select, read in all the data\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :]\\n else:\\n # do select operations on everything except data_array, flag_array\\n # and nsample_array\\n self._select_metadata(\\n blt_inds, freq_inds, pol_inds, history_update_string, keep_all_metadata\\n )\\n\\n # just read in the right portions of the data and flag arrays\\n if blt_frac == min_frac:\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\\n if freq_frac < 1:\\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\\n if pol_frac < 1:\\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\\n elif freq_frac == min_frac:\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[:, :, :, :, freq_inds, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[:, :, :, freq_inds, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\\n\\n if blt_frac < 1:\\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\\n if pol_frac < 1:\\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\\n else:\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[:, :, :, :, :, pol_inds, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[:, :, :, :, pol_inds, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\\n\\n if blt_frac < 1:\\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\\n if freq_frac < 1:\\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\\n\\n assert len(raw_data_array.shape) == 5\\n # FITS uvw direction convention is opposite ours and Miriad's.\\n # So conjugate the visibilities and flip the uvws:\\n self.data_array = (\\n raw_data_array[:, :, :, :, 0] - 1j * raw_data_array[:, :, :, :, 1]\\n )\\n self.flag_array = raw_data_array[:, :, :, :, 2] <= 0\\n self.nsample_array = np.abs(raw_data_array[:, :, :, :, 2])\\n\\n # check if object has all required UVParameters set\\n if run_check:\\n self.check(\\n check_extra=check_extra,\\n run_check_acceptability=run_check_acceptability,\\n strict_uvw_antpos_check=strict_uvw_antpos_check,\\n )\",\n \"def import_raw(self,read_teff=False,**kwargs):\\n \\n #build dirs\\n self._build_em_dirs()\\n\\n for tn in self.Tn:\\n #initialize counter and flag\\n counter=0\\n #build wait-time specific path\\n tn_path = self.root_path%tn\\n #create em results dir if needed\\n em_res_tn_dir=os.path.join(self.em_res_top_dir,'tn%d'%tn)\\n if not os.path.exists(em_res_tn_dir):\\n os.makedirs(em_res_tn_dir)\\n for pfile in os.listdir(tn_path):\\n if 'heat_amp' not in pfile and 'dem' not in pfile:\\n self.logger.debug(\\\"Reading %s\\\"%pfile)\\n data = np.loadtxt(os.path.join(tn_path,pfile))\\n n_index = 2\\n t_index = 1\\n if 'electron' in tn_path or 'ion' in tn_path: n_index += 1\\n if read_teff:\\n n_index = 3\\n t_index = 2\\n t,T,n = data[:,0],data[:,t_index],data[:,n_index]\\n #calculate emission measure distribution\\n self.binner.set_data(t,T,n)\\n self.binner.build_em_dist()\\n #save data\\n with open(os.path.join(em_res_tn_dir,os.path.splitext(pfile)[0]+'.pickle'),'wb') as f:\\n pickle.dump({'T':self.binner.T_em_flat, 'em':self.binner.em_flat/self.aspect_ratio_factor, 'bins':self.binner.T_em_histo_bins},f)\\n #increment counter\\n counter += 1\\n else:\\n continue\\n\\n #Estimate percentage of files read\\n self.logger.info(\\\"Tn = %d s finished, Estimated total # of events simulated: %.2f %%\\\"%(tn, counter*int(np.ceil(t[-1]/(self.tpulse+tn)))))\",\n \"def prep_data(self, num_processes):\\n filenames = os.listdir(self.beatmaps_root)\\n processes = []\\n for i in range(num_processes):\\n start = i * (len(filenames) // num_processes)\\n end = None\\n if i != num_processes - 1:\\n end = (i + 1) * (len(filenames) // num_processes)\\n else:\\n end = len(filenames)\\n processes.append(Process(target=self._prep_data_worker,\\n args=(start, end, filenames)))\\n for p in processes:\\n p.start()\\n for p in processes:\\n p.join()\",\n \"def load(fnames, tag=None, inst_id=None):\\n\\n all_data = []\\n\\n # Dst data is actually stored by year but users can load by day.\\n # Extract the actual dates from the input list of filenames as\\n # well as the names of the actual files.\\n fdates = []\\n ufnames = []\\n for filename in fnames:\\n fdates.append(dt.datetime.strptime(filename[-10:], '%Y-%m-%d'))\\n ufnames.append(filename[0:-11])\\n\\n # Get unique filenames that map to actual data\\n ufnames = np.unique(ufnames).tolist()\\n\\n # Load unique files\\n for fname in ufnames:\\n with open(fname) as open_f:\\n lines = open_f.readlines()\\n idx = 0\\n\\n # Check if all lines are good\\n max_lines = 0\\n for line in lines:\\n if len(line) > 1:\\n max_lines += 1\\n\\n # Prep memory\\n yr = np.zeros(max_lines * 24, dtype=int)\\n mo = np.zeros(max_lines * 24, dtype=int)\\n day = np.zeros(max_lines * 24, dtype=int)\\n ut = np.zeros(max_lines * 24, dtype=int)\\n dst = np.zeros(max_lines * 24, dtype=int)\\n\\n # Read data\\n for line in lines:\\n if len(line) > 1:\\n temp_year = int(line[14:16] + line[3:5])\\n if temp_year > 57:\\n temp_year += 1900\\n else:\\n temp_year += 2000\\n\\n yr[idx:idx + 24] = temp_year\\n mo[idx:idx + 24] = int(line[5:7])\\n day[idx:idx + 24] = int(line[8:10])\\n ut[idx:idx + 24] = np.arange(24)\\n temp = line.strip()[20:-4]\\n temp2 = [temp[4 * i:4 * (i + 1)] for i in np.arange(24)]\\n dst[idx:idx + 24] = temp2\\n idx += 24\\n\\n # Prep datetime index for the data and create DataFrame\\n start = dt.datetime(yr[0], mo[0], day[0], ut[0])\\n stop = dt.datetime(yr[-1], mo[-1], day[-1], ut[-1])\\n dates = pds.date_range(start, stop, freq='H')\\n new_data = pds.DataFrame(dst, index=dates, columns=['dst'])\\n\\n # Add to all data loaded for filenames\\n all_data.append(new_data)\\n\\n # Combine data together\\n data = pds.concat(all_data, sort=True, axis=0)\\n\\n # Pull out requested days\\n data = data.iloc[data.index >= fdates[0], :]\\n data = data.iloc[data.index < fdates[-1] + pds.DateOffset(days=1), :]\\n\\n # Create metadata\\n meta = pysat.Meta()\\n meta['dst'] = {meta.labels.units: 'nT',\\n meta.labels.name: 'Dst',\\n meta.labels.notes: tags[tag],\\n meta.labels.desc: 'Disturbance storm-time index',\\n meta.labels.fill_val: np.nan,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n\\n return data, meta\",\n \"def copy_raw_data(spark, input_data, output_data):\\n # load smaller test table from parquet files\\n immigration_data_small = os.path.join(input_data, 'sas_data/')\\n immigration_small_df = spark.read.parquet(immigration_data_small)\\n \\n # load full table from sas files \\n immigration_data_path = os.path.join(input_data, 'data/18-83510-I94-Data-2016/*.sas7bdat')\\n immigration_data = [f for f in glob.glob(immigration_data_path)]\\n\\n for file in immigration_data:\\n if file == immigration_data[0]:\\n immigration_df = spark.read.format('com.github.saurfang.sas.spark').load(file)\\n else:\\n new_df = spark.read.format('com.github.saurfang.sas.spark').load(file)\\n immigration_df = outter_union(immigration_df, new_df)\\n \\n temp_data = os.path.join(input_data, 'GlobalLandTemperaturesByState.csv')\\n temp_df = spark.read.csv(temp_data, header=True)\\n logging.info('Temperature data successfully loaded')\\n\\n cities_data = os.path.join(input_data, 'us-cities-demographics.csv')\\n cities_df = spark.read.csv(cities_data, header=True, sep=';')\\n logging.info('Cities data successfully loaded')\\n\\n airports_data = os.path.join(input_data, 'airport-codes_csv.csv')\\n airports_df = spark.read.csv(airports_data, header=True)\\n logging.info('Airports data successfully loaded')\\n\\n\\n # put all tables into one dictionary\\n df_raw_all = {#'immigration_data': immigration_small_df, # activate for using small test dataset\\n 'immigration_data': immigration_df, # activate for using full dataset\\n 'temp_data': temp_df, \\n 'cities_data': cities_df,\\n 'airport_data': airports_df\\n }\\n\\n for file, df in df_raw_all.items():\\n # remove spaces and minus in column-names of dataframes\\n df = df.select([F.col(col).alias(col.replace(' ', '_').replace('-', '_')) for col in df.columns])\\n # write parquet files to raw path\\n path = os.path.join(output_data, 'raw', file)\\n df.write.parquet(path)\\n logging.info(f'All tables copied to {output_data} as parquet')\",\n \"def load_data(self):\\n for set_name in self.image_dir_path:\\n if self.verbose:\\n print('\\\\n> Loading data files for the set: ' + set_name)\\n\\n # image dir\\n image_dir = os.path.join(self.data_path, self.image_dir_path[set_name])\\n\\n # annotation file path\\n annot_filepath = os.path.join(self.data_path, self.annotation_path[set_name])\\n\\n if 'test' in set_name:\\n yield load_data_test(set_name, image_dir, annot_filepath, self.verbose)\\n else:\\n yield self.load_data_trainval(set_name, image_dir, annot_filepath)\",\n \"def prepareData(args):\\n print(\\\"Starting preprocessing\\\")\\n\\n # params\\n max_midi = args['max_midi']\\n min_midi = args['min_midi']\\n note_range = args['note_range']\\n window_size = args['window_size']\\n sr = args['sr']\\n hop_length = args['hop_length']\\n wav_dir = args['wav_dir']\\n\\n datapath = os.path.join(args['proj_root'], 'Features')\\n bin_multiple = int(args['bin_multiple'])\\n\\n framecnt = 0\\n maxFramesPerFile = args['maxFramesPerFile']\\n maxFrames = args['maxFrames']\\n\\n fileappend = str(maxFramesPerFile) + 'pf_max' + str(maxFrames) + '.dat'\\n\\n filenameIN = os.path.join(datapath, 'input_' + fileappend)\\n filenameOUT = os.path.join(datapath, 'output_' + fileappend)\\n\\n if os.path.isfile(filenameIN) and os.path.isfile(filenameOUT):\\n n_bins = note_range * bin_multiple\\n print('loading precomputed data from ' + filenameIN)\\n mmi = np.memmap(filenameIN, mode='r', dtype=\\\"float64\\\")\\n inputs = np.reshape(mmi, (-1, window_size, n_bins))\\n\\n mmo = np.memmap(filenameOUT, mode='r', dtype=\\\"float64\\\")\\n outputs = np.reshape(mmo, (-1, note_range))\\n\\n return inputs, outputs, datapath\\n\\n inputs, outputs = [], []\\n addCnt, errCnt = 0, 0\\n\\n # hack to deal with high PPQ from MAPS\\n # https://github.com/craffel/pretty-midi/issues/112\\n pretty_midi.pretty_midi.MAX_TICK = 1e10\\n\\n for s in os.listdir(wav_dir):\\n subdir = os.path.join(wav_dir, s)\\n if not os.path.isdir(subdir):\\n continue\\n # recursively search in subdir\\n print(subdir)\\n for dp, dn, filenames in os.walk(subdir):\\n # in each level of the directory, look at filenames ending with .mid\\n for f in filenames:\\n # if there exists a .wav file and .midi file with the same name\\n\\n if f.endswith('.wav'):\\n audio_filename = f\\n fprefix = audio_filename.split('.wav')[0]\\n mid_fn = fprefix + '.mid'\\n txt_fn = fprefix + '.txt'\\n print(\\\"Handling files {}\\\".format(fprefix))\\n if mid_fn in filenames:\\n # extract_features\\n audio_filename = os.path.join(dp, audio_filename)\\n inputnp = extract_features(audio_filename, args)\\n times = librosa.frames_to_time(np.arange(inputnp.shape[0]), sr=sr, hop_length=hop_length)\\n # mid2outputnp\\n mid_fn = os.path.join(dp, mid_fn)\\n pm_mid = pretty_midi.PrettyMIDI(mid_fn)\\n\\n outputnp = mid2outputnp(pm_mid, times, args)\\n\\n # check that num onsets is equal\\n if inputnp.shape[0] == outputnp.shape[0]:\\n # Some filtering highly pragmatic filtering on the data!!\\n # take only frames that are \\\"sufficiently loud\\\", ...\\n good2take = np.array(inputnp.max(axis=(1, 2)) > 0.05)\\n # ... and always omit the last frame as this has been padded ...\\n good2take[-1] = False # omit last\\n # ... and only take frames with at least one true label (i.e. some tone is played)\\n good2take = good2take & (outputnp.max(axis=1) > 0)\\n outputnp = outputnp[good2take, ]\\n inputnp = inputnp[good2take, ]\\n\\n addCnt += 1\\n if inputnp.shape[0] > maxFramesPerFile > 0:\\n inputnp = inputnp[:maxFramesPerFile]\\n outputnp = outputnp[:maxFramesPerFile]\\n framecnt += inputnp.shape[0]\\n print(\\\"framecnt is {}\\\".format(framecnt))\\n inputs.append(inputnp)\\n outputs.append(outputnp)\\n else:\\n print(\\\"error for fprefix {}\\\".format(fprefix))\\n errCnt += 1\\n print(inputnp.shape)\\n print(outputnp.shape)\\n\\n if framecnt > maxFrames > 0:\\n print(\\\"have enought frames, leaving {}\\\".format(subdir))\\n break\\n if framecnt > maxFrames > 0:\\n print(\\\"have enought frames, leaving {}\\\".format(wav_dir))\\n break\\n\\n if framecnt > maxFrames > 0:\\n print(\\\"have enought frames, leaving {}\\\".format(wav_dir))\\n break\\n\\n print(\\\"{} examples in dataset\\\".format(addCnt))\\n print(\\\"{} examples couldnt be processed\\\".format(errCnt))\\n\\n # concatenate dynamic list to numpy list of example\\n if addCnt:\\n inputs = np.concatenate(inputs)\\n outputs = np.concatenate(outputs)\\n\\n print(\\\"inputs.shape\\\")\\n print(inputs.shape)\\n print(\\\"outputs.shape\\\")\\n print(outputs.shape)\\n mmi = np.memmap(filename=filenameIN, mode='w+', shape=inputs.shape, dtype=\\\"float64\\\")\\n mmi[:] = inputs[:]\\n mmo = np.memmap(filename=filenameOUT, mode='w+', shape=outputs.shape, dtype=\\\"float64\\\")\\n mmo[:] = outputs[:]\\n del mmi\\n del mmo\\n\\n return inputs, outputs, datapath\",\n \"def load_all_data(self):\\n layers, layers_fnames = [], []\\n # TODO: add multiprocessing\\n for i in range(len(self.infiles)):\\n fname = self.infiles[i]\\n self.logger.info(\\n \\\"#Loading file: {} {}\\\".format(fname, \\\"(text file)\\\" if pathlib.Path(fname).suffix == \\\"\\\" else \\\"\\\"))\\n\\n # load text file\\n data = load_data_text(file_path=fname, sample_names=self.sn, feature_names=self.fn, drop_features=self.df,\\n drop_samples=self.ds)\\n layers.append(data)\\n layers_fnames.append(fname)\\n\\n return list(zip(layers_fnames, layers))\",\n \"def extractData():\\n for line in src:\\n line = str(line) # now each line is a string\\n line = line.rstrip()\\n if '%%' in line: #header\\n yield line\\n for desired in desStr:\\n if desired in line:\\n yield line\",\n \"def load_data(self) -> None:\",\n \"def lfp_extract(files):\\r\\n \\r\\n if 'lfpdata' in locals():\\r\\n del lfpdata\\r\\n \\r\\n for i, file in enumerate(files):\\r\\n \\r\\n ### load data\\r\\n matdat = sio.loadmat(file, variable_names = ['lfpsegs', 'lfpdata', 'fs', 'chnAreas'], \\r\\n struct_as_record = False, squeeze_me = True) \\r\\n \\r\\n \\r\\n \\r\\n ### extract the noused channels, only calculate once\\r\\n if i == 0:\\r\\n \\r\\n # chnAreas\\r\\n chnAreas = matdat['chnAreas'].tolist()\\r\\n \\r\\n # fs: sample rate\\r\\n fs = matdat['fs'] \\r\\n \\r\\n \\r\\n\\r\\n ### dealing lfp data\\r\\n \\r\\n # lfp (np.ndarray): nareas * ntemp * ntrials or ntemp * nareas * ntrials\\r\\n if 'lfpdata' in matdat.keys():\\r\\n lfpdata_1file = matdat['lfpdata']\\r\\n elif 'lfpsegs' in matdat.keys():\\r\\n lfpdata_1file = matdat['lfpsegs']\\r\\n\\r\\n n1, n2, n3 = lfpdata_1file.shape\\r\\n if n1 > n2: # ntemp * nareas * ntrials\\r\\n lfpdata_1file = np.transpose(lfpdata_1file, (1, 0, 2))\\r\\n \\r\\n # concatenate to lfpdata for all files\\r\\n if 'lfpdata' not in locals():\\r\\n lfpdata = lfpdata_1file\\r\\n else:\\r\\n lfpdata = np.concatenate((lfpdata, lfpdata_1file), axis = 2)\\r\\n \\r\\n \\r\\n return lfpdata, chnAreas, fs\",\n \"def prepare_data(raw=False, round_ratings=False):\\n print('Downloading input data...')\\n if raw:\\n # read data\\n review = get_input(\\n 'https://www.dropbox.com/s/mtln9b6udoydn2h/yelp_academic \\\\\\n _dataset_review_sample.csv?dl=1')\\n user = get_input(\\n 'https://www.dropbox.com/s/pngrptljotqm4ds/yelp_academic \\\\\\n _dataset_user.json?dl=1')\\n business = get_input(\\n 'https://www.dropbox.com/s/w0wy854u5swrhmc/yelp_academic \\\\\\n _dataset_business.json?dl=1')\\n\\n # join datasets\\n review_user = pd.merge(\\n review, user, on=\\\"user_id\\\",\\n how=\\\"left\\\", suffixes=(\\\"\\\", \\\"_user\\\"))\\n review_user_business = pd.merge(\\n review_user, business, on=\\\"business_id\\\",\\n how=\\\"left\\\", suffixes=(\\\"\\\", \\\"_business\\\"))\\n review_user_business = review_user_business[[\\n 'user_id', 'business_id',\\n 'stars', 'text',\\n 'name', 'average_stars',\\n 'name_business', 'stars_business',\\n 'categories', 'state', 'city']]\\n else:\\n review_user_business = get_input(\\n 'https://www.dropbox.com/s/sj445d95lljuc4p/small_sample.parquet?dl=1'\\n )\\n if round_ratings:\\n # bucketize numeric features to reduce dimensions\\n review_user_business['average_stars'] = review_user_business[\\n 'average_stars'].apply(lambda x: round_of_rating(x))\\n review_user_business['stars_business'] = review_user_business[\\n 'stars_business'].apply(lambda x: round_of_rating(x))\\n return review_user_business\",\n \"def get_examples(data_dir, mode, task_id, shard_id):\\n file_path = get_full_filename(data_dir, mode, task_id, shard_id)\\n relative_path = \\\"/\\\".join(file_path.split(\\\"/\\\")[3:])\\n tf.logging.info(\\\"Reading file: %s\\\" % (file_path))\\n print(relative_path)\\n #client = storage.Client(projectname, credentials=credentials)\\n #bucket = client.get_bucket(bucket_name)\\n blob = storage_bucket.blob(relative_path)\\n if not blob.exists():\\n tf.logging.info(\\\"Path doesn't exist\\\")\\n return None\\n nq_data = extract_nq_data(file_path)\\n tf.logging.info(\\\"NQ data Size: \\\" + str(len(nq_data.keys())))\\n\\n tf.logging.info(\\\"Performing entity extraction\\\")\\n fact_extracted_data = entity_link_nq(nq_data)\\n return fact_extracted_data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6336488","0.6332432","0.62876016","0.61459774","0.6088567","0.60835356","0.60774356","0.6022968","0.59951735","0.59720063","0.5907739","0.59039","0.5902059","0.5858731","0.5857515","0.5839464","0.58262634","0.5805191","0.58041966","0.57704633","0.57674676","0.5767066","0.5766261","0.5759553","0.57582587","0.57571167","0.57490057","0.57382554","0.57279223","0.5722449","0.5709959","0.5692178","0.5681544","0.56654185","0.5651087","0.5640296","0.563061","0.56212485","0.5615587","0.56072974","0.56064963","0.55956215","0.5595126","0.5575869","0.5573429","0.55713856","0.55693847","0.55668473","0.55648386","0.5558488","0.55479443","0.55313534","0.5531296","0.5528395","0.5525999","0.5523614","0.551583","0.55091393","0.5500598","0.5490713","0.54901826","0.54858804","0.548531","0.5482224","0.54811126","0.5478312","0.5477684","0.5476941","0.54704344","0.54673386","0.54673386","0.5446857","0.5440344","0.5438106","0.54326934","0.5424319","0.5422001","0.54059666","0.5405797","0.5404084","0.5402649","0.54010475","0.5397801","0.5385543","0.5384312","0.5377453","0.5375567","0.53743684","0.5374211","0.5371248","0.5369573","0.5365639","0.53631496","0.53561455","0.5351592","0.5351308","0.534976","0.534725","0.5339083","0.53370374","0.5335245"],"string":"[\n \"0.6336488\",\n \"0.6332432\",\n \"0.62876016\",\n \"0.61459774\",\n \"0.6088567\",\n \"0.60835356\",\n \"0.60774356\",\n \"0.6022968\",\n \"0.59951735\",\n \"0.59720063\",\n \"0.5907739\",\n \"0.59039\",\n \"0.5902059\",\n \"0.5858731\",\n \"0.5857515\",\n \"0.5839464\",\n \"0.58262634\",\n \"0.5805191\",\n \"0.58041966\",\n \"0.57704633\",\n \"0.57674676\",\n \"0.5767066\",\n \"0.5766261\",\n \"0.5759553\",\n \"0.57582587\",\n \"0.57571167\",\n \"0.57490057\",\n \"0.57382554\",\n \"0.57279223\",\n \"0.5722449\",\n \"0.5709959\",\n \"0.5692178\",\n \"0.5681544\",\n \"0.56654185\",\n \"0.5651087\",\n \"0.5640296\",\n \"0.563061\",\n \"0.56212485\",\n \"0.5615587\",\n \"0.56072974\",\n \"0.56064963\",\n \"0.55956215\",\n \"0.5595126\",\n \"0.5575869\",\n \"0.5573429\",\n \"0.55713856\",\n \"0.55693847\",\n \"0.55668473\",\n \"0.55648386\",\n \"0.5558488\",\n \"0.55479443\",\n \"0.55313534\",\n \"0.5531296\",\n \"0.5528395\",\n \"0.5525999\",\n \"0.5523614\",\n \"0.551583\",\n \"0.55091393\",\n \"0.5500598\",\n \"0.5490713\",\n \"0.54901826\",\n \"0.54858804\",\n \"0.548531\",\n \"0.5482224\",\n \"0.54811126\",\n \"0.5478312\",\n \"0.5477684\",\n \"0.5476941\",\n \"0.54704344\",\n \"0.54673386\",\n \"0.54673386\",\n \"0.5446857\",\n \"0.5440344\",\n \"0.5438106\",\n \"0.54326934\",\n \"0.5424319\",\n \"0.5422001\",\n \"0.54059666\",\n \"0.5405797\",\n \"0.5404084\",\n \"0.5402649\",\n \"0.54010475\",\n \"0.5397801\",\n \"0.5385543\",\n \"0.5384312\",\n \"0.5377453\",\n \"0.5375567\",\n \"0.53743684\",\n \"0.5374211\",\n \"0.5371248\",\n \"0.5369573\",\n \"0.5365639\",\n \"0.53631496\",\n \"0.53561455\",\n \"0.5351592\",\n \"0.5351308\",\n \"0.534976\",\n \"0.534725\",\n \"0.5339083\",\n \"0.53370374\",\n \"0.5335245\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21496,"cells":{"query":{"kind":"string","value":"Compute and store the QC metrics Runs the QC on the session and stores a map of the metrics for each datapoint for each test, and a map of which datapoints passed for each test"},"document":{"kind":"string","value":"def compute(self, **kwargs):\n if self.extractor is None:\n kwargs['download_data'] = kwargs.pop('download_data', self.download_data)\n self.load_data(**kwargs)\n self.log.info(f\"Session {self.session_path}: Running QC on behavior data...\")\n self.metrics, self.passed = get_bpodqc_metrics_frame(\n self.extractor.data,\n wheel_gain=self.extractor.settings['STIM_GAIN'], # The wheel gain\n photodiode=self.extractor.frame_ttls,\n audio=self.extractor.audio_ttls,\n re_encoding=self.extractor.wheel_encoding or 'X1',\n min_qt=self.extractor.settings.get('QUIESCENT_PERIOD') or 0.2\n )\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def compute(self, download_data=None):\n if self.extractor is None:\n # If download_data is None, decide based on whether eid or session path was provided\n ensure_data = self.download_data if download_data is None else download_data\n self.load_data(download_data=ensure_data)\n self.log.info(f\"Session {self.session_path}: Running QC on habituation data...\")\n\n # Initialize checks\n prefix = '_task_'\n data = self.extractor.data\n metrics = {}\n passed = {}\n\n # Check all reward volumes == 3.0ul\n check = prefix + 'reward_volumes'\n metrics[check] = data['rewardVolume']\n passed[check] = metrics[check] == 3.0\n\n # Check session durations are increasing in steps >= 12 minutes\n check = prefix + 'habituation_time'\n if not self.one or not self.session_path:\n self.log.warning('unable to determine session trials without ONE')\n metrics[check] = passed[check] = None\n else:\n subject, session_date = self.session_path.parts[-3:-1]\n # compute from the date specified\n date_minus_week = (\n datetime.strptime(session_date, '%Y-%m-%d') - timedelta(days=7)\n ).strftime('%Y-%m-%d')\n sessions = self.one.alyx.rest('sessions', 'list', subject=subject,\n date_range=[date_minus_week, session_date],\n task_protocol='habituation')\n # Remove the current session if already registered\n if sessions and sessions[0]['start_time'].startswith(session_date):\n sessions = sessions[1:]\n metric = ([0, data['intervals'][-1, 1] - data['intervals'][0, 0]] +\n [(datetime.fromisoformat(x['end_time']) -\n datetime.fromisoformat(x['start_time'])).total_seconds() / 60\n for x in [self.one.alyx.get(s['url']) for s in sessions]])\n\n # The duration from raw trial data\n # duration = map(float, self.extractor.raw_data[-1]['elapsed_time'].split(':'))\n # duration = timedelta(**dict(zip(('hours', 'minutes', 'seconds'),\n # duration))).total_seconds() / 60\n metrics[check] = np.array(metric)\n passed[check] = np.diff(metric) >= 12\n\n # Check event orders: trial_start < stim on < stim center < feedback < stim off\n check = prefix + 'trial_event_sequence'\n nans = (\n np.isnan(data[\"intervals\"][:, 0]) | # noqa\n np.isnan(data[\"stimOn_times\"]) | # noqa\n np.isnan(data[\"stimCenter_times\"]) |\n np.isnan(data[\"valveOpen_times\"]) | # noqa\n np.isnan(data[\"stimOff_times\"])\n )\n a = np.less(data[\"intervals\"][:, 0], data[\"stimOn_times\"], where=~nans)\n b = np.less(data[\"stimOn_times\"], data[\"stimCenter_times\"], where=~nans)\n c = np.less(data[\"stimCenter_times\"], data[\"valveOpen_times\"], where=~nans)\n d = np.less(data[\"valveOpen_times\"], data[\"stimOff_times\"], where=~nans)\n\n metrics[check] = a & b & c & d & ~nans\n passed[check] = metrics[check].astype(float)\n\n # Check that the time difference between the visual stimulus center-command being\n # triggered and the stimulus effectively appearing in the center is smaller than 150 ms.\n check = prefix + 'stimCenter_delays'\n metric = np.nan_to_num(data[\"stimCenter_times\"] - data[\"stimCenterTrigger_times\"],\n nan=np.inf)\n passed[check] = (metric <= 0.15) & (metric > 0)\n metrics[check] = metric\n\n # Phase check\n check = prefix + 'phase'\n metric = data['phase']\n passed[check] = (metric <= 2 * np.pi) & (metric >= 0)\n metrics[check] = metric\n\n check = prefix + 'phase_distribution'\n metric, _ = np.histogram(data['phase'])\n _, p = chisquare(metric)\n passed[check] = p < 0.05\n metrics[check] = metric\n\n # Checks common to training QC\n checks = [check_goCue_delays, check_stimOn_goCue_delays,\n check_stimOn_delays, check_stimOff_delays]\n for fcn in checks:\n check = prefix + fcn.__name__[6:]\n metrics[check], passed[check] = fcn(data)\n\n self.metrics, self.passed = (metrics, passed)","def qc_metrics(self, files_in, qc_files):\n self.cmd(\"{samtools} index {bam_in}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in=files_in[0],\n ),\n shell=True)\n self.cmd(\"{samtools} idxstats {bam_in} | tee {qc_file}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in = files_in[0],\n qc_file = qc_files[0],\n ),\n shell=True,\n log_output=True)\n self.cmd(\"{samtools} flagstat {bam_in} | tee {qc_file}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in = files_in[0],\n qc_file = qc_files[1],\n ),\n shell=True,\n log_output=True)\n \n self.checkpoint(qc_files[0])\n self.checkpoint(qc_files[1])\n self.checkpoint(qc_files[2])","def compute_session_status(self):\n if self.passed is None:\n raise AttributeError('passed is None; compute QC first')\n # Get mean passed of each check, or None if passed is None or all NaN\n results = {k: None if v is None or np.isnan(v).all() else np.nanmean(v)\n for k, v in self.passed.items()}\n session_outcome, outcomes = self.compute_session_status_from_dict(results)\n return session_outcome, results, outcomes","def get_bpodqc_metrics_frame(data, **kwargs):\n def is_metric(x):\n return isfunction(x) and x.__name__.startswith('check_')\n # Find all methods that begin with 'check_'\n checks = getmembers(sys.modules[__name__], is_metric)\n prefix = '_task_' # Extended QC fields will start with this\n # Method 'check_foobar' stored with key '_task_foobar' in metrics map\n qc_metrics_map = {prefix + k[6:]: fn(data, **kwargs) for k, fn in checks}\n\n # Split metrics and passed frames\n metrics = {}\n passed = {}\n for k in qc_metrics_map:\n metrics[k], passed[k] = qc_metrics_map[k]\n\n # Add a check for trial level pass: did a given trial pass all checks?\n n_trials = data['intervals'].shape[0]\n # Trial-level checks return an array the length that equals the number of trials\n trial_level_passed = [m for m in passed.values()\n if isinstance(m, Sized) and len(m) == n_trials]\n name = prefix + 'passed_trial_checks'\n metrics[name] = reduce(np.logical_and, trial_level_passed or (None, None))\n passed[name] = metrics[name].astype(float) if trial_level_passed else None\n\n return metrics, passed","def metric_tests(self) -> Dict[str, FAIRResultEvaluationCriterium]:\n return self._metric_tests","def run_tests(self):\n\n self.test_report = []\n\n #dict of unsorted lists\n dict_of_un_lists = self.dict_un_lists_intersection_test(self.data_dict)\n self.test_report.append(dict_of_un_lists)\n\n #dict of sets\n dict_of_sets = self.build_dict_of_sets(self.data_dict)\n self.test_report.append(self.dict_sets_intersection_test(dict_of_sets))\n\n #pandas - experimental and probably not the way to use pandas\n # dict_of_pandas = self.build_dict_of_panda_series(self.data_dict)\n # self.test_report.append(self.dicts_any_intersection_node_test(dict_of_pandas))\n\n # print results\n\n if self.verbose:\n self.print_tests_results()","def test_evaluate(self):\n # test normalized by 'bbox_size'\n jhmdb_pck_metric = JhmdbPCKAccuracy(thr=0.5, norm_item='bbox')\n jhmdb_pck_metric.process(self.data_batch, self.data_samples)\n pck_results = jhmdb_pck_metric.evaluate(self.batch_size)\n target = {\n 'Head PCK': 1.0,\n 'Sho PCK': 1.0,\n 'Elb PCK': 1.0,\n 'Wri PCK': 1.0,\n 'Hip PCK': 1.0,\n 'Knee PCK': 1.0,\n 'Ank PCK': 1.0,\n 'PCK': 1.0,\n }\n self.assertDictEqual(pck_results, target)\n\n # test normalized by 'torso_size'\n jhmdb_tpck_metric = JhmdbPCKAccuracy(thr=0.2, norm_item='torso')\n jhmdb_tpck_metric.process(self.data_batch, self.data_samples)\n tpck_results = jhmdb_tpck_metric.evaluate(self.batch_size)\n target = {\n 'Head tPCK': 1.0,\n 'Sho tPCK': 1.0,\n 'Elb tPCK': 1.0,\n 'Wri tPCK': 1.0,\n 'Hip tPCK': 1.0,\n 'Knee tPCK': 1.0,\n 'Ank tPCK': 1.0,\n 'tPCK': 1.0,\n }\n self.assertDictEqual(tpck_results, target)","def qc_metrics(\n data: AnnData,\n mito_prefix: str = \"MT-\",\n min_genes: int = 500,\n max_genes: int = 6000,\n min_umis: int = 100,\n max_umis: int = 600000,\n percent_mito: float = 10.0,\n percent_cells: float = 0.05,\n) -> None:\n\n data.obs[\"passed_qc\"] = False\n\n data.obs[\"n_genes\"] = data.X.getnnz(axis=1)\n data.obs[\"n_counts\"] = data.X.sum(axis=1).A1\n\n mito_prefixes = mito_prefix.split(\",\")\n\n def startswith(name):\n for prefix in mito_prefixes:\n if name.startswith(prefix):\n return True\n return False\n\n mito_genes = data.var_names.map(startswith).values.nonzero()[0]\n data.obs[\"percent_mito\"] = (data.X[:, mito_genes].sum(axis=1).A1 / np.maximum(\n data.obs[\"n_counts\"].values, 1.0\n )) * 100\n\n # Assign passed_qc\n filters = [\n data.obs[\"n_genes\"] >= min_genes,\n data.obs[\"n_genes\"] < max_genes,\n data.obs[\"n_counts\"] >= min_umis,\n data.obs[\"n_counts\"] < max_umis,\n data.obs[\"percent_mito\"] < percent_mito,\n ]\n\n data.obs.loc[np.logical_and.reduce(filters), \"passed_qc\"] = True\n\n var = data.var\n data = data[\n data.obs[\"passed_qc\"]\n ] # compute gene stats in space of filtered cells only\n\n var[\"n_cells\"] = data.X.getnnz(axis=0)\n var[\"percent_cells\"] = (var[\"n_cells\"] / data.shape[0]) * 100\n var[\"robust\"] = var[\"percent_cells\"] >= percent_cells\n var[\"highly_variable_features\"] = var[\n \"robust\"\n ] # default all robust genes are \"highly\" variable","def calc_data(self):\n\n circ_counts = {}\n for trialidx in range(self._ntrials):\n for _, depth in enumerate(self._depths):\n circ_name = 'qv_depth_%d_trial_%d' % (depth, trialidx)\n\n # get the counts form ALL executed circuits\n count_list = []\n for result in self._result_list:\n try:\n count_list.append(result.get_counts(circ_name))\n except (QiskitError, KeyError):\n pass\n\n circ_counts[circ_name] = \\\n build_counts_dict_from_list(count_list)\n\n self._circ_shots[circ_name] = \\\n sum(circ_counts[circ_name].values())\n\n # calculate the heavy output probability\n self._heavy_output_counts[circ_name] = \\\n self._subset_probability(\n self._heavy_outputs[circ_name],\n circ_counts[circ_name])","def compute_metrics(self):\n pass","def collect_data(self):\n exp_conf: ec.ExperimentConfiguration\n # Disabled multiprocess run because of huge memory usage\n processes_number = 1 # self._campaign_configuration['General']['j']\n if processes_number == 1:\n self._logger.info(\"-->Evaluate experiments (sequentially)\")\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\n exp_conf.evaluate()\n if bool(self._campaign_configuration['General']['generate_plots']):\n exp_conf.generate_plots()\n self._logger.info(\"<--\")\n else:\n self._logger.info(\"-->Evaluate experiments (in parallel)\")\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\n if bool(self._campaign_configuration['General']['generate_plots']):\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\n self._logger.info(\"<--\")\n\n self.raw_results = {}\n for exp_conf in self._exp_confs:\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes","def get_test_cases_coverage(session_id):\n tc_stats={}\n tc_stats_list=[]\n total_executed=0\n sql='SELECT DISTINCT(test_id) FROM stats WHERE session_id=:sid AND test_id!=\"null\"'\n params={\"sid\":session_id}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n tests=c.fetchall()\n conn.close()\n if len(tests)>0:\n for t in tests:\n total_executed=0\n sql=\"SELECT DISTINCT(file_id) FROM stats WHERE session_id=:sid AND test_id=:tid\"\n params={\"sid\":session_id,\"tid\":t[0]}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n files=c.fetchall()\n conn.close()\n for f in files:\n line_count=get_executable_lines_count_for_file(f[0])\n # get executions\n sql=\"SELECT COUNT(DISTINCT line_guid) FROM stats WHERE session_id= :sid AND file_id= :fid AND test_id=:tid\"\n params={\"sid\":session_id,\"tid\":t[0],\"fid\":f[0]}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n executed=c.fetchone()\n conn.close()\n total_executed+=executed[0]\n # save test case and it's executions\n tc_stats={}\n tc_stats[\"test_id\"]=t[0]\n tc_stats[\"total_executed\"]=total_executed\n tc_stats[\"total_executed\"]\n \n tc_stats_list.append(tc_stats)\n return tc_stats_list","def mgcEval(self):\n import numpy as np\n def report_to_df(report):\n\n \"\"\"\n function to convert classification report to dataframe (for visualisation plot)\n \"\"\"\n\n report = re.sub(r\" +\", \" \", report).replace(\"avg / total\", \"avg/total\").replace(\"\\n \", \"\\n\")\n # update this due to sklearn classification report output change\n report = re.sub(r\" +\", \" \", report).replace(\"micro avg\", \"micro_avg\").replace(\"macro avg\", \"macro_avg\").replace(\"weighted avg\", \"weighted_avg\").replace(\"\\n \", \"\\n\")\n report_df = pd.read_csv(StringIO(\"Classes\" + report), sep=' ', index_col=0) \n return(report_df)\n \n #txt report to df\n class_rpttop1 = classification_report(self.y_true, self.y_pred)\n df_report = report_to_df(class_rpttop1)\n\n df_report = df_report.iloc[:self.nb_classes, :].copy()\n df_report.index = df_report.index.astype(int)\n \n\n # classifier prediction metrics\n def classMetrics(averagex):\n precision, recall, fscore, support = score(self.y_true, self.y_pred, average=averagex)\n \n return(\n print(''), \n print('-------------{0:}--------------------'.format(averagex)), \n print('precision: {0:.4f}'.format(precision)),\n print('recall: {0:.4f}'.format(recall)),\n print('fscore: {0:.4f}'.format(fscore)),\n print(''),\n print('kappa score: {0:.4f}'.format(cohen_kappa_score(self.y_true, self.y_pred))),\n print('accuracy score: {0:.4f}'.format(accuracy_score(self.y_true, self.y_pred))))\n \n def predSamp():\n\n correct = np.nonzero(self.y_pred==self.y_true)[0]\n incorrect = np.nonzero(self.y_pred!=self.y_true)[0]\n\n # quick check of the number of correct prediction from validation set\n print(\"\")\n print(\"correct/total = {0: .4f}\".format(len(correct)/(len(correct)+len(incorrect))))\n print(\"total correct sample = {0: .0f}\".format(len(correct)))\n print('------------------------------------------------------------------')\n \n def classReport():\n print('----------------------------- Classfication Report -------------------------------')\n print(classification_report(pd.Series(self.y_true).map(self.dict_label), pd.Series(self.y_pred).map(self.dict_label)))\n \n self.class_rpt = pd.concat([pd.DataFrame(pd.Series(df_report.index.tolist()).map(self.dict_label), columns = ['label']), df_report], axis = 1)\n \n self.classMetricsMac = classMetrics(\"macro\")\n self.classMetricsMic = classMetrics(\"micro\")\n self.predSample = predSamp()\n self.class_rptTop1 = classReport()\n \n return self","def calculate_dataset_metrics(self):\n pass","def run_tests():\n with open(FILENAME) as file:\n # Loads testing parameters from the yaml file.\n tests = yaml.safe_load(file)\n\n # create a dataframe to keep the results\n test_dict = tests['Tests']\n results = pd.DataFrame(test_dict)\n results['Last Average Score'] = \"\"\n results['No of Q-Learning episodes'] = \"\"\n\n # run experiments:\n for i, test in enumerate(test_dict):\n grid = Rooms(test[\"env_size\"], testing=True)\n learning = QLearning(grid, test[\"gamma\"], test[\"alpha\"], test[\"agent_start_pos\"])\n e_greedy = Policy(\"e-greedy\", test[\"epsilon\"], test[\"decay\"])\n greedy = Policy(policy_type=\"greedy\")\n experiment = Experiments(grid, learning, greedy, test[\"iters\"],\n test[\"agent_start_pos\"], test[\"test_no\"])\n\n for session in range(test[\"iters\"]):\n learning.run_multiple_episodes(test[\"batch_episodes\"], e_greedy)\n mean_reward = experiment.run_experiments(test[\"exp_per_batch\"])\n\n results.loc[i,'Last Average Score'] = mean_reward\n results.loc[i,'No of Q-Learning episodes'] = (session + 1) * test[\"batch_episodes\"]\n\n # save results to csv file\n filename = 'results/' + 'test_table.csv'\n results.to_csv(filename)\n\n # plot & save graphs\n experiment.generate_results(test[\"test_no\"], test)\n\n return results","def test_evaluate(self):\n # test normalized by 'bbox'\n pck_metric = PCKAccuracy(thr=0.5, norm_item='bbox')\n pck_metric.process(self.data_batch, self.data_samples)\n pck = pck_metric.evaluate(self.batch_size)\n target = {'PCK': 1.0}\n self.assertDictEqual(pck, target)\n\n # test normalized by 'head_size'\n pckh_metric = PCKAccuracy(thr=0.3, norm_item='head')\n pckh_metric.process(self.data_batch, self.data_samples)\n pckh = pckh_metric.evaluate(self.batch_size)\n target = {'PCKh': 1.0}\n self.assertDictEqual(pckh, target)\n\n # test normalized by 'torso_size'\n tpck_metric = PCKAccuracy(thr=0.05, norm_item=['bbox', 'torso'])\n tpck_metric.process(self.data_batch, self.data_samples)\n tpck = tpck_metric.evaluate(self.batch_size)\n self.assertIsInstance(tpck, dict)\n target = {\n 'PCK': 1.0,\n 'tPCK': 1.0,\n }\n self.assertDictEqual(tpck, target)","def initialize_metrics():\n metrics = {\n 'cd_losses': [],\n 'cd_corrects': [],\n 'cd_precisions': [],\n 'cd_recalls': [],\n 'cd_f1scores': [],\n }\n\n return metrics","def run_tests(self, validate=False):\n fitness = 0\n\n for test_set in [self.debugger.PASS, self.debugger.FAIL]:\n passed = self.run_test_set(test_set, validate=validate)\n ratio = passed / len(self.debugger.collectors[test_set])\n fitness += self.weight(test_set) * ratio\n\n return fitness","def run_test(self):\n self.output_analytics = self.run_inference()\n self.output_df = pd.DataFrame(self.output_analytics)","def compute_metrics(self, results: list) -> dict:","def evaluate_benchmarks(self):\n\n # iterate over replicates\n results = {}\n for replicate_id, replicate in self.replicates:\n\n # evaluate benchmark for current replicate\n bmark = SimulationBenchmark(replicate.copy(),\n graph=self.graphs[replicate_id],\n **self.params)\n\n # store results\n results[replicate_id] = dict(\n\n labels_MAE=bmark.scores['labels'].MAE,\n level_only_MAE=bmark.scores['level_only'].MAE,\n spatial_only_MAE=bmark.scores['spatial_only'].MAE,\n community_MAE=bmark.scores['labels_comm'].MAE,\n\n labels_PCT=bmark.scores['labels'].percent_correct,\n level_only_PCT=bmark.scores['level_only'].percent_correct,\n spatial_only_PCT=bmark.scores['spatial_only'].percent_correct,\n community_PCT=bmark.scores['labels_comm'].percent_correct)\n\n # compile dataframe\n results = pd.DataFrame.from_dict(results, orient='index')\n results.index.set_names(self.multiindex, inplace=True)\n\n return results","def _calculate_metrics(self):\n metrics = {}\n precision, recall = self.calc_precision_recall()\n metrics[\"precision\"] = precision\n metrics[\"recall\"] = recall\n metrics[\"entropy\"] = self.calc_entropy()\n metrics[\"component_entropy\"] = self.calc_component_entropy()\n metrics[\"num_comps\"] = len(self.get_components())\n metrics[\"num_diagnoses\"] = len(self.diagnoses)\n metrics[\"distinct_diagnoses_scores\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\n metrics[\"num_tests\"] = len(self.get_tests())\n metrics[\"num_distinct_traces\"] = len(self.get_distinct_traces())\n metrics[\"num_failed_tests\"] = len(self._get_tests_by_error(1))\n metrics[\"num_passed_tests\"] = len(self._get_tests_by_error(0))\n passed_comps = set(self._get_components_by_error(0))\n failed_comps = set(self.get_components_in_failed_tests())\n metrics[\"num_failed_comps\"] = len(failed_comps)\n metrics[\"only_failed_comps\"] = len(failed_comps - passed_comps)\n metrics[\"only_passed_comps\"] = len(passed_comps - failed_comps)\n metrics[\"num_bugs\"] = len(self.get_bugs())\n metrics[\"wasted\"] = self.calc_wasted_components()\n metrics[\"top_k\"] = self.calc_top_k()\n metrics[\"num_comps_in_diagnoses\"] = len(self._get_comps_in_diagnoses())\n metrics[\"bugs_cover_ratio\"] = self._get_bugs_cover_ratio()\n metrics[\"average_trace_size\"] = self._get_average_trace_size()\n metrics[\"average_component_activity\"] = self._get_average_component_activity()\n metrics[\"average_diagnosis_size\"] = self._get_average_diagnosis_size()\n metrics[\"bugs_scores_average\"], metrics[\"bugs_scores_std\"], metrics[\"bugs_scores_entropy\"] = self._get_bugs_scores()\n metrics[\"non_bugs_scores_average\"], metrics[\"non_bugs_scores_std\"], metrics[\"non_bugs_scores_entropy\"] = self._get_non_bugs_scores()\n metrics.update(self.cardinality())\n # metrics[\"ochiai\"] = self.calc_ochiai_values()\n return metrics","def run_tests():\n with open(FILENAME) as file:\n\n # Loads the test hyper-parameters as dictionaries.\n tests = yaml.safe_load(file)\n \n # create a dataframe to keep the results\n test_dict = tests['Tests']\n results = pd.DataFrame(test_dict)\n results[\"Episode\"] = \"\"\n results['Max average score'] = \"\"\n\n for i, test in enumerate(tests['Tests']):\n\n env = gym.make(test['env'])\n env.reset()\n\n actor_critic = ActorCritic(env, test['episodes'], test['max_score'], \n test['hidden_size'], test['gamma'], test['save'])\n\n ## run training \n best_score, episode, rew_hist = actor_critic.train()\n\n results.loc[i,'Episode'] = episode\n results.loc[i,'Max average score'] = best_score\n\n plot_graphs(test, rew_hist)\n\n # save results to csv file\n filename = 'results/' + 'test_table.csv'\n results.to_csv(filename)\n\n return results","def evaluate(self):\n results = dict()\n for metric in self.metrics:\n print('Evaluating clustering with metric %s' % metric)\n if metric in LABEL_METRICS.keys():\n results[metric] = LABEL_METRICS[metric](self.X, self.model.labels_)\n results['adjusted_rand_score'] = SCORE_METRICS['adjusted_rand_score'](self.Y[:, 0], self.model.labels_)\n self.results = results\n return results","def evaluate(self, test):\r\n self.logger.info(\"Testing model over test set\")\r\n metrics = self.run_evaluate(test)\r\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\r\n for k, v in metrics.items()])\r\n self.logger.info(msg)\r\n return metrics","def make_metrics(self):\n num_batches = self.data_loader.number_of_batches()\n dose_score_vec = np.zeros(num_batches)\n\n # Only make calculations if data_loader is not empty\n if not self.data_loader.file_paths_list:\n print('No patient information was given to calculate metrics')\n else:\n # Change batch size to 1\n self.data_loader.batch_size = 1 # Loads data related to ground truth patient information\n if self.dose_loader is not None:\n self.dose_loader.batch_size = 1 # Loads data related to ground truth patient information\n\n for idx in tqdm.tqdm(range(num_batches)):\n # Get roi masks for patient\n self.get_constant_patient_features(idx)\n # Get dose tensors for reference dose and evaluate criteria\n reference_dose = self.get_patient_dose_tensor(self.data_loader)\n if reference_dose is not None:\n self.reference_dose_metric_df = self.calculate_metrics(self.reference_dose_metric_df, reference_dose)\n # If a dose loader was provided, calculate the score\n if self.dose_loader is not None:\n new_dose = self.get_patient_dose_tensor(self.dose_loader)\n # Make metric data frames\n self.new_dose_metric_df = self.calculate_metrics(self.new_dose_metric_df, new_dose)\n # Evaluate mean absolute error of 3D dose\n dose_score_vec[idx] = np.sum(np.abs(reference_dose - new_dose)) / np.sum(self.possible_dose_mask)\n # Save metrics at the patient level (this is a template for how DVH stream participants could save\n # their files\n # self.dose_metric_df.loc[self.patient_list[0]].to_csv('{}.csv'.format(self.patient_list[0]))\n\n if self.dose_loader is not None:\n dvh_score = np.nanmean(np.abs(self.reference_dose_metric_df - self.new_dose_metric_df).values)\n dose_score = dose_score_vec.mean()\n return dvh_score, dose_score\n else:\n print('No new dose provided. Metrics were only calculated for the provided dose.')","def run_faqc(self, **kwargs):\n if self.qc is True:\n build([FaQC.SummarizeQC(fastq_dic=self.fastq_dic,\n num_cpus=self.num_cpus,\n workdir=self.workdir)],\n local_scheduler=self.local_scheduler,\n workers=1)\n qc_dic = {}\n for samp, path in self.fastq_dic.items():\n trim_dir = os.path.join(self.workdir, \"processes\", \"qc\", samp)\n qc_dic[samp] = trim_dir + \"/\" + samp + \".1.trimmed.fastq\" + \":\" + \\\n trim_dir + \"/\" + samp + \".2.trimmed.fastq\" \n return qc_dic\n\n else:\n return self.fastq_dic","def calculate_metrics(self):\n self.data_stats = self.sqlContext.read.format(\"org.apache.spark.sql.cassandra\").options(table=self.cassandra_trip_table, keyspace=self.cassandra_keyspace).load()\n self.data_stats = self.data_stats.groupBy(['time_block','day','month','borough_name']).agg(func.avg('num_trips').alias('mean'))","def evaluate_data():\n try:\n # General system related info\n ram = psutil.virtual_memory()\n total_ram = round((ram.total / 1024 / 1024),2)\n free_ram = round((ram.available / 1024 / 1024),2)\n used_ram = round((ram.used / 1024 / 1024),2)\n cpu_total = psutil.cpu_count(logical=True)\n cpu_loadavg = round([x / cpu_total * 100 for x in psutil.getloadavg()][0],2)\n acs_8080 = sp.getoutput(\"netstat -an|grep -c 8080\")\n acs_8181 = sp.getoutput(\"netstat -an|grep -c 8181\")\n acs_8443 = sp.getoutput(\"netstat -an|grep -c 8443\")\n mysql = sp.getoutput(\"netstat -an|grep -c 3306\")\n oracle = sp.getoutput(\"netstat -an|grep -c 1521\")\n logging.info('General system info obtained')\n except Exception as e:\n logging.exception(f\"EXCEPTION: {e} \\n Full stack trace: \\n\", exc_info=1)\n # Process specific details\n try:\n iis_pid = SystemInformation.get_pid(\"w3wp.exe\")\n iis_ram = SystemInformation.get_ram_usage(iis_pid)\n iis_cpu = SystemInformation.get_cpu_usage(iis_pid)\n java_pid = SystemInformation.get_pid(\"java.exe\")\n java_ram = SystemInformation.get_ram_usage(java_pid)\n java_cpu = SystemInformation.get_cpu_usage(java_pid)\n mysqld_pid = SystemInformation.get_pid(\"mysqld.exe\")\n mysqld_ram = SystemInformation.get_ram_usage(mysqld_pid) \n mysqld_cpu = SystemInformation.get_cpu_usage(mysqld_pid)\n except Exception as e:\n logging.exception(f\"EXCEPTION: {e} \\n Full stack trace: \\n\", exc_info=1)\n\n try:\n dictionary = {}\n now = datetime.datetime.now()\n timestampt = now.strftime(\"%Y-%m-%d-%H:%M:%S\")\n fieldnames = ['timestampt','total_ram','free_ram','used_ram','cpu_total','cpu_loadavg','acs_8080','acs_8181','acs_8443','mysql','oracle','iis_ram','iis_cpu','java_ram','java_cpu','mysqld_ram','mysqld_cpu']\n for var in fieldnames:\n dictionary[var] = eval(var)\n \n logging.info('Data for report generated')\n return dictionary\n except Exception as e:\n logging.exception(f\"EXCEPTION: {e} \\n Full stack trace: \\n\", exc_info=1)","def _cv_results(self, metrics):\n\n param_keys = self.param_combs[0].keys()\n param_dict = {k: [comb[k] for comb in self.param_combs]\n for k in param_keys}\n df_metric_result = {k: pd.DataFrame({'Metric mean': self.mean[k],\n 'Std. dev.': self.std[k],\n **param_dict})\n for k in metrics.keys()}\n self.cv_results_ = df_metric_result","def execute_testsets(testsets):\n group_results = dict() #results, by group\n group_failure_counts = dict()\n total_failures = 0\n myinteractive = False\n\n for testset in testsets:\n mytests = testset.tests\n myconfig = testset.config\n mybenchmarks = testset.benchmarks\n\n #Make sure we actually have tests to execute\n if not mytests and not mybenchmarks:\n # no tests in this test set, probably just imports.. skip to next test set\n break\n\n myinteractive = True if myinteractive or myconfig.interactive else False\n\n #Run tests, collecting statistics as needed\n for test in mytests:\n #Initialize the dictionaries to store test fail counts and results\n if test.group not in group_results:\n group_results[test.group] = list()\n group_failure_counts[test.group] = 0\n\n result = run_test(test, test_config = myconfig)\n result.body = None # Remove the body, save some memory!\n\n if not result.passed: #Print failure, increase failure counts for that test group\n logging.error('Test Failed: '+test.name+\" URL=\"+test.url+\" Group=\"+test.group+\" HTTP Status Code: \"+str(result.response_code))\n\n if test.validators is not None:\n for validator in test.validators:\n if validator.passed == False:\n logging.warning(\" Validation Failed: \" + str(validator))\n\n #Increment test failure counts for that group (adding an entry if not present)\n failures = group_failure_counts[test.group]\n failures = failures + 1\n group_failure_counts[test.group] = failures\n\n else: #Test passed, print results\n logging.info('Test Succeeded: '+test.name+\" URL=\"+test.url+\" Group=\"+test.group)\n\n #Add results for this test group to the resultset\n group_results[test.group].append(result)\n\n # handle stop_on_failure flag\n if not result.passed and test.stop_on_failure is not None and test.stop_on_failure:\n print 'STOP ON FAILURE! stopping test set execution, continuing with other test sets'\n break\n\n for benchmark in mybenchmarks: # Run benchmarks, analyze, write\n if not benchmark.metrics:\n logging.debug('Skipping benchmark, no metrics to collect')\n continue\n\n logging.info(\"Benchmark Starting: \"+benchmark.name+\" Group: \"+benchmark.group)\n curl = configure_curl(benchmark, myconfig)\n benchmark_result = run_benchmark(curl, benchmark, myconfig)\n print benchmark_result\n logging.info(\"Benchmark Done: \"+benchmark.name+\" Group: \"+benchmark.group)\n\n if benchmark.output_file: # Write file\n write_method = OUTPUT_METHODS[benchmark.output_format]\n my_file = open(benchmark.output_file, 'w') # Overwrites file\n logging.debug(\"Benchmark writing to file: \" + benchmark.output_file)\n write_method(my_file, benchmark_result, benchmark, test_config = myconfig)\n my_file.close()\n\n if myinteractive:\n # a break for when interactive bits are complete, before summary data\n print \"===================================\"\n\n #Print summary results\n for group in sorted(group_results.keys()):\n test_count = len(group_results[group])\n failures = group_failure_counts[group]\n total_failures = total_failures + failures\n if (failures > 0):\n print u'Test Group '+group+u' FAILED: '+ str((test_count-failures))+'/'+str(test_count) + u' Tests Passed!'\n else:\n print u'Test Group '+group+u' SUCCEEDED: '+ str((test_count-failures))+'/'+str(test_count) + u' Tests Passed!'\n\n return total_failures","def execute(self, context):\n redshift_hook = PostgresHook(postgres_conn_id=self.redshift_conn_id)\n\n for data_check in self.data_checks:\n records = redshift_hook.get_records(data_check[\"sql\"])\n num_records = records[0][0]\n\n assert (num_records != data_check[\"expected_result\"]) , \\\n f\"Data quality test returned unexpected result.\"\n\n self.log.info('DataQualityOperator not implemented yet')","def metrics(self):\n raise NotImplementedError(\"metrics\")","def do_system_evaluation(dataset, result_path, dataset_evaluation_mode='folds'):\n\n # Set warnings off, sklearn metrics will trigger warning for classes without\n # predicted samples in F1-scoring. This is just to keep printing clean.\n warnings.simplefilter(\"ignore\")\n\n overall_metrics_per_scene = {}\n\n for scene_id, scene_label in enumerate(dataset.scene_labels):\n if scene_label not in overall_metrics_per_scene:\n overall_metrics_per_scene[scene_label] = {}\n\n dcase2016_segment_based_metric = DCASE2016_EventDetection_SegmentBasedMetrics(class_list=dataset.event_labels(scene_label=scene_label))\n dcase2016_event_based_metric = DCASE2016_EventDetection_EventBasedMetrics(class_list=dataset.event_labels(scene_label=scene_label))\n\n for fold in dataset.folds(mode=dataset_evaluation_mode):\n results = []\n result_filename = get_result_filename(fold=fold, scene_label=scene_label, path=result_path)\n\n if os.path.isfile(result_filename):\n with open(result_filename, 'rt') as f:\n for row in csv.reader(f, delimiter='\\t'):\n results.append(row)\n else:\n raise IOError(\"Result file not found [%s]\" % result_filename)\n\n for file_id, item in enumerate(dataset.test(fold, scene_label=scene_label)):\n current_file_results = []\n for result_line in results:\n if len(result_line) != 0 and result_line[0] == dataset.absolute_to_relative(item['file']):\n current_file_results.append(\n {'file': result_line[0],\n 'event_onset': float(result_line[1]),\n 'event_offset': float(result_line[2]),\n 'event_label': result_line[3].rstrip()\n }\n )\n meta = dataset.file_meta(dataset.absolute_to_relative(item['file']))\n\n dcase2016_segment_based_metric.evaluate(system_output=current_file_results, annotated_ground_truth=meta)\n dcase2016_event_based_metric.evaluate(system_output=current_file_results, annotated_ground_truth=meta)\n\n overall_metrics_per_scene[scene_label]['segment_based_metrics'] = dcase2016_segment_based_metric.results()\n overall_metrics_per_scene[scene_label]['event_based_metrics'] = dcase2016_event_based_metric.results()\n\n print \" Evaluation over %d folds\" % dataset.fold_count\n print \" \"\n print \" Results per scene \"\n print \" {:18s} | {:5s} | | {:39s} \".format('', 'Main', 'Secondary metrics')\n print \" {:18s} | {:5s} | | {:38s} | {:14s} | {:14s} | {:14s} \".format('', '', 'Seg/Overall','Seg/Class', 'Event/Overall','Event/Class')\n print \" {:18s} | {:5s} | | {:6s} : {:5s} : {:5s} : {:5s} : {:5s} | {:6s} : {:5s} | {:6s} : {:5s} | {:6s} : {:5s} |\".format('Scene', 'ER', 'F1', 'ER', 'ER/S', 'ER/D', 'ER/I', 'F1', 'ER', 'F1', 'ER', 'F1', 'ER')\n print \" -------------------+-------+ +--------+-------+-------+-------+-------+--------+-------+--------+-------+--------+-------+\"\n averages = {\n 'segment_based_metrics': {\n 'overall': {\n 'ER': [],\n 'F': [],\n },\n 'class_wise_average': {\n 'ER': [],\n 'F': [],\n }\n },\n 'event_based_metrics': {\n 'overall': {\n 'ER': [],\n 'F': [],\n },\n 'class_wise_average': {\n 'ER': [],\n 'F': [],\n }\n },\n }\n for scene_id, scene_label in enumerate(dataset.scene_labels):\n print \" {:18s} | {:5.2f} | | {:4.1f} % : {:5.2f} : {:5.2f} : {:5.2f} : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} |\".format(scene_label,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['F'] * 100,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['S'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['D'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['I'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F']*100,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'],\n overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['F']*100,\n overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['ER'],\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F']*100,\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'],\n )\n averages['segment_based_metrics']['overall']['ER'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'])\n averages['segment_based_metrics']['overall']['F'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['F'])\n averages['segment_based_metrics']['class_wise_average']['ER'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'])\n averages['segment_based_metrics']['class_wise_average']['F'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F'])\n averages['event_based_metrics']['overall']['ER'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['ER'])\n averages['event_based_metrics']['overall']['F'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['F'])\n averages['event_based_metrics']['class_wise_average']['ER'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'])\n averages['event_based_metrics']['class_wise_average']['F'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F'])\n\n print \" -------------------+-------+ +--------+-------+-------+-------+-------+--------+-------+--------+-------+--------+-------+\"\n print \" {:18s} | {:5.2f} | | {:4.1f} % : {:5.2f} : {:21s} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} |\".format('Average',\n numpy.mean(averages['segment_based_metrics']['overall']['ER']),\n numpy.mean(averages['segment_based_metrics']['overall']['F'])*100,\n numpy.mean(averages['segment_based_metrics']['overall']['ER']),\n ' ',\n numpy.mean(averages['segment_based_metrics']['class_wise_average']['F'])*100,\n numpy.mean(averages['segment_based_metrics']['class_wise_average']['ER']),\n numpy.mean(averages['event_based_metrics']['overall']['F'])*100,\n numpy.mean(averages['event_based_metrics']['overall']['ER']),\n numpy.mean(averages['event_based_metrics']['class_wise_average']['F'])*100,\n numpy.mean(averages['event_based_metrics']['class_wise_average']['ER']),\n )\n\n print \" \"\n # Restore warnings to default settings\n warnings.simplefilter(\"default\")\n print \" Results per events \"\n\n for scene_id, scene_label in enumerate(dataset.scene_labels):\n print \" \"\n print \" \"+scene_label.upper()\n print \" {:20s} | {:30s} | | {:15s} \".format('', 'Segment-based', 'Event-based')\n print \" {:20s} | {:5s} : {:5s} : {:6s} : {:5s} | | {:5s} : {:5s} : {:6s} : {:5s} |\".format('Event', 'Nref', 'Nsys', 'F1', 'ER', 'Nref', 'Nsys', 'F1', 'ER')\n print \" ---------------------+-------+-------+--------+-------+ +-------+-------+--------+-------+\"\n seg_Nref = 0\n seg_Nsys = 0\n\n event_Nref = 0\n event_Nsys = 0\n for event_label in sorted(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise']):\n print \" {:20s} | {:5d} : {:5d} : {:4.1f} % : {:5.2f} | | {:5d} : {:5d} : {:4.1f} % : {:5.2f} |\".format(event_label,\n int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nref']),\n int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nsys']),\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['F']*100,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['ER'],\n int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nref']),\n int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nsys']),\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['F']*100,\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['ER'])\n seg_Nref += int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nref'])\n seg_Nsys += int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nsys'])\n\n event_Nref += int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nref'])\n event_Nsys += int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nsys'])\n print \" ---------------------+-------+-------+--------+-------+ +-------+-------+--------+-------+\"\n print \" {:20s} | {:5d} : {:5d} : {:14s} | | {:5d} : {:5d} : {:14s} |\".format('Sum',\n seg_Nref,\n seg_Nsys,\n '',\n event_Nref,\n event_Nsys,\n '')\n print \" {:20s} | {:5s} {:5s} : {:4.1f} % : {:5.2f} | | {:5s} {:5s} : {:4.1f} % : {:5.2f} |\".format('Average',\n '', '',\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F']*100,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'],\n '', '',\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F']*100,\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'])\n print \" \"","def compute_statistics(self):","def evaluate(self, test):\n self.logger.info(\"Testing model over test set\")\n metrics = self.run_evaluate(test)\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\n for k, v in metrics.items()])\n self.logger.info(msg)\n return metrics","def evaluate(self, dataset):\n logging.info('Start evaluation')\n\n loss, predictions, labels = self.run_one_epoch(dataset, RunnerPhase.VALIDATE)\n\n metrics_dict = self.metric_class.get_metrics_dict(predictions, labels)\n\n eval_info = self.metric_class.metrics_dict_to_str(metrics_dict)\n\n logging.info(eval_info)\n\n logging.info('Evaluation finished')\n\n return metrics_dict","def compute_metrics(self, train_data, test_data, criterion):\n m = self.metrics\n warnings.filterwarnings('ignore','Mean of empty slice')\n\n ## load data\n trn, trn_labs = train_data\n tst, tst_labs = test_data\n\n # trn = trn.transpose(1,0)\n tst = tst.transpose(1,0)\n\n t_final = -(np.flipud(trn!=self.padding).argmax(0)+1)\n test_tfinal = -(np.flipud(tst!=self.padding).argmax(0)+1)\n\n ntest = tst.size(1)\n P = self.decoder.out_features\n\n ## training data ###########################################################\n # hidden = self.init_hidden(trn.size(1))\n # out, hidden = self.transparent_forward(trn, hidden)\n # # output = out[t_final, np.arange(trn.size(1)), :]\n # output = out.squeeze()\n # # compute orthogonality\n # mem_act = np.array([np.cumsum(trn==p,axis=0).int().detach().numpy() % 2 \\\n # for p in range(self.q_)]).transpose((1,2,0))\n\n # ps_clf = LinearDecoder(self, 2**(self.q_-1), MeanClassifier)\n # ps = []\n # for d in Dichotomies(mem_act, 'simple'):\n # np.warnings.filterwarnings('ignore',message='invalid value encountered in')\n # ps_clf.fit(hidden.detach().numpy(), d)\n # new_ps = ps_clf.orthogonality()\n # ps.append(new_ps)\n # # if new_ps > ps:\n # # ps = new_ps\n # m['train_parallelism'] = np.append(m['train_parallelism'], np.array(ps).T, axis=0)\n\n # # print(mem_act.shape)\n # # print(hidden.shape)\n # # self.orth_clf.fit(hidden.detach().numpy(), mem_act)\n # # orth_score = self.orth_clf.orthogonality()\n # # m['train_orthogonality'] = np.append(m['train_orthogonality'], orth_score)\n\n ## test data ##############################################################\n hidden = self.init_hidden(tst.size(1))\n out, hidden = self.transparent_forward(tst, hidden)\n # output = out.squeeze()\n # print(hidden.shape)\n # print(out.shape)\n # print(test_tfinal)\n output = out[test_tfinal, np.arange(tst.size(1)), :]\n # raise Exception\n\n # compute loss\n test_loss = criterion(output.squeeze(0),tst_labs.squeeze())\n\n m['test_loss'] = np.append(m['test_loss'], test_loss.item())\n\n # compute orthogonality\n # mem_act = np.array([np.cumsum(tst==p,axis=0).int().detach().numpy() % 2 \\\n # for p in range(self.q_)]).transpose((1,2,0))\n\n # # self.orth_clf.fit(hidden.detach().numpy(), mem_act)\n # # orth_score = self.orth_clf.orthogonality()\n # # m['test_orthogonality'] = np.append(m['test_orthogonality'], orth_score)\n\n # # compute parallelism\n # ps_clf = LinearDecoder(self, 2**(self.q_-1), MeanClassifier)\n # ps = []\n # for d in Dichotomies(mem_act, 'simple'):\n # np.warnings.filterwarnings('ignore',message='invalid value encountered in')\n # ps_clf.fit(hidden.detach().numpy(), d)\n # new_ps = ps_clf.orthogonality()\n # ps.append(new_ps)\n # # if new_ps > ps:\n # # ps = new_ps\n # m['test_parallelism'] = np.append(m['test_parallelism'], np.array(ps).T, axis=0)\n\n ## package #################################################################\n self.metrics = m\n warnings.filterwarnings('default')","def test_get_qc_metrics(integrated_ff):\n\n key, ff_env = integrated_ff['ff_key'], integrated_ff['ff_env']\n uuid = '331106bc-8535-3338-903e-854af460b544'\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, key=key, ff_env=ff_env)\n assert len(qc_metrics.keys()) == 1\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\n target_qc = qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']\n assert 'QualityMetric' in target_qc['values']['@type']\n assert target_qc['organism'] == 'human'\n assert target_qc['experiment_type'] == 'Dilution Hi-C'\n assert target_qc['experiment_subclass'] == 'Hi-C'\n assert target_qc['source_file_association'] == 'processed_files'\n assert target_qc['source_experiment'] == '4DNEXO67APV1'\n assert target_qc['source_experimentSet'] == '4DNESOPFAAA1'\n assert target_qc['biosource_summary'] == \"GM12878\"\n\n kwargs = { # do same as above w/ kwargs, specify to include raw files this time\n 'key': key,\n 'ff_env': ff_env,\n 'include_raw_files': True\n }\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, **kwargs)\n assert len(qc_metrics.keys()) == 2\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\n assert '4c9dabc6-61d6-4054-a951-c4fdd0023800' in qc_metrics\n assert 'QualityMetric' in qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']['values']['@type']\n assert 'QualityMetric' in qc_metrics['4c9dabc6-61d6-4054-a951-c4fdd0023800']['values']['@type']","def compute_statistics(self):\n for i in range(len(self.wine_matrix[0, :])):\n feature = self.wine_matrix[:, i]\n self.wine_stats['feature ' + str(i)] = {}\n if i == 11: # results column\n self.wine_stats['feature ' + str(i)]['positive_class_ratio'] = (feature == 1).sum() / len(feature)\n null, self.wine_stats['feature ' + str(i)]['pvalue'] = stats.normaltest(feature)\n\n # plot\n # pyplot.hist(feature, bins=50)\n # pyplot.show()\n\n for i in range(len(self.cancer_matrix[0, :])):\n feature = self.cancer_matrix[:, i]\n self.cancer_stats['feature ' + str(i)] = {}\n if i == 10: # results column\n self.cancer_stats['feature ' + str(i)]['positive_class_ratio'] = (feature == 1).sum() / len(feature)\n null, self.cancer_stats['feature ' + str(i)]['pvalue'] = stats.normaltest(feature)\n\n # plot\n # pyplot.hist(feature, bins=50)\n # pyplot.show()","def _run():\n subprocess.check_call(\n [\n \"tools/bazel\",\n \"build\",\n \"-c\",\n \"opt\",\n \"test/core/memory_usage/memory_usage_test\",\n ]\n )\n ret = {}\n for name, benchmark_args in _BENCHMARKS.items():\n for scenario, extra_args in _SCENARIOS.items():\n # TODO(chenancy) Remove when minstack is implemented for channel\n if name == \"channel\" and scenario == \"minstack\":\n continue\n try:\n output = subprocess.check_output(\n [\n \"bazel-bin/test/core/memory_usage/memory_usage_test\",\n ]\n + benchmark_args\n + extra_args\n )\n except subprocess.CalledProcessError as e:\n print(\"Error running benchmark:\", e)\n continue\n for line in output.splitlines():\n for key, (pattern, conversion) in _INTERESTING.items():\n m = re.match(pattern, line)\n if m:\n ret[scenario + \": \" + key] = conversion(m.group(1))\n return ret","def session_counting (self, target_dict, IEI_timeRange = (0, 900, 1), cal_IEI = True, cal_duration = True, cal_latency = True, cal_inputDistribution = True, num_bins = 10, **kwards):\r\n if len(self.df) == 0:\r\n #if empty then pass without analysis\r\n pass\r\n else:\r\n get_kwards = lambda x: (\"\",\"\") if x == None else x\r\n input1OnOff = get_kwards(kwards.get('Input1OnOff'))\r\n input2OnOff = get_kwards(kwards.get('Input2OnOff'))\r\n input3OnOff = get_kwards(kwards.get('Input3OnOff'))\r\n input4OnOff = get_kwards(kwards.get('Input4OnOff'))\r\n \r\n #get a start and end time point\r\n if 'Start' in self.df['States'].values:\r\n start = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Start')]['Time']\r\n else:\r\n start = pd.Series({'Start': self.df['Time'].values[0]-1})\r\n \r\n if 'Finish' in self.df['States'].values:\r\n end = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Finish')]['Time']\r\n else:\r\n end = pd.Series({'Finish': self.df['Time'].values[-1]+1}) #plus 1 second\r\n \r\n #get data from each event window\r\n event = self.df[(self.df['Time']>= start.iloc[0])&(self.df['Time']<= end.iloc[0])]\r\n \r\n result_dict = {}\r\n for k, v in target_dict.items():\r\n \r\n if k == 'Input1':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input1OnOff)\r\n elif k == 'Input2':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input2OnOff)\r\n elif k == 'Input3':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input3OnOff)\r\n elif k == 'Input4':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input4OnOff)\r\n else:\r\n result_dict [v[1]] = self.__counting (event, v, self.subject)\r\n \r\n return result_dict","def metric_tests(self, metric_tests: Dict[str, FAIRResultEvaluationCriterium]):\n\n self._metric_tests = metric_tests","def makedata():\n # train\n print('Clean Train Dataset and separate questions')\n df = pd.read_csv(TRAIN_DATASET).replace(np.nan, ' ')\n t = df.shape[0] * 2\n print t\n df['question1'] = cleanText(df['question1'])\n df['question2'] = cleanText(df['question2'])\n\n df.to_csv(os.path.join(rootpathdata_cleaned, 'train.csx'), index=False)\n overallquestions = df['question1'].tolist() + df['question2'].tolist()\n tpm = pd.DataFrame()\n tpm['question'] = overallquestions\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'train_allquestions.csx'), index=False)\n # test\n\n print('Clean Test Dataset and separate questions')\n df = pd.read_csv(TEST_DATASET).fillna(' ')\n t1 = df.shape[0] * 2\n df['question1'] = cleanText(df['question1'])\n df['question2'] = cleanText(df['question2'])\n df.to_csv(os.path.join(rootpathdata_cleaned, 'test.csx'), index=False)\n\n overallquestions += df['question1'].tolist() + df['question2'].tolist()\n tpm = pd.DataFrame()\n tpm['question'] = overallquestions\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'test_allquestions.csx'), index=False)\n print len(overallquestions), t1 + t","def evaluate(self, benchmark_data, metrics={}, options={}):\n dir_name = list(benchmark_data.keys())[0]\n relations = list(benchmark_data.values())[0]\n \n if \"relation\" in options :\n relations = [options[\"relation\"]]\n \n precision_total = 0\n for relation in relations :\n if relation.endswith(\"_inv\") :\n continue\n relation = relation.replace(\":\", \"_\")\n evaluate.setup(relation, dir_name)\n precision_total += evaluate.evaluate_logic()\n \n result = {}\n result[\"MAP\"] = precision_total/len(relations)\n\n return result","def get_chartdata():\n callback = bottle.request.query.get('callback')\n y_axis = bottle.request.query.get('y_axis').strip()\n w_acts = [\"action='%s'\" % act for act in bottle.request.query.get('actions').strip().split(',')]\n w_acts = 'AND (%s)' % ' OR '.join(w_acts) if w_acts else ''\n f_value = 'AVG(latency)' if y_axis.startswith('avg') else 'COUNT(timestamp)'\n atomic = 1 if y_axis in ['aops', 'avgl'] else 0\n\n db_conn = tools.get_db_conn('%s.db' % bottle.request.query.test_run_id)\n sql = 'SELECT test_run_status, timestamp_started, timestamp_completed FROM info LIMIT 1'\n status, started, finished = tools.db_query(db_conn, sql)[1][0]\n progress = int(float(finished) - float(started)) if finished \\\n else int(tools.get_timestamp() - float(started))\n\n sql = 'SELECT substr(timestamp, 0, 11), code, %s FROM recs ' % f_value + \\\n 'WHERE atomic=%s %s GROUP BY code, substr(timestamp, 0, 11) ' % (atomic, w_acts) + \\\n 'ORDER BY id DESC LIMIT 3600' # last 1 hour activity\n\n result = tools.db_query(db_conn, sql)[1] if finished else tools.db_query(db_conn, sql)[1][:-1]\n result = list(reversed(result))\n results = {str(abs(int(item[0]) - int(float(started)))):\n {'failed': 0, 'passed': 0, 'incomplete': 0} for item in result}\n for item in result: # item[0] - timestamp, item[1] - code (None if incomplete), item[2] - value\n timestamp = str(int(item[0]) - int(float(started)))\n value = item[2] or 0\n results[timestamp]['failed'] += value if item[1] and item[1] != 200 else 0\n results[timestamp]['passed'] += value if item[1] == 200 else 0\n results[timestamp]['incomplete'] += value if item[1] == None else 0\n results = [{'timestamp': key, 'failed': value['failed'], 'passed': value['passed'],\n 'incomplete': value['incomplete']} for key, value in results.items()]\n result = {bottle.request.query.slave: results, 'status': status,\n 'started': started, 'finished': finished or '(not finished)', 'progress': progress}\n return '{0}({1})'.format(callback, result)","def test_scores(self) -> np.ndarray:\n return np.asarray(self.test_metric_dict[self.metric_name])","def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\n hist = {k: {} for k in {\"mks0\", \"mks1\", \"mks2\", \"l\"}} # pylint: disable=C0208\n wei = {k: {} for k in hist}\n res[\"hist\"] = hist\n res[\"histnow\"] = wei\n\n for el, _ in self.enumerate_test_metric(qset):\n le = len(el.value)\n w = el.weight\n res[\"mks0\"] += w * el.mks0\n res[\"mks1\"] += w * el.mks1\n res[\"mks2\"] += w * el.mks2\n res[\"sum_weights\"] += w\n res[\"sum_wlen\"] += w * le\n res[\"n\"] += 1\n\n if el.mks0 not in hist[\"mks0\"]:\n hist[\"mks0\"][el.mks0] = w\n wei[\"mks0\"][el.mks0] = 1\n else:\n hist[\"mks0\"][el.mks0] += w\n wei[\"mks0\"][el.mks0] += 1\n if el.mks1 not in hist[\"mks1\"]:\n hist[\"mks1\"][el.mks1] = w\n wei[\"mks1\"][el.mks1] = 1\n else:\n hist[\"mks1\"][el.mks1] += w\n wei[\"mks1\"][el.mks1] += 1\n if el.mks2 not in hist[\"mks2\"]:\n hist[\"mks2\"][el.mks2] = w\n wei[\"mks2\"][el.mks2] = 1\n else:\n hist[\"mks2\"][el.mks2] += w\n wei[\"mks2\"][el.mks2] += 1\n if le not in hist[\"l\"]:\n hist[\"l\"][le] = w\n wei[\"l\"][le] = 1\n else:\n hist[\"l\"][le] += w\n wei[\"l\"][le] += 1\n return res","def metrics_evaluation(y_true, y_prob, threshold, df_type='train'):\n\n y_pred = (y_prob>=threshold).astype(int)\n \n tn = metrics.confusion_matrix(y_true, y_pred)[0][0]\n fp = metrics.confusion_matrix(y_true, y_pred)[0][1]\n fn = metrics.confusion_matrix(y_true, y_pred)[1][0]\n tp = metrics.confusion_matrix(y_true, y_pred)[1][1]\n\n accuracy_scr = metrics.accuracy_score(y_true, y_pred)\n precision_scr = metrics.precision_score(y_true, y_pred)\n recall_scr = metrics.recall_score(y_true, y_pred)\n f1_scr = metrics.f1_score(y_true, y_pred)\n roc_auc_scr = metrics.roc_auc_score(y_true, y_pred)\n\n result = {'Dataset': df_type, 'No obs': len(y_true), 'Threshold': threshold,\n 'TP':tp, 'FP': fp, 'TN': tn, 'FN':fn , \n 'Accuracy Score':accuracy_scr, 'Precision Score':precision_scr, \n 'Recall Score':recall_scr, 'F1 Score':f1_scr, 'ROC AUC Score':roc_auc_scr}\n\n return result","def set_metrics(self):","def prepareAccumulatedMetrics(self):\n displayDF = analyzeMetricsDF(self.resultList)\n displayDF.to_csv(\"data/results.csv\")","def test_get_qc_metrics_logic_unit():\n with mock.patch(\"dcicutils.ff_utils.get_metadata\") as mock_get_metadata:\n mock_get_metadata.side_effect = mocked_get_metadata_from_data_files\n print() # start output on a fresh line\n input_uuid = \"431106bc-8535-4448-903e-854af460b260\"\n result = ff_utils.get_associated_qc_metrics(input_uuid)\n assert \"131106bc-8535-4448-903e-854abbbbbbbb\" in result # quick pre-test\n assert result == get_mocked_result(kind='QC metrics',\n dirname='test_qc_metrics',\n uuid=input_uuid)","def calc_metrics(data, sampled_data_list, dataset_type):\n result={}\n for sampled_data in sampled_data_list:\n c2st_roc_auc_metric = c2st_roc_auc(data, sampled_data)\n if \"c2st_roc_auc\" in result:\n result[\"c2st_roc_auc\"].append(c2st_roc_auc_metric)\n else:\n result[\"c2st_roc_auc\"] = [c2st_roc_auc_metric]\n mmd_p_val, mmd_stat = rbf_mmd_test(data.values, sampled_data.values)\n if \"mmd_p_val\" in result:\n result[\"mmd_p_val\"].append(mmd_p_val)\n result[\"mmd_stat\"].append(mmd_stat)\n else:\n result[\"mmd_p_val\"] = [mmd_p_val]\n result[\"mmd_stat\"] = [mmd_stat]\n ks_p_val, ks_stat, ks_n, ks_p_val_list, ks_stat_list = ks_test(data, sampled_data)\n if dataset_type != \"norm_dataset\":\n ks_p_val = ks_permutation(ks_stat_list, data, sampled_data)\n if \"ks_p_val\" in result:\n result[\"ks_p_val\"].append(ks_p_val)\n result[\"ks_stat\"].append(ks_stat)\n else:\n result[\"ks_p_val\"] = [ks_p_val]\n result[\"ks_stat\"] = [ks_stat]\n acc_r, acc_g = c2st_accuracy(data, sampled_data)\n if \"c2st_acc_r\" in result:\n result[\"c2st_acc_r\"].append(acc_r)\n result[\"c2st_acc_g\"].append(acc_g)\n else:\n result[\"c2st_acc_r\"] = [acc_r]\n result[\"c2st_acc_g\"] = [acc_g]\n return result","def test_evaluate(self):\n # test normalized by 'head_size'\n mpii_pck_metric = MpiiPCKAccuracy(thr=0.3, norm_item='head')\n mpii_pck_metric.process(self.data_batch, self.data_samples)\n pck_results = mpii_pck_metric.evaluate(self.batch_size)\n target = {\n 'Head PCK': 100.0,\n 'Shoulder PCK': 100.0,\n 'Elbow PCK': 100.0,\n 'Wrist PCK': 100.0,\n 'Hip PCK': 100.0,\n 'Knee PCK': 100.0,\n 'Ankle PCK': 100.0,\n 'PCK': 100.0,\n 'PCK@0.1': 100.0,\n }\n self.assertDictEqual(pck_results, target)","def _compute_experiment_statistics(self):\n pass","def _evaluate(self) -> dict:\n self.load()\n self.evaluate_all()\n self.finalize_results()\n log.debug(\"Clearing global instrumentation variables\")\n del_globals()","def measure(self,qc,qb,cb):\n if isinstance(qb,list) and isinstance(cb,list):\n assert len(qb) == len(cb)\n for q,c in zip(qb,cb):\n qc.measure(q,c)\n else:\n qc.measure(qb,cb)\n if self.ibmq:\n job = qk.execute(qc, \n backend = self.backend, \n shots=self.shots,\n optimization_level=self.optimization_level,\n initial_layout=self.layout)\n self.monitor(job)\n else:\n job = qk.execute(qc, \n backend = self.backend, \n shots=self.shots,\n optimization_level=self.optimization_level,\n noise_model=self.noise_model,\n coupling_map=self.coupling_map,\n basis_gates=self.basis_gates,\n initial_layout=self.layout,\n seed_transpiler=self.seed,\n seed_simulator=self.seed)\n return job.result().get_counts(qc)","def test_run(id_, args, kwargs, expected):\n # Remove results for test.\n results_path = expected['results_path']\n shutil.rmtree(results_path, ignore_errors=True)\n # Start code.\n # [future] attempts to run classification with n_jobs>1\n # global cnfg_default\n # sys.modules['cnfg_default'] = get_params(args[0], 'cnfg_default')\n # import cnfg_default\n # #from cnfg_default import custom_score_metric\n objects = pycnfg.run(oid='default', *args, **kwargs)\n tmp = {k: type(v).__name__ for k, v in objects.items()}\n print('OBJECTS:')\n print(tmp)\n # Compare results:\n # * Compare objects (keys and str of values).\n objects_ = expected['objects']\n objects = {k: type(v).__name__ for k, v in objects.items()}\n if objects != objects_:\n print(set(objects.items()) ^ set(objects_.items()))\n assert objects == objects_\n # for k, v in objects.items():\n # assert k in objects_\n # assert type(v).__name__ == objects_[k]\n # * Compare predictions csv(all available).\n pred_path = glob.glob(f\"{results_path}/models/*_pred.csv\")\n pred_path_ = glob.glob(expected['pred_path'])\n assert len(pred_path) == len(pred_path_)\n for act, exp in zip(sorted(pred_path), sorted(pred_path_)):\n file_diff(act, exp)\n assert filecmp.cmp(act, exp)\n # * Compare test logs.\n logs_path = glob.glob(f\"{results_path}/logs*/*_test.log\")[0]\n logs_path_ = expected['logs_path']\n file_diff(logs_path, logs_path_)\n assert filecmp.cmp(logs_path, logs_path_)\n # * Compare runs dataframe, non-universe columns.\n runs_path = f\"{results_path}/runs\"\n runs_path_ = expected['runs_path']\n df = runs_loader(runs_path)\n df_ = runs_loader(runs_path_)\n # First False/True for each element, then check all by columns.\n # col1 True\n # col2 False\n # dtype: bool\n df_diff = df.eq(df_).all()\n # Column names that are not equal.\n columns = sorted(list(df_diff[df_diff==False].dropna().index))\n # columns_eq = sorted(list(df_diff[df_diff==True].dropna().index))\n columns_ = expected['columns_diff']\n print('DIFF:\\n', columns)\n time.sleep(1)\n # assert columns == columns_\n # * Compare model.\n model_path = glob.glob(f\"{results_path}/models/*.model\")\n model_path_ = glob.glob(expected['model_path'])\n assert len(model_path) == len(model_path_)\n for act, exp in zip(sorted(model_path), sorted(model_path_)):\n assert filecmp.cmp(act, exp)\n return","def run(self):\n question_stats = self.MultipleChoiceQuestionAggregator(self._course)\n mapper = models_utils.QueryMapper(\n EventEntity.all(), batch_size=500, report_every=1000)\n mapper.run(question_stats.visit)\n return (question_stats.id_to_questions_dict,\n question_stats.id_to_assessments_dict)","def __dataset_statistics(self) -> None:\n # Print the expressions\n print(f'Available expressions: {self.idx_to_expression.values()}')\n \n # Print dataset cardinalities\n stats_table = PrettyTable()\n stats_table.field_names = ['Train samples', 'PublicTest samples', 'PrivateTest samples', 'Number of expressions']\n stats_table.add_row([len(self.db[self.db['Usage'] == 'Training']), len(self.db[self.db['Usage'] == 'PublicTest']), len(self.db[self.db['Usage'] == 'PrivateTest']), len(self.db.expression.unique().tolist())])\n print(stats_table)\n \n def eval_class_cardinality(expressions: list, train: str) -> [list, list]:\n cardinality = [len(self.db[(self.db['expression']==expr) & (self.db['Usage']==train)]) for expr in expressions]\n frac = [len(self.db[(self.db['expression']==expr) & (self.db['Usage']==train)])/len(self.db[self.db['Usage']==train]) for expr in expressions]\n return cardinality, frac\n\n expressions = self.db.expression.unique()\n expressions.sort()\n \n # Print expressions statistics --> Training \n stats_table = PrettyTable()\n stats_table.title = 'Training Samples'\n stats_table.field_names = [self.idx_to_expression[label] for label in expressions]\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='Training')\n stats_table.add_row(cardinality)\n stats_table.add_row(frac)\n\n # Print expressions statistics --> Validation \n stats_table2 = PrettyTable()\n stats_table2.title = 'Validation Samples'\n stats_table2.field_names = [self.idx_to_expression[label] for label in expressions]\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='PublicTest')\n stats_table2.add_row(cardinality)\n stats_table2.add_row(frac)\n\n # Print expressions statistics --> Test \n stats_table3 = PrettyTable()\n stats_table3.title = 'Test Samples'\n stats_table3.field_names = [self.idx_to_expression[label] for label in expressions]\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='PrivateTest')\n stats_table3.add_row(cardinality)\n stats_table3.add_row(frac)\n \n print(stats_table)\n print(stats_table2)\n print(stats_table3)","def test_metrics(self):\n # Check the route\n self.check_metrics(self.test_metrics_submission_id, False, \"award\")\n self.check_metrics(self.test_metrics_submission_id, True, \"award_financial\")\n self.check_metrics(self.test_metrics_submission_id, True, \"appropriations\")","def log_evaluation(tester, name, description):\r\n\tfor dataset, output in tester.preds.items():\r\n\t\tresults = pandas.DataFrame.from_dict(output)\r\n\t\tpath = os.path.join(\r\n\t\t\tEXPERIMENT_PATH, tester.config[\"name\"] + '-' + dataset)\r\n\t\twith open(path + \".csv\", \"w\") as f:\r\n\t\t\tresults.to_csv(f, sep=\"\\t\", encoding='utf-8',\r\n\t\t\t\tfloat_format='%.3f', index=False)","def _eval_classifier(self):\n\n y_pred_baseline = self.df_baseline[self.score_column]\n y_pred_sample = self.df_sample[self.score_column]\n\n y_label_baseline = self.df_baseline[self.label_column]\n y_label_sample = self.df_sample[self.label_column]\n\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\n try:\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\n except ValueError:\n auc_baseline = \"NA\"\n\n precision_sample = precision_score(y_label_sample, y_pred_sample)\n recall_sample = recall_score(y_label_sample, y_pred_sample)\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\n f1_sample = f1_score(y_label_sample, y_pred_sample)\n try:\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\n except ValueError:\n auc_sample = \"NA\"\n\n metrics_df = pd.DataFrame(\n {\n \"Accuracy\": [acc_baseline, acc_sample],\n \"Precision\": [precision_baseline, precision_sample],\n \"Recall\": [recall_baseline, recall_sample],\n \"F1\": [f1_baseline, f1_sample],\n \"AUC\": [auc_baseline, auc_sample],\n },\n index=[\"baseline\", \"sample\"],\n )\n\n self.performance_comparison = metrics_df","def _perform_measurement(self, qubits: Sequence['cirq.Qid']) -> List[int]:\n return [self.state._measure(self.qubit_map[q], self.prng) for q in qubits]","def metrics(self):\n \n if self.mse.shape[0]>1:\n raise ValueError('Metrics can only handle single observations.')\n \n if self.N==1:\n pred = float('nan')\n err = float('nan')\n y_true = float('nan')\n else:\n pred = int(self._predictions[-1])\n err = self._mse[-1]\n y_true = int(self.label[0])\n \n is_outlier = {\"type\":\"GAUGE\",\"key\":\"is_outlier\",\"value\":pred}\n mse = {\"type\":\"GAUGE\",\"key\":\"mse\",\"value\":err}\n obs = {\"type\":\"GAUGE\",\"key\":\"observation\",\"value\":self.N - 1}\n threshold = {\"type\":\"GAUGE\",\"key\":\"threshold\",\"value\":self.threshold}\n \n label = {\"type\":\"GAUGE\",\"key\":\"label\",\"value\":y_true}\n \n accuracy_tot = {\"type\":\"GAUGE\",\"key\":\"accuracy_tot\",\"value\":self.metric[4]}\n precision_tot = {\"type\":\"GAUGE\",\"key\":\"precision_tot\",\"value\":self.metric[5]}\n recall_tot = {\"type\":\"GAUGE\",\"key\":\"recall_tot\",\"value\":self.metric[6]}\n f1_score_tot = {\"type\":\"GAUGE\",\"key\":\"f1_tot\",\"value\":self.metric[7]}\n f2_score_tot = {\"type\":\"GAUGE\",\"key\":\"f2_tot\",\"value\":self.metric[8]}\n \n accuracy_roll = {\"type\":\"GAUGE\",\"key\":\"accuracy_roll\",\"value\":self.metric[9]}\n precision_roll = {\"type\":\"GAUGE\",\"key\":\"precision_roll\",\"value\":self.metric[10]}\n recall_roll = {\"type\":\"GAUGE\",\"key\":\"recall_roll\",\"value\":self.metric[11]}\n f1_score_roll = {\"type\":\"GAUGE\",\"key\":\"f1_roll\",\"value\":self.metric[12]}\n f2_score_roll = {\"type\":\"GAUGE\",\"key\":\"f2_roll\",\"value\":self.metric[13]}\n \n true_negative = {\"type\":\"GAUGE\",\"key\":\"true_negative\",\"value\":self.metric[0]}\n false_positive = {\"type\":\"GAUGE\",\"key\":\"false_positive\",\"value\":self.metric[1]}\n false_negative = {\"type\":\"GAUGE\",\"key\":\"false_negative\",\"value\":self.metric[2]}\n true_positive = {\"type\":\"GAUGE\",\"key\":\"true_positive\",\"value\":self.metric[3]}\n \n nb_outliers_roll = {\"type\":\"GAUGE\",\"key\":\"nb_outliers_roll\",\"value\":self.metric[14]}\n nb_labels_roll = {\"type\":\"GAUGE\",\"key\":\"nb_labels_roll\",\"value\":self.metric[15]}\n nb_outliers_tot = {\"type\":\"GAUGE\",\"key\":\"nb_outliers_tot\",\"value\":self.metric[16]}\n nb_labels_tot = {\"type\":\"GAUGE\",\"key\":\"nb_labels_tot\",\"value\":self.metric[17]}\n \n return [is_outlier,mse,obs,threshold,label,\n accuracy_tot,precision_tot,recall_tot,f1_score_tot,f2_score_tot,\n accuracy_roll,precision_roll,recall_roll,f1_score_roll,f2_score_roll,\n true_negative,false_positive,false_negative,true_positive,\n nb_outliers_roll,nb_labels_roll,nb_outliers_tot,nb_labels_tot]","def qa_test():\r\n # Reads Code and Runs Code Metrics\r\n with open(\"BrainDataVisualiser.py\",\"r\") as file:\r\n code = file.read()\r\n with open(\"QA_LOGS.txt\",\"a\") as file:\r\n # Timestamp and append metric results to log\r\n file.write(datetime.date.today().strftime(\"%b-%d-%Y\")+\"\\n\\t\")\r\n file.write(\"General Analysis\\n\\t\\t\")\r\n file.write(str(analyze(code))+\"\\n\\t\")\r\n file.write(\"Cyclomatic Complexity\\n\")\r\n for i in cc_visit(code):\r\n file.write(\"\\t\\t\"+cc_rank(i.complexity)+\" \"+str(i)+\"\\n\")","def evaluate(self, test_data, test_labels):\n raise NotImplementedError","def generate_stats(results, ads, vmid, session_date, export_folder, process_ex_time):\n try:\n os.makedirs(export_folder)\n except OSError:\n pass\n\n # to be read and inserted into db\n totalads = 0 # total number of ads seen during this session\n totaluniqads = len(ads) # does not support multicategories at this point\n\n # for each category, for each test site, count total number of ads seen\n totalad_category = {} \n # for each category, for each test site, count total number of uniq ads seen\n uniqad_category = {}\n \n with open(os.path.join(export_folder, 'session_bugs.csv'), 'w') as bugs_wtr:\n bugs_wtr.write('#Ad-UID, Website-URL, Refresh-Num, Training-Topic,\\\n Site-Context, BugCount, BugSrc\\n')\n for train_category, cat_dict in results.items():\n totalad_category[train_category] = {}\n uniqad_category[train_category] = {}\n for test_site, bug_dict_list in cat_dict.items():\n total_ads = 0 # for each site\n uniq_ads = [] # for each site\n for refresh_num in range(len(bug_dict_list)):\n bug_dict = bug_dict_list[refresh_num]\n for bug, bugcount in bug_dict.items():\n if bug.is_ad():\n uuid = bug.get_uuid()\n bugs_wtr.write('{0}, {1}, {2}, {3}, {4}, {5}, {6}\\n'.format(uuid, test_site,\n refresh_num, train_category, 'N/A', bugcount, bug.get_src()))\n total_ads += bugcount\n if bug not in uniq_ads:\n uniq_ads.append(bug)\n totalad_category[train_category][test_site] = total_ads\n uniqad_category[train_category][test_site] = len(uniq_ads)\n totalads += total_ads # global count for total ads\n\n with open(os.path.join(export_folder, 'session_stats.csv'), 'w') as ses_wtr:\n # write some metadata information about this session\n ses_wtr.write('#VMID: %s\\n' % vmid)\n ses_wtr.write('#Session-Date: %s\\n' % session_date)\n ses_wtr.write('#Time to complete: %s\\n' % process_ex_time)\n ses_wtr.write('#Training Categories: %s\\n' % str(results.keys()))\n ses_wtr.write('#Total Number of ads: %d\\n' % totalads)\n ses_wtr.write('#Total Uniq ads: %d\\n\\n' % totaluniqads)\n ses_wtr.write('#TrainingTopic, Test-Site, NumberOfVisit, TotalAds, UniqAds\\n')\n\n for train_category, cat_dict in results.items(): \n for test_site, bug_dict_list in cat_dict.items():\n num_of_visit = len(bug_dict_list)\n ses_wtr.write('{0}, {1}, {2}, {3}, {4}\\n'.format(train_category,\n test_site, num_of_visit, totalad_category[train_category][test_site],\n uniqad_category[train_category][test_site]))","def main():\n test_folders = argv[1]\n benchmark_file = argv[2]\n output_path = argv[3]\n\n method = ['n', 'a', 'a']\n bigram = ['False', 'False', 'True']\n output_file = output_path + '/' + 'method_comparison_cosine_values.csv'\n\n with open(test_folders, 'r') as f:\n test_folders = f.read()\n\n test_folders = test_folders.splitlines()\n\n with open(benchmark_file, 'r') as f:\n benchmark_file = f.read()\n\n benchmark_file = benchmark_file.splitlines()\n\n # initialize big data frame\n frames = []\n\n for k in xrange(len(benchmark_file)):\n\n test = str(test_folders[k]).replace('\"', '')\n print \"Reading test files from folder:\"\n print test\n\n benchmark = str(benchmark_file[k]).replace('\"', '')\n print \"Reading benchmark form file:\"\n print benchmark\n\n # read file paths from test documents folder\n query = sorted([os.path.join(test, f) for f in os.listdir(test) if f.endswith('.txt')])\n\n # load benchmark text file\n with open(benchmark, \"r\", encoding=\"utf-8\", errors='ignore') as doc:\n raw = doc.read()\n\n # initialize dict of dicts for data frame\n method_csv = {}\n\n for j in xrange(len(method)):\n # extract features from benchmark\n dtm = ExtractFeatures(method[j], bigram[j])\n benchmark_name = benchmark_file[k].split('\\\\')[-1]\n benchmark_features = dtm.extract_features_from_text(raw, benchmark_name)\n\n # extract terms from each text document to create a vocabulary (keeping unique terms only)\n vocabulary = sorted(set(w[1] for w in benchmark_features))\n print \"{0} features produced.\".format(str(len(vocabulary)))\n\n benchmark_dtv = DTM(vocabulary, benchmark_name, benchmark_features)\n benchmark_dtv = benchmark_dtv.compute_dtv()\n\n # load test document features\n test_features = []\n for q in query:\n dtm1 = ExtractFeatures(method[j], bigram[j])\n test_features = test_features + dtm1.extract_features_from_file(q)\n\n documents = sorted(set([d for d, w in test_features]))\n print \"{0} test documents read.\".format(str(len(documents)))\n\n print \"Computing DTM...\"\n test_dtm = DTM(vocabulary, documents, test_features)\n test_dtm = test_dtm.compute_dtm()\n\n print \"Computing cosine values...\"\n dv = {}\n for i in xrange(len(documents)):\n d = 1 - spatial.distance.cosine(benchmark_dtv[benchmark_name], test_dtm[documents[i]])\n if isnan(d):\n d = 0\n dv[documents[i]] = d\n\n this_method = \"method=\" + method[j] + '_' + \"bigram=\" + bigram[j]\n method_csv[this_method] = pd.Series(dv)\n\n print \"Saving to data frame...\"\n df = pd.DataFrame(method_csv)\n test = test.split('\\\\')[-1]\n test = test.split('.')[0]\n df['test_group'] = test\n\n frames.append(df)\n\n result = pd.concat(frames)\n\n print \"Saving results to file: \", output_file\n result.to_csv(output_file)\n\n print 'Finished computing {0} data frames'.format(str(len(test_folders)))","def test_step(self, x_test, y_test):\n\n print(\"Evaluation:\")\n\n input_x_op = self.session.graph.get_operation_by_name(\"input_x\").outputs[0]\n input_y_op = self.session.graph.get_operation_by_name(\"input_y\").outputs[0]\n global_step_op = self.session.graph.get_operation_by_name(\"global_step\").outputs[0]\n\n loss_op = self.session.graph.get_operation_by_name(\"loss/loss\").outputs[0]\n\n predictions_op = self.session.graph.get_operation_by_name(\"output/predictions\").outputs[0] \n\n accuracy_op = self.session.graph.get_operation_by_name(\"accuracy/accuracy\").outputs[0]\n confusion_update_op = self.session.graph.get_operation_by_name(\"accuracy/confusion_update\").outputs[0]\n\n d_ = {\n input_x_op: x_test,\n input_y_op: y_test\n }\n\n self.init_dataset(d_)\n\n valid_batches_per_epoch = (len(x_test) - 1) // self.FLAGS.batch_size + 1\n\n sum_accuracy = 0\n \n confusion_variable = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=\"accuracy/confusion\")[0]\n self.session.run([confusion_variable.initializer])\n\n for current_step in range(valid_batches_per_epoch):\n\n if self.FLAGS.summary:\n step, summaries, loss, accuracy, cnf_matrix, predictions = self.session.run(\n [global_step_op, self.dev_summary_op, loss_op, accuracy_op, confusion_update_op, predictions_op])\n\n self.writer.add_summary(summaries, step)\n else:\n step, loss, accuracy, cnf_matrix, predictions = self.session.run(\n [global_step_op, loss_op, accuracy_op, confusion_update_op, predictions_op]) \n\n sum_accuracy += accuracy\n\n try:\n all_predictions = np.concatenate((all_predictions, predictions), axis=0)\n except NameError:\n all_predictions = predictions\n\n\n valid_accuracy = sum_accuracy / valid_batches_per_epoch\n\n time_str = datetime.datetime.now().isoformat()\n print(\"{}: valid_accuracy {:g}\".format(time_str, valid_accuracy))\n print(\"Confusion matrix:\")\n print(cnf_matrix)\n\n return valid_accuracy, all_predictions","def compute_accuracy_measures(self, gt):\n data = quantification.compute_accuracy_measures(self.image, gt.image)\n return data","def test_fetch_qc_metrics_logic_integrated(mocked_replicate_experiment):\n result = ff_utils.fetch_files_qc_metrics(\n ff_utils.get_metadata(\"331106bc-8535-3338-903e-854af460b544\", ff_env='fourfront-mastertest'),\n ff_env='fourfront-mastertest',\n associated_files=['other_processed_files'],\n ignore_typical_fields=False)\n assert '131106bc-8535-4448-903e-854af460b000' in result\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in result","def run(self, inputIn):\n measureList = self.inputToInternal(inputIn)\n outputDict = {}\n assert(len(self.features) == len(measureList))\n for metricInstance in self.metricsDict.values():\n metricEngine = MetricDistributor.factory.returnInstance('MetricDistributor', metricInstance)\n for cnt in range(len(self.targets)):\n nodeName = (str(self.targets[cnt]) + '_' + str(self.features[cnt])).replace(\"|\",\"_\")\n varName = metricInstance.name + '|' + nodeName\n output = metricEngine.evaluate(measureList[cnt], weights=self.weight, multiOutput=self.multiOutput)\n outputDict[varName] = np.atleast_1d(output)\n return outputDict","def run_evaluate(self, test):\n accs = []\n correct_preds, total_correct, total_preds = 0., 0., 0.\n for words, labels in minibatches(test, self.config.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words)\n\n for lab, lab_pred, length in zip(labels, labels_pred,\n sequence_lengths):\n lab = lab[:length]\n lab_pred = lab_pred[:length]\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\n\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\n lab_pred_chunks = set(get_chunks(lab_pred,\n self.config.vocab_tags))\n\n correct_preds += len(lab_chunks & lab_pred_chunks)\n total_preds += len(lab_pred_chunks)\n total_correct += len(lab_chunks)\n\n p = correct_preds / total_preds if correct_preds > 0 else 0\n r = correct_preds / total_correct if correct_preds > 0 else 0\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\n acc = np.mean(accs)\n print('*'*20, '\\n')\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\n')\n print('*'*20)\n\n return {\"acc\": 100*acc, \"f1\": 100*f1}","def run_evaluate(self, test):\n accs = []\n correct_preds, total_correct, total_preds = 0., 0., 0.\n for words, labels in minibatches(test, self.config.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words)\n\n for lab, lab_pred, length in zip(labels, labels_pred,\n sequence_lengths):\n lab = lab[:length]\n lab_pred = lab_pred[:length]\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\n\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\n lab_pred_chunks = set(get_chunks(lab_pred,\n self.config.vocab_tags))\n\n correct_preds += len(lab_chunks & lab_pred_chunks)\n total_preds += len(lab_pred_chunks)\n total_correct += len(lab_chunks)\n\n p = correct_preds / total_preds if correct_preds > 0 else 0\n r = correct_preds / total_correct if correct_preds > 0 else 0\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\n acc = np.mean(accs)\n\n return {\"acc\": 100*acc, \"f1\": 100*f1}","def gather_sample(self):\n\n for _pid in self._select_processes():\n if not self.__trackers.get(_pid):\n self.__trackers[_pid] = ProcessTracker(_pid, self._logger, self.__id)\n\n self._reset_absolute_metrics()\n\n for _tracker in self.__trackers.values():\n _metrics = _tracker.collect()\n self.record_metrics(_tracker.pid, _metrics)\n\n self._calculate_aggregated_metrics()\n self._remove_dead_processes()\n\n self.print_metrics()","def load_results(self):\n self.find_benchmark_directories()\n for (benchmark, producer), result in self.results.items():\n print('Reading results for ' + benchmark + ' ' + producer)\n if not result.directory:\n print('No results found for ' + benchmark + ' ' + producer)\n else:\n print('Generating report for: ' + result.directory)\n report = Report(result.directory)\n result.reports = report.generate()","def getMeasures():","def execute(self):\r\n factors = self.factors\r\n variables = list(self.variables)\r\n variables.remove(self.query)\r\n\r\n for fac in factors:\r\n self.set_observations(fac)\r\n\r\n for var in variables:\r\n if var not in self.obs:\r\n factors = self.eliminate_variable(var, factors)\r\n\r\n result = factor_module.multiply_batch(self.query, factors)\r\n denominator = sum(result.get_cpt())\r\n print(denominator)\r\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}","def save_metrics(self):\n self.data_stats.write.format(\"org.apache.spark.sql.cassandra\").mode(\"append\").options(table=self.cassandra_stats_table, keyspace=self.cassandra_keyspace).save()\n print (\"Saved data successfully\")","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def __init__(self, metrics, gt, pred):\n self.dict_metrics = self.compute_metrics(metrics, gt, pred)","def evaluate(cfg: DictConfig):\n\n experiments = cfg.get('experiment_type', f'{cfg.model.name}_only')\n fixed_t0 = cfg.get('fixed_t0', False)\n ext = '_fixedT0' if fixed_t0 else ''\n\n base_dir = cfg.device.root\n datasource = cfg.datasource.name\n\n if experiments == 'ablations':\n models = {\n 'FluxRGNN': ['final',\n 'final_without_encoder',\n 'final_without_boundary'],\n 'LocalLSTM': ['final']\n }\n elif experiments == 'final':\n models = {\n 'FluxRGNN': ['final'],\n 'GAM': ['final'],\n 'HA': ['final'],\n 'GBT': ['final']\n }\n else:\n m = cfg.model.name\n year = cfg.datasource.test_year\n\n # find all experiments available for this model, datasource and test year\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{year}')\n models = {\n m : [ f.name for f in os.scandir(result_dir) if f.is_dir() ]\n }\n\n\n # thresholds for binary classification metrics\n if cfg.datasource.name == 'abm':\n thresholds = [0.0019, 0.0207]\n else:\n thresholds = [0, 10, 20]\n\n rmse_per_hour = []\n mae_per_hour = []\n pcc_per_hour = []\n bin_per_hour = []\n\n rmse_per_night = []\n mae_per_night = []\n\n output_dir = osp.join(base_dir, 'results', datasource, f'performance_evaluation{ext}', experiments)\n os.makedirs(output_dir, exist_ok=True)\n\n counter = 0\n\n for m, dirs in models.items():\n print(f'evaluate {m}')\n\n for d in dirs:\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{cfg.datasource.test_year}', d)\n\n # check if directory exists\n if os.path.isdir(result_dir):\n results, model_cfg = load_cv_results(result_dir, trials=cfg.task.repeats, ext=ext)\n\n df_prep = pd.read_csv(osp.join(base_dir, 'data', 'preprocessed',\n f'{model_cfg[\"t_unit\"]}_{model_cfg[\"model\"][\"edge_type\"]}_ndummy={model_cfg[\"datasource\"][\"n_dummy_radars\"]}',\n datasource, cfg.season, str(cfg.datasource.test_year), 'dynamic_features.csv'))\n tidx2night = dict(zip(df_prep.tidx, df_prep.nightID))\n\n rmse_per_hour.append(compute_rmse(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n mae_per_hour.append(compute_mae(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n pcc_per_hour.append(compute_pcc(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n\n if fixed_t0:\n rmse_per_night.append(compute_rmse_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\n mae_per_night.append(compute_mae_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\n\n # compute binary classification measures\n for thr in thresholds:\n bin_per_hour.append(compute_bin(m, d, results, groupby=['horizon', 'trial'], threshold=thr, km2=True))\n\n counter += 1\n\n else:\n print(f'Experiment \"{d}\" for model \"{m}\" and datasource \"{datasource}\" is not available. '\n f'Use \"run_experiments.py model={m} datasource={datasource} +experiment={d}\" to run this experiment.')\n\n if counter > 0:\n rmse_per_hour = pd.concat(rmse_per_hour)\n rmse_per_hour.to_csv(osp.join(output_dir, f'rmse_per_hour.csv'))\n\n mae_per_hour = pd.concat(mae_per_hour)\n mae_per_hour.to_csv(osp.join(output_dir, f'mae_per_hour.csv'))\n\n pcc_per_hour = pd.concat(pcc_per_hour)\n pcc_per_hour.to_csv(osp.join(output_dir, f'pcc_per_hour.csv'))\n\n bin_per_hour = pd.concat(bin_per_hour)\n bin_per_hour.to_csv(osp.join(output_dir, f'bin_per_hour.csv'))\n\n if fixed_t0:\n rmse_per_night = pd.concat(rmse_per_night)\n rmse_per_night.to_csv(osp.join(output_dir, f'rmse_per_night.csv'))\n\n mae_per_night = pd.concat(mae_per_night)\n mae_per_night.to_csv(osp.join(output_dir, f'mae_per_night.csv'))","def compute_metrics(self, results: list) -> dict:\n dump(results, self.out_file_path)\n print_log(\n f'Results has been saved to {self.out_file_path}.',\n logger='current')\n return {}","def test(self):\n for data_tier in self.data_tiers:\n tot = len(self.preprocessed_data[data_tier]['features'])\n p = int(math.floor(tot*0.2))\n test_features = np.array(self.preprocessed_data[data_tier]['features'][p:])\n trend_test_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][p:])\n avg_test_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][p:])\n accuracy_trend = self.clf_trend[data_tier].score(test_features, trend_test_classifications)\n accuracy_avg = self.clf_avg[data_tier].score(test_features, avg_test_classifications)\n self.logger.info('The accuracy of %s trend classifier for data tier %s is %.3f', self.name, data_tier, accuracy_trend)\n self.logger.info('The accuracy of %s avg regressor for data tier %s is %.3f', self.name, data_tier, accuracy_avg)","def run(self):\n if self.verbose:\n print(f'Running {self.name} tests...')\n\n # try running setup if there is one\n if self.setup:\n self.__process_setup()\n\n final_report = [None] * len(self.tests)\n\n for test_in, test_out in sorted(self.tests.items()):\n # increment total num of tests\n self.total += 1\n\n if self.verbose:\n print(f'#{self.total}')\n\n # evaluate test input w/ setup vars, if any\n try:\n inp = eval(test_in, self.vars)\n except Exception as err:\n print(f'Issue during evaluation of test input: {err}')\n final_report[self.total - 1] = 'input eval error'\n if self.verbose:\n print(f'Test input was: {test_in}')\n print('Vars from execution: {}'.format({k : v for k, v in self.vars.items() if k != '__builtins__'}))\n continue\n\n \n # checking if function input has more than one arg\n if type(inp) in (list, tuple):\n try:\n student_out = self.student_function(*inp)\n except Exception as err:\n print(f'Issue while running student code: {err}')\n final_report[self.total - 1] = f'student code error: {err}; input: {inp}; func_name: {self.name}'\n if self.verbose:\n print(f'Function being run was: {self.name}')\n print(f'Inputs were: {inp}')\n continue\n else:\n try:\n student_out = self.student_function(inp)\n except Exception as err:\n print(f'Issue while running student code: {err}')\n final_report[self.total - 1] = f'student code error: {err}; input: {inp}; func_name: {self.name}'\n if self.verbose:\n print(f'Function being run was: {self.name}')\n print(f'Input was: {inp}')\n continue\n\n # ans alias for ease of answer checking\n self.vars['ans'] = student_out\n\n if self.schema:\n format_vals = eval(test_out, self.vars)\n results, maybe_failed_schema = self.__process_schema(format_vals)\n if all(results):\n self.correct += 1\n final_report[self.total - 1] = 'PASSED'\n else:\n # failed at least one of the tests\n failed_str = \" and \".join([\", \".join(maybe_failed_schema[:-1]),maybe_failed_schema[-1]] if len(maybe_failed_schema) > 2 else maybe_failed_schema)\n final_report[self.total - 1] = f'FAILED; failed following assertion(s): {failed_str}'\n else:\n expected_ans = eval(test_out, self.vars)\n if student_out == expected_ans:\n self.correct += 1\n final_report[self.total - 1] = 'PASSED'\n else:\n # failed the only test\n final_report[self.total - 1] = f'FAILED; got {repr(student_out)} but expected {repr(expected_ans)}'\n\n # run callback function, if there is one\n if self.callback:\n if self.verbose:\n print('Running callback...')\n print('call back is:', self.callback)\n\n # once done, put the final report on the queue\n self.queue.put((self.student_username, self.name, f'{self.correct}/{self.total}', final_report))","def execute(self, context):\n if len(self.data_quality_checks) == 0:\n self.log.info('DataQualityOperator not implemented yet')\n return\n \n redshift_hook = PostgresHook(postgres_conn_id=self.redshift_conn_id) \n \n errors = 0\n failure_tests = []\n\n # process each sql stmt for data quality relevant to each dimension table:\n # Dimension tables : a. songplays, b. songs, c. artists, d. users, e. time\n \n for (curr_table, check_stmt) in zip(self.list_of_tables, self.data_quality_checks):\n curr_sql = check_stmt.get('check_sql')\n result1 = check_stmt.get('expected_result')\n \n self.log.info('Current Table Processed : ' + curr_table)\n\n try:\n records = redshift_hook.get_records(curr_sql)[0]\n except Exception as e:\n self.loginfo(f\"Error : {curr_table} : Query failed : {e}\")\n\n # record error when actual result is not the same as expected result\n if result1 != records[0]:\n errors += 1\n failure_tests.append(curr_table + ' : ' + curr_sql)\n \n # display Failure or Success Message \n if errors > 0:\n self.log.info(failure_tests)\n self.log.info('Failure Msg : Tests Failed')\n raise ValueError('Error : Failed : Data Quality check')\n else:\n self.log.info('Success : All Data Quality Tests passed')","def dataStats(self):\n print (\"Performing statistical analysis of the data\")\n # stuff to do","def _test_evaluate(self, format_only, outfile_predix=None):\n metric = MOTChallengeMetric(\n metric=['HOTA', 'CLEAR', 'Identity'],\n format_only=format_only,\n outfile_prefix=outfile_predix)\n metric.dataset_meta = {'classes': ('pedestrian', )}\n data_batch = dict(input=None, data_samples=None)\n predictions = self._get_predictions_demo()\n metric.process(data_batch, predictions)\n eval_results = metric.evaluate()\n return eval_results","def save_performances(self):\r\n nb_datasets = len(self.results)\r\n resu = [[] for k in range(nb_datasets)]\r\n\r\n # fetch results\r\n for k in range(nb_datasets):\r\n best = np.argmax(self.results[k]['mean_test_score'])\r\n resu[k].append(('score', self.results[k]['mean_test_score'][best]))\r\n resu[k] = resu[k] + list(self.results[k]['params'][best].items())\r\n\r\n # write results in csv\r\n for k, resu in enumerate(resu):\r\n with open('results/final_results_{}.csv'.format(k), 'a') as file:\r\n writer = csv.writer(file)\r\n writer.writerow(resu)","def run_and_evaluate():\n tsp_problems = read_all_problems()\n # Empty list of metrics\n results = []\n for problem in tqdm.tqdm(tsp_problems):\n # As random factors are involved repeat experiments a couple of times\n best_routes_base = []\n best_routes_af = []\n best_routes_ms = []\n base_times = []\n af_times = []\n ms_times = []\n for i in range(10):\n # Base solution\n start_time = timeit.default_timer()\n best_route_base = solve_tsp_basic(problem)\n base_time = timeit.default_timer() - start_time\n best_routes_base.append(Fitness(route=best_route_base).route_distance())\n base_times.append(base_time)\n\n # AF clustering solution\n start_time = timeit.default_timer()\n best_route_af = solve_tsp_affinity_propagation(problem)\n af_time = timeit.default_timer() - start_time\n best_routes_af.append(Fitness(route=best_route_af).route_distance())\n af_times.append(af_time)\n\n # MS solution\n start_time = timeit.default_timer()\n best_route_ms = solve_mean_shift(problem)\n ms_time = timeit.default_timer() - start_time\n best_routes_ms.append(Fitness(route=best_route_ms).route_distance())\n ms_times.append(ms_time)\n\n results.append(\n {\n \"problem name\": problem.name,\n \"optimal solution\": find_route_optimal_route_length(problem),\n \"baseline tour length\": mean(best_routes_base),\n \"af clustering tour length\": mean(best_routes_af),\n \"ms clustering tour length\": mean(best_routes_ms),\n \"baseline algorithm time\": mean(base_times),\n \"af clustering algorithm time\": mean(af_times),\n \"ms clustering algorithm time\": mean(ms_times),\n }\n )\n # Create dataframe and safe results\n df = pd.DataFrame(results)\n df.to_csv(\"results.csv\", index=False)\n return df","def init_metrics(self):\n\n self.metrics = {}\n\n self.metrics['train_loss'] = np.zeros(0)\n self.metrics['test_loss'] = np.zeros(0)\n\n # self.orth_clf = LinearDecoder(self, self.q_, MeanClassifier)\n # self.metrics['train_orthogonality'] = np.zeros(0)\n # self.metrics['test_orthogonality'] = np.zeros(0)\n\n self.metrics['train_parallelism'] = np.zeros((0,self.q_)) \n self.metrics['test_parallelism'] = np.zeros((0,self.q_))","def evaluate(self) -> Dict[str, float]:\n eval_dataloader = self.get_eval_dataloader()\n\n output = self._prediction_loop(eval_dataloader, description=\"Evaluation\")\n return output.metrics","def metrics_env(cmd_ctx, cpc, **options):\n cmd_ctx.execute_cmd(lambda: cmd_metrics_env(cmd_ctx, cpc, options))","def test_cw_metrics(self):\n\n instances = set()\n result = self.cw_client.list_metrics(Namespace=\"CWAgent\", MetricName=\"cpu_usage_system\")\n for i in result[\"Metrics\"]:\n instances.add(i[\"Dimensions\"][0][\"Value\"])\n\n for key, value in self.cdk_output_map.items():\n if \"Instance\" in key:\n self.assertTrue(value in instances)","def _build_eval_metrics(self, results, features, labels):\n metrics = {}\n for metric in self.metrics:\n metrics[metric.IDENTIFIER] = getters.get_metric(\n metric.IDENTIFIER, results, labels, **metric.to_dict())\n return metrics","def evaluate(self, epoch, exploration_paths):\n logger.log(\"Collecting samples for evaluation\")\n paths = self._sample_eval_paths(epoch)\n statistics = OrderedDict()\n\n statistics.update(self._statistics_from_paths(paths, \"Test\"))\n statistics.update(self._get_other_statistics())\n statistics.update(self._statistics_from_paths(exploration_paths,\n \"Exploration\"))\n\n statistics['AverageReturn'] = get_average_returns(paths)\n statistics['Epoch'] = epoch\n\n for key, value in statistics.items():\n logger.record_tabular(key, value)\n\n self.log_diagnostics(paths)","def evaluation(self):\n rows_list = []\n for name in self.single_classifier_best.keys():\n row = {}\n row['algorithm'] = name \n row[self.scoring_metric] = self.single_classifier_best[name].best_score_\n rows_list.append(row)\n \n scoring_df = pd.DataFrame(rows_list)\n scoring_sorted = scoring_df.sort_values(self.scoring_metric, ascending=False)\n print()\n print('*'*shutil.get_terminal_size().columns)\n print(scoring_sorted)\n print('*'*shutil.get_terminal_size().columns)\n self.evaluation_scores = scoring_sorted","def getIndependentTestSetPerf(ml_df,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,group_col,model_type,ml_model,n_splits=10,n_repeats=10,n_jobs=1): \n X = ml_df[roi_cols].values\n X_col_names = roi_cols.copy()\n grp1_idx = np.array(ml_df[group_col]=='internal')\n grp2_idx = np.array(ml_df[group_col]=='external')\n\n # Check input var types and create dummy vars if needed\n if len(covar_continuous_cols) > 0:\n X_continuous_covar = ml_df[covar_continuous_cols].values\n print('Using {} continuous covar'.format(len(covar_continuous_cols)))\n X = np.hstack((X, X_continuous_covar))\n X_col_names += list(covar_continuous_cols)\n if len(covar_cat_cols) > 0:\n X_cat_covar_df = pd.get_dummies(ml_df[covar_cat_cols])\n X_cat_covar = X_cat_covar_df.values\n print('Using {} categorical cols as {} cat covar (dummies)'.format(covar_cat_cols,X_cat_covar.shape[1]))\n X = np.hstack((X, X_cat_covar))\n X_col_names += list(X_cat_covar_df.columns)\n\n print('n of input columns: {}'.format(len(X_col_names)))\n if model_type.lower() == 'classification':\n y = pd.get_dummies(ml_df[outcome_col]).values[:,0]\n print('Data shapes X {}, y {} ({})'.format(X.shape, len(y), list(ml_df[outcome_col].value_counts()))) \n perf_metric = 'roc_auc'\n cv = RepeatedStratifiedKFold(n_splits=n_splits,n_repeats=n_repeats,random_state=0)\n elif model_type.lower() == 'regression':\n y = ml_df[outcome_col].values\n print('Data shapes X {}, y {} ({:3.2f}m, {:3.2f}sd)'.format(X.shape, len(y), np.mean(y),np.std(y))) \n perf_metric = 'neg_mean_squared_error'\n cv = ShuffleSplit(n_splits=n_splits*n_repeats, random_state=0)\n else:\n print('unknown model type {} (needs to be classification or regression)'.format(model_type))\n\n\n print('Using {} model with perf metric {}'.format(model_type, perf_metric))\n\n X1 = X[grp1_idx]\n y1 = y[grp1_idx]\n X2 = X[grp2_idx]\n y2 = y[grp2_idx]\n\n scores_df_CV = pd.DataFrame()\n for train_index, test_index in cv.split(X1):\n X1_tr = X1[train_index]\n y1_tr = y1[train_index]\n X1_te = X1[test_index]\n y1_te = y1[test_index]\n \n ml_model.fit(X1_tr,y1_tr)\n y1_pred = ml_model.predict(X1_te)\n y2_pred = ml_model.predict(X2)\n \n if perf_metric == 'neg_mean_squared_error':\n perf1 = mean_squared_error(y1_te, y1_pred)\n perf2 = mean_squared_error(y2, y2_pred)\n else:\n print('Unknown scoring function {}'.format(perf_metric))\n perf1 = 0\n perf2 = 0\n \n scores_df = pd.DataFrame() \n scores_df[perf_metric] = [perf1,perf2]\n scores_df['test_subset'] = ['internal','external']\n scores_df_CV = scores_df_CV.append(scores_df)\n\n return scores_df_CV","def run(self):\n self.tf_idf_scores = self.tf_idf()\n self.word_scores = self.create_word_score()\n self.keyword_scores = self.create_keyword_score()\n self.text_ranks = self.create_text_rank()\n self.pos_scores = {}\n self.z_area_scores = {}\n self.create_pos_and_area_score()\n self.all_scores = self.weight_distribution()\n self.all_scores_dict = self.get_all_scores_dict()\n return self.get_keywords()"],"string":"[\n \"def compute(self, download_data=None):\\n if self.extractor is None:\\n # If download_data is None, decide based on whether eid or session path was provided\\n ensure_data = self.download_data if download_data is None else download_data\\n self.load_data(download_data=ensure_data)\\n self.log.info(f\\\"Session {self.session_path}: Running QC on habituation data...\\\")\\n\\n # Initialize checks\\n prefix = '_task_'\\n data = self.extractor.data\\n metrics = {}\\n passed = {}\\n\\n # Check all reward volumes == 3.0ul\\n check = prefix + 'reward_volumes'\\n metrics[check] = data['rewardVolume']\\n passed[check] = metrics[check] == 3.0\\n\\n # Check session durations are increasing in steps >= 12 minutes\\n check = prefix + 'habituation_time'\\n if not self.one or not self.session_path:\\n self.log.warning('unable to determine session trials without ONE')\\n metrics[check] = passed[check] = None\\n else:\\n subject, session_date = self.session_path.parts[-3:-1]\\n # compute from the date specified\\n date_minus_week = (\\n datetime.strptime(session_date, '%Y-%m-%d') - timedelta(days=7)\\n ).strftime('%Y-%m-%d')\\n sessions = self.one.alyx.rest('sessions', 'list', subject=subject,\\n date_range=[date_minus_week, session_date],\\n task_protocol='habituation')\\n # Remove the current session if already registered\\n if sessions and sessions[0]['start_time'].startswith(session_date):\\n sessions = sessions[1:]\\n metric = ([0, data['intervals'][-1, 1] - data['intervals'][0, 0]] +\\n [(datetime.fromisoformat(x['end_time']) -\\n datetime.fromisoformat(x['start_time'])).total_seconds() / 60\\n for x in [self.one.alyx.get(s['url']) for s in sessions]])\\n\\n # The duration from raw trial data\\n # duration = map(float, self.extractor.raw_data[-1]['elapsed_time'].split(':'))\\n # duration = timedelta(**dict(zip(('hours', 'minutes', 'seconds'),\\n # duration))).total_seconds() / 60\\n metrics[check] = np.array(metric)\\n passed[check] = np.diff(metric) >= 12\\n\\n # Check event orders: trial_start < stim on < stim center < feedback < stim off\\n check = prefix + 'trial_event_sequence'\\n nans = (\\n np.isnan(data[\\\"intervals\\\"][:, 0]) | # noqa\\n np.isnan(data[\\\"stimOn_times\\\"]) | # noqa\\n np.isnan(data[\\\"stimCenter_times\\\"]) |\\n np.isnan(data[\\\"valveOpen_times\\\"]) | # noqa\\n np.isnan(data[\\\"stimOff_times\\\"])\\n )\\n a = np.less(data[\\\"intervals\\\"][:, 0], data[\\\"stimOn_times\\\"], where=~nans)\\n b = np.less(data[\\\"stimOn_times\\\"], data[\\\"stimCenter_times\\\"], where=~nans)\\n c = np.less(data[\\\"stimCenter_times\\\"], data[\\\"valveOpen_times\\\"], where=~nans)\\n d = np.less(data[\\\"valveOpen_times\\\"], data[\\\"stimOff_times\\\"], where=~nans)\\n\\n metrics[check] = a & b & c & d & ~nans\\n passed[check] = metrics[check].astype(float)\\n\\n # Check that the time difference between the visual stimulus center-command being\\n # triggered and the stimulus effectively appearing in the center is smaller than 150 ms.\\n check = prefix + 'stimCenter_delays'\\n metric = np.nan_to_num(data[\\\"stimCenter_times\\\"] - data[\\\"stimCenterTrigger_times\\\"],\\n nan=np.inf)\\n passed[check] = (metric <= 0.15) & (metric > 0)\\n metrics[check] = metric\\n\\n # Phase check\\n check = prefix + 'phase'\\n metric = data['phase']\\n passed[check] = (metric <= 2 * np.pi) & (metric >= 0)\\n metrics[check] = metric\\n\\n check = prefix + 'phase_distribution'\\n metric, _ = np.histogram(data['phase'])\\n _, p = chisquare(metric)\\n passed[check] = p < 0.05\\n metrics[check] = metric\\n\\n # Checks common to training QC\\n checks = [check_goCue_delays, check_stimOn_goCue_delays,\\n check_stimOn_delays, check_stimOff_delays]\\n for fcn in checks:\\n check = prefix + fcn.__name__[6:]\\n metrics[check], passed[check] = fcn(data)\\n\\n self.metrics, self.passed = (metrics, passed)\",\n \"def qc_metrics(self, files_in, qc_files):\\n self.cmd(\\\"{samtools} index {bam_in}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in=files_in[0],\\n ),\\n shell=True)\\n self.cmd(\\\"{samtools} idxstats {bam_in} | tee {qc_file}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in = files_in[0],\\n qc_file = qc_files[0],\\n ),\\n shell=True,\\n log_output=True)\\n self.cmd(\\\"{samtools} flagstat {bam_in} | tee {qc_file}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in = files_in[0],\\n qc_file = qc_files[1],\\n ),\\n shell=True,\\n log_output=True)\\n \\n self.checkpoint(qc_files[0])\\n self.checkpoint(qc_files[1])\\n self.checkpoint(qc_files[2])\",\n \"def compute_session_status(self):\\n if self.passed is None:\\n raise AttributeError('passed is None; compute QC first')\\n # Get mean passed of each check, or None if passed is None or all NaN\\n results = {k: None if v is None or np.isnan(v).all() else np.nanmean(v)\\n for k, v in self.passed.items()}\\n session_outcome, outcomes = self.compute_session_status_from_dict(results)\\n return session_outcome, results, outcomes\",\n \"def get_bpodqc_metrics_frame(data, **kwargs):\\n def is_metric(x):\\n return isfunction(x) and x.__name__.startswith('check_')\\n # Find all methods that begin with 'check_'\\n checks = getmembers(sys.modules[__name__], is_metric)\\n prefix = '_task_' # Extended QC fields will start with this\\n # Method 'check_foobar' stored with key '_task_foobar' in metrics map\\n qc_metrics_map = {prefix + k[6:]: fn(data, **kwargs) for k, fn in checks}\\n\\n # Split metrics and passed frames\\n metrics = {}\\n passed = {}\\n for k in qc_metrics_map:\\n metrics[k], passed[k] = qc_metrics_map[k]\\n\\n # Add a check for trial level pass: did a given trial pass all checks?\\n n_trials = data['intervals'].shape[0]\\n # Trial-level checks return an array the length that equals the number of trials\\n trial_level_passed = [m for m in passed.values()\\n if isinstance(m, Sized) and len(m) == n_trials]\\n name = prefix + 'passed_trial_checks'\\n metrics[name] = reduce(np.logical_and, trial_level_passed or (None, None))\\n passed[name] = metrics[name].astype(float) if trial_level_passed else None\\n\\n return metrics, passed\",\n \"def metric_tests(self) -> Dict[str, FAIRResultEvaluationCriterium]:\\n return self._metric_tests\",\n \"def run_tests(self):\\n\\n self.test_report = []\\n\\n #dict of unsorted lists\\n dict_of_un_lists = self.dict_un_lists_intersection_test(self.data_dict)\\n self.test_report.append(dict_of_un_lists)\\n\\n #dict of sets\\n dict_of_sets = self.build_dict_of_sets(self.data_dict)\\n self.test_report.append(self.dict_sets_intersection_test(dict_of_sets))\\n\\n #pandas - experimental and probably not the way to use pandas\\n # dict_of_pandas = self.build_dict_of_panda_series(self.data_dict)\\n # self.test_report.append(self.dicts_any_intersection_node_test(dict_of_pandas))\\n\\n # print results\\n\\n if self.verbose:\\n self.print_tests_results()\",\n \"def test_evaluate(self):\\n # test normalized by 'bbox_size'\\n jhmdb_pck_metric = JhmdbPCKAccuracy(thr=0.5, norm_item='bbox')\\n jhmdb_pck_metric.process(self.data_batch, self.data_samples)\\n pck_results = jhmdb_pck_metric.evaluate(self.batch_size)\\n target = {\\n 'Head PCK': 1.0,\\n 'Sho PCK': 1.0,\\n 'Elb PCK': 1.0,\\n 'Wri PCK': 1.0,\\n 'Hip PCK': 1.0,\\n 'Knee PCK': 1.0,\\n 'Ank PCK': 1.0,\\n 'PCK': 1.0,\\n }\\n self.assertDictEqual(pck_results, target)\\n\\n # test normalized by 'torso_size'\\n jhmdb_tpck_metric = JhmdbPCKAccuracy(thr=0.2, norm_item='torso')\\n jhmdb_tpck_metric.process(self.data_batch, self.data_samples)\\n tpck_results = jhmdb_tpck_metric.evaluate(self.batch_size)\\n target = {\\n 'Head tPCK': 1.0,\\n 'Sho tPCK': 1.0,\\n 'Elb tPCK': 1.0,\\n 'Wri tPCK': 1.0,\\n 'Hip tPCK': 1.0,\\n 'Knee tPCK': 1.0,\\n 'Ank tPCK': 1.0,\\n 'tPCK': 1.0,\\n }\\n self.assertDictEqual(tpck_results, target)\",\n \"def qc_metrics(\\n data: AnnData,\\n mito_prefix: str = \\\"MT-\\\",\\n min_genes: int = 500,\\n max_genes: int = 6000,\\n min_umis: int = 100,\\n max_umis: int = 600000,\\n percent_mito: float = 10.0,\\n percent_cells: float = 0.05,\\n) -> None:\\n\\n data.obs[\\\"passed_qc\\\"] = False\\n\\n data.obs[\\\"n_genes\\\"] = data.X.getnnz(axis=1)\\n data.obs[\\\"n_counts\\\"] = data.X.sum(axis=1).A1\\n\\n mito_prefixes = mito_prefix.split(\\\",\\\")\\n\\n def startswith(name):\\n for prefix in mito_prefixes:\\n if name.startswith(prefix):\\n return True\\n return False\\n\\n mito_genes = data.var_names.map(startswith).values.nonzero()[0]\\n data.obs[\\\"percent_mito\\\"] = (data.X[:, mito_genes].sum(axis=1).A1 / np.maximum(\\n data.obs[\\\"n_counts\\\"].values, 1.0\\n )) * 100\\n\\n # Assign passed_qc\\n filters = [\\n data.obs[\\\"n_genes\\\"] >= min_genes,\\n data.obs[\\\"n_genes\\\"] < max_genes,\\n data.obs[\\\"n_counts\\\"] >= min_umis,\\n data.obs[\\\"n_counts\\\"] < max_umis,\\n data.obs[\\\"percent_mito\\\"] < percent_mito,\\n ]\\n\\n data.obs.loc[np.logical_and.reduce(filters), \\\"passed_qc\\\"] = True\\n\\n var = data.var\\n data = data[\\n data.obs[\\\"passed_qc\\\"]\\n ] # compute gene stats in space of filtered cells only\\n\\n var[\\\"n_cells\\\"] = data.X.getnnz(axis=0)\\n var[\\\"percent_cells\\\"] = (var[\\\"n_cells\\\"] / data.shape[0]) * 100\\n var[\\\"robust\\\"] = var[\\\"percent_cells\\\"] >= percent_cells\\n var[\\\"highly_variable_features\\\"] = var[\\n \\\"robust\\\"\\n ] # default all robust genes are \\\"highly\\\" variable\",\n \"def calc_data(self):\\n\\n circ_counts = {}\\n for trialidx in range(self._ntrials):\\n for _, depth in enumerate(self._depths):\\n circ_name = 'qv_depth_%d_trial_%d' % (depth, trialidx)\\n\\n # get the counts form ALL executed circuits\\n count_list = []\\n for result in self._result_list:\\n try:\\n count_list.append(result.get_counts(circ_name))\\n except (QiskitError, KeyError):\\n pass\\n\\n circ_counts[circ_name] = \\\\\\n build_counts_dict_from_list(count_list)\\n\\n self._circ_shots[circ_name] = \\\\\\n sum(circ_counts[circ_name].values())\\n\\n # calculate the heavy output probability\\n self._heavy_output_counts[circ_name] = \\\\\\n self._subset_probability(\\n self._heavy_outputs[circ_name],\\n circ_counts[circ_name])\",\n \"def compute_metrics(self):\\n pass\",\n \"def collect_data(self):\\n exp_conf: ec.ExperimentConfiguration\\n # Disabled multiprocess run because of huge memory usage\\n processes_number = 1 # self._campaign_configuration['General']['j']\\n if processes_number == 1:\\n self._logger.info(\\\"-->Evaluate experiments (sequentially)\\\")\\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\\n exp_conf.evaluate()\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n exp_conf.generate_plots()\\n self._logger.info(\\\"<--\\\")\\n else:\\n self._logger.info(\\\"-->Evaluate experiments (in parallel)\\\")\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n self._logger.info(\\\"<--\\\")\\n\\n self.raw_results = {}\\n for exp_conf in self._exp_confs:\\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes\",\n \"def get_test_cases_coverage(session_id):\\n tc_stats={}\\n tc_stats_list=[]\\n total_executed=0\\n sql='SELECT DISTINCT(test_id) FROM stats WHERE session_id=:sid AND test_id!=\\\"null\\\"'\\n params={\\\"sid\\\":session_id}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n tests=c.fetchall()\\n conn.close()\\n if len(tests)>0:\\n for t in tests:\\n total_executed=0\\n sql=\\\"SELECT DISTINCT(file_id) FROM stats WHERE session_id=:sid AND test_id=:tid\\\"\\n params={\\\"sid\\\":session_id,\\\"tid\\\":t[0]}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n files=c.fetchall()\\n conn.close()\\n for f in files:\\n line_count=get_executable_lines_count_for_file(f[0])\\n # get executions\\n sql=\\\"SELECT COUNT(DISTINCT line_guid) FROM stats WHERE session_id= :sid AND file_id= :fid AND test_id=:tid\\\"\\n params={\\\"sid\\\":session_id,\\\"tid\\\":t[0],\\\"fid\\\":f[0]}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n executed=c.fetchone()\\n conn.close()\\n total_executed+=executed[0]\\n # save test case and it's executions\\n tc_stats={}\\n tc_stats[\\\"test_id\\\"]=t[0]\\n tc_stats[\\\"total_executed\\\"]=total_executed\\n tc_stats[\\\"total_executed\\\"]\\n \\n tc_stats_list.append(tc_stats)\\n return tc_stats_list\",\n \"def mgcEval(self):\\n import numpy as np\\n def report_to_df(report):\\n\\n \\\"\\\"\\\"\\n function to convert classification report to dataframe (for visualisation plot)\\n \\\"\\\"\\\"\\n\\n report = re.sub(r\\\" +\\\", \\\" \\\", report).replace(\\\"avg / total\\\", \\\"avg/total\\\").replace(\\\"\\\\n \\\", \\\"\\\\n\\\")\\n # update this due to sklearn classification report output change\\n report = re.sub(r\\\" +\\\", \\\" \\\", report).replace(\\\"micro avg\\\", \\\"micro_avg\\\").replace(\\\"macro avg\\\", \\\"macro_avg\\\").replace(\\\"weighted avg\\\", \\\"weighted_avg\\\").replace(\\\"\\\\n \\\", \\\"\\\\n\\\")\\n report_df = pd.read_csv(StringIO(\\\"Classes\\\" + report), sep=' ', index_col=0) \\n return(report_df)\\n \\n #txt report to df\\n class_rpttop1 = classification_report(self.y_true, self.y_pred)\\n df_report = report_to_df(class_rpttop1)\\n\\n df_report = df_report.iloc[:self.nb_classes, :].copy()\\n df_report.index = df_report.index.astype(int)\\n \\n\\n # classifier prediction metrics\\n def classMetrics(averagex):\\n precision, recall, fscore, support = score(self.y_true, self.y_pred, average=averagex)\\n \\n return(\\n print(''), \\n print('-------------{0:}--------------------'.format(averagex)), \\n print('precision: {0:.4f}'.format(precision)),\\n print('recall: {0:.4f}'.format(recall)),\\n print('fscore: {0:.4f}'.format(fscore)),\\n print(''),\\n print('kappa score: {0:.4f}'.format(cohen_kappa_score(self.y_true, self.y_pred))),\\n print('accuracy score: {0:.4f}'.format(accuracy_score(self.y_true, self.y_pred))))\\n \\n def predSamp():\\n\\n correct = np.nonzero(self.y_pred==self.y_true)[0]\\n incorrect = np.nonzero(self.y_pred!=self.y_true)[0]\\n\\n # quick check of the number of correct prediction from validation set\\n print(\\\"\\\")\\n print(\\\"correct/total = {0: .4f}\\\".format(len(correct)/(len(correct)+len(incorrect))))\\n print(\\\"total correct sample = {0: .0f}\\\".format(len(correct)))\\n print('------------------------------------------------------------------')\\n \\n def classReport():\\n print('----------------------------- Classfication Report -------------------------------')\\n print(classification_report(pd.Series(self.y_true).map(self.dict_label), pd.Series(self.y_pred).map(self.dict_label)))\\n \\n self.class_rpt = pd.concat([pd.DataFrame(pd.Series(df_report.index.tolist()).map(self.dict_label), columns = ['label']), df_report], axis = 1)\\n \\n self.classMetricsMac = classMetrics(\\\"macro\\\")\\n self.classMetricsMic = classMetrics(\\\"micro\\\")\\n self.predSample = predSamp()\\n self.class_rptTop1 = classReport()\\n \\n return self\",\n \"def calculate_dataset_metrics(self):\\n pass\",\n \"def run_tests():\\n with open(FILENAME) as file:\\n # Loads testing parameters from the yaml file.\\n tests = yaml.safe_load(file)\\n\\n # create a dataframe to keep the results\\n test_dict = tests['Tests']\\n results = pd.DataFrame(test_dict)\\n results['Last Average Score'] = \\\"\\\"\\n results['No of Q-Learning episodes'] = \\\"\\\"\\n\\n # run experiments:\\n for i, test in enumerate(test_dict):\\n grid = Rooms(test[\\\"env_size\\\"], testing=True)\\n learning = QLearning(grid, test[\\\"gamma\\\"], test[\\\"alpha\\\"], test[\\\"agent_start_pos\\\"])\\n e_greedy = Policy(\\\"e-greedy\\\", test[\\\"epsilon\\\"], test[\\\"decay\\\"])\\n greedy = Policy(policy_type=\\\"greedy\\\")\\n experiment = Experiments(grid, learning, greedy, test[\\\"iters\\\"],\\n test[\\\"agent_start_pos\\\"], test[\\\"test_no\\\"])\\n\\n for session in range(test[\\\"iters\\\"]):\\n learning.run_multiple_episodes(test[\\\"batch_episodes\\\"], e_greedy)\\n mean_reward = experiment.run_experiments(test[\\\"exp_per_batch\\\"])\\n\\n results.loc[i,'Last Average Score'] = mean_reward\\n results.loc[i,'No of Q-Learning episodes'] = (session + 1) * test[\\\"batch_episodes\\\"]\\n\\n # save results to csv file\\n filename = 'results/' + 'test_table.csv'\\n results.to_csv(filename)\\n\\n # plot & save graphs\\n experiment.generate_results(test[\\\"test_no\\\"], test)\\n\\n return results\",\n \"def test_evaluate(self):\\n # test normalized by 'bbox'\\n pck_metric = PCKAccuracy(thr=0.5, norm_item='bbox')\\n pck_metric.process(self.data_batch, self.data_samples)\\n pck = pck_metric.evaluate(self.batch_size)\\n target = {'PCK': 1.0}\\n self.assertDictEqual(pck, target)\\n\\n # test normalized by 'head_size'\\n pckh_metric = PCKAccuracy(thr=0.3, norm_item='head')\\n pckh_metric.process(self.data_batch, self.data_samples)\\n pckh = pckh_metric.evaluate(self.batch_size)\\n target = {'PCKh': 1.0}\\n self.assertDictEqual(pckh, target)\\n\\n # test normalized by 'torso_size'\\n tpck_metric = PCKAccuracy(thr=0.05, norm_item=['bbox', 'torso'])\\n tpck_metric.process(self.data_batch, self.data_samples)\\n tpck = tpck_metric.evaluate(self.batch_size)\\n self.assertIsInstance(tpck, dict)\\n target = {\\n 'PCK': 1.0,\\n 'tPCK': 1.0,\\n }\\n self.assertDictEqual(tpck, target)\",\n \"def initialize_metrics():\\n metrics = {\\n 'cd_losses': [],\\n 'cd_corrects': [],\\n 'cd_precisions': [],\\n 'cd_recalls': [],\\n 'cd_f1scores': [],\\n }\\n\\n return metrics\",\n \"def run_tests(self, validate=False):\\n fitness = 0\\n\\n for test_set in [self.debugger.PASS, self.debugger.FAIL]:\\n passed = self.run_test_set(test_set, validate=validate)\\n ratio = passed / len(self.debugger.collectors[test_set])\\n fitness += self.weight(test_set) * ratio\\n\\n return fitness\",\n \"def run_test(self):\\n self.output_analytics = self.run_inference()\\n self.output_df = pd.DataFrame(self.output_analytics)\",\n \"def compute_metrics(self, results: list) -> dict:\",\n \"def evaluate_benchmarks(self):\\n\\n # iterate over replicates\\n results = {}\\n for replicate_id, replicate in self.replicates:\\n\\n # evaluate benchmark for current replicate\\n bmark = SimulationBenchmark(replicate.copy(),\\n graph=self.graphs[replicate_id],\\n **self.params)\\n\\n # store results\\n results[replicate_id] = dict(\\n\\n labels_MAE=bmark.scores['labels'].MAE,\\n level_only_MAE=bmark.scores['level_only'].MAE,\\n spatial_only_MAE=bmark.scores['spatial_only'].MAE,\\n community_MAE=bmark.scores['labels_comm'].MAE,\\n\\n labels_PCT=bmark.scores['labels'].percent_correct,\\n level_only_PCT=bmark.scores['level_only'].percent_correct,\\n spatial_only_PCT=bmark.scores['spatial_only'].percent_correct,\\n community_PCT=bmark.scores['labels_comm'].percent_correct)\\n\\n # compile dataframe\\n results = pd.DataFrame.from_dict(results, orient='index')\\n results.index.set_names(self.multiindex, inplace=True)\\n\\n return results\",\n \"def _calculate_metrics(self):\\n metrics = {}\\n precision, recall = self.calc_precision_recall()\\n metrics[\\\"precision\\\"] = precision\\n metrics[\\\"recall\\\"] = recall\\n metrics[\\\"entropy\\\"] = self.calc_entropy()\\n metrics[\\\"component_entropy\\\"] = self.calc_component_entropy()\\n metrics[\\\"num_comps\\\"] = len(self.get_components())\\n metrics[\\\"num_diagnoses\\\"] = len(self.diagnoses)\\n metrics[\\\"distinct_diagnoses_scores\\\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\\n metrics[\\\"num_tests\\\"] = len(self.get_tests())\\n metrics[\\\"num_distinct_traces\\\"] = len(self.get_distinct_traces())\\n metrics[\\\"num_failed_tests\\\"] = len(self._get_tests_by_error(1))\\n metrics[\\\"num_passed_tests\\\"] = len(self._get_tests_by_error(0))\\n passed_comps = set(self._get_components_by_error(0))\\n failed_comps = set(self.get_components_in_failed_tests())\\n metrics[\\\"num_failed_comps\\\"] = len(failed_comps)\\n metrics[\\\"only_failed_comps\\\"] = len(failed_comps - passed_comps)\\n metrics[\\\"only_passed_comps\\\"] = len(passed_comps - failed_comps)\\n metrics[\\\"num_bugs\\\"] = len(self.get_bugs())\\n metrics[\\\"wasted\\\"] = self.calc_wasted_components()\\n metrics[\\\"top_k\\\"] = self.calc_top_k()\\n metrics[\\\"num_comps_in_diagnoses\\\"] = len(self._get_comps_in_diagnoses())\\n metrics[\\\"bugs_cover_ratio\\\"] = self._get_bugs_cover_ratio()\\n metrics[\\\"average_trace_size\\\"] = self._get_average_trace_size()\\n metrics[\\\"average_component_activity\\\"] = self._get_average_component_activity()\\n metrics[\\\"average_diagnosis_size\\\"] = self._get_average_diagnosis_size()\\n metrics[\\\"bugs_scores_average\\\"], metrics[\\\"bugs_scores_std\\\"], metrics[\\\"bugs_scores_entropy\\\"] = self._get_bugs_scores()\\n metrics[\\\"non_bugs_scores_average\\\"], metrics[\\\"non_bugs_scores_std\\\"], metrics[\\\"non_bugs_scores_entropy\\\"] = self._get_non_bugs_scores()\\n metrics.update(self.cardinality())\\n # metrics[\\\"ochiai\\\"] = self.calc_ochiai_values()\\n return metrics\",\n \"def run_tests():\\n with open(FILENAME) as file:\\n\\n # Loads the test hyper-parameters as dictionaries.\\n tests = yaml.safe_load(file)\\n \\n # create a dataframe to keep the results\\n test_dict = tests['Tests']\\n results = pd.DataFrame(test_dict)\\n results[\\\"Episode\\\"] = \\\"\\\"\\n results['Max average score'] = \\\"\\\"\\n\\n for i, test in enumerate(tests['Tests']):\\n\\n env = gym.make(test['env'])\\n env.reset()\\n\\n actor_critic = ActorCritic(env, test['episodes'], test['max_score'], \\n test['hidden_size'], test['gamma'], test['save'])\\n\\n ## run training \\n best_score, episode, rew_hist = actor_critic.train()\\n\\n results.loc[i,'Episode'] = episode\\n results.loc[i,'Max average score'] = best_score\\n\\n plot_graphs(test, rew_hist)\\n\\n # save results to csv file\\n filename = 'results/' + 'test_table.csv'\\n results.to_csv(filename)\\n\\n return results\",\n \"def evaluate(self):\\n results = dict()\\n for metric in self.metrics:\\n print('Evaluating clustering with metric %s' % metric)\\n if metric in LABEL_METRICS.keys():\\n results[metric] = LABEL_METRICS[metric](self.X, self.model.labels_)\\n results['adjusted_rand_score'] = SCORE_METRICS['adjusted_rand_score'](self.Y[:, 0], self.model.labels_)\\n self.results = results\\n return results\",\n \"def evaluate(self, test):\\r\\n self.logger.info(\\\"Testing model over test set\\\")\\r\\n metrics = self.run_evaluate(test)\\r\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\r\\n for k, v in metrics.items()])\\r\\n self.logger.info(msg)\\r\\n return metrics\",\n \"def make_metrics(self):\\n num_batches = self.data_loader.number_of_batches()\\n dose_score_vec = np.zeros(num_batches)\\n\\n # Only make calculations if data_loader is not empty\\n if not self.data_loader.file_paths_list:\\n print('No patient information was given to calculate metrics')\\n else:\\n # Change batch size to 1\\n self.data_loader.batch_size = 1 # Loads data related to ground truth patient information\\n if self.dose_loader is not None:\\n self.dose_loader.batch_size = 1 # Loads data related to ground truth patient information\\n\\n for idx in tqdm.tqdm(range(num_batches)):\\n # Get roi masks for patient\\n self.get_constant_patient_features(idx)\\n # Get dose tensors for reference dose and evaluate criteria\\n reference_dose = self.get_patient_dose_tensor(self.data_loader)\\n if reference_dose is not None:\\n self.reference_dose_metric_df = self.calculate_metrics(self.reference_dose_metric_df, reference_dose)\\n # If a dose loader was provided, calculate the score\\n if self.dose_loader is not None:\\n new_dose = self.get_patient_dose_tensor(self.dose_loader)\\n # Make metric data frames\\n self.new_dose_metric_df = self.calculate_metrics(self.new_dose_metric_df, new_dose)\\n # Evaluate mean absolute error of 3D dose\\n dose_score_vec[idx] = np.sum(np.abs(reference_dose - new_dose)) / np.sum(self.possible_dose_mask)\\n # Save metrics at the patient level (this is a template for how DVH stream participants could save\\n # their files\\n # self.dose_metric_df.loc[self.patient_list[0]].to_csv('{}.csv'.format(self.patient_list[0]))\\n\\n if self.dose_loader is not None:\\n dvh_score = np.nanmean(np.abs(self.reference_dose_metric_df - self.new_dose_metric_df).values)\\n dose_score = dose_score_vec.mean()\\n return dvh_score, dose_score\\n else:\\n print('No new dose provided. Metrics were only calculated for the provided dose.')\",\n \"def run_faqc(self, **kwargs):\\n if self.qc is True:\\n build([FaQC.SummarizeQC(fastq_dic=self.fastq_dic,\\n num_cpus=self.num_cpus,\\n workdir=self.workdir)],\\n local_scheduler=self.local_scheduler,\\n workers=1)\\n qc_dic = {}\\n for samp, path in self.fastq_dic.items():\\n trim_dir = os.path.join(self.workdir, \\\"processes\\\", \\\"qc\\\", samp)\\n qc_dic[samp] = trim_dir + \\\"/\\\" + samp + \\\".1.trimmed.fastq\\\" + \\\":\\\" + \\\\\\n trim_dir + \\\"/\\\" + samp + \\\".2.trimmed.fastq\\\" \\n return qc_dic\\n\\n else:\\n return self.fastq_dic\",\n \"def calculate_metrics(self):\\n self.data_stats = self.sqlContext.read.format(\\\"org.apache.spark.sql.cassandra\\\").options(table=self.cassandra_trip_table, keyspace=self.cassandra_keyspace).load()\\n self.data_stats = self.data_stats.groupBy(['time_block','day','month','borough_name']).agg(func.avg('num_trips').alias('mean'))\",\n \"def evaluate_data():\\n try:\\n # General system related info\\n ram = psutil.virtual_memory()\\n total_ram = round((ram.total / 1024 / 1024),2)\\n free_ram = round((ram.available / 1024 / 1024),2)\\n used_ram = round((ram.used / 1024 / 1024),2)\\n cpu_total = psutil.cpu_count(logical=True)\\n cpu_loadavg = round([x / cpu_total * 100 for x in psutil.getloadavg()][0],2)\\n acs_8080 = sp.getoutput(\\\"netstat -an|grep -c 8080\\\")\\n acs_8181 = sp.getoutput(\\\"netstat -an|grep -c 8181\\\")\\n acs_8443 = sp.getoutput(\\\"netstat -an|grep -c 8443\\\")\\n mysql = sp.getoutput(\\\"netstat -an|grep -c 3306\\\")\\n oracle = sp.getoutput(\\\"netstat -an|grep -c 1521\\\")\\n logging.info('General system info obtained')\\n except Exception as e:\\n logging.exception(f\\\"EXCEPTION: {e} \\\\n Full stack trace: \\\\n\\\", exc_info=1)\\n # Process specific details\\n try:\\n iis_pid = SystemInformation.get_pid(\\\"w3wp.exe\\\")\\n iis_ram = SystemInformation.get_ram_usage(iis_pid)\\n iis_cpu = SystemInformation.get_cpu_usage(iis_pid)\\n java_pid = SystemInformation.get_pid(\\\"java.exe\\\")\\n java_ram = SystemInformation.get_ram_usage(java_pid)\\n java_cpu = SystemInformation.get_cpu_usage(java_pid)\\n mysqld_pid = SystemInformation.get_pid(\\\"mysqld.exe\\\")\\n mysqld_ram = SystemInformation.get_ram_usage(mysqld_pid) \\n mysqld_cpu = SystemInformation.get_cpu_usage(mysqld_pid)\\n except Exception as e:\\n logging.exception(f\\\"EXCEPTION: {e} \\\\n Full stack trace: \\\\n\\\", exc_info=1)\\n\\n try:\\n dictionary = {}\\n now = datetime.datetime.now()\\n timestampt = now.strftime(\\\"%Y-%m-%d-%H:%M:%S\\\")\\n fieldnames = ['timestampt','total_ram','free_ram','used_ram','cpu_total','cpu_loadavg','acs_8080','acs_8181','acs_8443','mysql','oracle','iis_ram','iis_cpu','java_ram','java_cpu','mysqld_ram','mysqld_cpu']\\n for var in fieldnames:\\n dictionary[var] = eval(var)\\n \\n logging.info('Data for report generated')\\n return dictionary\\n except Exception as e:\\n logging.exception(f\\\"EXCEPTION: {e} \\\\n Full stack trace: \\\\n\\\", exc_info=1)\",\n \"def _cv_results(self, metrics):\\n\\n param_keys = self.param_combs[0].keys()\\n param_dict = {k: [comb[k] for comb in self.param_combs]\\n for k in param_keys}\\n df_metric_result = {k: pd.DataFrame({'Metric mean': self.mean[k],\\n 'Std. dev.': self.std[k],\\n **param_dict})\\n for k in metrics.keys()}\\n self.cv_results_ = df_metric_result\",\n \"def execute_testsets(testsets):\\n group_results = dict() #results, by group\\n group_failure_counts = dict()\\n total_failures = 0\\n myinteractive = False\\n\\n for testset in testsets:\\n mytests = testset.tests\\n myconfig = testset.config\\n mybenchmarks = testset.benchmarks\\n\\n #Make sure we actually have tests to execute\\n if not mytests and not mybenchmarks:\\n # no tests in this test set, probably just imports.. skip to next test set\\n break\\n\\n myinteractive = True if myinteractive or myconfig.interactive else False\\n\\n #Run tests, collecting statistics as needed\\n for test in mytests:\\n #Initialize the dictionaries to store test fail counts and results\\n if test.group not in group_results:\\n group_results[test.group] = list()\\n group_failure_counts[test.group] = 0\\n\\n result = run_test(test, test_config = myconfig)\\n result.body = None # Remove the body, save some memory!\\n\\n if not result.passed: #Print failure, increase failure counts for that test group\\n logging.error('Test Failed: '+test.name+\\\" URL=\\\"+test.url+\\\" Group=\\\"+test.group+\\\" HTTP Status Code: \\\"+str(result.response_code))\\n\\n if test.validators is not None:\\n for validator in test.validators:\\n if validator.passed == False:\\n logging.warning(\\\" Validation Failed: \\\" + str(validator))\\n\\n #Increment test failure counts for that group (adding an entry if not present)\\n failures = group_failure_counts[test.group]\\n failures = failures + 1\\n group_failure_counts[test.group] = failures\\n\\n else: #Test passed, print results\\n logging.info('Test Succeeded: '+test.name+\\\" URL=\\\"+test.url+\\\" Group=\\\"+test.group)\\n\\n #Add results for this test group to the resultset\\n group_results[test.group].append(result)\\n\\n # handle stop_on_failure flag\\n if not result.passed and test.stop_on_failure is not None and test.stop_on_failure:\\n print 'STOP ON FAILURE! stopping test set execution, continuing with other test sets'\\n break\\n\\n for benchmark in mybenchmarks: # Run benchmarks, analyze, write\\n if not benchmark.metrics:\\n logging.debug('Skipping benchmark, no metrics to collect')\\n continue\\n\\n logging.info(\\\"Benchmark Starting: \\\"+benchmark.name+\\\" Group: \\\"+benchmark.group)\\n curl = configure_curl(benchmark, myconfig)\\n benchmark_result = run_benchmark(curl, benchmark, myconfig)\\n print benchmark_result\\n logging.info(\\\"Benchmark Done: \\\"+benchmark.name+\\\" Group: \\\"+benchmark.group)\\n\\n if benchmark.output_file: # Write file\\n write_method = OUTPUT_METHODS[benchmark.output_format]\\n my_file = open(benchmark.output_file, 'w') # Overwrites file\\n logging.debug(\\\"Benchmark writing to file: \\\" + benchmark.output_file)\\n write_method(my_file, benchmark_result, benchmark, test_config = myconfig)\\n my_file.close()\\n\\n if myinteractive:\\n # a break for when interactive bits are complete, before summary data\\n print \\\"===================================\\\"\\n\\n #Print summary results\\n for group in sorted(group_results.keys()):\\n test_count = len(group_results[group])\\n failures = group_failure_counts[group]\\n total_failures = total_failures + failures\\n if (failures > 0):\\n print u'Test Group '+group+u' FAILED: '+ str((test_count-failures))+'/'+str(test_count) + u' Tests Passed!'\\n else:\\n print u'Test Group '+group+u' SUCCEEDED: '+ str((test_count-failures))+'/'+str(test_count) + u' Tests Passed!'\\n\\n return total_failures\",\n \"def execute(self, context):\\n redshift_hook = PostgresHook(postgres_conn_id=self.redshift_conn_id)\\n\\n for data_check in self.data_checks:\\n records = redshift_hook.get_records(data_check[\\\"sql\\\"])\\n num_records = records[0][0]\\n\\n assert (num_records != data_check[\\\"expected_result\\\"]) , \\\\\\n f\\\"Data quality test returned unexpected result.\\\"\\n\\n self.log.info('DataQualityOperator not implemented yet')\",\n \"def metrics(self):\\n raise NotImplementedError(\\\"metrics\\\")\",\n \"def do_system_evaluation(dataset, result_path, dataset_evaluation_mode='folds'):\\n\\n # Set warnings off, sklearn metrics will trigger warning for classes without\\n # predicted samples in F1-scoring. This is just to keep printing clean.\\n warnings.simplefilter(\\\"ignore\\\")\\n\\n overall_metrics_per_scene = {}\\n\\n for scene_id, scene_label in enumerate(dataset.scene_labels):\\n if scene_label not in overall_metrics_per_scene:\\n overall_metrics_per_scene[scene_label] = {}\\n\\n dcase2016_segment_based_metric = DCASE2016_EventDetection_SegmentBasedMetrics(class_list=dataset.event_labels(scene_label=scene_label))\\n dcase2016_event_based_metric = DCASE2016_EventDetection_EventBasedMetrics(class_list=dataset.event_labels(scene_label=scene_label))\\n\\n for fold in dataset.folds(mode=dataset_evaluation_mode):\\n results = []\\n result_filename = get_result_filename(fold=fold, scene_label=scene_label, path=result_path)\\n\\n if os.path.isfile(result_filename):\\n with open(result_filename, 'rt') as f:\\n for row in csv.reader(f, delimiter='\\\\t'):\\n results.append(row)\\n else:\\n raise IOError(\\\"Result file not found [%s]\\\" % result_filename)\\n\\n for file_id, item in enumerate(dataset.test(fold, scene_label=scene_label)):\\n current_file_results = []\\n for result_line in results:\\n if len(result_line) != 0 and result_line[0] == dataset.absolute_to_relative(item['file']):\\n current_file_results.append(\\n {'file': result_line[0],\\n 'event_onset': float(result_line[1]),\\n 'event_offset': float(result_line[2]),\\n 'event_label': result_line[3].rstrip()\\n }\\n )\\n meta = dataset.file_meta(dataset.absolute_to_relative(item['file']))\\n\\n dcase2016_segment_based_metric.evaluate(system_output=current_file_results, annotated_ground_truth=meta)\\n dcase2016_event_based_metric.evaluate(system_output=current_file_results, annotated_ground_truth=meta)\\n\\n overall_metrics_per_scene[scene_label]['segment_based_metrics'] = dcase2016_segment_based_metric.results()\\n overall_metrics_per_scene[scene_label]['event_based_metrics'] = dcase2016_event_based_metric.results()\\n\\n print \\\" Evaluation over %d folds\\\" % dataset.fold_count\\n print \\\" \\\"\\n print \\\" Results per scene \\\"\\n print \\\" {:18s} | {:5s} | | {:39s} \\\".format('', 'Main', 'Secondary metrics')\\n print \\\" {:18s} | {:5s} | | {:38s} | {:14s} | {:14s} | {:14s} \\\".format('', '', 'Seg/Overall','Seg/Class', 'Event/Overall','Event/Class')\\n print \\\" {:18s} | {:5s} | | {:6s} : {:5s} : {:5s} : {:5s} : {:5s} | {:6s} : {:5s} | {:6s} : {:5s} | {:6s} : {:5s} |\\\".format('Scene', 'ER', 'F1', 'ER', 'ER/S', 'ER/D', 'ER/I', 'F1', 'ER', 'F1', 'ER', 'F1', 'ER')\\n print \\\" -------------------+-------+ +--------+-------+-------+-------+-------+--------+-------+--------+-------+--------+-------+\\\"\\n averages = {\\n 'segment_based_metrics': {\\n 'overall': {\\n 'ER': [],\\n 'F': [],\\n },\\n 'class_wise_average': {\\n 'ER': [],\\n 'F': [],\\n }\\n },\\n 'event_based_metrics': {\\n 'overall': {\\n 'ER': [],\\n 'F': [],\\n },\\n 'class_wise_average': {\\n 'ER': [],\\n 'F': [],\\n }\\n },\\n }\\n for scene_id, scene_label in enumerate(dataset.scene_labels):\\n print \\\" {:18s} | {:5.2f} | | {:4.1f} % : {:5.2f} : {:5.2f} : {:5.2f} : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} |\\\".format(scene_label,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['F'] * 100,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['S'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['D'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['I'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F']*100,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'],\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['F']*100,\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['ER'],\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F']*100,\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'],\\n )\\n averages['segment_based_metrics']['overall']['ER'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'])\\n averages['segment_based_metrics']['overall']['F'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['F'])\\n averages['segment_based_metrics']['class_wise_average']['ER'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'])\\n averages['segment_based_metrics']['class_wise_average']['F'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F'])\\n averages['event_based_metrics']['overall']['ER'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['ER'])\\n averages['event_based_metrics']['overall']['F'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['F'])\\n averages['event_based_metrics']['class_wise_average']['ER'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'])\\n averages['event_based_metrics']['class_wise_average']['F'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F'])\\n\\n print \\\" -------------------+-------+ +--------+-------+-------+-------+-------+--------+-------+--------+-------+--------+-------+\\\"\\n print \\\" {:18s} | {:5.2f} | | {:4.1f} % : {:5.2f} : {:21s} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} |\\\".format('Average',\\n numpy.mean(averages['segment_based_metrics']['overall']['ER']),\\n numpy.mean(averages['segment_based_metrics']['overall']['F'])*100,\\n numpy.mean(averages['segment_based_metrics']['overall']['ER']),\\n ' ',\\n numpy.mean(averages['segment_based_metrics']['class_wise_average']['F'])*100,\\n numpy.mean(averages['segment_based_metrics']['class_wise_average']['ER']),\\n numpy.mean(averages['event_based_metrics']['overall']['F'])*100,\\n numpy.mean(averages['event_based_metrics']['overall']['ER']),\\n numpy.mean(averages['event_based_metrics']['class_wise_average']['F'])*100,\\n numpy.mean(averages['event_based_metrics']['class_wise_average']['ER']),\\n )\\n\\n print \\\" \\\"\\n # Restore warnings to default settings\\n warnings.simplefilter(\\\"default\\\")\\n print \\\" Results per events \\\"\\n\\n for scene_id, scene_label in enumerate(dataset.scene_labels):\\n print \\\" \\\"\\n print \\\" \\\"+scene_label.upper()\\n print \\\" {:20s} | {:30s} | | {:15s} \\\".format('', 'Segment-based', 'Event-based')\\n print \\\" {:20s} | {:5s} : {:5s} : {:6s} : {:5s} | | {:5s} : {:5s} : {:6s} : {:5s} |\\\".format('Event', 'Nref', 'Nsys', 'F1', 'ER', 'Nref', 'Nsys', 'F1', 'ER')\\n print \\\" ---------------------+-------+-------+--------+-------+ +-------+-------+--------+-------+\\\"\\n seg_Nref = 0\\n seg_Nsys = 0\\n\\n event_Nref = 0\\n event_Nsys = 0\\n for event_label in sorted(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise']):\\n print \\\" {:20s} | {:5d} : {:5d} : {:4.1f} % : {:5.2f} | | {:5d} : {:5d} : {:4.1f} % : {:5.2f} |\\\".format(event_label,\\n int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nref']),\\n int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nsys']),\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['F']*100,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['ER'],\\n int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nref']),\\n int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nsys']),\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['F']*100,\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['ER'])\\n seg_Nref += int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nref'])\\n seg_Nsys += int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nsys'])\\n\\n event_Nref += int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nref'])\\n event_Nsys += int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nsys'])\\n print \\\" ---------------------+-------+-------+--------+-------+ +-------+-------+--------+-------+\\\"\\n print \\\" {:20s} | {:5d} : {:5d} : {:14s} | | {:5d} : {:5d} : {:14s} |\\\".format('Sum',\\n seg_Nref,\\n seg_Nsys,\\n '',\\n event_Nref,\\n event_Nsys,\\n '')\\n print \\\" {:20s} | {:5s} {:5s} : {:4.1f} % : {:5.2f} | | {:5s} {:5s} : {:4.1f} % : {:5.2f} |\\\".format('Average',\\n '', '',\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F']*100,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'],\\n '', '',\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F']*100,\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'])\\n print \\\" \\\"\",\n \"def compute_statistics(self):\",\n \"def evaluate(self, test):\\n self.logger.info(\\\"Testing model over test set\\\")\\n metrics = self.run_evaluate(test)\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\n for k, v in metrics.items()])\\n self.logger.info(msg)\\n return metrics\",\n \"def evaluate(self, dataset):\\n logging.info('Start evaluation')\\n\\n loss, predictions, labels = self.run_one_epoch(dataset, RunnerPhase.VALIDATE)\\n\\n metrics_dict = self.metric_class.get_metrics_dict(predictions, labels)\\n\\n eval_info = self.metric_class.metrics_dict_to_str(metrics_dict)\\n\\n logging.info(eval_info)\\n\\n logging.info('Evaluation finished')\\n\\n return metrics_dict\",\n \"def compute_metrics(self, train_data, test_data, criterion):\\n m = self.metrics\\n warnings.filterwarnings('ignore','Mean of empty slice')\\n\\n ## load data\\n trn, trn_labs = train_data\\n tst, tst_labs = test_data\\n\\n # trn = trn.transpose(1,0)\\n tst = tst.transpose(1,0)\\n\\n t_final = -(np.flipud(trn!=self.padding).argmax(0)+1)\\n test_tfinal = -(np.flipud(tst!=self.padding).argmax(0)+1)\\n\\n ntest = tst.size(1)\\n P = self.decoder.out_features\\n\\n ## training data ###########################################################\\n # hidden = self.init_hidden(trn.size(1))\\n # out, hidden = self.transparent_forward(trn, hidden)\\n # # output = out[t_final, np.arange(trn.size(1)), :]\\n # output = out.squeeze()\\n # # compute orthogonality\\n # mem_act = np.array([np.cumsum(trn==p,axis=0).int().detach().numpy() % 2 \\\\\\n # for p in range(self.q_)]).transpose((1,2,0))\\n\\n # ps_clf = LinearDecoder(self, 2**(self.q_-1), MeanClassifier)\\n # ps = []\\n # for d in Dichotomies(mem_act, 'simple'):\\n # np.warnings.filterwarnings('ignore',message='invalid value encountered in')\\n # ps_clf.fit(hidden.detach().numpy(), d)\\n # new_ps = ps_clf.orthogonality()\\n # ps.append(new_ps)\\n # # if new_ps > ps:\\n # # ps = new_ps\\n # m['train_parallelism'] = np.append(m['train_parallelism'], np.array(ps).T, axis=0)\\n\\n # # print(mem_act.shape)\\n # # print(hidden.shape)\\n # # self.orth_clf.fit(hidden.detach().numpy(), mem_act)\\n # # orth_score = self.orth_clf.orthogonality()\\n # # m['train_orthogonality'] = np.append(m['train_orthogonality'], orth_score)\\n\\n ## test data ##############################################################\\n hidden = self.init_hidden(tst.size(1))\\n out, hidden = self.transparent_forward(tst, hidden)\\n # output = out.squeeze()\\n # print(hidden.shape)\\n # print(out.shape)\\n # print(test_tfinal)\\n output = out[test_tfinal, np.arange(tst.size(1)), :]\\n # raise Exception\\n\\n # compute loss\\n test_loss = criterion(output.squeeze(0),tst_labs.squeeze())\\n\\n m['test_loss'] = np.append(m['test_loss'], test_loss.item())\\n\\n # compute orthogonality\\n # mem_act = np.array([np.cumsum(tst==p,axis=0).int().detach().numpy() % 2 \\\\\\n # for p in range(self.q_)]).transpose((1,2,0))\\n\\n # # self.orth_clf.fit(hidden.detach().numpy(), mem_act)\\n # # orth_score = self.orth_clf.orthogonality()\\n # # m['test_orthogonality'] = np.append(m['test_orthogonality'], orth_score)\\n\\n # # compute parallelism\\n # ps_clf = LinearDecoder(self, 2**(self.q_-1), MeanClassifier)\\n # ps = []\\n # for d in Dichotomies(mem_act, 'simple'):\\n # np.warnings.filterwarnings('ignore',message='invalid value encountered in')\\n # ps_clf.fit(hidden.detach().numpy(), d)\\n # new_ps = ps_clf.orthogonality()\\n # ps.append(new_ps)\\n # # if new_ps > ps:\\n # # ps = new_ps\\n # m['test_parallelism'] = np.append(m['test_parallelism'], np.array(ps).T, axis=0)\\n\\n ## package #################################################################\\n self.metrics = m\\n warnings.filterwarnings('default')\",\n \"def test_get_qc_metrics(integrated_ff):\\n\\n key, ff_env = integrated_ff['ff_key'], integrated_ff['ff_env']\\n uuid = '331106bc-8535-3338-903e-854af460b544'\\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, key=key, ff_env=ff_env)\\n assert len(qc_metrics.keys()) == 1\\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\\n target_qc = qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']\\n assert 'QualityMetric' in target_qc['values']['@type']\\n assert target_qc['organism'] == 'human'\\n assert target_qc['experiment_type'] == 'Dilution Hi-C'\\n assert target_qc['experiment_subclass'] == 'Hi-C'\\n assert target_qc['source_file_association'] == 'processed_files'\\n assert target_qc['source_experiment'] == '4DNEXO67APV1'\\n assert target_qc['source_experimentSet'] == '4DNESOPFAAA1'\\n assert target_qc['biosource_summary'] == \\\"GM12878\\\"\\n\\n kwargs = { # do same as above w/ kwargs, specify to include raw files this time\\n 'key': key,\\n 'ff_env': ff_env,\\n 'include_raw_files': True\\n }\\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, **kwargs)\\n assert len(qc_metrics.keys()) == 2\\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\\n assert '4c9dabc6-61d6-4054-a951-c4fdd0023800' in qc_metrics\\n assert 'QualityMetric' in qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']['values']['@type']\\n assert 'QualityMetric' in qc_metrics['4c9dabc6-61d6-4054-a951-c4fdd0023800']['values']['@type']\",\n \"def compute_statistics(self):\\n for i in range(len(self.wine_matrix[0, :])):\\n feature = self.wine_matrix[:, i]\\n self.wine_stats['feature ' + str(i)] = {}\\n if i == 11: # results column\\n self.wine_stats['feature ' + str(i)]['positive_class_ratio'] = (feature == 1).sum() / len(feature)\\n null, self.wine_stats['feature ' + str(i)]['pvalue'] = stats.normaltest(feature)\\n\\n # plot\\n # pyplot.hist(feature, bins=50)\\n # pyplot.show()\\n\\n for i in range(len(self.cancer_matrix[0, :])):\\n feature = self.cancer_matrix[:, i]\\n self.cancer_stats['feature ' + str(i)] = {}\\n if i == 10: # results column\\n self.cancer_stats['feature ' + str(i)]['positive_class_ratio'] = (feature == 1).sum() / len(feature)\\n null, self.cancer_stats['feature ' + str(i)]['pvalue'] = stats.normaltest(feature)\\n\\n # plot\\n # pyplot.hist(feature, bins=50)\\n # pyplot.show()\",\n \"def _run():\\n subprocess.check_call(\\n [\\n \\\"tools/bazel\\\",\\n \\\"build\\\",\\n \\\"-c\\\",\\n \\\"opt\\\",\\n \\\"test/core/memory_usage/memory_usage_test\\\",\\n ]\\n )\\n ret = {}\\n for name, benchmark_args in _BENCHMARKS.items():\\n for scenario, extra_args in _SCENARIOS.items():\\n # TODO(chenancy) Remove when minstack is implemented for channel\\n if name == \\\"channel\\\" and scenario == \\\"minstack\\\":\\n continue\\n try:\\n output = subprocess.check_output(\\n [\\n \\\"bazel-bin/test/core/memory_usage/memory_usage_test\\\",\\n ]\\n + benchmark_args\\n + extra_args\\n )\\n except subprocess.CalledProcessError as e:\\n print(\\\"Error running benchmark:\\\", e)\\n continue\\n for line in output.splitlines():\\n for key, (pattern, conversion) in _INTERESTING.items():\\n m = re.match(pattern, line)\\n if m:\\n ret[scenario + \\\": \\\" + key] = conversion(m.group(1))\\n return ret\",\n \"def session_counting (self, target_dict, IEI_timeRange = (0, 900, 1), cal_IEI = True, cal_duration = True, cal_latency = True, cal_inputDistribution = True, num_bins = 10, **kwards):\\r\\n if len(self.df) == 0:\\r\\n #if empty then pass without analysis\\r\\n pass\\r\\n else:\\r\\n get_kwards = lambda x: (\\\"\\\",\\\"\\\") if x == None else x\\r\\n input1OnOff = get_kwards(kwards.get('Input1OnOff'))\\r\\n input2OnOff = get_kwards(kwards.get('Input2OnOff'))\\r\\n input3OnOff = get_kwards(kwards.get('Input3OnOff'))\\r\\n input4OnOff = get_kwards(kwards.get('Input4OnOff'))\\r\\n \\r\\n #get a start and end time point\\r\\n if 'Start' in self.df['States'].values:\\r\\n start = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Start')]['Time']\\r\\n else:\\r\\n start = pd.Series({'Start': self.df['Time'].values[0]-1})\\r\\n \\r\\n if 'Finish' in self.df['States'].values:\\r\\n end = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Finish')]['Time']\\r\\n else:\\r\\n end = pd.Series({'Finish': self.df['Time'].values[-1]+1}) #plus 1 second\\r\\n \\r\\n #get data from each event window\\r\\n event = self.df[(self.df['Time']>= start.iloc[0])&(self.df['Time']<= end.iloc[0])]\\r\\n \\r\\n result_dict = {}\\r\\n for k, v in target_dict.items():\\r\\n \\r\\n if k == 'Input1':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input1OnOff)\\r\\n elif k == 'Input2':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input2OnOff)\\r\\n elif k == 'Input3':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input3OnOff)\\r\\n elif k == 'Input4':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input4OnOff)\\r\\n else:\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject)\\r\\n \\r\\n return result_dict\",\n \"def metric_tests(self, metric_tests: Dict[str, FAIRResultEvaluationCriterium]):\\n\\n self._metric_tests = metric_tests\",\n \"def makedata():\\n # train\\n print('Clean Train Dataset and separate questions')\\n df = pd.read_csv(TRAIN_DATASET).replace(np.nan, ' ')\\n t = df.shape[0] * 2\\n print t\\n df['question1'] = cleanText(df['question1'])\\n df['question2'] = cleanText(df['question2'])\\n\\n df.to_csv(os.path.join(rootpathdata_cleaned, 'train.csx'), index=False)\\n overallquestions = df['question1'].tolist() + df['question2'].tolist()\\n tpm = pd.DataFrame()\\n tpm['question'] = overallquestions\\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'train_allquestions.csx'), index=False)\\n # test\\n\\n print('Clean Test Dataset and separate questions')\\n df = pd.read_csv(TEST_DATASET).fillna(' ')\\n t1 = df.shape[0] * 2\\n df['question1'] = cleanText(df['question1'])\\n df['question2'] = cleanText(df['question2'])\\n df.to_csv(os.path.join(rootpathdata_cleaned, 'test.csx'), index=False)\\n\\n overallquestions += df['question1'].tolist() + df['question2'].tolist()\\n tpm = pd.DataFrame()\\n tpm['question'] = overallquestions\\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'test_allquestions.csx'), index=False)\\n print len(overallquestions), t1 + t\",\n \"def evaluate(self, benchmark_data, metrics={}, options={}):\\n dir_name = list(benchmark_data.keys())[0]\\n relations = list(benchmark_data.values())[0]\\n \\n if \\\"relation\\\" in options :\\n relations = [options[\\\"relation\\\"]]\\n \\n precision_total = 0\\n for relation in relations :\\n if relation.endswith(\\\"_inv\\\") :\\n continue\\n relation = relation.replace(\\\":\\\", \\\"_\\\")\\n evaluate.setup(relation, dir_name)\\n precision_total += evaluate.evaluate_logic()\\n \\n result = {}\\n result[\\\"MAP\\\"] = precision_total/len(relations)\\n\\n return result\",\n \"def get_chartdata():\\n callback = bottle.request.query.get('callback')\\n y_axis = bottle.request.query.get('y_axis').strip()\\n w_acts = [\\\"action='%s'\\\" % act for act in bottle.request.query.get('actions').strip().split(',')]\\n w_acts = 'AND (%s)' % ' OR '.join(w_acts) if w_acts else ''\\n f_value = 'AVG(latency)' if y_axis.startswith('avg') else 'COUNT(timestamp)'\\n atomic = 1 if y_axis in ['aops', 'avgl'] else 0\\n\\n db_conn = tools.get_db_conn('%s.db' % bottle.request.query.test_run_id)\\n sql = 'SELECT test_run_status, timestamp_started, timestamp_completed FROM info LIMIT 1'\\n status, started, finished = tools.db_query(db_conn, sql)[1][0]\\n progress = int(float(finished) - float(started)) if finished \\\\\\n else int(tools.get_timestamp() - float(started))\\n\\n sql = 'SELECT substr(timestamp, 0, 11), code, %s FROM recs ' % f_value + \\\\\\n 'WHERE atomic=%s %s GROUP BY code, substr(timestamp, 0, 11) ' % (atomic, w_acts) + \\\\\\n 'ORDER BY id DESC LIMIT 3600' # last 1 hour activity\\n\\n result = tools.db_query(db_conn, sql)[1] if finished else tools.db_query(db_conn, sql)[1][:-1]\\n result = list(reversed(result))\\n results = {str(abs(int(item[0]) - int(float(started)))):\\n {'failed': 0, 'passed': 0, 'incomplete': 0} for item in result}\\n for item in result: # item[0] - timestamp, item[1] - code (None if incomplete), item[2] - value\\n timestamp = str(int(item[0]) - int(float(started)))\\n value = item[2] or 0\\n results[timestamp]['failed'] += value if item[1] and item[1] != 200 else 0\\n results[timestamp]['passed'] += value if item[1] == 200 else 0\\n results[timestamp]['incomplete'] += value if item[1] == None else 0\\n results = [{'timestamp': key, 'failed': value['failed'], 'passed': value['passed'],\\n 'incomplete': value['incomplete']} for key, value in results.items()]\\n result = {bottle.request.query.slave: results, 'status': status,\\n 'started': started, 'finished': finished or '(not finished)', 'progress': progress}\\n return '{0}({1})'.format(callback, result)\",\n \"def test_scores(self) -> np.ndarray:\\n return np.asarray(self.test_metric_dict[self.metric_name])\",\n \"def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\\n hist = {k: {} for k in {\\\"mks0\\\", \\\"mks1\\\", \\\"mks2\\\", \\\"l\\\"}} # pylint: disable=C0208\\n wei = {k: {} for k in hist}\\n res[\\\"hist\\\"] = hist\\n res[\\\"histnow\\\"] = wei\\n\\n for el, _ in self.enumerate_test_metric(qset):\\n le = len(el.value)\\n w = el.weight\\n res[\\\"mks0\\\"] += w * el.mks0\\n res[\\\"mks1\\\"] += w * el.mks1\\n res[\\\"mks2\\\"] += w * el.mks2\\n res[\\\"sum_weights\\\"] += w\\n res[\\\"sum_wlen\\\"] += w * le\\n res[\\\"n\\\"] += 1\\n\\n if el.mks0 not in hist[\\\"mks0\\\"]:\\n hist[\\\"mks0\\\"][el.mks0] = w\\n wei[\\\"mks0\\\"][el.mks0] = 1\\n else:\\n hist[\\\"mks0\\\"][el.mks0] += w\\n wei[\\\"mks0\\\"][el.mks0] += 1\\n if el.mks1 not in hist[\\\"mks1\\\"]:\\n hist[\\\"mks1\\\"][el.mks1] = w\\n wei[\\\"mks1\\\"][el.mks1] = 1\\n else:\\n hist[\\\"mks1\\\"][el.mks1] += w\\n wei[\\\"mks1\\\"][el.mks1] += 1\\n if el.mks2 not in hist[\\\"mks2\\\"]:\\n hist[\\\"mks2\\\"][el.mks2] = w\\n wei[\\\"mks2\\\"][el.mks2] = 1\\n else:\\n hist[\\\"mks2\\\"][el.mks2] += w\\n wei[\\\"mks2\\\"][el.mks2] += 1\\n if le not in hist[\\\"l\\\"]:\\n hist[\\\"l\\\"][le] = w\\n wei[\\\"l\\\"][le] = 1\\n else:\\n hist[\\\"l\\\"][le] += w\\n wei[\\\"l\\\"][le] += 1\\n return res\",\n \"def metrics_evaluation(y_true, y_prob, threshold, df_type='train'):\\n\\n y_pred = (y_prob>=threshold).astype(int)\\n \\n tn = metrics.confusion_matrix(y_true, y_pred)[0][0]\\n fp = metrics.confusion_matrix(y_true, y_pred)[0][1]\\n fn = metrics.confusion_matrix(y_true, y_pred)[1][0]\\n tp = metrics.confusion_matrix(y_true, y_pred)[1][1]\\n\\n accuracy_scr = metrics.accuracy_score(y_true, y_pred)\\n precision_scr = metrics.precision_score(y_true, y_pred)\\n recall_scr = metrics.recall_score(y_true, y_pred)\\n f1_scr = metrics.f1_score(y_true, y_pred)\\n roc_auc_scr = metrics.roc_auc_score(y_true, y_pred)\\n\\n result = {'Dataset': df_type, 'No obs': len(y_true), 'Threshold': threshold,\\n 'TP':tp, 'FP': fp, 'TN': tn, 'FN':fn , \\n 'Accuracy Score':accuracy_scr, 'Precision Score':precision_scr, \\n 'Recall Score':recall_scr, 'F1 Score':f1_scr, 'ROC AUC Score':roc_auc_scr}\\n\\n return result\",\n \"def set_metrics(self):\",\n \"def prepareAccumulatedMetrics(self):\\n displayDF = analyzeMetricsDF(self.resultList)\\n displayDF.to_csv(\\\"data/results.csv\\\")\",\n \"def test_get_qc_metrics_logic_unit():\\n with mock.patch(\\\"dcicutils.ff_utils.get_metadata\\\") as mock_get_metadata:\\n mock_get_metadata.side_effect = mocked_get_metadata_from_data_files\\n print() # start output on a fresh line\\n input_uuid = \\\"431106bc-8535-4448-903e-854af460b260\\\"\\n result = ff_utils.get_associated_qc_metrics(input_uuid)\\n assert \\\"131106bc-8535-4448-903e-854abbbbbbbb\\\" in result # quick pre-test\\n assert result == get_mocked_result(kind='QC metrics',\\n dirname='test_qc_metrics',\\n uuid=input_uuid)\",\n \"def calc_metrics(data, sampled_data_list, dataset_type):\\n result={}\\n for sampled_data in sampled_data_list:\\n c2st_roc_auc_metric = c2st_roc_auc(data, sampled_data)\\n if \\\"c2st_roc_auc\\\" in result:\\n result[\\\"c2st_roc_auc\\\"].append(c2st_roc_auc_metric)\\n else:\\n result[\\\"c2st_roc_auc\\\"] = [c2st_roc_auc_metric]\\n mmd_p_val, mmd_stat = rbf_mmd_test(data.values, sampled_data.values)\\n if \\\"mmd_p_val\\\" in result:\\n result[\\\"mmd_p_val\\\"].append(mmd_p_val)\\n result[\\\"mmd_stat\\\"].append(mmd_stat)\\n else:\\n result[\\\"mmd_p_val\\\"] = [mmd_p_val]\\n result[\\\"mmd_stat\\\"] = [mmd_stat]\\n ks_p_val, ks_stat, ks_n, ks_p_val_list, ks_stat_list = ks_test(data, sampled_data)\\n if dataset_type != \\\"norm_dataset\\\":\\n ks_p_val = ks_permutation(ks_stat_list, data, sampled_data)\\n if \\\"ks_p_val\\\" in result:\\n result[\\\"ks_p_val\\\"].append(ks_p_val)\\n result[\\\"ks_stat\\\"].append(ks_stat)\\n else:\\n result[\\\"ks_p_val\\\"] = [ks_p_val]\\n result[\\\"ks_stat\\\"] = [ks_stat]\\n acc_r, acc_g = c2st_accuracy(data, sampled_data)\\n if \\\"c2st_acc_r\\\" in result:\\n result[\\\"c2st_acc_r\\\"].append(acc_r)\\n result[\\\"c2st_acc_g\\\"].append(acc_g)\\n else:\\n result[\\\"c2st_acc_r\\\"] = [acc_r]\\n result[\\\"c2st_acc_g\\\"] = [acc_g]\\n return result\",\n \"def test_evaluate(self):\\n # test normalized by 'head_size'\\n mpii_pck_metric = MpiiPCKAccuracy(thr=0.3, norm_item='head')\\n mpii_pck_metric.process(self.data_batch, self.data_samples)\\n pck_results = mpii_pck_metric.evaluate(self.batch_size)\\n target = {\\n 'Head PCK': 100.0,\\n 'Shoulder PCK': 100.0,\\n 'Elbow PCK': 100.0,\\n 'Wrist PCK': 100.0,\\n 'Hip PCK': 100.0,\\n 'Knee PCK': 100.0,\\n 'Ankle PCK': 100.0,\\n 'PCK': 100.0,\\n 'PCK@0.1': 100.0,\\n }\\n self.assertDictEqual(pck_results, target)\",\n \"def _compute_experiment_statistics(self):\\n pass\",\n \"def _evaluate(self) -> dict:\\n self.load()\\n self.evaluate_all()\\n self.finalize_results()\\n log.debug(\\\"Clearing global instrumentation variables\\\")\\n del_globals()\",\n \"def measure(self,qc,qb,cb):\\n if isinstance(qb,list) and isinstance(cb,list):\\n assert len(qb) == len(cb)\\n for q,c in zip(qb,cb):\\n qc.measure(q,c)\\n else:\\n qc.measure(qb,cb)\\n if self.ibmq:\\n job = qk.execute(qc, \\n backend = self.backend, \\n shots=self.shots,\\n optimization_level=self.optimization_level,\\n initial_layout=self.layout)\\n self.monitor(job)\\n else:\\n job = qk.execute(qc, \\n backend = self.backend, \\n shots=self.shots,\\n optimization_level=self.optimization_level,\\n noise_model=self.noise_model,\\n coupling_map=self.coupling_map,\\n basis_gates=self.basis_gates,\\n initial_layout=self.layout,\\n seed_transpiler=self.seed,\\n seed_simulator=self.seed)\\n return job.result().get_counts(qc)\",\n \"def test_run(id_, args, kwargs, expected):\\n # Remove results for test.\\n results_path = expected['results_path']\\n shutil.rmtree(results_path, ignore_errors=True)\\n # Start code.\\n # [future] attempts to run classification with n_jobs>1\\n # global cnfg_default\\n # sys.modules['cnfg_default'] = get_params(args[0], 'cnfg_default')\\n # import cnfg_default\\n # #from cnfg_default import custom_score_metric\\n objects = pycnfg.run(oid='default', *args, **kwargs)\\n tmp = {k: type(v).__name__ for k, v in objects.items()}\\n print('OBJECTS:')\\n print(tmp)\\n # Compare results:\\n # * Compare objects (keys and str of values).\\n objects_ = expected['objects']\\n objects = {k: type(v).__name__ for k, v in objects.items()}\\n if objects != objects_:\\n print(set(objects.items()) ^ set(objects_.items()))\\n assert objects == objects_\\n # for k, v in objects.items():\\n # assert k in objects_\\n # assert type(v).__name__ == objects_[k]\\n # * Compare predictions csv(all available).\\n pred_path = glob.glob(f\\\"{results_path}/models/*_pred.csv\\\")\\n pred_path_ = glob.glob(expected['pred_path'])\\n assert len(pred_path) == len(pred_path_)\\n for act, exp in zip(sorted(pred_path), sorted(pred_path_)):\\n file_diff(act, exp)\\n assert filecmp.cmp(act, exp)\\n # * Compare test logs.\\n logs_path = glob.glob(f\\\"{results_path}/logs*/*_test.log\\\")[0]\\n logs_path_ = expected['logs_path']\\n file_diff(logs_path, logs_path_)\\n assert filecmp.cmp(logs_path, logs_path_)\\n # * Compare runs dataframe, non-universe columns.\\n runs_path = f\\\"{results_path}/runs\\\"\\n runs_path_ = expected['runs_path']\\n df = runs_loader(runs_path)\\n df_ = runs_loader(runs_path_)\\n # First False/True for each element, then check all by columns.\\n # col1 True\\n # col2 False\\n # dtype: bool\\n df_diff = df.eq(df_).all()\\n # Column names that are not equal.\\n columns = sorted(list(df_diff[df_diff==False].dropna().index))\\n # columns_eq = sorted(list(df_diff[df_diff==True].dropna().index))\\n columns_ = expected['columns_diff']\\n print('DIFF:\\\\n', columns)\\n time.sleep(1)\\n # assert columns == columns_\\n # * Compare model.\\n model_path = glob.glob(f\\\"{results_path}/models/*.model\\\")\\n model_path_ = glob.glob(expected['model_path'])\\n assert len(model_path) == len(model_path_)\\n for act, exp in zip(sorted(model_path), sorted(model_path_)):\\n assert filecmp.cmp(act, exp)\\n return\",\n \"def run(self):\\n question_stats = self.MultipleChoiceQuestionAggregator(self._course)\\n mapper = models_utils.QueryMapper(\\n EventEntity.all(), batch_size=500, report_every=1000)\\n mapper.run(question_stats.visit)\\n return (question_stats.id_to_questions_dict,\\n question_stats.id_to_assessments_dict)\",\n \"def __dataset_statistics(self) -> None:\\n # Print the expressions\\n print(f'Available expressions: {self.idx_to_expression.values()}')\\n \\n # Print dataset cardinalities\\n stats_table = PrettyTable()\\n stats_table.field_names = ['Train samples', 'PublicTest samples', 'PrivateTest samples', 'Number of expressions']\\n stats_table.add_row([len(self.db[self.db['Usage'] == 'Training']), len(self.db[self.db['Usage'] == 'PublicTest']), len(self.db[self.db['Usage'] == 'PrivateTest']), len(self.db.expression.unique().tolist())])\\n print(stats_table)\\n \\n def eval_class_cardinality(expressions: list, train: str) -> [list, list]:\\n cardinality = [len(self.db[(self.db['expression']==expr) & (self.db['Usage']==train)]) for expr in expressions]\\n frac = [len(self.db[(self.db['expression']==expr) & (self.db['Usage']==train)])/len(self.db[self.db['Usage']==train]) for expr in expressions]\\n return cardinality, frac\\n\\n expressions = self.db.expression.unique()\\n expressions.sort()\\n \\n # Print expressions statistics --> Training \\n stats_table = PrettyTable()\\n stats_table.title = 'Training Samples'\\n stats_table.field_names = [self.idx_to_expression[label] for label in expressions]\\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='Training')\\n stats_table.add_row(cardinality)\\n stats_table.add_row(frac)\\n\\n # Print expressions statistics --> Validation \\n stats_table2 = PrettyTable()\\n stats_table2.title = 'Validation Samples'\\n stats_table2.field_names = [self.idx_to_expression[label] for label in expressions]\\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='PublicTest')\\n stats_table2.add_row(cardinality)\\n stats_table2.add_row(frac)\\n\\n # Print expressions statistics --> Test \\n stats_table3 = PrettyTable()\\n stats_table3.title = 'Test Samples'\\n stats_table3.field_names = [self.idx_to_expression[label] for label in expressions]\\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='PrivateTest')\\n stats_table3.add_row(cardinality)\\n stats_table3.add_row(frac)\\n \\n print(stats_table)\\n print(stats_table2)\\n print(stats_table3)\",\n \"def test_metrics(self):\\n # Check the route\\n self.check_metrics(self.test_metrics_submission_id, False, \\\"award\\\")\\n self.check_metrics(self.test_metrics_submission_id, True, \\\"award_financial\\\")\\n self.check_metrics(self.test_metrics_submission_id, True, \\\"appropriations\\\")\",\n \"def log_evaluation(tester, name, description):\\r\\n\\tfor dataset, output in tester.preds.items():\\r\\n\\t\\tresults = pandas.DataFrame.from_dict(output)\\r\\n\\t\\tpath = os.path.join(\\r\\n\\t\\t\\tEXPERIMENT_PATH, tester.config[\\\"name\\\"] + '-' + dataset)\\r\\n\\t\\twith open(path + \\\".csv\\\", \\\"w\\\") as f:\\r\\n\\t\\t\\tresults.to_csv(f, sep=\\\"\\\\t\\\", encoding='utf-8',\\r\\n\\t\\t\\t\\tfloat_format='%.3f', index=False)\",\n \"def _eval_classifier(self):\\n\\n y_pred_baseline = self.df_baseline[self.score_column]\\n y_pred_sample = self.df_sample[self.score_column]\\n\\n y_label_baseline = self.df_baseline[self.label_column]\\n y_label_sample = self.df_sample[self.label_column]\\n\\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\\n try:\\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\\n except ValueError:\\n auc_baseline = \\\"NA\\\"\\n\\n precision_sample = precision_score(y_label_sample, y_pred_sample)\\n recall_sample = recall_score(y_label_sample, y_pred_sample)\\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\\n f1_sample = f1_score(y_label_sample, y_pred_sample)\\n try:\\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\\n except ValueError:\\n auc_sample = \\\"NA\\\"\\n\\n metrics_df = pd.DataFrame(\\n {\\n \\\"Accuracy\\\": [acc_baseline, acc_sample],\\n \\\"Precision\\\": [precision_baseline, precision_sample],\\n \\\"Recall\\\": [recall_baseline, recall_sample],\\n \\\"F1\\\": [f1_baseline, f1_sample],\\n \\\"AUC\\\": [auc_baseline, auc_sample],\\n },\\n index=[\\\"baseline\\\", \\\"sample\\\"],\\n )\\n\\n self.performance_comparison = metrics_df\",\n \"def _perform_measurement(self, qubits: Sequence['cirq.Qid']) -> List[int]:\\n return [self.state._measure(self.qubit_map[q], self.prng) for q in qubits]\",\n \"def metrics(self):\\n \\n if self.mse.shape[0]>1:\\n raise ValueError('Metrics can only handle single observations.')\\n \\n if self.N==1:\\n pred = float('nan')\\n err = float('nan')\\n y_true = float('nan')\\n else:\\n pred = int(self._predictions[-1])\\n err = self._mse[-1]\\n y_true = int(self.label[0])\\n \\n is_outlier = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"is_outlier\\\",\\\"value\\\":pred}\\n mse = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"mse\\\",\\\"value\\\":err}\\n obs = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"observation\\\",\\\"value\\\":self.N - 1}\\n threshold = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"threshold\\\",\\\"value\\\":self.threshold}\\n \\n label = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"label\\\",\\\"value\\\":y_true}\\n \\n accuracy_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"accuracy_tot\\\",\\\"value\\\":self.metric[4]}\\n precision_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"precision_tot\\\",\\\"value\\\":self.metric[5]}\\n recall_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"recall_tot\\\",\\\"value\\\":self.metric[6]}\\n f1_score_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f1_tot\\\",\\\"value\\\":self.metric[7]}\\n f2_score_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f2_tot\\\",\\\"value\\\":self.metric[8]}\\n \\n accuracy_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"accuracy_roll\\\",\\\"value\\\":self.metric[9]}\\n precision_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"precision_roll\\\",\\\"value\\\":self.metric[10]}\\n recall_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"recall_roll\\\",\\\"value\\\":self.metric[11]}\\n f1_score_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f1_roll\\\",\\\"value\\\":self.metric[12]}\\n f2_score_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f2_roll\\\",\\\"value\\\":self.metric[13]}\\n \\n true_negative = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"true_negative\\\",\\\"value\\\":self.metric[0]}\\n false_positive = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"false_positive\\\",\\\"value\\\":self.metric[1]}\\n false_negative = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"false_negative\\\",\\\"value\\\":self.metric[2]}\\n true_positive = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"true_positive\\\",\\\"value\\\":self.metric[3]}\\n \\n nb_outliers_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_outliers_roll\\\",\\\"value\\\":self.metric[14]}\\n nb_labels_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_labels_roll\\\",\\\"value\\\":self.metric[15]}\\n nb_outliers_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_outliers_tot\\\",\\\"value\\\":self.metric[16]}\\n nb_labels_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_labels_tot\\\",\\\"value\\\":self.metric[17]}\\n \\n return [is_outlier,mse,obs,threshold,label,\\n accuracy_tot,precision_tot,recall_tot,f1_score_tot,f2_score_tot,\\n accuracy_roll,precision_roll,recall_roll,f1_score_roll,f2_score_roll,\\n true_negative,false_positive,false_negative,true_positive,\\n nb_outliers_roll,nb_labels_roll,nb_outliers_tot,nb_labels_tot]\",\n \"def qa_test():\\r\\n # Reads Code and Runs Code Metrics\\r\\n with open(\\\"BrainDataVisualiser.py\\\",\\\"r\\\") as file:\\r\\n code = file.read()\\r\\n with open(\\\"QA_LOGS.txt\\\",\\\"a\\\") as file:\\r\\n # Timestamp and append metric results to log\\r\\n file.write(datetime.date.today().strftime(\\\"%b-%d-%Y\\\")+\\\"\\\\n\\\\t\\\")\\r\\n file.write(\\\"General Analysis\\\\n\\\\t\\\\t\\\")\\r\\n file.write(str(analyze(code))+\\\"\\\\n\\\\t\\\")\\r\\n file.write(\\\"Cyclomatic Complexity\\\\n\\\")\\r\\n for i in cc_visit(code):\\r\\n file.write(\\\"\\\\t\\\\t\\\"+cc_rank(i.complexity)+\\\" \\\"+str(i)+\\\"\\\\n\\\")\",\n \"def evaluate(self, test_data, test_labels):\\n raise NotImplementedError\",\n \"def generate_stats(results, ads, vmid, session_date, export_folder, process_ex_time):\\n try:\\n os.makedirs(export_folder)\\n except OSError:\\n pass\\n\\n # to be read and inserted into db\\n totalads = 0 # total number of ads seen during this session\\n totaluniqads = len(ads) # does not support multicategories at this point\\n\\n # for each category, for each test site, count total number of ads seen\\n totalad_category = {} \\n # for each category, for each test site, count total number of uniq ads seen\\n uniqad_category = {}\\n \\n with open(os.path.join(export_folder, 'session_bugs.csv'), 'w') as bugs_wtr:\\n bugs_wtr.write('#Ad-UID, Website-URL, Refresh-Num, Training-Topic,\\\\\\n Site-Context, BugCount, BugSrc\\\\n')\\n for train_category, cat_dict in results.items():\\n totalad_category[train_category] = {}\\n uniqad_category[train_category] = {}\\n for test_site, bug_dict_list in cat_dict.items():\\n total_ads = 0 # for each site\\n uniq_ads = [] # for each site\\n for refresh_num in range(len(bug_dict_list)):\\n bug_dict = bug_dict_list[refresh_num]\\n for bug, bugcount in bug_dict.items():\\n if bug.is_ad():\\n uuid = bug.get_uuid()\\n bugs_wtr.write('{0}, {1}, {2}, {3}, {4}, {5}, {6}\\\\n'.format(uuid, test_site,\\n refresh_num, train_category, 'N/A', bugcount, bug.get_src()))\\n total_ads += bugcount\\n if bug not in uniq_ads:\\n uniq_ads.append(bug)\\n totalad_category[train_category][test_site] = total_ads\\n uniqad_category[train_category][test_site] = len(uniq_ads)\\n totalads += total_ads # global count for total ads\\n\\n with open(os.path.join(export_folder, 'session_stats.csv'), 'w') as ses_wtr:\\n # write some metadata information about this session\\n ses_wtr.write('#VMID: %s\\\\n' % vmid)\\n ses_wtr.write('#Session-Date: %s\\\\n' % session_date)\\n ses_wtr.write('#Time to complete: %s\\\\n' % process_ex_time)\\n ses_wtr.write('#Training Categories: %s\\\\n' % str(results.keys()))\\n ses_wtr.write('#Total Number of ads: %d\\\\n' % totalads)\\n ses_wtr.write('#Total Uniq ads: %d\\\\n\\\\n' % totaluniqads)\\n ses_wtr.write('#TrainingTopic, Test-Site, NumberOfVisit, TotalAds, UniqAds\\\\n')\\n\\n for train_category, cat_dict in results.items(): \\n for test_site, bug_dict_list in cat_dict.items():\\n num_of_visit = len(bug_dict_list)\\n ses_wtr.write('{0}, {1}, {2}, {3}, {4}\\\\n'.format(train_category,\\n test_site, num_of_visit, totalad_category[train_category][test_site],\\n uniqad_category[train_category][test_site]))\",\n \"def main():\\n test_folders = argv[1]\\n benchmark_file = argv[2]\\n output_path = argv[3]\\n\\n method = ['n', 'a', 'a']\\n bigram = ['False', 'False', 'True']\\n output_file = output_path + '/' + 'method_comparison_cosine_values.csv'\\n\\n with open(test_folders, 'r') as f:\\n test_folders = f.read()\\n\\n test_folders = test_folders.splitlines()\\n\\n with open(benchmark_file, 'r') as f:\\n benchmark_file = f.read()\\n\\n benchmark_file = benchmark_file.splitlines()\\n\\n # initialize big data frame\\n frames = []\\n\\n for k in xrange(len(benchmark_file)):\\n\\n test = str(test_folders[k]).replace('\\\"', '')\\n print \\\"Reading test files from folder:\\\"\\n print test\\n\\n benchmark = str(benchmark_file[k]).replace('\\\"', '')\\n print \\\"Reading benchmark form file:\\\"\\n print benchmark\\n\\n # read file paths from test documents folder\\n query = sorted([os.path.join(test, f) for f in os.listdir(test) if f.endswith('.txt')])\\n\\n # load benchmark text file\\n with open(benchmark, \\\"r\\\", encoding=\\\"utf-8\\\", errors='ignore') as doc:\\n raw = doc.read()\\n\\n # initialize dict of dicts for data frame\\n method_csv = {}\\n\\n for j in xrange(len(method)):\\n # extract features from benchmark\\n dtm = ExtractFeatures(method[j], bigram[j])\\n benchmark_name = benchmark_file[k].split('\\\\\\\\')[-1]\\n benchmark_features = dtm.extract_features_from_text(raw, benchmark_name)\\n\\n # extract terms from each text document to create a vocabulary (keeping unique terms only)\\n vocabulary = sorted(set(w[1] for w in benchmark_features))\\n print \\\"{0} features produced.\\\".format(str(len(vocabulary)))\\n\\n benchmark_dtv = DTM(vocabulary, benchmark_name, benchmark_features)\\n benchmark_dtv = benchmark_dtv.compute_dtv()\\n\\n # load test document features\\n test_features = []\\n for q in query:\\n dtm1 = ExtractFeatures(method[j], bigram[j])\\n test_features = test_features + dtm1.extract_features_from_file(q)\\n\\n documents = sorted(set([d for d, w in test_features]))\\n print \\\"{0} test documents read.\\\".format(str(len(documents)))\\n\\n print \\\"Computing DTM...\\\"\\n test_dtm = DTM(vocabulary, documents, test_features)\\n test_dtm = test_dtm.compute_dtm()\\n\\n print \\\"Computing cosine values...\\\"\\n dv = {}\\n for i in xrange(len(documents)):\\n d = 1 - spatial.distance.cosine(benchmark_dtv[benchmark_name], test_dtm[documents[i]])\\n if isnan(d):\\n d = 0\\n dv[documents[i]] = d\\n\\n this_method = \\\"method=\\\" + method[j] + '_' + \\\"bigram=\\\" + bigram[j]\\n method_csv[this_method] = pd.Series(dv)\\n\\n print \\\"Saving to data frame...\\\"\\n df = pd.DataFrame(method_csv)\\n test = test.split('\\\\\\\\')[-1]\\n test = test.split('.')[0]\\n df['test_group'] = test\\n\\n frames.append(df)\\n\\n result = pd.concat(frames)\\n\\n print \\\"Saving results to file: \\\", output_file\\n result.to_csv(output_file)\\n\\n print 'Finished computing {0} data frames'.format(str(len(test_folders)))\",\n \"def test_step(self, x_test, y_test):\\n\\n print(\\\"Evaluation:\\\")\\n\\n input_x_op = self.session.graph.get_operation_by_name(\\\"input_x\\\").outputs[0]\\n input_y_op = self.session.graph.get_operation_by_name(\\\"input_y\\\").outputs[0]\\n global_step_op = self.session.graph.get_operation_by_name(\\\"global_step\\\").outputs[0]\\n\\n loss_op = self.session.graph.get_operation_by_name(\\\"loss/loss\\\").outputs[0]\\n\\n predictions_op = self.session.graph.get_operation_by_name(\\\"output/predictions\\\").outputs[0] \\n\\n accuracy_op = self.session.graph.get_operation_by_name(\\\"accuracy/accuracy\\\").outputs[0]\\n confusion_update_op = self.session.graph.get_operation_by_name(\\\"accuracy/confusion_update\\\").outputs[0]\\n\\n d_ = {\\n input_x_op: x_test,\\n input_y_op: y_test\\n }\\n\\n self.init_dataset(d_)\\n\\n valid_batches_per_epoch = (len(x_test) - 1) // self.FLAGS.batch_size + 1\\n\\n sum_accuracy = 0\\n \\n confusion_variable = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=\\\"accuracy/confusion\\\")[0]\\n self.session.run([confusion_variable.initializer])\\n\\n for current_step in range(valid_batches_per_epoch):\\n\\n if self.FLAGS.summary:\\n step, summaries, loss, accuracy, cnf_matrix, predictions = self.session.run(\\n [global_step_op, self.dev_summary_op, loss_op, accuracy_op, confusion_update_op, predictions_op])\\n\\n self.writer.add_summary(summaries, step)\\n else:\\n step, loss, accuracy, cnf_matrix, predictions = self.session.run(\\n [global_step_op, loss_op, accuracy_op, confusion_update_op, predictions_op]) \\n\\n sum_accuracy += accuracy\\n\\n try:\\n all_predictions = np.concatenate((all_predictions, predictions), axis=0)\\n except NameError:\\n all_predictions = predictions\\n\\n\\n valid_accuracy = sum_accuracy / valid_batches_per_epoch\\n\\n time_str = datetime.datetime.now().isoformat()\\n print(\\\"{}: valid_accuracy {:g}\\\".format(time_str, valid_accuracy))\\n print(\\\"Confusion matrix:\\\")\\n print(cnf_matrix)\\n\\n return valid_accuracy, all_predictions\",\n \"def compute_accuracy_measures(self, gt):\\n data = quantification.compute_accuracy_measures(self.image, gt.image)\\n return data\",\n \"def test_fetch_qc_metrics_logic_integrated(mocked_replicate_experiment):\\n result = ff_utils.fetch_files_qc_metrics(\\n ff_utils.get_metadata(\\\"331106bc-8535-3338-903e-854af460b544\\\", ff_env='fourfront-mastertest'),\\n ff_env='fourfront-mastertest',\\n associated_files=['other_processed_files'],\\n ignore_typical_fields=False)\\n assert '131106bc-8535-4448-903e-854af460b000' in result\\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in result\",\n \"def run(self, inputIn):\\n measureList = self.inputToInternal(inputIn)\\n outputDict = {}\\n assert(len(self.features) == len(measureList))\\n for metricInstance in self.metricsDict.values():\\n metricEngine = MetricDistributor.factory.returnInstance('MetricDistributor', metricInstance)\\n for cnt in range(len(self.targets)):\\n nodeName = (str(self.targets[cnt]) + '_' + str(self.features[cnt])).replace(\\\"|\\\",\\\"_\\\")\\n varName = metricInstance.name + '|' + nodeName\\n output = metricEngine.evaluate(measureList[cnt], weights=self.weight, multiOutput=self.multiOutput)\\n outputDict[varName] = np.atleast_1d(output)\\n return outputDict\",\n \"def run_evaluate(self, test):\\n accs = []\\n correct_preds, total_correct, total_preds = 0., 0., 0.\\n for words, labels in minibatches(test, self.config.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words)\\n\\n for lab, lab_pred, length in zip(labels, labels_pred,\\n sequence_lengths):\\n lab = lab[:length]\\n lab_pred = lab_pred[:length]\\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\\n\\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\\n lab_pred_chunks = set(get_chunks(lab_pred,\\n self.config.vocab_tags))\\n\\n correct_preds += len(lab_chunks & lab_pred_chunks)\\n total_preds += len(lab_pred_chunks)\\n total_correct += len(lab_chunks)\\n\\n p = correct_preds / total_preds if correct_preds > 0 else 0\\n r = correct_preds / total_correct if correct_preds > 0 else 0\\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\\n acc = np.mean(accs)\\n print('*'*20, '\\\\n')\\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\\\n')\\n print('*'*20)\\n\\n return {\\\"acc\\\": 100*acc, \\\"f1\\\": 100*f1}\",\n \"def run_evaluate(self, test):\\n accs = []\\n correct_preds, total_correct, total_preds = 0., 0., 0.\\n for words, labels in minibatches(test, self.config.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words)\\n\\n for lab, lab_pred, length in zip(labels, labels_pred,\\n sequence_lengths):\\n lab = lab[:length]\\n lab_pred = lab_pred[:length]\\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\\n\\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\\n lab_pred_chunks = set(get_chunks(lab_pred,\\n self.config.vocab_tags))\\n\\n correct_preds += len(lab_chunks & lab_pred_chunks)\\n total_preds += len(lab_pred_chunks)\\n total_correct += len(lab_chunks)\\n\\n p = correct_preds / total_preds if correct_preds > 0 else 0\\n r = correct_preds / total_correct if correct_preds > 0 else 0\\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\\n acc = np.mean(accs)\\n\\n return {\\\"acc\\\": 100*acc, \\\"f1\\\": 100*f1}\",\n \"def gather_sample(self):\\n\\n for _pid in self._select_processes():\\n if not self.__trackers.get(_pid):\\n self.__trackers[_pid] = ProcessTracker(_pid, self._logger, self.__id)\\n\\n self._reset_absolute_metrics()\\n\\n for _tracker in self.__trackers.values():\\n _metrics = _tracker.collect()\\n self.record_metrics(_tracker.pid, _metrics)\\n\\n self._calculate_aggregated_metrics()\\n self._remove_dead_processes()\\n\\n self.print_metrics()\",\n \"def load_results(self):\\n self.find_benchmark_directories()\\n for (benchmark, producer), result in self.results.items():\\n print('Reading results for ' + benchmark + ' ' + producer)\\n if not result.directory:\\n print('No results found for ' + benchmark + ' ' + producer)\\n else:\\n print('Generating report for: ' + result.directory)\\n report = Report(result.directory)\\n result.reports = report.generate()\",\n \"def getMeasures():\",\n \"def execute(self):\\r\\n factors = self.factors\\r\\n variables = list(self.variables)\\r\\n variables.remove(self.query)\\r\\n\\r\\n for fac in factors:\\r\\n self.set_observations(fac)\\r\\n\\r\\n for var in variables:\\r\\n if var not in self.obs:\\r\\n factors = self.eliminate_variable(var, factors)\\r\\n\\r\\n result = factor_module.multiply_batch(self.query, factors)\\r\\n denominator = sum(result.get_cpt())\\r\\n print(denominator)\\r\\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}\",\n \"def save_metrics(self):\\n self.data_stats.write.format(\\\"org.apache.spark.sql.cassandra\\\").mode(\\\"append\\\").options(table=self.cassandra_stats_table, keyspace=self.cassandra_keyspace).save()\\n print (\\\"Saved data successfully\\\")\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def __init__(self, metrics, gt, pred):\\n self.dict_metrics = self.compute_metrics(metrics, gt, pred)\",\n \"def evaluate(cfg: DictConfig):\\n\\n experiments = cfg.get('experiment_type', f'{cfg.model.name}_only')\\n fixed_t0 = cfg.get('fixed_t0', False)\\n ext = '_fixedT0' if fixed_t0 else ''\\n\\n base_dir = cfg.device.root\\n datasource = cfg.datasource.name\\n\\n if experiments == 'ablations':\\n models = {\\n 'FluxRGNN': ['final',\\n 'final_without_encoder',\\n 'final_without_boundary'],\\n 'LocalLSTM': ['final']\\n }\\n elif experiments == 'final':\\n models = {\\n 'FluxRGNN': ['final'],\\n 'GAM': ['final'],\\n 'HA': ['final'],\\n 'GBT': ['final']\\n }\\n else:\\n m = cfg.model.name\\n year = cfg.datasource.test_year\\n\\n # find all experiments available for this model, datasource and test year\\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{year}')\\n models = {\\n m : [ f.name for f in os.scandir(result_dir) if f.is_dir() ]\\n }\\n\\n\\n # thresholds for binary classification metrics\\n if cfg.datasource.name == 'abm':\\n thresholds = [0.0019, 0.0207]\\n else:\\n thresholds = [0, 10, 20]\\n\\n rmse_per_hour = []\\n mae_per_hour = []\\n pcc_per_hour = []\\n bin_per_hour = []\\n\\n rmse_per_night = []\\n mae_per_night = []\\n\\n output_dir = osp.join(base_dir, 'results', datasource, f'performance_evaluation{ext}', experiments)\\n os.makedirs(output_dir, exist_ok=True)\\n\\n counter = 0\\n\\n for m, dirs in models.items():\\n print(f'evaluate {m}')\\n\\n for d in dirs:\\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{cfg.datasource.test_year}', d)\\n\\n # check if directory exists\\n if os.path.isdir(result_dir):\\n results, model_cfg = load_cv_results(result_dir, trials=cfg.task.repeats, ext=ext)\\n\\n df_prep = pd.read_csv(osp.join(base_dir, 'data', 'preprocessed',\\n f'{model_cfg[\\\"t_unit\\\"]}_{model_cfg[\\\"model\\\"][\\\"edge_type\\\"]}_ndummy={model_cfg[\\\"datasource\\\"][\\\"n_dummy_radars\\\"]}',\\n datasource, cfg.season, str(cfg.datasource.test_year), 'dynamic_features.csv'))\\n tidx2night = dict(zip(df_prep.tidx, df_prep.nightID))\\n\\n rmse_per_hour.append(compute_rmse(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n mae_per_hour.append(compute_mae(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n pcc_per_hour.append(compute_pcc(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n\\n if fixed_t0:\\n rmse_per_night.append(compute_rmse_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\\n mae_per_night.append(compute_mae_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\\n\\n # compute binary classification measures\\n for thr in thresholds:\\n bin_per_hour.append(compute_bin(m, d, results, groupby=['horizon', 'trial'], threshold=thr, km2=True))\\n\\n counter += 1\\n\\n else:\\n print(f'Experiment \\\"{d}\\\" for model \\\"{m}\\\" and datasource \\\"{datasource}\\\" is not available. '\\n f'Use \\\"run_experiments.py model={m} datasource={datasource} +experiment={d}\\\" to run this experiment.')\\n\\n if counter > 0:\\n rmse_per_hour = pd.concat(rmse_per_hour)\\n rmse_per_hour.to_csv(osp.join(output_dir, f'rmse_per_hour.csv'))\\n\\n mae_per_hour = pd.concat(mae_per_hour)\\n mae_per_hour.to_csv(osp.join(output_dir, f'mae_per_hour.csv'))\\n\\n pcc_per_hour = pd.concat(pcc_per_hour)\\n pcc_per_hour.to_csv(osp.join(output_dir, f'pcc_per_hour.csv'))\\n\\n bin_per_hour = pd.concat(bin_per_hour)\\n bin_per_hour.to_csv(osp.join(output_dir, f'bin_per_hour.csv'))\\n\\n if fixed_t0:\\n rmse_per_night = pd.concat(rmse_per_night)\\n rmse_per_night.to_csv(osp.join(output_dir, f'rmse_per_night.csv'))\\n\\n mae_per_night = pd.concat(mae_per_night)\\n mae_per_night.to_csv(osp.join(output_dir, f'mae_per_night.csv'))\",\n \"def compute_metrics(self, results: list) -> dict:\\n dump(results, self.out_file_path)\\n print_log(\\n f'Results has been saved to {self.out_file_path}.',\\n logger='current')\\n return {}\",\n \"def test(self):\\n for data_tier in self.data_tiers:\\n tot = len(self.preprocessed_data[data_tier]['features'])\\n p = int(math.floor(tot*0.2))\\n test_features = np.array(self.preprocessed_data[data_tier]['features'][p:])\\n trend_test_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][p:])\\n avg_test_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][p:])\\n accuracy_trend = self.clf_trend[data_tier].score(test_features, trend_test_classifications)\\n accuracy_avg = self.clf_avg[data_tier].score(test_features, avg_test_classifications)\\n self.logger.info('The accuracy of %s trend classifier for data tier %s is %.3f', self.name, data_tier, accuracy_trend)\\n self.logger.info('The accuracy of %s avg regressor for data tier %s is %.3f', self.name, data_tier, accuracy_avg)\",\n \"def run(self):\\n if self.verbose:\\n print(f'Running {self.name} tests...')\\n\\n # try running setup if there is one\\n if self.setup:\\n self.__process_setup()\\n\\n final_report = [None] * len(self.tests)\\n\\n for test_in, test_out in sorted(self.tests.items()):\\n # increment total num of tests\\n self.total += 1\\n\\n if self.verbose:\\n print(f'#{self.total}')\\n\\n # evaluate test input w/ setup vars, if any\\n try:\\n inp = eval(test_in, self.vars)\\n except Exception as err:\\n print(f'Issue during evaluation of test input: {err}')\\n final_report[self.total - 1] = 'input eval error'\\n if self.verbose:\\n print(f'Test input was: {test_in}')\\n print('Vars from execution: {}'.format({k : v for k, v in self.vars.items() if k != '__builtins__'}))\\n continue\\n\\n \\n # checking if function input has more than one arg\\n if type(inp) in (list, tuple):\\n try:\\n student_out = self.student_function(*inp)\\n except Exception as err:\\n print(f'Issue while running student code: {err}')\\n final_report[self.total - 1] = f'student code error: {err}; input: {inp}; func_name: {self.name}'\\n if self.verbose:\\n print(f'Function being run was: {self.name}')\\n print(f'Inputs were: {inp}')\\n continue\\n else:\\n try:\\n student_out = self.student_function(inp)\\n except Exception as err:\\n print(f'Issue while running student code: {err}')\\n final_report[self.total - 1] = f'student code error: {err}; input: {inp}; func_name: {self.name}'\\n if self.verbose:\\n print(f'Function being run was: {self.name}')\\n print(f'Input was: {inp}')\\n continue\\n\\n # ans alias for ease of answer checking\\n self.vars['ans'] = student_out\\n\\n if self.schema:\\n format_vals = eval(test_out, self.vars)\\n results, maybe_failed_schema = self.__process_schema(format_vals)\\n if all(results):\\n self.correct += 1\\n final_report[self.total - 1] = 'PASSED'\\n else:\\n # failed at least one of the tests\\n failed_str = \\\" and \\\".join([\\\", \\\".join(maybe_failed_schema[:-1]),maybe_failed_schema[-1]] if len(maybe_failed_schema) > 2 else maybe_failed_schema)\\n final_report[self.total - 1] = f'FAILED; failed following assertion(s): {failed_str}'\\n else:\\n expected_ans = eval(test_out, self.vars)\\n if student_out == expected_ans:\\n self.correct += 1\\n final_report[self.total - 1] = 'PASSED'\\n else:\\n # failed the only test\\n final_report[self.total - 1] = f'FAILED; got {repr(student_out)} but expected {repr(expected_ans)}'\\n\\n # run callback function, if there is one\\n if self.callback:\\n if self.verbose:\\n print('Running callback...')\\n print('call back is:', self.callback)\\n\\n # once done, put the final report on the queue\\n self.queue.put((self.student_username, self.name, f'{self.correct}/{self.total}', final_report))\",\n \"def execute(self, context):\\n if len(self.data_quality_checks) == 0:\\n self.log.info('DataQualityOperator not implemented yet')\\n return\\n \\n redshift_hook = PostgresHook(postgres_conn_id=self.redshift_conn_id) \\n \\n errors = 0\\n failure_tests = []\\n\\n # process each sql stmt for data quality relevant to each dimension table:\\n # Dimension tables : a. songplays, b. songs, c. artists, d. users, e. time\\n \\n for (curr_table, check_stmt) in zip(self.list_of_tables, self.data_quality_checks):\\n curr_sql = check_stmt.get('check_sql')\\n result1 = check_stmt.get('expected_result')\\n \\n self.log.info('Current Table Processed : ' + curr_table)\\n\\n try:\\n records = redshift_hook.get_records(curr_sql)[0]\\n except Exception as e:\\n self.loginfo(f\\\"Error : {curr_table} : Query failed : {e}\\\")\\n\\n # record error when actual result is not the same as expected result\\n if result1 != records[0]:\\n errors += 1\\n failure_tests.append(curr_table + ' : ' + curr_sql)\\n \\n # display Failure or Success Message \\n if errors > 0:\\n self.log.info(failure_tests)\\n self.log.info('Failure Msg : Tests Failed')\\n raise ValueError('Error : Failed : Data Quality check')\\n else:\\n self.log.info('Success : All Data Quality Tests passed')\",\n \"def dataStats(self):\\n print (\\\"Performing statistical analysis of the data\\\")\\n # stuff to do\",\n \"def _test_evaluate(self, format_only, outfile_predix=None):\\n metric = MOTChallengeMetric(\\n metric=['HOTA', 'CLEAR', 'Identity'],\\n format_only=format_only,\\n outfile_prefix=outfile_predix)\\n metric.dataset_meta = {'classes': ('pedestrian', )}\\n data_batch = dict(input=None, data_samples=None)\\n predictions = self._get_predictions_demo()\\n metric.process(data_batch, predictions)\\n eval_results = metric.evaluate()\\n return eval_results\",\n \"def save_performances(self):\\r\\n nb_datasets = len(self.results)\\r\\n resu = [[] for k in range(nb_datasets)]\\r\\n\\r\\n # fetch results\\r\\n for k in range(nb_datasets):\\r\\n best = np.argmax(self.results[k]['mean_test_score'])\\r\\n resu[k].append(('score', self.results[k]['mean_test_score'][best]))\\r\\n resu[k] = resu[k] + list(self.results[k]['params'][best].items())\\r\\n\\r\\n # write results in csv\\r\\n for k, resu in enumerate(resu):\\r\\n with open('results/final_results_{}.csv'.format(k), 'a') as file:\\r\\n writer = csv.writer(file)\\r\\n writer.writerow(resu)\",\n \"def run_and_evaluate():\\n tsp_problems = read_all_problems()\\n # Empty list of metrics\\n results = []\\n for problem in tqdm.tqdm(tsp_problems):\\n # As random factors are involved repeat experiments a couple of times\\n best_routes_base = []\\n best_routes_af = []\\n best_routes_ms = []\\n base_times = []\\n af_times = []\\n ms_times = []\\n for i in range(10):\\n # Base solution\\n start_time = timeit.default_timer()\\n best_route_base = solve_tsp_basic(problem)\\n base_time = timeit.default_timer() - start_time\\n best_routes_base.append(Fitness(route=best_route_base).route_distance())\\n base_times.append(base_time)\\n\\n # AF clustering solution\\n start_time = timeit.default_timer()\\n best_route_af = solve_tsp_affinity_propagation(problem)\\n af_time = timeit.default_timer() - start_time\\n best_routes_af.append(Fitness(route=best_route_af).route_distance())\\n af_times.append(af_time)\\n\\n # MS solution\\n start_time = timeit.default_timer()\\n best_route_ms = solve_mean_shift(problem)\\n ms_time = timeit.default_timer() - start_time\\n best_routes_ms.append(Fitness(route=best_route_ms).route_distance())\\n ms_times.append(ms_time)\\n\\n results.append(\\n {\\n \\\"problem name\\\": problem.name,\\n \\\"optimal solution\\\": find_route_optimal_route_length(problem),\\n \\\"baseline tour length\\\": mean(best_routes_base),\\n \\\"af clustering tour length\\\": mean(best_routes_af),\\n \\\"ms clustering tour length\\\": mean(best_routes_ms),\\n \\\"baseline algorithm time\\\": mean(base_times),\\n \\\"af clustering algorithm time\\\": mean(af_times),\\n \\\"ms clustering algorithm time\\\": mean(ms_times),\\n }\\n )\\n # Create dataframe and safe results\\n df = pd.DataFrame(results)\\n df.to_csv(\\\"results.csv\\\", index=False)\\n return df\",\n \"def init_metrics(self):\\n\\n self.metrics = {}\\n\\n self.metrics['train_loss'] = np.zeros(0)\\n self.metrics['test_loss'] = np.zeros(0)\\n\\n # self.orth_clf = LinearDecoder(self, self.q_, MeanClassifier)\\n # self.metrics['train_orthogonality'] = np.zeros(0)\\n # self.metrics['test_orthogonality'] = np.zeros(0)\\n\\n self.metrics['train_parallelism'] = np.zeros((0,self.q_)) \\n self.metrics['test_parallelism'] = np.zeros((0,self.q_))\",\n \"def evaluate(self) -> Dict[str, float]:\\n eval_dataloader = self.get_eval_dataloader()\\n\\n output = self._prediction_loop(eval_dataloader, description=\\\"Evaluation\\\")\\n return output.metrics\",\n \"def metrics_env(cmd_ctx, cpc, **options):\\n cmd_ctx.execute_cmd(lambda: cmd_metrics_env(cmd_ctx, cpc, options))\",\n \"def test_cw_metrics(self):\\n\\n instances = set()\\n result = self.cw_client.list_metrics(Namespace=\\\"CWAgent\\\", MetricName=\\\"cpu_usage_system\\\")\\n for i in result[\\\"Metrics\\\"]:\\n instances.add(i[\\\"Dimensions\\\"][0][\\\"Value\\\"])\\n\\n for key, value in self.cdk_output_map.items():\\n if \\\"Instance\\\" in key:\\n self.assertTrue(value in instances)\",\n \"def _build_eval_metrics(self, results, features, labels):\\n metrics = {}\\n for metric in self.metrics:\\n metrics[metric.IDENTIFIER] = getters.get_metric(\\n metric.IDENTIFIER, results, labels, **metric.to_dict())\\n return metrics\",\n \"def evaluate(self, epoch, exploration_paths):\\n logger.log(\\\"Collecting samples for evaluation\\\")\\n paths = self._sample_eval_paths(epoch)\\n statistics = OrderedDict()\\n\\n statistics.update(self._statistics_from_paths(paths, \\\"Test\\\"))\\n statistics.update(self._get_other_statistics())\\n statistics.update(self._statistics_from_paths(exploration_paths,\\n \\\"Exploration\\\"))\\n\\n statistics['AverageReturn'] = get_average_returns(paths)\\n statistics['Epoch'] = epoch\\n\\n for key, value in statistics.items():\\n logger.record_tabular(key, value)\\n\\n self.log_diagnostics(paths)\",\n \"def evaluation(self):\\n rows_list = []\\n for name in self.single_classifier_best.keys():\\n row = {}\\n row['algorithm'] = name \\n row[self.scoring_metric] = self.single_classifier_best[name].best_score_\\n rows_list.append(row)\\n \\n scoring_df = pd.DataFrame(rows_list)\\n scoring_sorted = scoring_df.sort_values(self.scoring_metric, ascending=False)\\n print()\\n print('*'*shutil.get_terminal_size().columns)\\n print(scoring_sorted)\\n print('*'*shutil.get_terminal_size().columns)\\n self.evaluation_scores = scoring_sorted\",\n \"def getIndependentTestSetPerf(ml_df,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,group_col,model_type,ml_model,n_splits=10,n_repeats=10,n_jobs=1): \\n X = ml_df[roi_cols].values\\n X_col_names = roi_cols.copy()\\n grp1_idx = np.array(ml_df[group_col]=='internal')\\n grp2_idx = np.array(ml_df[group_col]=='external')\\n\\n # Check input var types and create dummy vars if needed\\n if len(covar_continuous_cols) > 0:\\n X_continuous_covar = ml_df[covar_continuous_cols].values\\n print('Using {} continuous covar'.format(len(covar_continuous_cols)))\\n X = np.hstack((X, X_continuous_covar))\\n X_col_names += list(covar_continuous_cols)\\n if len(covar_cat_cols) > 0:\\n X_cat_covar_df = pd.get_dummies(ml_df[covar_cat_cols])\\n X_cat_covar = X_cat_covar_df.values\\n print('Using {} categorical cols as {} cat covar (dummies)'.format(covar_cat_cols,X_cat_covar.shape[1]))\\n X = np.hstack((X, X_cat_covar))\\n X_col_names += list(X_cat_covar_df.columns)\\n\\n print('n of input columns: {}'.format(len(X_col_names)))\\n if model_type.lower() == 'classification':\\n y = pd.get_dummies(ml_df[outcome_col]).values[:,0]\\n print('Data shapes X {}, y {} ({})'.format(X.shape, len(y), list(ml_df[outcome_col].value_counts()))) \\n perf_metric = 'roc_auc'\\n cv = RepeatedStratifiedKFold(n_splits=n_splits,n_repeats=n_repeats,random_state=0)\\n elif model_type.lower() == 'regression':\\n y = ml_df[outcome_col].values\\n print('Data shapes X {}, y {} ({:3.2f}m, {:3.2f}sd)'.format(X.shape, len(y), np.mean(y),np.std(y))) \\n perf_metric = 'neg_mean_squared_error'\\n cv = ShuffleSplit(n_splits=n_splits*n_repeats, random_state=0)\\n else:\\n print('unknown model type {} (needs to be classification or regression)'.format(model_type))\\n\\n\\n print('Using {} model with perf metric {}'.format(model_type, perf_metric))\\n\\n X1 = X[grp1_idx]\\n y1 = y[grp1_idx]\\n X2 = X[grp2_idx]\\n y2 = y[grp2_idx]\\n\\n scores_df_CV = pd.DataFrame()\\n for train_index, test_index in cv.split(X1):\\n X1_tr = X1[train_index]\\n y1_tr = y1[train_index]\\n X1_te = X1[test_index]\\n y1_te = y1[test_index]\\n \\n ml_model.fit(X1_tr,y1_tr)\\n y1_pred = ml_model.predict(X1_te)\\n y2_pred = ml_model.predict(X2)\\n \\n if perf_metric == 'neg_mean_squared_error':\\n perf1 = mean_squared_error(y1_te, y1_pred)\\n perf2 = mean_squared_error(y2, y2_pred)\\n else:\\n print('Unknown scoring function {}'.format(perf_metric))\\n perf1 = 0\\n perf2 = 0\\n \\n scores_df = pd.DataFrame() \\n scores_df[perf_metric] = [perf1,perf2]\\n scores_df['test_subset'] = ['internal','external']\\n scores_df_CV = scores_df_CV.append(scores_df)\\n\\n return scores_df_CV\",\n \"def run(self):\\n self.tf_idf_scores = self.tf_idf()\\n self.word_scores = self.create_word_score()\\n self.keyword_scores = self.create_keyword_score()\\n self.text_ranks = self.create_text_rank()\\n self.pos_scores = {}\\n self.z_area_scores = {}\\n self.create_pos_and_area_score()\\n self.all_scores = self.weight_distribution()\\n self.all_scores_dict = self.get_all_scores_dict()\\n return self.get_keywords()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6188606","0.6146431","0.6113068","0.60673046","0.59287566","0.5926206","0.5902293","0.5877014","0.5784998","0.573546","0.5707369","0.5694776","0.56773263","0.5656921","0.5625058","0.5584204","0.55599093","0.5556537","0.55550545","0.55543596","0.5553796","0.5546866","0.5515304","0.5514842","0.54901385","0.547845","0.5477112","0.54697996","0.54434395","0.5441672","0.54385304","0.5429144","0.54263127","0.5403806","0.53979415","0.5397859","0.53834146","0.53816015","0.5370104","0.53674585","0.5361128","0.5360299","0.53454566","0.5343958","0.5343271","0.5334091","0.5330974","0.5324864","0.53203326","0.53147334","0.53123724","0.5307588","0.5300606","0.5288199","0.5286383","0.5283398","0.5278919","0.52783406","0.5277541","0.527685","0.5263186","0.5255599","0.52555627","0.5255115","0.52354074","0.5234422","0.5229043","0.5228924","0.5223216","0.5218491","0.5216664","0.52111244","0.5206782","0.52020866","0.5197677","0.5196538","0.51941574","0.5189047","0.5187281","0.51864547","0.51862675","0.5177438","0.517207","0.5170011","0.51695096","0.51673484","0.51638067","0.5159105","0.5154646","0.5149917","0.5147544","0.51453435","0.5141724","0.514136","0.5139894","0.51266134","0.51151025","0.51141363","0.5111171","0.51080686"],"string":"[\n \"0.6188606\",\n \"0.6146431\",\n \"0.6113068\",\n \"0.60673046\",\n \"0.59287566\",\n \"0.5926206\",\n \"0.5902293\",\n \"0.5877014\",\n \"0.5784998\",\n \"0.573546\",\n \"0.5707369\",\n \"0.5694776\",\n \"0.56773263\",\n \"0.5656921\",\n \"0.5625058\",\n \"0.5584204\",\n \"0.55599093\",\n \"0.5556537\",\n \"0.55550545\",\n \"0.55543596\",\n \"0.5553796\",\n \"0.5546866\",\n \"0.5515304\",\n \"0.5514842\",\n \"0.54901385\",\n \"0.547845\",\n \"0.5477112\",\n \"0.54697996\",\n \"0.54434395\",\n \"0.5441672\",\n \"0.54385304\",\n \"0.5429144\",\n \"0.54263127\",\n \"0.5403806\",\n \"0.53979415\",\n \"0.5397859\",\n \"0.53834146\",\n \"0.53816015\",\n \"0.5370104\",\n \"0.53674585\",\n \"0.5361128\",\n \"0.5360299\",\n \"0.53454566\",\n \"0.5343958\",\n \"0.5343271\",\n \"0.5334091\",\n \"0.5330974\",\n \"0.5324864\",\n \"0.53203326\",\n \"0.53147334\",\n \"0.53123724\",\n \"0.5307588\",\n \"0.5300606\",\n \"0.5288199\",\n \"0.5286383\",\n \"0.5283398\",\n \"0.5278919\",\n \"0.52783406\",\n \"0.5277541\",\n \"0.527685\",\n \"0.5263186\",\n \"0.5255599\",\n \"0.52555627\",\n \"0.5255115\",\n \"0.52354074\",\n \"0.5234422\",\n \"0.5229043\",\n \"0.5228924\",\n \"0.5223216\",\n \"0.5218491\",\n \"0.5216664\",\n \"0.52111244\",\n \"0.5206782\",\n \"0.52020866\",\n \"0.5197677\",\n \"0.5196538\",\n \"0.51941574\",\n \"0.5189047\",\n \"0.5187281\",\n \"0.51864547\",\n \"0.51862675\",\n \"0.5177438\",\n \"0.517207\",\n \"0.5170011\",\n \"0.51695096\",\n \"0.51673484\",\n \"0.51638067\",\n \"0.5159105\",\n \"0.5154646\",\n \"0.5149917\",\n \"0.5147544\",\n \"0.51453435\",\n \"0.5141724\",\n \"0.514136\",\n \"0.5139894\",\n \"0.51266134\",\n \"0.51151025\",\n \"0.51141363\",\n \"0.5111171\",\n \"0.51080686\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61870587"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":21497,"cells":{"query":{"kind":"string","value":"Given a dictionary of results, computes the overall session QC for each key and aggregates in a single value"},"document":{"kind":"string","value":"def compute_session_status_from_dict(results):\n indices = np.zeros(len(results), dtype=int)\n for i, k in enumerate(results):\n if k in TaskQC.criteria.keys():\n indices[i] = TaskQC._thresholding(results[k], thresholds=TaskQC.criteria[k])\n else:\n indices[i] = TaskQC._thresholding(results[k], thresholds=TaskQC.criteria['default'])\n\n def key_map(x):\n return 'NOT_SET' if x < 0 else list(TaskQC.criteria['default'].keys())[x]\n # Criteria map is in order of severity so the max index is our overall QC outcome\n session_outcome = key_map(max(indices))\n outcomes = dict(zip(results.keys(), map(key_map, indices)))\n return session_outcome, outcomes"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def aggregate_results(results):\n\n for (config,con,dec),folds in results.iteritems():\n m = MODEL_PATTERN.match(config)\n if m:\n mode = m.groupdict()['mode'] # mle, rl, mrt, ...\n model = m.groupdict()['model'] # haem, hacm, hard, ...\n align = m.groupdict()['align'] # crp, cls ...\n else:\n mode, model, align = '', '', ''\n # mean accuracies across seeds for each fold\n foldaccuracies = []\n # we count number of models over folds and seeds\n num_individual_models = 0\n\n for foldname,fold in folds.items():\n if 'Q' in options.mode:\n seedaccurracies = fold.values()[:1] if fold.values() else [] # pick one\n# SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\n else:\n seedaccurracies = []\n for seed_acc in fold.values():\n seedaccurracies.append(seed_acc)\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\n # aggregate on fold level\n fold['__MEAN__'] = float(np.mean(seedaccurracies))\n fold['__SD__'] = float(np.std(seedaccurracies))\n l = len(seedaccurracies)\n num_individual_models += l\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__MEAN__')] += l\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__SD__')] += l\n\n # statistics over seeds for this fold\n fold['__STATS__'] = fold['__MEAN__'], fold['__SD__'], l\n foldaccuracies.append(fold['__MEAN__'])\n # aggregate on (config, condition, decoding) level\n folds['__MEAN__'] = float(np.mean(foldaccuracies))\n folds['__SD__'] = float(np.std(foldaccuracies))\n # statistics over folds for this (config, condition, decoding)\n folds['__STATS__'] = folds['__MEAN__'], folds['__SD__'], num_individual_models","def compute_metrics(self, results: list) -> dict:","def score_aggregate(results):\n scores = []\n truth_count = detected_count = segment_count = 0\n\n for res in results:\n scores.append(res[\"scores\"])\n truth_count += len(res[\"labels\"])\n detected_count += len(res[\"detected\"])\n segment_count += len(res[\"scores\"][\"segments\"])\n\n ret = dict()\n ret[\"scores\"] = sum_scores(scores)\n ret[\"stats\"] = dict(truth_count=truth_count, detected_count=detected_count, segment_count=segment_count)\n return ret","def get_results_stats(self, results, key_by_date=True):\n stats = {}\n for r in results:\n if key_by_date:\n key = r.get(1)\n value = r.get(2)\n else:\n key = r.get(2)\n value = r.get(1)\n\n if key not in stats:\n stats[key] = {}\n\n if value not in stats[key]:\n stats[key][value] = 1\n else:\n stats[key][value] += 1\n\n # sort each keyset\n if not key_by_date:\n stats[key] = self._stats_sort(stats[key])\n\n if stats:\n # only if sorted per key\n if key_by_date:\n stats = self._stats_sort(stats)\n\n return stats","def aggregate_results(self, results):\n result = dict()\n result['MAE'] = self.average_dict_items(results, 'MAE')\n result['MdAE'] = self.average_dict_items(results, 'MdAE')\n result['RMSE'] = self.average_dict_items(results, 'RMSE')\n result['SMAPE'] = self.average_dict_items(results, 'SMAPE')\n result['num_values'] = self.average_dict_items(results, 'num_values')\n return result","def reduce_result(results):\n agg = OrderedDict()\n for result in results:\n # Keys by model and explore, adds additional values for `passed` to a set\n agg.setdefault((result[\"model\"], result[\"explore\"]), set()).add(\n result[\"passed\"]\n )\n reduced = [\n {\"model\": k[0], \"explore\": k[1], \"passed\": min(v)}\n for k, v in agg.items()\n ]\n return reduced","def aggregate_batch_evals(result_dict: dict, all_runs: list) -> dict:\n # Loop over all evals (e.g. b_1_eval_0) and merge + aggregate data\n new_results_dict = {}\n for eval in all_runs:\n all_seeds_for_run = list(result_dict[eval].keys())\n eval_dict = aggregate_single_eval(result_dict[eval], all_seeds_for_run, eval)\n new_results_dict[eval] = eval_dict[eval]\n return new_results_dict","def aggregate_over_seeds(result_dict: DotMap, batch_case: bool = False) -> DotMap:\n all_runs = list(result_dict.keys())\n if batch_case:\n # Perform seed aggregation for all evaluations\n new_results_dict = aggregate_batch_evals(result_dict, all_runs)\n else:\n new_results_dict = aggregate_single_eval(result_dict, all_runs, \"eval\")\n return DotMap(new_results_dict, _dynamic=False)","def aggregate_results(self):\n\n raise NotImplementedError","def average_metrics_results(results):\n res = {}\n\n if len(results) == 0:\n return {}\n\n for key in results[0]:\n try:\n res[key] = sum([r[key] for r in results]) / len(results)\n except TypeError:\n res[key] = [sum(b)/len(results) for b in zip(*[s[key] for s in results])]\n return res","def accumulate_study_results(ids, prob):\n sum_result = {}\n cnt_result = {}\n size = prob.shape[0]\n for i in range(size):\n study_id = ids[i]\n idx = int(study_id)\n if idx not in cnt_result:\n cnt_result[idx] = 0.\n sum_result[idx] = np.zeros((1, prob.shape[1]), dtype=np.float32)\n cnt_result[idx] += 1\n sum_result[idx] += prob[i, :]\n for i in cnt_result.keys():\n sum_result[i][:] /= cnt_result[i]\n return sum_result","def aggregate_single_eval( # noqa: C901\n result_dict: dict, all_seeds_for_run: list, eval_name: str\n) -> dict:\n new_results_dict = {}\n data_temp = result_dict[all_seeds_for_run[0]]\n # Get all main data source keys (\"meta\", \"stats\", \"time\")\n data_sources = list(data_temp.keys())\n # Get all variables within the data sources\n data_items = {\n data_sources[i]: list(data_temp[data_sources[i]].keys())\n for i in range(len(data_sources))\n }\n # Collect all runs together - data at this point is not modified\n source_to_store = {key: {} for key in data_sources}\n for ds in data_sources:\n data_to_store = {key: [] for key in data_items[ds]}\n for i, o_name in enumerate(data_items[ds]):\n for i, seed_id in enumerate(all_seeds_for_run):\n seed_run = result_dict[seed_id]\n data_to_store[o_name].append(seed_run[ds][o_name][:])\n source_to_store[ds] = data_to_store\n new_results_dict[eval_name] = source_to_store\n\n # Aggregate over the collected runs\n aggregate_sources = {key: {} for key in data_sources}\n for ds in data_sources:\n if ds in [\"time\"]:\n aggregate_dict = {key: {} for key in data_items[ds]}\n for i, o_name in enumerate(data_items[ds]):\n aggregate_dict[o_name] = new_results_dict[eval_name][ds][o_name][0]\n # Mean over stats data\n elif ds in [\"stats\"]:\n aggregate_dict = {key: {} for key in data_items[ds]}\n for i, o_name in enumerate(data_items[ds]):\n if type(new_results_dict[eval_name][ds][o_name][0][0]) not in [\n str,\n bytes,\n np.bytes_,\n np.str_,\n ]:\n # Compute mean and standard deviation over seeds\n mean_tol, std_tol = tolerant_mean(\n new_results_dict[eval_name][ds][o_name]\n )\n aggregate_dict[o_name][\"mean\"] = mean_tol\n aggregate_dict[o_name][\"std\"] = std_tol\n\n # Compute 10, 25, 50, 75, 90 percentiles over seeds\n p50, p10, p25, p75, p90 = tolerant_median(\n new_results_dict[eval_name][ds][o_name]\n )\n aggregate_dict[o_name][\"p50\"] = p50\n aggregate_dict[o_name][\"p10\"] = p10\n aggregate_dict[o_name][\"p25\"] = p25\n aggregate_dict[o_name][\"p75\"] = p75\n aggregate_dict[o_name][\"p90\"] = p90\n else:\n aggregate_dict[o_name] = new_results_dict[eval_name][ds][o_name]\n # Append over all meta data (strings, seeds nothing to mean)\n elif ds == \"meta\":\n aggregate_dict = {}\n for i, o_name in enumerate(data_items[ds]):\n temp = (\n np.array(new_results_dict[eval_name][ds][o_name])\n .squeeze()\n .astype(\"U200\")\n )\n # Get rid of duplicate experiment dir strings\n if o_name in [\n \"experiment_dir\",\n \"eval_id\",\n \"config_fname\",\n \"model_type\",\n ]:\n aggregate_dict[o_name] = str(np.unique(temp)[0])\n else:\n aggregate_dict[o_name] = temp\n\n # Add seeds as clean array of integers to dict\n aggregate_dict[\"seeds\"] = [int(s.split(\"_\")[1]) for s in all_seeds_for_run]\n else:\n raise ValueError\n aggregate_sources[ds] = aggregate_dict\n new_results_dict[eval_name] = aggregate_sources\n return new_results_dict","def generate_stats(results, ads, vmid, session_date, export_folder, process_ex_time):\n try:\n os.makedirs(export_folder)\n except OSError:\n pass\n\n # to be read and inserted into db\n totalads = 0 # total number of ads seen during this session\n totaluniqads = len(ads) # does not support multicategories at this point\n\n # for each category, for each test site, count total number of ads seen\n totalad_category = {} \n # for each category, for each test site, count total number of uniq ads seen\n uniqad_category = {}\n \n with open(os.path.join(export_folder, 'session_bugs.csv'), 'w') as bugs_wtr:\n bugs_wtr.write('#Ad-UID, Website-URL, Refresh-Num, Training-Topic,\\\n Site-Context, BugCount, BugSrc\\n')\n for train_category, cat_dict in results.items():\n totalad_category[train_category] = {}\n uniqad_category[train_category] = {}\n for test_site, bug_dict_list in cat_dict.items():\n total_ads = 0 # for each site\n uniq_ads = [] # for each site\n for refresh_num in range(len(bug_dict_list)):\n bug_dict = bug_dict_list[refresh_num]\n for bug, bugcount in bug_dict.items():\n if bug.is_ad():\n uuid = bug.get_uuid()\n bugs_wtr.write('{0}, {1}, {2}, {3}, {4}, {5}, {6}\\n'.format(uuid, test_site,\n refresh_num, train_category, 'N/A', bugcount, bug.get_src()))\n total_ads += bugcount\n if bug not in uniq_ads:\n uniq_ads.append(bug)\n totalad_category[train_category][test_site] = total_ads\n uniqad_category[train_category][test_site] = len(uniq_ads)\n totalads += total_ads # global count for total ads\n\n with open(os.path.join(export_folder, 'session_stats.csv'), 'w') as ses_wtr:\n # write some metadata information about this session\n ses_wtr.write('#VMID: %s\\n' % vmid)\n ses_wtr.write('#Session-Date: %s\\n' % session_date)\n ses_wtr.write('#Time to complete: %s\\n' % process_ex_time)\n ses_wtr.write('#Training Categories: %s\\n' % str(results.keys()))\n ses_wtr.write('#Total Number of ads: %d\\n' % totalads)\n ses_wtr.write('#Total Uniq ads: %d\\n\\n' % totaluniqads)\n ses_wtr.write('#TrainingTopic, Test-Site, NumberOfVisit, TotalAds, UniqAds\\n')\n\n for train_category, cat_dict in results.items(): \n for test_site, bug_dict_list in cat_dict.items():\n num_of_visit = len(bug_dict_list)\n ses_wtr.write('{0}, {1}, {2}, {3}, {4}\\n'.format(train_category,\n test_site, num_of_visit, totalad_category[train_category][test_site],\n uniqad_category[train_category][test_site]))","def summary(self):\n summary = defaultdict(int)\n\n for r in self.results:\n summary[r.result] += 1\n\n return summary","def process_metrics_overall(\n self, the_dict, names=[\"metric\", \"phase\", \"epoch\", \"performance\"]\n ):\n result = (\n pd.DataFrame(the_dict)\n .reset_index()\n .melt(id_vars=\"index\")\n .set_index([\"index\", \"variable\"])\n .value.apply(pd.Series)\n .stack()\n .reset_index()\n )\n result.columns = names\n return result","def _cv_results(self, metrics):\n\n param_keys = self.param_combs[0].keys()\n param_dict = {k: [comb[k] for comb in self.param_combs]\n for k in param_keys}\n df_metric_result = {k: pd.DataFrame({'Metric mean': self.mean[k],\n 'Std. dev.': self.std[k],\n **param_dict})\n for k in metrics.keys()}\n self.cv_results_ = df_metric_result","def summarizeResults(results, what, discard=(), minName=None, maxName=None):\n # threadCounts = sorted (transpose(results).keys())\n threadCounts = [t for t in list(transpose(results).keys()) if t not in discard]\n if not isinstance(threadCounts[0], str):\n threadCounts.sort()\n\n sds = {}\n meanValues = {}\n what_SD = \"SD\" if what == \"Mean\" else what + \"_SD\"\n\n for k in list(results.keys()):\n res = results[k]\n meanValues[k] = [\n None if res.get(tc, None) == None else res[tc].__dict__.get(what, None)\n for tc in threadCounts\n ]\n if minName != None and maxName != None:\n sds[k] = [\n None\n if res.get(tc, None) == None\n else convertMinMaxIntoError(res[tc], what, minName, maxName)\n for tc in threadCounts\n ]\n else:\n sds[k] = [\n None\n if res.get(tc, None) == None\n else res[tc].__dict__.get(what_SD, None)\n for tc in threadCounts\n ]\n return (threadCounts, meanValues, sds)","def sum(app, args):\n if not args.key:\n db = get_db(app)\n notrans = db.transient.count()\n print(\"No Transient records: \", notrans)\n if notrans > 0:\n print(\"Total data Transient: \", nicesize(\n list(db.transient.aggregate([\n {\"$group\": {\"_id\": None,\n \"total\": {\"$sum\": \"$size\"}}}]))[0]['total']))\n print(\" No Core records: \", db.transient.count())\n return\n\n kname, kinfo = key_info(app.conf, args.key)\n res = _single_sum(app, group_by=kname, force=args.force)\n total_size = int(0)\n total_count = 0\n mgn = len(\"Total\")\n for reshost in res:\n gid = reshost['_id']\n if gid is None:\n mgn = max(4, mgn)\n else:\n mgn = max(len(str(reshost['_id'])), mgn)\n\n fms = \"{:\" + str(mgn) + \"}\\t{:>10}\\t{:>9}\"\n if args.human:\n print(\"# {}:\".format(kname))\n for reshost in res:\n total = reshost['total']\n count = reshost['count']\n total_size += int(total)\n total_count += count\n if args.human:\n total_human = nicesize(total)\n count_human = nicenumber(count)\n categ = reshost['_id']\n if categ is None:\n categ = \"<undefined>\"\n\n print(fms.format(\n categ, total_human, count_human))\n else:\n print(\"{}\\t{}\\t{}\".format(\n reshost['_id'], total, count))\n\n if args.human:\n total_size_human = nicesize(total_size)\n total_count_human = nicenumber(total_count)\n print(fms.format('', '-'*10, '-'*9))\n print(fms.format(\n \"Total\", total_size_human, total_count_human))\n else:\n print(\"Total\\t{}\\t{}\".format(total_size, total_count))","def process_result_dict(\n the_dict, names=[\"metric\", \"phase\", \"epoch\", \"performance\"]\n ):\n result = (\n pd.DataFrame(the_dict)\n .reset_index()\n .melt(id_vars=\"index\")\n .set_index([\"index\", \"variable\"])\n .value.apply(pd.Series)\n .stack()\n .reset_index()\n )\n result.columns = names\n return result","def get_job_metrics_summary_for_task(query):\n metric_list = ['hs06sec', 'gco2_global']\n metrics = {}\n for m in metric_list:\n metrics[m] = {'finished': 0, 'failed': 0, 'total': 0}\n\n hquery = copy.deepcopy(query)\n hquery['jobstatus__in'] = ('finished', 'failed')\n\n if 'jeditaskid' in hquery:\n\n hs06sec_sum = []\n # getting jobs. Can not use the .annotate() as there can be duplicates\n jobs = []\n jvalues = ['pandaid', 'jobstatus', ] + metric_list\n jobs.extend(Jobsarchived4.objects.filter(**hquery).values(*jvalues))\n jobs.extend(Jobsarchived.objects.filter(**hquery).values(*jvalues))\n jobs = drop_duplicates(jobs)\n\n for job in jobs:\n for m in metric_list:\n metrics[m]['total'] += job[m] if m in job and job[m] is not None else 0\n if job['jobstatus'] == 'finished':\n metrics[m]['finished'] += job[m] if m in job and job[m] is not None else 0\n elif job['jobstatus'] == 'failed':\n metrics[m]['failed'] += job[m] if m in job and job[m] is not None else 0\n\n # getting data from ATLARC DB, only hs06s\n pj_models = get_pandajob_arch_models_by_year(query['modificationtime__castdate__range'])\n if len(pj_models) > 0:\n for pjm in pj_models:\n try:\n hs06sec_sum.extend(pjm.objects.filter(**hquery).values('jobstatus').annotate(hs06secsum=Sum('hs06sec')))\n except Exception as ex:\n _logger.exception('Failed to get hs06sec from {} at ATLARC DB:\\n{}'.format(pjm, ex))\n\n if len(hs06sec_sum) > 0:\n for hs in hs06sec_sum:\n metrics['hs06sec']['total'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\n if hs['jobstatus'] == 'finished':\n metrics['hs06sec']['finished'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\n elif hs['jobstatus'] == 'failed':\n metrics['hs06sec']['failed'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\n\n\n return metrics","def calc_data(self):\n\n circ_counts = {}\n for trialidx in range(self._ntrials):\n for _, depth in enumerate(self._depths):\n circ_name = 'qv_depth_%d_trial_%d' % (depth, trialidx)\n\n # get the counts form ALL executed circuits\n count_list = []\n for result in self._result_list:\n try:\n count_list.append(result.get_counts(circ_name))\n except (QiskitError, KeyError):\n pass\n\n circ_counts[circ_name] = \\\n build_counts_dict_from_list(count_list)\n\n self._circ_shots[circ_name] = \\\n sum(circ_counts[circ_name].values())\n\n # calculate the heavy output probability\n self._heavy_output_counts[circ_name] = \\\n self._subset_probability(\n self._heavy_outputs[circ_name],\n circ_counts[circ_name])","def aggregator(index_keynames, value_keynames, ts_keyname, func, interval = 60 * 5):\n data = {}\n ts = None\n #print ts_keyname\n for parsts, parsdata in func():\n #print parsdata\n #print parsdata[\"log_timestamp\"]\n if ts is None:\n ts = parsts\n key = tuple((parsdata[key] for key in index_keynames))\n values = tuple((int(parsdata[key]) for key in value_keynames))\n if key not in data:\n data[key] = values\n else:\n data[key] = tuple((data[key][index] + int(values[index]) for index in range(len(values))))\n if parsts > (ts + interval):\n for keys, values in data.items():\n yield \"%s\\t%s\\t%s\" % (ts, \"\\t\".join((str(index_key) for index_key in keys)), \"\\t\".join((str(value_key) for value_key in values)))\n ts = None\n data = {}","def _print_aggregate_results(\n task: Task, task_results: Dict[Task, List[List[Dict[str, Any]]]]\n) -> None:\n aggregate_task_result = aggregate_nvs_results(task_results[task])\n print(\"\")\n print(f\"Aggregate results for task={task}:\")\n pretty_print_nvs_metrics(aggregate_task_result)\n print(\"\")","def get_test_cases_coverage(session_id):\n tc_stats={}\n tc_stats_list=[]\n total_executed=0\n sql='SELECT DISTINCT(test_id) FROM stats WHERE session_id=:sid AND test_id!=\"null\"'\n params={\"sid\":session_id}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n tests=c.fetchall()\n conn.close()\n if len(tests)>0:\n for t in tests:\n total_executed=0\n sql=\"SELECT DISTINCT(file_id) FROM stats WHERE session_id=:sid AND test_id=:tid\"\n params={\"sid\":session_id,\"tid\":t[0]}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n files=c.fetchall()\n conn.close()\n for f in files:\n line_count=get_executable_lines_count_for_file(f[0])\n # get executions\n sql=\"SELECT COUNT(DISTINCT line_guid) FROM stats WHERE session_id= :sid AND file_id= :fid AND test_id=:tid\"\n params={\"sid\":session_id,\"tid\":t[0],\"fid\":f[0]}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n executed=c.fetchone()\n conn.close()\n total_executed+=executed[0]\n # save test case and it's executions\n tc_stats={}\n tc_stats[\"test_id\"]=t[0]\n tc_stats[\"total_executed\"]=total_executed\n tc_stats[\"total_executed\"]\n \n tc_stats_list.append(tc_stats)\n return tc_stats_list","def gather_results(dataset: Dataset,\n conf: Namespace\n ) -> \"dict[str, dict[str, any]]\":\n\n data = {}\n\n for k in np.copy(dataset.folds):\n print(f\"\\nFold {k}\", '~'*60)\n\n dataset.set_fold(k)\n calibrated_scores = APPROACHES[conf.approach](dataset=dataset, conf=conf)\n\n data[f'fold{k}'] = {\n 'scores': calibrated_scores,\n 'metrics': get_metrics(calibrated_scores, dataset, conf)\n }\n\n return data","def compute_session_status(self):\n if self.passed is None:\n raise AttributeError('passed is None; compute QC first')\n # Get mean passed of each check, or None if passed is None or all NaN\n results = {k: None if v is None or np.isnan(v).all() else np.nanmean(v)\n for k, v in self.passed.items()}\n session_outcome, outcomes = self.compute_session_status_from_dict(results)\n return session_outcome, results, outcomes","def calculates_results_stats(results_dic): \n # Creates empty dictionary for results_stats_dic\n results_stats_dic = dict()\n \n # Sets all counters to initial values of zero so that they can \n # be incremented while processing through the images in results_dic \n results_stats_dic['n_dogs_img'] = 0\n results_stats_dic['n_match'] = 0\n results_stats_dic['n_correct_dogs'] = 0\n results_stats_dic['n_correct_notdogs'] = 0\n results_stats_dic['n_correct_breed'] = 0\n \n # process through the results dictionary\n for key in results_dic:\n \n # Labels Match Exactly\n if results_dic[key][2] == 1:\n results_stats_dic['n_match'] += 1\n\n # TODO: 5a. REPLACE pass with CODE that counts how many pet images of\n # dogs had their breed correctly classified. This happens \n # when the pet image label indicates the image is-a-dog AND \n # the pet image label and the classifier label match. You \n # will need to write a conditional statement that determines\n # when the dog breed is correctly classified and then \n # increments 'n_correct_breed' by 1. Recall 'n_correct_breed' \n # is a key in the results_stats_dic dictionary with it's value \n # representing the number of correctly classified dog breeds.\n # \n # Pet Image Label is a Dog AND Labels match- counts Correct Breed\n if results_dic[key][3] == 1 and results_dic[key][2] == 1:\n results_stats_dic['n_correct_breed'] += 1\n \n # Pet Image Label is a Dog - counts number of dog images\n if results_dic[key][3] == 1:\n results_stats_dic['n_dogs_img'] += 1\n \n # Classifier classifies image as Dog (& pet image is a dog)\n # counts number of correct dog classifications\n if results_dic[key][4] == 1:\n results_stats_dic['n_correct_dogs'] += 1\n\n # TODO: 5b. REPLACE pass with CODE that counts how many pet images \n # that are NOT dogs were correctly classified. This happens \n # when the pet image label indicates the image is-NOT-a-dog \n # AND the classifier label indicates the images is-NOT-a-dog.\n # You will need to write a conditional statement that \n # determines when the classifier label indicates the image \n # is-NOT-a-dog and then increments 'n_correct_notdogs' by 1. \n # Recall the 'else:' above 'pass' already indicates that the \n # pet image label indicates the image is-NOT-a-dog and \n # 'n_correct_notdogs' is a key in the results_stats_dic dictionary \n # with it's value representing the number of correctly \n # classified NOT-a-dog images.\n # \n # Pet Image Label is NOT a Dog\n else:\n # Classifier classifies image as NOT a Dog(& pet image isn't a dog)\n # counts number of correct NOT dog clasifications.\n if results_dic[key][3] == 0 and results_dic[key][4] == 0:\n results_stats_dic['n_correct_notdogs'] += 1\n\n\n # Calculates run statistics (counts & percentages) below that are calculated\n # using the counters from above.\n\n # calculates number of total images\n results_stats_dic['n_images'] = len(results_dic)\n\n # calculates number of not-a-dog images using - images & dog images counts\n results_stats_dic['n_notdogs_img'] = (results_stats_dic['n_images'] - \n results_stats_dic['n_dogs_img']) \n\n # TODO: 5c. REPLACE zero(0.0) with CODE that calculates the % of correctly\n # matched images. Recall that this can be calculated by the\n # number of correctly matched images ('n_match') divided by the \n # number of images('n_images'). This result will need to be \n # multiplied by 100.0 to provide the percentage.\n # \n # Calculates % correct for matches\n results_stats_dic['pct_match'] = (results_stats_dic['n_match'] / results_stats_dic['n_images']) * 100\n\n # TODO: 5d. REPLACE zero(0.0) with CODE that calculates the % of correctly\n # classified dog images. Recall that this can be calculated by \n # the number of correctly classified dog images('n_correct_dogs')\n # divided by the number of dog images('n_dogs_img'). This result \n # will need to be multiplied by 100.0 to provide the percentage.\n # \n # Calculates % correct dogs\n results_stats_dic['pct_correct_dogs'] = (results_stats_dic['n_correct_dogs'] / results_stats_dic['n_dogs_img']) * 100\n\n # TODO: 5e. REPLACE zero(0.0) with CODE that calculates the % of correctly\n # classified breeds of dogs. Recall that this can be calculated \n # by the number of correctly classified breeds of dog('n_correct_breed') \n # divided by the number of dog images('n_dogs_img'). This result \n # will need to be multiplied by 100.0 to provide the percentage.\n # \n # Calculates % correct breed of dog\n results_stats_dic['pct_correct_breed'] = (results_stats_dic['n_correct_breed'] / results_stats_dic['n_dogs_img']) * 100\n\n # Calculates % correct not-a-dog images\n # Uses conditional statement for when no 'not a dog' images were submitted \n if results_stats_dic['n_notdogs_img'] > 0:\n results_stats_dic['pct_correct_notdogs'] = (results_stats_dic['n_correct_notdogs'] /\n results_stats_dic['n_notdogs_img']) * 100.0\n else:\n results_stats_dic['pct_correct_notdogs'] = 0.0\n\n \n # TODO 5f. REPLACE None with the results_stats_dic dictionary that you \n # created with this function \n return results_stats_dic","def extract_score(results):\n total_score = 0;\n total_possible_score = 0;\n for k in results.keys():\n total_score = total_score + results[k][0]\n total_possible_score = total_possible_score + results[k][1]\n return (total_score, total_possible_score)","def get_DFGs_result_summary(DFGs):\n DFGs_summary = dict()\n for DFG_name in DFGs:\n DFGs_summary[DFG] = {}\n for res in jenkins_const.RESULTS:\n DFGs_summary[DFG_name][res] = Job.count(\n name='DFG-{}'.format(DFG_name),\n last_build_res=res)\n return DFGs_summary","def totalize_measurement(conts_dict, si_model):\n print('######## BEGIN CHECKING TOTAL ########')\n for cont_measure, doc_measure in [\n ['packages', 'total_packages'],\n ['container_weight', 'total_weight'],\n ['container_measurement', 'total_measurement']\n ]:\n doc_qua, doc_unit = split_quantity_unit(si_model[doc_measure])\n if not doc_qua:\n doc_qua = '0'\n if floatable(doc_qua.replace(',', '')):\n doc_qua = float(doc_qua.replace(',', ''))\n else:\n doc_qua = 0\n conts_detail = [\n split_quantity_unit(cont.get(cont_measure, '0'))\n for cont in conts_dict\n ]\n\n print(cont_measure, ':', conts_detail, '|', doc_qua, '-', doc_unit)\n\n conts_unit = list(set([\n cont_unit\n for cont_qua, cont_unit in conts_detail\n ]))\n if len(conts_unit) == 1:\n conts_sum = sum([\n float(cont_qua.replace(',', ''))\n for cont_qua, cont_unit in conts_detail\n if floatable(cont_qua.replace(',', ''))\n ])\n conts_unit = conts_unit[0]\n else:\n conts_sum = 0\n conts_unit = ''\n\n if conts_sum != doc_qua and conts_unit and conts_sum > 0:\n print('### Containers', cont_measure, conts_sum,\n '=/= SI', doc_measure, doc_qua, '###')\n if doc_measure == 'total_packages':\n si_model[doc_measure] = f\"{conts_sum:,.0f}\" + conts_unit\n else:\n si_model[doc_measure] = f\"{conts_sum:,.3f}\" + conts_unit\n\n return si_model","def results(key):\n poll = repository.get_poll(key)\n poll.calculate_stats()\n return render_template(\n 'results.jade',\n title='Results',\n year=datetime.now().year,\n poll=poll,\n )","def legal_universal_search_results():\n advisory_opinions = advisory_opinions_search_results()\n regulations = regulations_search_results()\n total_count = advisory_opinions['total_advisory_opinions'] + regulations['total_regulations']\n results = {\"total_all\": total_count}\n results.update(advisory_opinions)\n results.update(regulations)\n return results","def mean_accuracy_per_setting(results):\n ###TODO\n min_freq = {}\n feature = {}\n punct = {}\n \n #step 1 -> loop over results to get list of values for particular \n # setting of punct, features,min_freq \n #keys = ['punct','features','min_freq','accuracy']\n \n for d in results:\n \n if d['min_freq'] not in min_freq.keys():\n min_freq.setdefault(d['min_freq'],[]).append(d['accuracy'])\n else :\n min_freq[d['min_freq']].append(d['accuracy'])\n \n if d['punct'] not in punct.keys():\n punct.setdefault(d['punct'],[]).append(d['accuracy'])\n else :\n punct[d['punct']].append(d['accuracy'])\n \n if d['features'] not in feature.keys(): \n feature.setdefault(d['features'],[]).append(d['accuracy'])\n else : \n feature[d['features']].append(d['accuracy'])\n \n \n #print('min_freq = ',min_freq)\n #print('feature = ',feature)\n #print('punct = ',punct) \n \n # step 2 -> find average for each setting\n tuple_list = [] \n for fet in feature.keys():\n \n t1 = 'features='\n for f in fet:\n t1 += f.__name__ + ' '\n \n #print(t1)\n avg = np.mean(feature[fet],dtype=np.float64) \n tuple_list.append((avg,t1))\n\n\n #print('After features result = ',result) \n \n for freq in min_freq.keys():\n t1 = 'min_freq=' + str(freq)\n avg = np.mean(min_freq[freq],dtype=np.float64) \n tuple_list.append((avg,t1))\n \n #print('After mean_freq result = ',result) \n \n for pun in punct.keys():\n t1 = 'punct=' + str(pun)\n avg = np.mean(punct[pun],dtype=np.float64) \n tuple_list.append((avg,t1))\n \n #print('After punct result = ',result) \n \n \n tuple_list.sort(key=lambda x:(-x[0]))\n #print('2.Sorted result = ',result) \n \n \n return(tuple_list) \n \n pass","def _compute_traj_stats(traj_obs_dict):\n traj_stats = { k : {} for k in traj_obs_dict }\n for k in traj_obs_dict:\n traj_stats[k][\"n\"] = traj_obs_dict[k].shape[0]\n traj_stats[k][\"mean\"] = traj_obs_dict[k].mean(axis=0, keepdims=True) # [1, ...]\n traj_stats[k][\"sqdiff\"] = ((traj_obs_dict[k] - traj_stats[k][\"mean\"]) ** 2).sum(axis=0, keepdims=True) # [1, ...]\n return traj_stats","def evalRun(rerankRun, qrelsDict, metricFunc, debug=False):\n resArr = []\n\n for qid, scoreDict in rerankRun.items():\n relsSortedByScores = []\n\n val = 0\n\n if qid in qrelsDict:\n queryQrelDict = qrelsDict[qid]\n\n for did, score in getSorteScoresFromScoreDict(scoreDict):\n rel_score = 0\n if did in queryQrelDict:\n rel_score = queryQrelDict[did]\n\n relsSortedByScores.append(rel_score)\n\n val = metricFunc(relsSortedByScores, queryQrelDict) if queryQrelDict else 0\n\n if debug:\n print('%s %g' % (qid, val))\n\n resArr.append(val)\n\n res = np.mean(resArr)\n if debug:\n print('mean %g' % res)\n\n return res","def result(self) -> Dict[int, float]:\n return {k: v.result() for k, v in self._topk_acc_dict.items()}","def calc_stats(results, number, concurrency):\n\n all_res = results.all_res\n count = len(all_res)\n\n amax = np.amax(all_res)\n amin = np.amin(all_res)\n\n return {\n \"rps\": len(all_res) / float(results.total_time),\n \"mean\": np.mean(all_res),\n \"min\": amin,\n \"max\": amax,\n \"amp\": float(amax - amin),\n \"median\": np.median(all_res),\n \"stdev\": np.std(all_res),\n \"perc_95\": np.percentile(all_res, 95),\n \"perc_80\": np.percentile(all_res, 80),\n \"failed\": number - count,\n \"total_time\": results.total_time,\n \"count\": count,\n \"number\": number,\n \"concurrency\": concurrency,\n \"server\": results.server,\n }","def evaluate(out_dict, n):\n out = dict()\n for key, entry in out_dict.items():\n out[key] = dict()\n for it_count, data in entry.items():\n total = 0.\n count = 0\n for x_list in data.values():\n total += analytic_value_VaR(x_list[-1])\n count += 1\n out[key][it_count] = total / count\n np.save('normal_out_all_cvar_%d.npy' % n, out)\n print(out)","def session_counting (self, target_dict, IEI_timeRange = (0, 900, 1), cal_IEI = True, cal_duration = True, cal_latency = True, cal_inputDistribution = True, num_bins = 10, **kwards):\r\n if len(self.df) == 0:\r\n #if empty then pass without analysis\r\n pass\r\n else:\r\n get_kwards = lambda x: (\"\",\"\") if x == None else x\r\n input1OnOff = get_kwards(kwards.get('Input1OnOff'))\r\n input2OnOff = get_kwards(kwards.get('Input2OnOff'))\r\n input3OnOff = get_kwards(kwards.get('Input3OnOff'))\r\n input4OnOff = get_kwards(kwards.get('Input4OnOff'))\r\n \r\n #get a start and end time point\r\n if 'Start' in self.df['States'].values:\r\n start = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Start')]['Time']\r\n else:\r\n start = pd.Series({'Start': self.df['Time'].values[0]-1})\r\n \r\n if 'Finish' in self.df['States'].values:\r\n end = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Finish')]['Time']\r\n else:\r\n end = pd.Series({'Finish': self.df['Time'].values[-1]+1}) #plus 1 second\r\n \r\n #get data from each event window\r\n event = self.df[(self.df['Time']>= start.iloc[0])&(self.df['Time']<= end.iloc[0])]\r\n \r\n result_dict = {}\r\n for k, v in target_dict.items():\r\n \r\n if k == 'Input1':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input1OnOff)\r\n elif k == 'Input2':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input2OnOff)\r\n elif k == 'Input3':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input3OnOff)\r\n elif k == 'Input4':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input4OnOff)\r\n else:\r\n result_dict [v[1]] = self.__counting (event, v, self.subject)\r\n \r\n return result_dict","def compute_key_value(self) -> Dict[str, float]:\n # @TODO: ddp hotfix, could be done better\n if self._is_ddp:\n for key in self.statistics:\n value: List[np.ndarray] = all_gather(self.statistics[key])\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\n self.statistics[key] = value\n\n per_class, micro, macro, weighted = self.compute()\n metrics = self._convert_metrics_to_kv(\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\n )\n return metrics","def _merge_test_results(test_results_dict, test_error_dict):\n merged_test_results = {}\n for testtype, testresults in test_results_dict.items():\n for name, val in testresults.items():\n if name == 'stats':\n if isinstance(val, dict):\n for n, v in val.items():\n merged_test_results['%s_%s' % (n, testtype.upper())] = v\n else:\n continue\n else:\n merged_test_results['%s_%s' % (name, testtype.upper())] = val\n\n merged_test_results['error_code_test'] = test_error_dict['error_code_test']\n\n return merged_test_results","def __calculate_agg_shap_scores(self):\n self.agg_stats_timer = SimbaTimer(start=True)\n for clf_state, clf_state_name in zip(range(2), [\"ABSENT\", \"PRESENT\"]):\n self.results = {}\n self.df_save_path = os.path.join(\n self.shap_logs_path,\n \"SHAP_summary_{}_{}_{}.csv\".format(\n self.classifier_name, clf_state_name, self.datetime\n ),\n )\n shap_clf_sliced = self.shap_df[\n self.shap_df[self.classifier_name] == clf_state\n ]\n for feature_category, feature_time_bin in itertools.product(\n self.unique_feature_category_names, self.unique_time_bin_names\n ):\n if feature_category not in self.results.keys():\n self.results[feature_category] = {}\n feature_names_sliced = list(\n self.feature_categories_df.loc[\n :, (feature_category, feature_time_bin)\n ]\n )\n feature_names_sliced = [\n x\n for x in feature_names_sliced\n if str(x) != \"nan\" and x in shap_clf_sliced\n ]\n self.results[feature_category][feature_time_bin] = round(\n shap_clf_sliced[feature_names_sliced].sum(axis=1).mean() * 100, 6\n )\n self.__save_aggregate_scores()\n self.agg_stats_timer.stop_timer()\n self.visualization_timer = SimbaTimer(start=True)\n\n stdout_success(\n msg=f\"Aggregate SHAP statistics saved in {self.shap_logs_path} directory\",\n elapsed_time=self.agg_stats_timer.elapsed_time_str,\n )","def selectedComparisons(samples_dict):\n sectors=\"peripherals\",\"intermediaries\",\"hubs\"\n ks_measures={}\n for analyses_type in samples_dict[sectors[0]]:\n ks_measures[analyses_type]={}\n for analysis_grouping in samples_dict[sectors[0]][analyses_type]:\n ks_measures[analyses_type][analysis_grouping]={}\n if samples_dict[sectors[0]][analyses_type][analysis_grouping]==dict:\n ks_measures[analyses_type][analysis_grouping]={}\n for analysis in samples_dict[sectors[0]][analyses_type][analysis_grouping]:\n for var in samples_dict[sectors[0]][analyses_type][analysis_grouping][analysis]:\n samples_peripherals=samples_dict[sectors[0]][analyses_type][analysis_grouping][analysis]\n samples_intermediaries=samples_dict[sectors[1]][analyses_type][analysis_grouping][analysis]\n samples_hubs=samples_dict[sectors[2]][analyses_type][analysis_grouping][analysis]\n ks_measures[analysis][\"peripherals_intermediaries\"]=P.kolmogorovSmirnovTest(samples_peripherals,samples_intermediaries)\n ks_measures[analysis][\"peripherals_hubs\"]=P.kolmogorovSmirnovTest(samples_peripherals,samples_hubs)\n ks_measures[analysis][\"hubs_intermediaries\"]=P.kolmogorovSmirnovTest(samples_hubs,samples_intermediaries)\n else:\n for var in samples_dict[sectors[0]][analyses_type][analysis_grouping]:\n samples_peripherals=samples_dict[sectors[0]][analyses_type][analysis_grouping]\n samples_intermediaries=samples_dict[sectors[1]][analyses_type][analysis_grouping]\n samples_hubs=samples_dict[sectors[2]][analyses_type][analysis_grouping]\n\n\n\n samples[sector][analyses][analysis_grouping]=updateDict(samples[sector][analyses][analysis_grouping],getSamples(authors_analysis[analyses][author][analysis_grouping]))","def format_results(self, results_dict, data, cached_data):\n new_results = {}\n status = self.STATUS_MAP[results_dict['info']['exitFlag']]\n new_results[s.STATUS] = status\n\n # Timing data\n new_results[s.SOLVE_TIME] = results_dict[\"info\"][\"timing\"][\"tsolve\"]\n new_results[s.SETUP_TIME] = results_dict[\"info\"][\"timing\"][\"tsetup\"]\n new_results[s.NUM_ITERS] = results_dict[\"info\"][\"iter\"]\n\n if new_results[s.STATUS] in s.SOLUTION_PRESENT:\n primal_val = results_dict['info']['pcost']\n new_results[s.VALUE] = primal_val + data[s.OFFSET]\n new_results[s.PRIMAL] = results_dict['x']\n new_results[s.EQ_DUAL] = results_dict['y']\n new_results[s.INEQ_DUAL] = results_dict['z']\n\n return new_results","def compute_query_summary_statistics(data):\n return {\n nameserver: _compute_summary_stats(entries)\n for nameserver, entries in data.items()\n }","def computeStats(results, independentVariable):\n common = {}\n\n # Collect lists of the values\n for v in results:\n test = v.__dict__[independentVariable]\n try:\n common[test].append(v)\n except:\n common[test] = [v]\n\n result = []\n # Sanity check for number of data items being summarized\n # print (\"Computing stats on \" + str(len(common.values()[0])))\n for measurements in list(common.values()):\n resultValues = {}\n resultValues[independentVariable] = measurements[0].__dict__[\n independentVariable\n ]\n # print (\"Measurement[\\\"\"+independentVariable+\"\\\"] : \" + str(resultValues[independentVariable]))\n fieldnames = list(measurements[0].__dict__.keys())\n fieldnames.remove(independentVariable)\n for stat in fieldnames:\n values = [m.__dict__[stat] for m in measurements]\n resultValues[stat] = mean(values)\n resultValues[stat + \"_SD\"] = standardDeviation(values, resultValues[stat])\n result.append(\n measurement(list(resultValues.keys()), list(resultValues.values()))\n )\n # print (\"Result: \" + str(result))\n return result","def collect(results, **kwargs):\n l = kwargs.get('logger')\n l.info(\n u'#{} Collect ADD.'.format(u'-' * 8)\n )\n\n l.info(\n u'#{} {} results from {} total items.'.format(\n u'-' * 12, len(results), sum([x['items_processed'] for x in results])\n )\n )\n \n final_result = sum([x['result'] for x in results])\n\n l.info(\n u'#{} Final result: {}.'.format(\n u'-' * 12, final_result\n )\n )\n\n return final_result","def summarize_results(folder, ruleset):\n systems_folder = os.path.join(folder, 'systems')\n results_folder = os.path.join(folder, 'results')\n\n rows = {}\n for system_folder in _get_sub_folders(results_folder):\n folder_parts = system_folder.split('/')\n system = folder_parts[-1]\n\n # Load corresponding system description.\n system_file = os.path.join(\n systems_folder, '{}.json'.format(system))\n if not os.path.exists(system_file):\n print('ERROR: Missing {}'.format(system_file))\n continue\n try:\n desc = _read_json_file(system_file)\n except:\n print('ERROR: Could not decode JSON struct in {}'.format(system_file))\n continue\n\n # Construct prefix portion of the row.\n row = ''\n if 'submitter' not in desc:\n print('ERROR: \"submitter\" field missing in {}'.format(system_file))\n continue\n row += '\"{}\",'.format(desc['submitter'])\n if 'system_name' not in desc:\n print('ERROR: \"system_name\" field missing in {}'.format(system_file))\n continue\n row += '\"{}\",'.format(_pretty_system_name(desc))\n if 'host_processor_model_name' not in desc:\n print('ERROR: \"host_processor_model_name\" field missing in {}'.format(system_file))\n continue\n row += '\"{}\",'.format(desc['host_processor_model_name'])\n if 'host_processor_core_count' not in desc:\n print('ERROR: \"host_processor_core_count\" field missing in {}'.format(system_file))\n continue\n row += '{},'.format(desc['host_processor_core_count'])\n if 'accelerator_model_name' not in desc:\n print('ERROR: \"accelerator_model_name\" field missing in {}'.format(system_file))\n continue\n row += '\"{}\",'.format(_pretty_accelerator_model_name(desc))\n if 'accelerators_per_node' not in desc:\n print('ERROR: \"accelerators_per_node\" field missing in {}'.format(system_file))\n continue\n row += '{},'.format(desc['accelerators_per_node'])\n if 'framework' not in desc:\n print('ERROR: \"framework\" field missing in {}'.format(system_file))\n continue\n row += '\"{}\",'.format(_pretty_framework(desc))\n\n # Collect scores for benchmarks.\n benchmark_scores = {}\n for benchmark_folder in _get_sub_folders(system_folder):\n folder_parts = benchmark_folder.split('/')\n benchmark = _benchmark_alias(folder_parts[-1])\n\n # Read scores from result files.\n pattern = '{folder}/result_*.txt'.format(folder=benchmark_folder)\n result_files = glob.glob(pattern, recursive=True)\n scores = []\n dropped_scores = 0\n for result_file in result_files:\n score = _read_mlperf_score(result_file, ruleset)\n if score is None:\n dropped_scores += 1\n else:\n scores.append(score)\n if dropped_scores > 1:\n print('CRITICAL ERROR: Too many non-converging runs for {} {}/{}'.\n format(desc['submitter'], system, benchmark))\n print('** CRITICAL ERROR ** Results in the table for {} {}/{} are NOT correct'.\n format(desc['submitter'], system, benchmark))\n if dropped_scores == 1:\n print('NOTICE: Dropping non-converged run for {} {}/{} using olympic scoring.'\n .format(desc['submitter'], system, benchmark))\n\n benchmark_scores[benchmark] = _compute_olympic_average(scores, dropped_scores)\n\n # Construct scores portion of the row.\n if ruleset == '0.6.0':\n allowed_benchmarks = _ALLOWED_BENCHMARKS_V06\n elif ruleset == '0.7.0':\n allowed_benchmarks = _ALLOWED_BENCHMARKS_V07\n for benchmark in allowed_benchmarks:\n if benchmark in benchmark_scores:\n row += '{:.2f},'.format(benchmark_scores[benchmark])\n else:\n row += ','\n\n # Construct postfix portion of the row.\n row += '{},'.format(_details_url(desc, ruleset))\n row += '{},'.format(_code_url(desc, ruleset))\n\n rows[_row_key(desc)] = row\n\n # Print rows in order of the sorted keys.\n for key in sorted(rows):\n print(rows[key])","def do_report(input):\n for (session_id, group) in itertools.groupby(input, get_session_id):\n group = list(group)\n elapsed = [finfo.elapsed for finfo in group]\n n = float(len(elapsed))\n mean = sum(elapsed) / n\n s = math.sqrt(\n (1 / (n - 1)) * sum((e - mean) ** 2 for e in elapsed)\n )\n yield SummaryData(\n session_id,\n group[0].message,\n min(elapsed),\n max(elapsed),\n mean,\n s\n )","def compute_metrics(self, results: list) -> dict:\n dump(results, self.out_file_path)\n print_log(\n f'Results has been saved to {self.out_file_path}.',\n logger='current')\n return {}","def calc_overall_evaluation(count_by_type_dict: dict):\n assert len(count_by_type_dict) > 0, \"count by domain class should not be empty!\"\n for domain_name, domain_cnt in count_by_type_dict.items():\n print('domain_cnt', domain_cnt)\n for mode, res in OverallEval[domain_name].items():\n OverallEval[domain_name][mode]['precision'] = res['precision'] / domain_cnt\n OverallEval[domain_name][mode]['recall'] = res['recall'] / domain_cnt\n OverallEval[domain_name][mode]['f1_score'] = res['f1_score'] / domain_cnt\n log = \"Domain:{}, mode:{}, P:{:.3f}, R:{:.3f}, f1:{:.3f}\".format(\n domain_name, mode, OverallEval[domain_name][mode]['precision'],\n OverallEval[domain_name][mode]['recall'],\n OverallEval[domain_name][mode]['f1_score'])\n print(log)\n #logger.info(log)\n return OverallEval","def compute_metrics(self, results: list) -> Dict[str, float]:\n logger: MMLogger = MMLogger.get_current_instance()\n\n # pred_coords: [N, K, D]\n pred_coords = np.concatenate(\n [result['pred_coords'] for result in results])\n if pred_coords.ndim == 4 and pred_coords.shape[1] == 1:\n pred_coords = np.squeeze(pred_coords, axis=1)\n # gt_coords: [N, K, D]\n gt_coords = np.stack([result['gt_coords'] for result in results])\n # mask: [N, K]\n mask = np.concatenate([result['mask'] for result in results])\n # action_category_indices: Dict[List[int]]\n action_category_indices = defaultdict(list)\n for idx, result in enumerate(results):\n action_category = result['action'].split('_')[0]\n action_category_indices[action_category].append(idx)\n\n error_name = self.mode.upper()\n\n logger.info(f'Evaluating {self.mode.upper()}...')\n metrics = dict()\n\n metrics[error_name] = keypoint_mpjpe(pred_coords, gt_coords, mask,\n self.ALIGNMENT[self.mode])\n\n for action_category, indices in action_category_indices.items():\n metrics[f'{error_name}_{action_category}'] = keypoint_mpjpe(\n pred_coords[indices], gt_coords[indices], mask[indices])\n\n return metrics","def get_results(self):\n d = {}\n# r = {}\n for analyser in self.xml_tree.getroot():\n for child in analyser:\n if child.tag == 'all-records':\n for record in child:\n attributes = record.attrib\n sample = attributes['sampleId']\n assay_id = attributes['assayId']\n genotype = attributes['genotypeId']\n quality = attributes['description'].split('.')[0]\n if re.match(r'rs\\d+', assay_id):\n if sample in d:\n if assay_id in d[sample]:\n for allele in list(genotype):\n if allele not in d[sample][assay_id]['genotype']:\n d[sample][assay_id]['genotype'] += allele\n if quality not in d[sample][assay_id]['quality']:\n d[sample][assay_id]['quality'].append(quality)\n else:\n d[sample][assay_id] = {'genotype': genotype, 'quality': [quality]}\n else:\n d[sample] = {assay_id: {'genotype': genotype, 'quality': [quality]}}\n# if sample in r:\n# if assay_id in r[sample]:\n# for allele in list(genotype):\n# if allele not in r[sample][assay_id]:\n# r[sample][assay_id] += allele\n# else:\n# r[sample][assay_id] = genotype\n# else:\n# r[sample] = {assay_id: genotype}\n# for k, v in r.items():\n# for k1, v1, in v.items():\n# if len(v1) == 1:\n# v[k1] += v1\n# pprint.pprint(r)\n# df = pd.DataFrame.from_dict(r).transpose()\n# print(df)\n# df.to_excel('snpcheck.xlsx')\n return d","def mean(self) -> \"Results\":\n results = Results()\n for mode, result in self.items():\n index = result.index\n kwargs = {}\n for key, value in list(result.items())[1:]:\n if value.ndim == 1:\n series = pd.Series(value, index=index)\n value = series.groupby(level=0).mean()\n else:\n df = pd.DataFrame(value)\n df[\"index\"] = index\n value = df.groupby(\"index\").mean()\n value.sort_index(inplace=True)\n kwargs[key] = value.to_numpy()\n kwargs[\"index\"] = value.index.to_numpy()\n dict = ivory.core.collections.Dict()\n results[mode] = dict(**kwargs)\n return results","def aggregate(self):\n data_to_track = {}\n for possession in self.possessions_to_track_aggregate:\n data_to_track[possession] = self._haves[possession]\n\n for variable in self.variables_to_track_aggregate:\n try:\n data_to_track[variable] = self.__dict__[variable]\n except KeyError:\n pass\n self.database_connection.put([\"aggregate\",\n data_to_track,\n self.group,\n self.round])","def _compute_global_stats():\n global_stats = []\n \n wmt16_group = Group.objects.filter(name='WMT16')\n wmt16_users = _get_active_users_for_group(wmt16_group)\n \n # Check how many HITs have been completed. We now consider a HIT to be\n # completed once it has been annotated by one or more annotators.\n #\n # Before we required `hit.users.count() >= 3` for greater overlap.\n hits_completed = HIT.objects.filter(mturk_only=False, completed=True).count()\n \n # Check any remaining active HITs which are not yet marked complete.\n for hit in HIT.objects.filter(active=True, mturk_only=False, completed=False):\n if hit.users.count() >= 1:\n hits_completed = hits_completed + 1\n hit.completed = True\n hit.save()\n \n # Compute remaining HITs for all language pairs.\n hits_remaining = HIT.compute_remaining_hits()\n \n # Compute number of results contributed so far.\n ranking_results = RankingResult.objects.filter(\n item__hit__completed=True, item__hit__mturk_only=False)\n \n from math import factorial\n system_comparisons = 0\n for result in ranking_results:\n result.reload_dynamic_fields()\n # TODO: this implicitly counts A=B comparisons for multi systems.\n # Basically, inflating the number of pairwise comparisons... Fix!\n combinations = factorial(result.systems)/(factorial(result.systems-2) * 2) if result.systems > 2 else 0\n system_comparisons = system_comparisons + combinations\n \n # Aggregate information about participating groups.\n groups = set()\n for user in wmt16_users:\n for group in _identify_groups_for_user(user):\n groups.add(group)\n \n # Compute average/total duration over all results.\n durations = RankingResult.objects.all().values_list('duration', flat=True)\n total_time = sum([datetime_to_seconds(x) for x in durations])\n avg_time = total_time / float(hits_completed or 1)\n avg_user_time = total_time / float(3 * hits_completed or 1)\n \n global_stats.append(('Users', len(wmt16_users)))\n global_stats.append(('Groups', len(groups)))\n global_stats.append(('HITs completed', '{0:,}'.format(hits_completed)))\n global_stats.append(('HITs remaining', '{0:,}'.format(hits_remaining)))\n global_stats.append(('Ranking results', '{0:,}'.format(ranking_results.count())))\n global_stats.append(('System comparisons', '{0:,}'.format(system_comparisons)))\n global_stats.append(('Average duration (per HIT)', seconds_to_timedelta(avg_time)))\n global_stats.append(('Average duration (per task)', seconds_to_timedelta(avg_user_time)))\n global_stats.append(('Total duration', seconds_to_timedelta(total_time)))\n \n # Create new status data snapshot\n TimedKeyValueData.update_status_if_changed('users', str(len(wmt16_users)))\n TimedKeyValueData.update_status_if_changed('groups', str(len(groups)))\n TimedKeyValueData.update_status_if_changed('hits_completed', str(hits_completed))\n TimedKeyValueData.update_status_if_changed('hits_remaining', str(hits_remaining))\n TimedKeyValueData.update_status_if_changed('ranking_results', str(ranking_results.count()))\n TimedKeyValueData.update_status_if_changed('system_comparisons', str(system_comparisons))\n TimedKeyValueData.update_status_if_changed('duration_per_hit', str(seconds_to_timedelta(avg_time)))\n TimedKeyValueData.update_status_if_changed('duration_per_task', str(seconds_to_timedelta(avg_user_time)))\n TimedKeyValueData.update_status_if_changed('duration_total', str(seconds_to_timedelta(total_time)))\n \n return global_stats","def execute(self):\r\n factors = self.factors\r\n variables = list(self.variables)\r\n variables.remove(self.query)\r\n\r\n for fac in factors:\r\n self.set_observations(fac)\r\n\r\n for var in variables:\r\n if var not in self.obs:\r\n factors = self.eliminate_variable(var, factors)\r\n\r\n result = factor_module.multiply_batch(self.query, factors)\r\n denominator = sum(result.get_cpt())\r\n print(denominator)\r\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}","def summarize_hits(df_hsps, option_cov=\"mean\", option_pid=\"mean\"):\n\n # Sort HSPs by query start position\n df_hsps = np.sort(df_hsps, order=\"qstart\")\n\n # N-term delta between query and subject\n delta_lg = np.abs(df_hsps[\"qstart\"] - df_hsps[\"sstart\"])\n\n # C-term delta between query and subject and add to length difference between aligned sequences\n delta_lg += np.abs(\n (df_hsps[\"qlen\"][0] - df_hsps[\"qend\"][-1])\n - (df_hsps[\"slen\"][0] - df_hsps[\"send\"])\n )\n\n # Internal gaps\n query_starts = df_hsps[\"qstart\"][1:]\n query_ends = df_hsps[\"qend\"][:-1]\n subject_starts = df_hsps[\"sstart\"][1:]\n subject_ends = df_hsps[\"send\"][:-1]\n\n delta_lg += np.sum(\n np.abs((query_starts - query_ends) - (subject_starts - subject_ends))\n )\n\n # Calculate total length, score, Identities and Positives :\n length_total = np.sum(df_hsps[\"lgHSP\"])\n pos_total = np.sum(df_hsps[\"pos\"])\n # id_total = np.sum(df_hsps.id.values)\n\n # Cumulative length of HSPs / shortest seq. length = % coverage\n frac_HSPshlen = calculate_coverage(\n length_total=length_total,\n length_query=df_hsps[\"qlen\"][0],\n length_subject=df_hsps[\"slen\"][0],\n option_cov=option_cov,\n )\n\n # Number of positives / shortest seq. length = percentage of identity\n pospercentsh = calculate_percid(\n pos_total=pos_total,\n length_query=df_hsps[\"qlen\"][0],\n length_subject=df_hsps[\"slen\"][0],\n length_total=length_total,\n option_pid=option_pid,\n )\n\n evalue = max(df_hsps[\"evalue\"])\n\n return (\n delta_lg,\n frac_HSPshlen,\n pospercentsh,\n evalue,\n df_hsps[\"stitle\"][0].decode(\"utf-8\"),\n )","def dataExtract(queryResults):\n days = ['MondayCollect',\n 'TuesdayCollect',\n 'WednesdayCollect',\n 'ThursdayCollect',\n 'FridayCollect',\n 'SaturdayCollect',\n 'SundayCollect']\n\n #counting the instances of bin collections\n parkCount = 0\n roadingCount = 0\n otherCount = 0\n\n #output totals of bin collections\n parkOutput = []\n roadingOutput = []\n otherOutput = []\n \n #iterate over each day\n for day in days:\n \n #iterate over the number of bins\n for i in range(len(queryResults)):\n \n #check if the bin was collected on the day...\n if str(queryResults[i]['attributes'][day]).strip().lower() == 'yes':\n \n #unknown formatting issue with the data, these lines fix it\n strResult = str(queryResults[i]['attributes']['Owner'])\n strResultForm = strResult.lower().strip()\n \n #update the counts if True\n if strResultForm == 'roading':\n roadingCount += 1\n elif strResultForm == 'parks':\n parkCount += 1\n elif strResultForm == 'private':\n otherCount += 1\n else:\n otherCount +=1\n\n #print \"Day: {} \\nparkCount: {} \\nroadingCount: {} \\notherCount: {} \\n\\n\".format(day,parkCount,roadingCount,otherCount)\n \n parkOutput.append(parkCount)\n roadingOutput.append(roadingCount)\n otherOutput.append(otherCount)\n \n parkCount = 0\n roadingCount =0\n otherCount =0\n \n return parkOutput,roadingOutput,otherOutput","def transformResults(threadCounts, values, function):\n res = {}\n for bm in list(values.keys()):\n res[bm] = []\n for (nThreads, v) in zip(threadCounts, values[bm]):\n res[bm].append(None if v == None else function(v, nThreads))\n return res","def rankResults(self, results:set, queryVec: dict):\n rankedResults = {}\n for result in results:\n cosineSim = 0.0\n for word in queryVec.keys():\n if result in self.invertedIndex[word]:\n cosineSim += queryVec[word]*self.invertedIndex[word][result]\n cosineSim += self.boostScore(result, queryVec.keys())\n rankedResults[result] = cosineSim\n\n return rankedResults","def mean_accuracy_per_setting(results):\n dict_ans = defaultdict(lambda: 0)\n dict_count = defaultdict(lambda: 0)\n for setting in results:\n if setting['punct'] == True:\n dict_ans['punct=True'] = dict_ans['punct=True'] + setting['accuracy']\n dict_count['punct=True'] = dict_count['punct=True'] + 1\n else:\n dict_ans['punct=False'] = dict_ans['punct=False'] + setting['accuracy']\n dict_count['punct=False'] = dict_count['punct=False'] + 1\n dict_ans['min_freq=' + str(setting['min_freq'])] = dict_ans['min_freq=' + str(setting['min_freq'])] + setting['accuracy']\n dict_count['min_freq=' + str(setting['min_freq'])] =dict_count['min_freq=' + str(setting['min_freq'])] + 1\n finalFeatureName = 'feature='\n for featureName in setting['features']:\n finalFeatureName = finalFeatureName + str(featureName).split()[1] + ' '\n dict_ans[finalFeatureName] = dict_ans[finalFeatureName] + setting['accuracy']\n dict_count[finalFeatureName] = dict_count[finalFeatureName] + 1\n listOfAaccurracy = [(v, k) for k, v in dict_ans.items()]\n meanAccuracyList = []\n for item in listOfAaccurracy:\n meanAccuracy = item[0] / dict_count[item[1]]\n meanAccuracyList.append((meanAccuracy, item[1]))\n return sorted(meanAccuracyList, key =lambda tup: -tup[0])","def count_results(self):\n for record in self._traced_records:\n if self._statistical_results.get(record.name) == None:\n self._statistical_results[record.name] = StatisticalResult(\n record.name)\n self._statistical_results[record.name].insert_record(\n record.kernel_time)\n self._total_time_ms += record.kernel_time\n self._statistical_results = {\n k: v\n for k, v in sorted(self._statistical_results.items(),\n key=lambda item: item[1],\n reverse=True)\n }","def compute_metrics(self, results: Sequence[Dict]) -> Dict:\n\n preds = []\n gts = []\n for result in results:\n preds.append(result['pred_labels'])\n gts.append(result['gt_labels'])\n preds = torch.cat(preds)\n gts = torch.cat(gts)\n\n assert preds.max() < self.num_classes\n assert gts.max() < self.num_classes\n\n cared_labels = preds.new_tensor(self.cared_labels, dtype=torch.long)\n\n hits = (preds == gts)[None, :]\n preds_per_label = cared_labels[:, None] == preds[None, :]\n gts_per_label = cared_labels[:, None] == gts[None, :]\n\n tp = (hits * preds_per_label).float()\n fp = (~hits * preds_per_label).float()\n fn = (~hits * gts_per_label).float()\n\n result = {}\n if 'macro' in self.mode:\n result['macro_f1'] = self._compute_f1(\n tp.sum(-1), fp.sum(-1), fn.sum(-1))\n if 'micro' in self.mode:\n result['micro_f1'] = self._compute_f1(tp.sum(), fp.sum(), fn.sum())\n\n return result","def prcp():\n \"\"\"Return the JSON representation of your dictionary.\"\"\"\n session = Session(engine)\n results_prcp = session.query(Measurement.date, Measurement.prcp).all()\n session.close()\n\n prcp_scores = []\n for p in prcp_query:\n my_dict = {}\n my_dict[prcp_query[0]] = prcp_query[1]\n prcp_scores.append(my_dict)\n\n return jsonify(prcp_scores)","def display_results(self, metrics):\n\n for k, v in self.cv_results_.items():\n# sorted_results = sort_results(v)\n print(f'Results for {k} metric:')\n print()\n print(v.sort_values(by=['Metric mean'], ascending=False))\n print()","def calc_stats(results):\r\n all_res = []\r\n count = 0\r\n for values in results.status_code_counter.values():\r\n all_res += values\r\n count += len(values)\r\n\r\n cum_time = sum(all_res)\r\n\r\n if cum_time == 0 or len(all_res) == 0:\r\n rps = avg = min_ = max_ = amp = 0\r\n else:\r\n if results.total_time == 0:\r\n rps = 0\r\n else:\r\n rps = len(all_res) / float(results.total_time)\r\n avg = sum(all_res) / len(all_res)\r\n max_ = max(all_res)\r\n min_ = min(all_res)\r\n amp = max(all_res) - min(all_res)\r\n stdev = math.sqrt(sum((x-avg)**2 for x in all_res) / count)\r\n\r\n return (\r\n RunStats(count, results.total_time, rps, avg, min_, max_, amp, stdev)\r\n )","def calculate_overall_results(pContestGroup, pContestsRequired, pYear):\n # Find out how many contests each band has done\n lCursor = connection.cursor()\n lCursor.execute(\"SELECT r.band_id, count(*) FROM contests_contestresult r, contests_contestevent e, contests_contest c WHERE r.contest_event_id = e.id AND e.contest_id = c.id AND c.group_id = %(groupid)s AND r.results_position < 9996 AND extract(year from e.date_of_event) = %(year)s AND c.exclude_from_group_results = false GROUP BY r.band_id\", {'groupid': pContestGroup.id, 'year' : pYear})\n lRows = lCursor.fetchall()\n lResults = {}\n for row in lRows:\n lBandId = row[0]\n lResultCount = int(row[1])\n if lResultCount >= pContestsRequired:\n lResults[str(lBandId)] = lResultCount\n lCursor.close()\n \n lBandIds = \",\".join(lResults.keys())\n \n if len(lBandIds) == 0:\n return []\n\n lCursor = connection.cursor()\n lCursor.execute(\"SELECT r.results_position, b.slug, r.band_name FROM bands_band b, contests_contestresult r, contests_contestevent e, contests_contest c WHERE b.id = r.band_id AND r.contest_event_id = e.id AND e.contest_id = c.id AND c.group_id = %s AND r.results_position < 9999 AND r.band_id IN (%s) AND extract(year from e.date_of_event) = %s AND c.exclude_from_group_results = false\" % (pContestGroup.id, lBandIds, pYear))\n lRows = lCursor.fetchall()\n lBands = {}\n lBandResults = {}\n for row in lRows:\n lPosition = row[0]\n if int(lPosition) == 0 or int(lPosition) > 9900:\n continue\n lBandSlug = row[1]\n lBandName = row[2]\n \n lBands[lBandSlug] = lBandName\n try:\n lExistingResults = lBandResults[lBandSlug]\n lExistingResults.append(lPosition)\n except KeyError:\n lExistingResults = []\n lExistingResults.append(lPosition)\n lBandResults[lBandSlug] = lExistingResults\n \n # Get total points for each band\n lBandTotals = {}\n lBandTotalsWithTieBreak = {}\n lBandSeventhResult = {}\n lFirstSixBandResults = {}\n for band_slug in lBandResults.keys():\n lFirstSixBandResults[band_slug] = sorted(lBandResults[band_slug])[:pContestsRequired]\n try:\n lBandSeventhResult[band_slug] = sorted(lBandResults[band_slug])[pContestsRequired]\n except IndexError:\n # band didn't compete in a seventh contest, so the results is worse than if they did\n lBandSeventhResult[band_slug] = 9999 \n lTotalPoints = sum(lFirstSixBandResults[band_slug])\n lTotalPointsPlusTieBreak = lTotalPoints + (1 - (1.0 / lBandSeventhResult[band_slug]))\n lBandTotals[band_slug] = lTotalPoints\n lBandTotalsWithTieBreak[band_slug] = lTotalPointsPlusTieBreak \n \n lDecoratedList = [(points, slug) for slug, points in lBandTotalsWithTieBreak.items()]\n lDecoratedList.sort()\n lSortedResults = [{'slug':slug, 'points':points} for points, slug in lDecoratedList]\n lPosition = 1\n for row in lSortedResults:\n row['band'] = lBands[row['slug']] \n row['position'] = lPosition\n row['display_points'] = lBandTotals[row['slug']]\n row['tiebreak'] = lBandSeventhResult[row['slug']]\n lPosition += 1\n\n return lSortedResults","def _summarize_results(df, metrics):\n def return_cm(x):\n if isinstance(x, int):\n return (0, 0, 0)\n\n elif len(x) > 3:\n return x[1:]\n\n return x\n\n def get_status(x):\n return {\n \"OK\": 0,\n \"ERROR\": 1\n }[x]\n\n df['status'] = df['status'].apply(get_status)\n df['confusion_matrix'] = df['confusion_matrix'].apply(ast.literal_eval)\n df['confusion_matrix'] = df['confusion_matrix'].apply(return_cm)\n df[['fp', 'fn', 'tp']] = pd.DataFrame(df['confusion_matrix'].tolist(), index=df.index)\n\n # calculate f1 score\n df_ = df.groupby(['dataset', 'pipeline'])[['fp', 'fn', 'tp']].sum().reset_index()\n\n precision = df_['tp'] / (df_['tp'] + df_['fp'])\n recall = df_['tp'] / (df_['tp'] + df_['fn'])\n df_['f1'] = 2 * (precision * recall) / (precision + recall)\n\n result = dict()\n\n # number of wins over ARIMA\n arima_pipeline = 'arima'\n intermediate = df_.set_index(['pipeline', 'dataset'])['f1'].unstack().T\n arima = intermediate.pop(arima_pipeline)\n\n result['# Wins'] = (intermediate.T > arima).sum(axis=1)\n result['# Wins'][arima_pipeline] = None\n\n # number of anomalies detected\n result['# Anomalies'] = df_.groupby('pipeline')[['tp', 'fp']].sum().sum(axis=1).to_dict()\n\n # average f1 score\n result['Average F1 Score'] = df_.groupby('pipeline')['f1'].mean().to_dict()\n\n # failure rate\n result['Failure Rate'] = df.groupby(\n ['dataset', 'pipeline'])['status'].mean().unstack('pipeline').T.mean(axis=1)\n\n result = pd.DataFrame(result)\n result.index.name = 'pipeline'\n result.reset_index(inplace=True)\n\n rank = 'Average F1 Score'\n result = _sort_leaderboard(result, rank, metrics)\n result = result.drop('rank', axis=1).set_index('pipeline')\n\n return result","def get_aggregated_values(self):\n if not self._initialized:\n raise Exception(\"To readout you must first initialize, then\"\n \"process batches!\")\n else:\n ret_vals = [q.readout() for q in self.quantities]\n return dict(zip(self.quantity_names, ret_vals))","def extract_results_test(self):\n assert len(self.results.keys()) != 0\n TESTS = [\n {\n \"input\": {\"molecules\": [\"DDSPDLPK\"], \"score_threshold\": 0.95},\n \"output\": {\n \"formula\": \"C(37)H(59)N(9)O(16)\",\n \"file_name\": \"BSA1.mzML\",\n \"scaling_factor\": 100,\n \"spec_id\": 1337,\n },\n }\n ]\n for test_dict in TESTS:\n for key, n, entry in self.results.extract_results(**test_dict[\"input\"]):\n print(key, entry)\n assert key.formula == test_dict[\"output\"][\"formula\"]\n assert key.file_name == test_dict[\"output\"][\"file_name\"]\n assert entry.scaling_factor == test_dict[\"output\"][\"scaling_factor\"]\n assert entry.spec_id == test_dict[\"output\"][\"spec_id\"]\n # print(self.results)\n # print(self.results.lookup)\n assert n == 0","def conlleval_overall_results(documents):\n counts = conlleval_evaluate(documents)\n overall, by_type = metrics(counts)\n return overall","def get_qps_as_dict(folder):\n df = process_oldisim_results(folder)\n return df.groupby(\"machine_type\").mean().QPS.to_dict()","def generate_metrics_data(metricsquery: List, resultsquery: Dict, deltaminutes: int = 5, Region_name: str = None) -> Dict:\r\n cloudwatch=client('cloudwatch', region_name=Region_name) \r\n paginator = cloudwatch.get_paginator('get_metric_data')\r\n metricsgroup=grouper(metricsquery)\r\n resultsquery['ApiCalls']=0 \r\n for mqs in metricsgroup:\r\n for response in paginator.paginate(MetricDataQueries=mqs, StartTime=datetime.now()-timedelta(minutes=deltaminutes),EndTime=datetime.now()):\r\n for results in response['MetricDataResults']:\r\n resultsquery[results['Id']].append({'results':results})\r\n resultsquery['ApiCalls']+=1\r\n return resultsquery","def calculate_score(label_dict, queries, results):\n\n total_score = 0.0\n\n log_header('Individual image scores')\n\n # Calculate score for all images\n for image_id in queries:\n if image_id in results.keys():\n # Run the score function\n image_score = score(\n label_dict=label_dict, target=image_id, selection=results[image_id]\n )\n else:\n logging.error('No result generated for %s' % image_id)\n\n image_score = 0.0\n\n total_score += image_score\n\n logging.info('%s: %8.6f' % (image_id, image_score))\n\n log_header('Average score over %d images: %10.8f' % (\n len(queries), total_score / len(queries)\n ))\n\n return total_score","def _rouge_score_compute(sentence_results: Dict[str, List[Tensor]]) ->Dict[str, Tensor]:\n results: Dict[str, Tensor] = {}\n if sentence_results == {}:\n return results\n for rouge_key, scores in sentence_results.items():\n results[rouge_key] = torch.tensor(scores).mean()\n return results","def aggregate_results(scores, stds):\n\n scores = pd.DataFrame(scores.values(),\n index=scores.keys(),\n columns=[\"SCORE MEAN\", ])\n stds = pd.DataFrame(stds.values(),\n index=stds.keys(),\n columns=[\"SCORE STD\", ])\n scores.index.name = param_names\n stds.index.name = param_names\n data = []\n for param_gropby_levels in ((0,), (1,), (2,), (3, 4), (5,)):\n aggregate_scores = scores.groupby(level=param_gropby_levels).mean()\n aggregate_stds = scores.groupby(level=param_gropby_levels).std()\n data.append((aggregate_scores, aggregate_stds))\n return data","def compileQcewStats(lid):\n\n\tregion = re.match('(^[a-zA-Z]+)', basename(lid)).group(1)\n\tlid_rows = selectQcewNearLid(lid, region)\n\n\tlists = defaultdict(list)\n\tcounts = defaultdict(float)\n\tprf_keys = ('NAME', 'NAICS')\n\tagg_keys = ('NAME', 'AVGEMP', 'TOTPAY', 'MEEI')\n\t\n\tfor lr in lid_rows:\n\t\t# non-profit\n\t\tif re.match('82.*|813.*', lr['NAICS']):\n\t\t\tcounts['np_emp'] += lr['AVGEMP']\n\t\t\tcounts['np_pay'] += lr['TOTPAY']\n\n\t\t\tnp_row = OrderedDict((k, lr[k]) for k in prf_keys)\n\t\t\tlists['np'].append(np_row)\n\n\t\t\t# reporting is for multiple locations (aggregated)\n\t\t\tif re.match('.*2.*|.*4.*', lr['MEEI']):\n\t\t\t\tagg_row = OrderedDict((k, lr[k]) for k in agg_keys)\n\t\t\t\tlists['agg'].append(agg_row)\n\t\t# for-profit\n\t\telse:\n\t\t\tcounts['fp_emp'] += lr['AVGEMP']\n\t\t\tcounts['fp_pay'] += lr['TOTPAY']\n\t\t\tcounts['fp_bus'] += 1\n\n\t\t\tp_row = OrderedDict((k, lr[k]) for k in prf_keys)\n\t\t\tlists['fp'].append(p_row)\n\n\t\t\t# reporting is for multiple locations (aggregated)\n\t\t\tif re.match('.*2.*|.*4.*', lr['MEEI']):\n\t\t\t\tcounts['agg_fp_emp'] += lr['AVGEMP']\n\t\t\t\tcounts['agg_fp_pay'] += lr['TOTPAY']\n\t\t\t\tcounts['agg_fp_bus'] += 1\n\n\t\t\t\tagg_row = OrderedDict((k, lr[k]) for k in agg_keys)\n\t\t\t\tlists['agg'].append(agg_row)\n\t\t\t# reporting address used is not physical address\n\t\t\tif lr['ATYPE'] != 'P':\n\t\t\t\tcounts['nph_fp_emp'] += lr['AVGEMP']\n\t\t\t\tcounts['nph_fp_pay'] += lr['TOTPAY']\n\t\t\t\tcounts['nph_fp_bus'] += 1\n\n\t\tcounts['emp'] += lr['AVGEMP']\n\t\tcounts['pay'] += lr['TOTPAY']\n\n\t# write the lists to csv\n\tcsv_template = '{0}_{1}_employers_{2}.csv'\n\tfor grp, l in lists.iteritems():\n\t\tcsv_name = csv_template.format(region, grp, yr)\n\t\tcsv_path = join(csv_dir, csv_name)\n\n\t\twith open(csv_path, 'wb') as csv_file:\n\t\t\tfields = [k for k in l[0]]\n\t\t\twriter = csv.DictWriter(csv_file, fields)\n\t\t\twriter.writeheader()\n\n\t\t\t# sort list (in some cases by multiple fields)\n\t\t\trsort = {('NAICS', 'NAME'): ['fp', 'np'], ('NAME',): ['agg']}\n\t\t\tsort = {i:k for k,v in rsort.iteritems() for i in v}\n\t\t\tfor row in sorted(l, key=lambda d: [d[k] for k in sort[grp]]):\n\t\t\t\twriter.writerow(row)\n\n\t# prep 'opverview' and 'for-profit' stats for writing\n\tstats = {}\n\tov_keys = ('fp_emp', 'np_emp', 'emp', 'fp_pay', 'np_pay', 'pay')\n\toverview = {k: int(counts[k]) for k in ov_keys}\n\tstats['overview'] = {'stats': overview, 'keys': ov_keys}\n\n\tp_emp = counts['fp_emp']\n\tp_pay = counts['fp_pay']\n\tp_bus = counts['fp_bus']\n\tfor_profit = OrderedDict([\n\t\t('for-prof emps', p_emp),\n\t\t('agg for-prof emp pct', \n\t\t\tround(counts['agg_fp_emp'] / p_emp, 4)),\n\t\t('non-phys addr for-prof emp pct', \n\t\t\tround(counts['nph_fp_emp'] / p_emp, 4)),\n\t\t\n\t\t('prof pay', p_pay),\n\t\t('agg for-prof pay pct', \n\t\t\tround(counts['agg_fp_pay'] / p_pay, 4)),\n\t\t('non-phys addr for-prof pay pct', \n\t\t\tround(counts['nph_fp_pay'] / p_pay, 4)),\n\t\t\n\t\t('agg for-prof bus pct', \n\t\t\tround(counts['agg_fp_bus'] / p_bus, 4)), \n\t\t('non-phys addr for-prof bus pct', \n\t\t\tround(counts['nph_fp_bus'] / p_bus, 4))])\n\tfp_keys = [k for k in for_profit]\n\tstats['for_profit'] = {'stats': for_profit, 'keys': fp_keys}\n\n\t# write stats to csv\n\tfor grp, d in stats.iteritems():\n\t\tcsv_name = '{0}_{1}_stats_{2}.csv'.format(region, grp, yr)\n\t\tcsv_path = join(csv_dir, csv_name)\n\t\twith open(csv_path, 'wb') as csv_file:\n\t\t\twriter = csv.DictWriter(csv_file, d['keys'])\n\t\t\twriter.writeheader()\n\t\t\twriter.writerow(d['stats'])","def output_result(self):\n output = {}\n output['draw'] = str(int(self.params['draw']))\n output['recordsTotal'] = str(self.cardinality)\n output['recordsFiltered'] = str(self.cardinality_filtered)\n if self.error:\n output['error'] = self.error\n return output\n\n output['data'] = self.results\n for k, v in self.yadcf_params:\n output[k] = v\n return output","def summary(data, key=itemgetter(0), value=itemgetter(1)):\n\n for k, group in groupby(data, key):\n yield (k, sum(value(row) for row in group))","def profile_group(func, args, kwargs, func_result):\n (collection, key, condition, initial, reduce) = args[:5]\n report_kvs = _profile_query(collection)\n\n if key:\n report_kvs['Group_Key'] = _to_json(key)\n\n if condition:\n report_kvs['Group_Condition'] = _to_json(condition)\n\n if initial:\n report_kvs['Group_Initial'] = _to_json(initial)\n\n if reduce:\n report_kvs['Group_Reduce'] = reduce\n\n return report_kvs","def print_metrics(result):\n logging.log(LOG_LEVEL_OUTPUT_INFO,\n '------------------------------------------------')\n logging.log(LOG_LEVEL_OUTPUT_INFO, ' KEY METRICS: ')\n logging.log(LOG_LEVEL_OUTPUT_INFO,\n '------------------------------------------------')\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* pages_count: %d',\n get_counter_metric(result, 'pages_count'))\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* revisions_count: %d',\n get_counter_metric(result, 'revisions_count'))\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* very_long_page_histories_count: %d',\n get_counter_metric(result, 'very_long_page_histories_count'))\n revisions_per_page_distr = get_distributions_metric(\n result, 'revisions_per_page_distr')\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* revisions_per_page_distr.mean: %d',\n revisions_per_page_distr.mean)\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* revisions_per_page_distr.sum: %d',\n revisions_per_page_distr.sum)\n cumulative_page_rev_size_distr = get_distributions_metric(\n result, 'cumulative_page_rev_size_distr')\n logging.log(LOG_LEVEL_OUTPUT_INFO,\n '* cumulative_page_rev_size_distr.mean: %d',\n cumulative_page_rev_size_distr.mean)\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* cumulative_page_rev_size_distr.sum: %d',\n cumulative_page_rev_size_distr.sum)","def class_stats_sums(self, job_classes):\n\n # --------------------------- initialisation ---------------------------\n\n # init class stats sum structure\n per_class_stats_sums = {}\n\n # add a key that contains metric rates from all the classes\n _all_class_stats_dict = {stat_metric: {field: 0.0 for field in kresults_stats_info[stat_metric][\"to_sum\"]}\n for stat_metric in kresults_stats_info.keys()}\n # ----------------------------------------------------------------------\n\n # calculate all the stats for each job class (per_class_stats is a list of lists - one list per job..)\n per_class_stats = self.class_stats(job_classes)\n\n # loop over statistics per class\n for class_name, stats_list in per_class_stats.items():\n\n # initialize all the requested sums..\n _class_stats_dict = {stat_metric: {field: 0.0 for field in kresults_stats_info[stat_metric][\"to_sum\"]}\n for stat_metric in kresults_stats_info.keys()}\n\n # loop over stats (per job) and make the sums\n for job_stats in stats_list:\n for stat_entry in job_stats:\n for stat_metric in stat_entry.keys():\n if stat_metric not in kresults_stats_info:\n print(f\"Warning: skipping unknown metric {stat_metric!r}\")\n continue\n\n for field in kresults_stats_info[stat_metric][\"to_sum\"]:\n\n if field in kresults_stats_info[stat_metric].get(\"per_process\", []):\n n_procs = len(job_stats)\n val = float(stat_entry[stat_metric][field])/float(n_procs)\n else:\n val = float(stat_entry[stat_metric][field])\n\n # add the summable metrics to class stats\n _class_stats_dict[stat_metric][field] += val\n\n # add the summable metrics to all-class stats\n _all_class_stats_dict[stat_metric][field] += val\n\n # Filter the fields for which aggregated time is still 0 (no operations have been summed up)\n for stat_metric in list(_class_stats_dict.keys()):\n if _class_stats_dict[stat_metric][\"elapsed\"] == 0.0:\n _class_stats_dict.pop(stat_metric)\n\n # also calculate the rates (according to the fields defined in kresults_stats_info)\n for stat_metric in _class_stats_dict.keys():\n\n # numerator and denominator for rate calculation\n num, den = kresults_stats_info[stat_metric][\"def_rate\"]\n\n # conversion factor\n fc = kresults_stats_info[stat_metric][\"conv\"]\n\n # get the rate\n rate = fc * _class_stats_dict[stat_metric][num] / _class_stats_dict[stat_metric][den]\n\n _class_stats_dict[stat_metric][\"rate\"] = rate\n\n # collect and store per-class stats\n per_class_stats_sums[class_name] = _class_stats_dict\n\n # ------- clean-up the all-class data -------\n # Filter the fields for which aggregated time is still 0 (no operations have been summed up)\n for stat_metric in list(_all_class_stats_dict.keys()):\n if _all_class_stats_dict[stat_metric][\"elapsed\"] == 0.0:\n _all_class_stats_dict.pop(stat_metric)\n\n # also calculate the rates (according to the fields defined in kresults_stats_info)\n for stat_metric in _all_class_stats_dict.keys():\n\n # numerator and denominator for rate calculation\n num, den = kresults_stats_info[stat_metric][\"def_rate\"]\n\n # conversion factor\n fc = kresults_stats_info[stat_metric][\"conv\"]\n\n # get the rate\n rate = fc * _all_class_stats_dict[stat_metric][num] / _all_class_stats_dict[stat_metric][den]\n\n _all_class_stats_dict[stat_metric][\"rate\"] = rate\n\n # collect and store the all-class stats\n per_class_stats_sums[\"all_classes\"] = _all_class_stats_dict\n\n return per_class_stats_sums","def home():\n\n connection = pypyodbc.connect(connectionString)\n \n cursor = connection.cursor()\n\n cachedResults['avgAgePerState'] = runQuery(cursor, avgAgePerStateCommand)\n cachedResults['avgAgePerTown'] = runQuery(cursor, avgAgePerTownCommand)\n cachedResults['avgAgePerProvince'] = runQuery(cursor, avgAgePerProvinceCommand)\n cachedResults['avgAgePerFacilityName'] = runQuery(cursor, avgAgePerFacilityNameCommand)\n cachedResults['avgAgePerFacilityType'] = runQuery(cursor, avgAgePerFacilityTypeCommand)\n\n cachedResults['eidTestResultTotal'] = runQuery(cursor, eidTestResultTotalCommand)\n cachedResults['eidTestResultAIDSTFacilityType'] = runQuery(cursor, eidTestResultAIDSTFacilityTypeCommand)\n cachedResults['eidTestResultAMIFacilityType'] = runQuery(cursor, eidTestResultAMIFacilityTypeCommand)\n cachedResults['eidTestResultDisHFacilityType'] = runQuery(cursor, eidTestResultDisHFacilityTypeCommand)\n cachedResults['eidTestResultGenHFacilityType'] = runQuery(cursor, eidTestResultGenHFacilityTypeCommand)\n cachedResults['eidTestResultMSFHFacilityType'] = runQuery(cursor, eidTestResultMSFHFacilityTypeCommand)\n cachedResults['eidTestResultNHLFacilityType'] = runQuery(cursor, eidTestResultNHLFacilityTypeCommand)\n cachedResults['eidTestResultSpHFacilityType'] = runQuery(cursor, eidTestResultSpHFacilityTypeCommand)\n cachedResults['eidTestResultSRHFacilityType'] = runQuery(cursor, eidTestResultSRHFacilityTypeCommand)\n cachedResults['eidTestResultTHFacilityType'] = runQuery(cursor, eidTestResultTHFacilityTypeCommand)\n\n cachedResults['avgTatTotal'] = runQuery(cursor, avgTatTotalCommand)\n cachedResults['avgTatAIDSTFacilityType'] = runQuery(cursor, avgTatAIDSTFacilityTypeCommand)\n cachedResults['avgTatAMIFacilityType'] = runQuery(cursor, avgTatAMIFacilityTypeCommand)\n cachedResults['avgTatDisHFacilityType'] = runQuery(cursor, avgTatDisHFacilityTypeCommand)\n cachedResults['avgTatGenHFacilityType'] = runQuery(cursor, avgTatGenHFacilityTypeCommand)\n cachedResults['avgTatMSFHFacilityType'] = runQuery(cursor, avgTatMSFHFacilityTypeCommand)\n cachedResults['avgTatNHLFacilityType'] = runQuery(cursor, avgTatNHLFacilityTypeCommand)\n cachedResults['avgTatSpHFacilityType'] = runQuery(cursor, avgTatSpHFacilityTypeCommand)\n cachedResults['avgTatSRHFacilityType'] = runQuery(cursor, avgTatSRHFacilityTypeCommand)\n cachedResults['avgTatTHFacilityType'] = runQuery(cursor, avgTatTHFacilityTypeCommand)\n\n cachedResults['trackSample'] = runQuery(cursor, trackSampleCommand)\n\n cachedResults['avgAgeNHL'] = runQuery(cursor, avgAgeNHLCommand)\n cachedResults['avgAgePHL'] = runQuery(cursor, avgAgePHLCommand)\n cachedResults['avgAgeUNION'] = runQuery(cursor, avgAgeUNIONCommand)\n\n cachedResults['eidTestResultNHLLab'] = runQuery(cursor, eidTestResultNHLLabCommand)\n cachedResults['eidTestResultPHLLab'] = runQuery(cursor, eidTestResultPHLLabCommand)\n cachedResults['eidTestResultUNIONLab'] = runQuery(cursor, eidTestResultUNIONLabCommand)\n\n cachedResults['avgTatNHLLab'] = runQuery(cursor, avgTatNHLLabCommand)\n cachedResults['avgTatPHLLab'] = runQuery(cursor, avgTatPHLLabCommand)\n cachedResults['avgTatUNIONLab'] = runQuery(cursor, avgTatUNIONLabCommand)\n\n connection.close()\n\n return render_template('index.html')","def qasmCircuitResults(self):\n returnedDictionary={}\n self.circutDrawing = self.draw()\n self.blochSpheres=self.separatedBlochSpheres()\n returnedDictionary[\"wires\"]=self.num_qubits\n returnedDictionary[\"probabilities\"] = self.separatedProbabilities()\n #returnedDictionary[\"blochSpheres\"] = self.separatedBlochSpheres()\n returnedDictionary[\"diracNotation\"] = self.diracNotation()\n returnedDictionary['chart'] = self.graph()\n returnedDictionary[\"link\"] = \"\"\n #returnedDictionary[\"qasmRows\"] = np.transpose(cols).tolist()\n \n if self.API_TOKEN != \"\":\n returnedDictionary[\"link\"] = self.runOnIBMQ()\n \n return returnedDictionary","def set_results(self, results, unique_keys):\n self._results = results\n self._compute_logic()\n\n for _, query in enumerate(self._results):\n\n flat = query.flatten_results(unique_keys)\n filename = 'flattened_{0}.csv'.format('_'.join(sorted(query.in_sets)))\n flat.to_csv(\n os.path.join(\n Configuration().csv.output_directory,\n '{0}'.format(filename)\n ),\n sep='\\t'\n )","def calc_metrics(data, sampled_data_list, dataset_type):\n result={}\n for sampled_data in sampled_data_list:\n c2st_roc_auc_metric = c2st_roc_auc(data, sampled_data)\n if \"c2st_roc_auc\" in result:\n result[\"c2st_roc_auc\"].append(c2st_roc_auc_metric)\n else:\n result[\"c2st_roc_auc\"] = [c2st_roc_auc_metric]\n mmd_p_val, mmd_stat = rbf_mmd_test(data.values, sampled_data.values)\n if \"mmd_p_val\" in result:\n result[\"mmd_p_val\"].append(mmd_p_val)\n result[\"mmd_stat\"].append(mmd_stat)\n else:\n result[\"mmd_p_val\"] = [mmd_p_val]\n result[\"mmd_stat\"] = [mmd_stat]\n ks_p_val, ks_stat, ks_n, ks_p_val_list, ks_stat_list = ks_test(data, sampled_data)\n if dataset_type != \"norm_dataset\":\n ks_p_val = ks_permutation(ks_stat_list, data, sampled_data)\n if \"ks_p_val\" in result:\n result[\"ks_p_val\"].append(ks_p_val)\n result[\"ks_stat\"].append(ks_stat)\n else:\n result[\"ks_p_val\"] = [ks_p_val]\n result[\"ks_stat\"] = [ks_stat]\n acc_r, acc_g = c2st_accuracy(data, sampled_data)\n if \"c2st_acc_r\" in result:\n result[\"c2st_acc_r\"].append(acc_r)\n result[\"c2st_acc_g\"].append(acc_g)\n else:\n result[\"c2st_acc_r\"] = [acc_r]\n result[\"c2st_acc_g\"] = [acc_g]\n return result","def evaluate(self, click_model, search_sessions):\n\n # Only use queries that occur more than MINUMUM_OCCURENCES times and have a true relevance\n counter = collections.Counter([session.query for session in search_sessions])\n useful_sessions = [query_id for query_id in counter if counter[query_id] >= self.minimum_occurences and query_id in self.relevances]\n\n # Group sessions by query\n sessions_dict = self._group_sessions_if_useful(search_sessions, useful_sessions)\n total_ndcg = 0\n not_useful = 0\n\n # For every useful query get the predicted relevance and compute NDCG\n for query_id in useful_sessions:\n \n rel = self.relevances[query_id]\n ideal_ranking = sorted(rel.values(),reverse = True)[:5]\n \n # Only use query if there is a document with a positive ranking. (Otherwise IDCG will be 0 -> NDCG undetermined.)\n if not any(ideal_ranking):\n not_useful += 1\n continue\n \n current_sessions = sessions_dict[query_id]\n pred_rels = dict()\n for session in current_sessions:\n for rank, result in enumerate(session.web_results):\n if not result.id in pred_rels:\n pred_rels[result.id] = click_model.predict_relevance(session.query, result.id)\n ranking = sorted([doc for doc in pred_rels],key = lambda doc : pred_rels[doc], reverse = True)\n \n ranking_relevances = self.get_relevances(query_id, ranking[:5])\n \n dcg = self.dcg(ranking_relevances)\n idcg = self.dcg(ideal_ranking) \n ndcg = dcg / idcg\n total_ndcg += ndcg\n\n # If too few queries there might not be any useful queries that also have a ranking in the true_relevances.\n assert not len(useful_sessions)-not_useful is 0\n\n # Average NDCG over all queries\n return total_ndcg / (len(useful_sessions)-not_useful)","def collect_data(self):\n exp_conf: ec.ExperimentConfiguration\n # Disabled multiprocess run because of huge memory usage\n processes_number = 1 # self._campaign_configuration['General']['j']\n if processes_number == 1:\n self._logger.info(\"-->Evaluate experiments (sequentially)\")\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\n exp_conf.evaluate()\n if bool(self._campaign_configuration['General']['generate_plots']):\n exp_conf.generate_plots()\n self._logger.info(\"<--\")\n else:\n self._logger.info(\"-->Evaluate experiments (in parallel)\")\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\n if bool(self._campaign_configuration['General']['generate_plots']):\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\n self._logger.info(\"<--\")\n\n self.raw_results = {}\n for exp_conf in self._exp_confs:\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes","def aggregate_log_dict(agg_dict, new_dict) -> dict:\n for k in new_dict:\n # init new if not present\n if k not in agg_dict:\n agg_dict[k] = {\n 'n': 0,\n 'sum': 0.0,\n 'max': new_dict[k],\n 'min': new_dict[k],\n }\n # aggregate\n agg_dict[k]['n'] += 1\n agg_dict[k]['sum'] += new_dict[k]\n agg_dict[k]['max'] = max(new_dict[k], agg_dict[k]['max'])\n agg_dict[k]['min'] = min(new_dict[k], agg_dict[k]['min'])\n # TODO: add more stats (e.g. stdev, max, minin the future)\n\n return agg_dict","def get_benchmark_aggregated_cov_df(coverage_dict, benchmark):\n dict_to_transform = {'fuzzer': [], 'aggregated_edges_covered': []}\n for key_pair, covered_regions in coverage_dict.items():\n current_fuzzer, current_benchmark = key_pair.split()\n if current_benchmark == benchmark:\n dict_to_transform['fuzzer'].append(current_fuzzer)\n dict_to_transform['aggregated_edges_covered'].append(\n len(covered_regions))\n return pd.DataFrame(dict_to_transform)","def apply(self):\n counter = {}\n for act in self.activities:\n freq = []\n for trace in self.log:\n freq.append(len(self.project_trace(trace, [act])))\n if not len(freq) == 0:\n counter[act] = {'sum': sum(freq), 'min': min(freq),\n 'max': max(freq)}\n return counter","def convert(self, data, *args, **kwargs):\n\n # all of this is still quite ugly and verrrry specific...\n json_data = {}\n for hit in data[\"hits\"][\"hits\"]:\n # pprint(hit)\n\n # get the PQ\n pq = hit.get(\"_source\", {}).get(\"metadata\", {}).get(\"PanDAQueue\", None)\n if not pq:\n continue\n\n # get the list of all benchmark results\n latest_list = (\n hit.get(\"inner_hits\", {})\n .get(\"most_recent\", {})\n .get(\"hits\", {})\n .get(\"hits\", [])\n )\n if len(latest_list) == 0:\n continue\n\n # get the average of the latest benchmark results.\n # Only results not older than 7d, and a maximum of 50 results (whichever value is hit first).\n # If we have no values more recent than 7d, simply use the last available one (that PQ is probably not online anymore anyway)\n values = []\n for d in latest_list:\n date = datetime.datetime.strptime(\n d.get(\"_source\", {}).get(\"timestamp\", \"\"), \"%Y-%m-%dT%H:%M:%SZ\"\n )\n two_days_ago = datetime.datetime.now() - datetime.timedelta(days=2)\n seven_days_ago = datetime.datetime.now() - datetime.timedelta(days=7)\n\n if date > two_days_ago:\n # we are within the last two days, so we take all the measurements we can get!\n values.append(d)\n elif (date < two_days_ago) and (date > seven_days_ago):\n # we are between 2 and 7 days ago, so take only values if we don't have 25 values already\n if len(values) < 30:\n values.append(d)\n elif date < seven_days_ago:\n # we are further away than 7 days, so take a maximum of 5 values from here if we don't have 5 yet\n if len(values) < 10:\n values.append(d)\n\n to_average = [\n i.get(\"_source\", {})\n .get(\"profiles\", {})\n .get(\"fastBmk\", {})\n .get(\"value\", 0.0)\n for i in values\n ]\n json_data[pq] = {\n \"avg_value\": float(sum(to_average)) / len(to_average),\n \"measurements\": len(to_average),\n }\n # print(len(to_average))\n\n return json_data","def organize_results(result_dicts_list, config_fn):\n\n metric_id = config_fn.get_metric_fn_id()[1]\n organized_results = []\n for results_list in result_dicts_list:\n for result_dict in results_list:\n dict_ = {}\n for key, value in result_dict.items():\n dict_[key] = value\n organized_results.append(dict_)\n pass\n\n return organized_results","def process_input_items(args):\n return dict(sum([Counter({sku: value * SCORES[k] for sku, value in\n Counter(args[k].split(',')).items()}) or Counter() for k in\n set(SCORES.keys()) & set(args.keys())], Counter()))","def get_results(self):\r\n r ={\r\n 'Gp_s' :np.array(self.Gp_guess_s), #Means of the posteriors\r\n 'Gm_s' :np.array(self.Gm_guess_s), #Means of the posteriors\r\n 'eGp_s':np.array(self.eGp_guess_s) , #Standard deviations of the posteriors\r\n 'eGm_s':np.array(self.eGm_guess_s) , #Standard deviations of the posteriors\r\n 'covGpGm_s':np.array(self.cov_GpGm_s) , #Covariances of the posteriors\r\n 't_tot_pulseSequences_s':np.array(self.t_tot_pulseSequences_s), #Time it takes for each batch of pulse sequences\r\n 't_tot_process_s':np.array(self.t_tot_process_s), #CPU time it takes for processing the Bayes stuff at each iteration\r\n 't_probe_p_s':np.array(self.t_probe_p_s), # Times probed for the diff p\r\n 't_probe_m_s':np.array(self.t_probe_m_s), # Times probed for the diff m\r\n 't_pulseSequences_s':np.array(self.t_pulseSequences_s),\r\n 't_process_s':np.array(self.t_process_s),\r\n 'iteration_s':np.array(self.nb_iteration_s), #Number of iterations performed\r\n 'R_tot_s':np.array(self.R_tot_s) #Total number of readout performed\r\n }\r\n return r","def iterate_results(results, extract_fn):\n outputs = {}\n for environment, environment_results in results.items():\n if environment not in outputs:\n outputs[environment] = {}\n for experimental_setting, setting_results in environment_results.items():\n outputs[environment][experimental_setting] = []\n for config, seeds_results in setting_results.items():\n for seed, actual_results in seeds_results.items():\n output = extract_fn(actual_results)\n outputs[environment][experimental_setting].append(output)\n outputs[environment][experimental_setting] = np.array(outputs[environment][experimental_setting])\n return outputs","def _aggregate(self, row):\n if not self._head:\n self._head = self._create_head(row)\n if self._args.head:\n return\n\n if 'key' not in self._state:\n self._state['key'] = self._replace_fields(self._args.key)\n\n if 'begin' not in self._state:\n self._state['begin'] = eval(self._replace_fields(self._args.begin))\n\n if 'reduce' not in self._state:\n self._state['reduce'] = self._replace_fields(self._args.reduce)\n\n if 'result_map' not in self._state:\n self._state['result_map'] = {}\n\n r = list(map(self._convert, row))\n\n key = eval(self._state['key'])\n\n if key not in self._state['result_map']:\n self._state['result_map'][key] = len(self._result)\n entry = deepcopy(self._state['begin'])\n self._result.append([key, entry])\n\n index = self._state['result_map'][key]\n\n ns = {\n '__result__': self._result[index][1],\n 'r': r\n }\n exec(self._state['reduce'], ns)\n self._result[index][1] = ns['__result__']","def _build_eval_metrics(self, results, features, labels):\n metrics = {}\n for metric in self.metrics:\n metrics[metric.IDENTIFIER] = getters.get_metric(\n metric.IDENTIFIER, results, labels, **metric.to_dict())\n return metrics","def store_results(main_dico, attempts_dico, temp_probas_dico, verbose_dico, review_strat, param, run_id, stud_id, t,\n mean_recall, sum_attempts, recall_probs, relative_mean_recall, attempts_per_skill, B, item_strategy):\n main_dico[\"skill_strategy\"].append(review_strat)\n main_dico[\"item_strategy\"].append(item_strategy)\n main_dico[\"param\"].append(param)\n main_dico[\"run_id\"].append(run_id)\n main_dico[\"stud_id\"].append(stud_id)\n main_dico[\"t\"].append(t)\n main_dico[\"mean_recall\"].append(np.around(mean_recall,5))\n main_dico[\"relative_mean_recall\"].append(relative_mean_recall)\n main_dico[\"sum_attempts\"].append(sum_attempts)\n for b in range(B):\n if (t < B) and (review_strat != \"no_review\"):\n attempts_dico[review_strat][param][item_strategy][t][\"att_skill_\"+str(b)] += attempts_per_skill[b]\n if t < B:\n temp_probas_dico[review_strat][param][item_strategy][\"learning\"].append(recall_probs)\n verbose_dico[item_strategy][review_strat][param][\"learning\"].append(mean_recall)\n else:\n temp_probas_dico[review_strat][param][item_strategy][\"retention\"].append(recall_probs)\n verbose_dico[item_strategy][review_strat][param][\"retention\"].append(mean_recall)"],"string":"[\n \"def aggregate_results(results):\\n\\n for (config,con,dec),folds in results.iteritems():\\n m = MODEL_PATTERN.match(config)\\n if m:\\n mode = m.groupdict()['mode'] # mle, rl, mrt, ...\\n model = m.groupdict()['model'] # haem, hacm, hard, ...\\n align = m.groupdict()['align'] # crp, cls ...\\n else:\\n mode, model, align = '', '', ''\\n # mean accuracies across seeds for each fold\\n foldaccuracies = []\\n # we count number of models over folds and seeds\\n num_individual_models = 0\\n\\n for foldname,fold in folds.items():\\n if 'Q' in options.mode:\\n seedaccurracies = fold.values()[:1] if fold.values() else [] # pick one\\n# SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\\n else:\\n seedaccurracies = []\\n for seed_acc in fold.values():\\n seedaccurracies.append(seed_acc)\\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\\n # aggregate on fold level\\n fold['__MEAN__'] = float(np.mean(seedaccurracies))\\n fold['__SD__'] = float(np.std(seedaccurracies))\\n l = len(seedaccurracies)\\n num_individual_models += l\\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__MEAN__')] += l\\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__SD__')] += l\\n\\n # statistics over seeds for this fold\\n fold['__STATS__'] = fold['__MEAN__'], fold['__SD__'], l\\n foldaccuracies.append(fold['__MEAN__'])\\n # aggregate on (config, condition, decoding) level\\n folds['__MEAN__'] = float(np.mean(foldaccuracies))\\n folds['__SD__'] = float(np.std(foldaccuracies))\\n # statistics over folds for this (config, condition, decoding)\\n folds['__STATS__'] = folds['__MEAN__'], folds['__SD__'], num_individual_models\",\n \"def compute_metrics(self, results: list) -> dict:\",\n \"def score_aggregate(results):\\n scores = []\\n truth_count = detected_count = segment_count = 0\\n\\n for res in results:\\n scores.append(res[\\\"scores\\\"])\\n truth_count += len(res[\\\"labels\\\"])\\n detected_count += len(res[\\\"detected\\\"])\\n segment_count += len(res[\\\"scores\\\"][\\\"segments\\\"])\\n\\n ret = dict()\\n ret[\\\"scores\\\"] = sum_scores(scores)\\n ret[\\\"stats\\\"] = dict(truth_count=truth_count, detected_count=detected_count, segment_count=segment_count)\\n return ret\",\n \"def get_results_stats(self, results, key_by_date=True):\\n stats = {}\\n for r in results:\\n if key_by_date:\\n key = r.get(1)\\n value = r.get(2)\\n else:\\n key = r.get(2)\\n value = r.get(1)\\n\\n if key not in stats:\\n stats[key] = {}\\n\\n if value not in stats[key]:\\n stats[key][value] = 1\\n else:\\n stats[key][value] += 1\\n\\n # sort each keyset\\n if not key_by_date:\\n stats[key] = self._stats_sort(stats[key])\\n\\n if stats:\\n # only if sorted per key\\n if key_by_date:\\n stats = self._stats_sort(stats)\\n\\n return stats\",\n \"def aggregate_results(self, results):\\n result = dict()\\n result['MAE'] = self.average_dict_items(results, 'MAE')\\n result['MdAE'] = self.average_dict_items(results, 'MdAE')\\n result['RMSE'] = self.average_dict_items(results, 'RMSE')\\n result['SMAPE'] = self.average_dict_items(results, 'SMAPE')\\n result['num_values'] = self.average_dict_items(results, 'num_values')\\n return result\",\n \"def reduce_result(results):\\n agg = OrderedDict()\\n for result in results:\\n # Keys by model and explore, adds additional values for `passed` to a set\\n agg.setdefault((result[\\\"model\\\"], result[\\\"explore\\\"]), set()).add(\\n result[\\\"passed\\\"]\\n )\\n reduced = [\\n {\\\"model\\\": k[0], \\\"explore\\\": k[1], \\\"passed\\\": min(v)}\\n for k, v in agg.items()\\n ]\\n return reduced\",\n \"def aggregate_batch_evals(result_dict: dict, all_runs: list) -> dict:\\n # Loop over all evals (e.g. b_1_eval_0) and merge + aggregate data\\n new_results_dict = {}\\n for eval in all_runs:\\n all_seeds_for_run = list(result_dict[eval].keys())\\n eval_dict = aggregate_single_eval(result_dict[eval], all_seeds_for_run, eval)\\n new_results_dict[eval] = eval_dict[eval]\\n return new_results_dict\",\n \"def aggregate_over_seeds(result_dict: DotMap, batch_case: bool = False) -> DotMap:\\n all_runs = list(result_dict.keys())\\n if batch_case:\\n # Perform seed aggregation for all evaluations\\n new_results_dict = aggregate_batch_evals(result_dict, all_runs)\\n else:\\n new_results_dict = aggregate_single_eval(result_dict, all_runs, \\\"eval\\\")\\n return DotMap(new_results_dict, _dynamic=False)\",\n \"def aggregate_results(self):\\n\\n raise NotImplementedError\",\n \"def average_metrics_results(results):\\n res = {}\\n\\n if len(results) == 0:\\n return {}\\n\\n for key in results[0]:\\n try:\\n res[key] = sum([r[key] for r in results]) / len(results)\\n except TypeError:\\n res[key] = [sum(b)/len(results) for b in zip(*[s[key] for s in results])]\\n return res\",\n \"def accumulate_study_results(ids, prob):\\n sum_result = {}\\n cnt_result = {}\\n size = prob.shape[0]\\n for i in range(size):\\n study_id = ids[i]\\n idx = int(study_id)\\n if idx not in cnt_result:\\n cnt_result[idx] = 0.\\n sum_result[idx] = np.zeros((1, prob.shape[1]), dtype=np.float32)\\n cnt_result[idx] += 1\\n sum_result[idx] += prob[i, :]\\n for i in cnt_result.keys():\\n sum_result[i][:] /= cnt_result[i]\\n return sum_result\",\n \"def aggregate_single_eval( # noqa: C901\\n result_dict: dict, all_seeds_for_run: list, eval_name: str\\n) -> dict:\\n new_results_dict = {}\\n data_temp = result_dict[all_seeds_for_run[0]]\\n # Get all main data source keys (\\\"meta\\\", \\\"stats\\\", \\\"time\\\")\\n data_sources = list(data_temp.keys())\\n # Get all variables within the data sources\\n data_items = {\\n data_sources[i]: list(data_temp[data_sources[i]].keys())\\n for i in range(len(data_sources))\\n }\\n # Collect all runs together - data at this point is not modified\\n source_to_store = {key: {} for key in data_sources}\\n for ds in data_sources:\\n data_to_store = {key: [] for key in data_items[ds]}\\n for i, o_name in enumerate(data_items[ds]):\\n for i, seed_id in enumerate(all_seeds_for_run):\\n seed_run = result_dict[seed_id]\\n data_to_store[o_name].append(seed_run[ds][o_name][:])\\n source_to_store[ds] = data_to_store\\n new_results_dict[eval_name] = source_to_store\\n\\n # Aggregate over the collected runs\\n aggregate_sources = {key: {} for key in data_sources}\\n for ds in data_sources:\\n if ds in [\\\"time\\\"]:\\n aggregate_dict = {key: {} for key in data_items[ds]}\\n for i, o_name in enumerate(data_items[ds]):\\n aggregate_dict[o_name] = new_results_dict[eval_name][ds][o_name][0]\\n # Mean over stats data\\n elif ds in [\\\"stats\\\"]:\\n aggregate_dict = {key: {} for key in data_items[ds]}\\n for i, o_name in enumerate(data_items[ds]):\\n if type(new_results_dict[eval_name][ds][o_name][0][0]) not in [\\n str,\\n bytes,\\n np.bytes_,\\n np.str_,\\n ]:\\n # Compute mean and standard deviation over seeds\\n mean_tol, std_tol = tolerant_mean(\\n new_results_dict[eval_name][ds][o_name]\\n )\\n aggregate_dict[o_name][\\\"mean\\\"] = mean_tol\\n aggregate_dict[o_name][\\\"std\\\"] = std_tol\\n\\n # Compute 10, 25, 50, 75, 90 percentiles over seeds\\n p50, p10, p25, p75, p90 = tolerant_median(\\n new_results_dict[eval_name][ds][o_name]\\n )\\n aggregate_dict[o_name][\\\"p50\\\"] = p50\\n aggregate_dict[o_name][\\\"p10\\\"] = p10\\n aggregate_dict[o_name][\\\"p25\\\"] = p25\\n aggregate_dict[o_name][\\\"p75\\\"] = p75\\n aggregate_dict[o_name][\\\"p90\\\"] = p90\\n else:\\n aggregate_dict[o_name] = new_results_dict[eval_name][ds][o_name]\\n # Append over all meta data (strings, seeds nothing to mean)\\n elif ds == \\\"meta\\\":\\n aggregate_dict = {}\\n for i, o_name in enumerate(data_items[ds]):\\n temp = (\\n np.array(new_results_dict[eval_name][ds][o_name])\\n .squeeze()\\n .astype(\\\"U200\\\")\\n )\\n # Get rid of duplicate experiment dir strings\\n if o_name in [\\n \\\"experiment_dir\\\",\\n \\\"eval_id\\\",\\n \\\"config_fname\\\",\\n \\\"model_type\\\",\\n ]:\\n aggregate_dict[o_name] = str(np.unique(temp)[0])\\n else:\\n aggregate_dict[o_name] = temp\\n\\n # Add seeds as clean array of integers to dict\\n aggregate_dict[\\\"seeds\\\"] = [int(s.split(\\\"_\\\")[1]) for s in all_seeds_for_run]\\n else:\\n raise ValueError\\n aggregate_sources[ds] = aggregate_dict\\n new_results_dict[eval_name] = aggregate_sources\\n return new_results_dict\",\n \"def generate_stats(results, ads, vmid, session_date, export_folder, process_ex_time):\\n try:\\n os.makedirs(export_folder)\\n except OSError:\\n pass\\n\\n # to be read and inserted into db\\n totalads = 0 # total number of ads seen during this session\\n totaluniqads = len(ads) # does not support multicategories at this point\\n\\n # for each category, for each test site, count total number of ads seen\\n totalad_category = {} \\n # for each category, for each test site, count total number of uniq ads seen\\n uniqad_category = {}\\n \\n with open(os.path.join(export_folder, 'session_bugs.csv'), 'w') as bugs_wtr:\\n bugs_wtr.write('#Ad-UID, Website-URL, Refresh-Num, Training-Topic,\\\\\\n Site-Context, BugCount, BugSrc\\\\n')\\n for train_category, cat_dict in results.items():\\n totalad_category[train_category] = {}\\n uniqad_category[train_category] = {}\\n for test_site, bug_dict_list in cat_dict.items():\\n total_ads = 0 # for each site\\n uniq_ads = [] # for each site\\n for refresh_num in range(len(bug_dict_list)):\\n bug_dict = bug_dict_list[refresh_num]\\n for bug, bugcount in bug_dict.items():\\n if bug.is_ad():\\n uuid = bug.get_uuid()\\n bugs_wtr.write('{0}, {1}, {2}, {3}, {4}, {5}, {6}\\\\n'.format(uuid, test_site,\\n refresh_num, train_category, 'N/A', bugcount, bug.get_src()))\\n total_ads += bugcount\\n if bug not in uniq_ads:\\n uniq_ads.append(bug)\\n totalad_category[train_category][test_site] = total_ads\\n uniqad_category[train_category][test_site] = len(uniq_ads)\\n totalads += total_ads # global count for total ads\\n\\n with open(os.path.join(export_folder, 'session_stats.csv'), 'w') as ses_wtr:\\n # write some metadata information about this session\\n ses_wtr.write('#VMID: %s\\\\n' % vmid)\\n ses_wtr.write('#Session-Date: %s\\\\n' % session_date)\\n ses_wtr.write('#Time to complete: %s\\\\n' % process_ex_time)\\n ses_wtr.write('#Training Categories: %s\\\\n' % str(results.keys()))\\n ses_wtr.write('#Total Number of ads: %d\\\\n' % totalads)\\n ses_wtr.write('#Total Uniq ads: %d\\\\n\\\\n' % totaluniqads)\\n ses_wtr.write('#TrainingTopic, Test-Site, NumberOfVisit, TotalAds, UniqAds\\\\n')\\n\\n for train_category, cat_dict in results.items(): \\n for test_site, bug_dict_list in cat_dict.items():\\n num_of_visit = len(bug_dict_list)\\n ses_wtr.write('{0}, {1}, {2}, {3}, {4}\\\\n'.format(train_category,\\n test_site, num_of_visit, totalad_category[train_category][test_site],\\n uniqad_category[train_category][test_site]))\",\n \"def summary(self):\\n summary = defaultdict(int)\\n\\n for r in self.results:\\n summary[r.result] += 1\\n\\n return summary\",\n \"def process_metrics_overall(\\n self, the_dict, names=[\\\"metric\\\", \\\"phase\\\", \\\"epoch\\\", \\\"performance\\\"]\\n ):\\n result = (\\n pd.DataFrame(the_dict)\\n .reset_index()\\n .melt(id_vars=\\\"index\\\")\\n .set_index([\\\"index\\\", \\\"variable\\\"])\\n .value.apply(pd.Series)\\n .stack()\\n .reset_index()\\n )\\n result.columns = names\\n return result\",\n \"def _cv_results(self, metrics):\\n\\n param_keys = self.param_combs[0].keys()\\n param_dict = {k: [comb[k] for comb in self.param_combs]\\n for k in param_keys}\\n df_metric_result = {k: pd.DataFrame({'Metric mean': self.mean[k],\\n 'Std. dev.': self.std[k],\\n **param_dict})\\n for k in metrics.keys()}\\n self.cv_results_ = df_metric_result\",\n \"def summarizeResults(results, what, discard=(), minName=None, maxName=None):\\n # threadCounts = sorted (transpose(results).keys())\\n threadCounts = [t for t in list(transpose(results).keys()) if t not in discard]\\n if not isinstance(threadCounts[0], str):\\n threadCounts.sort()\\n\\n sds = {}\\n meanValues = {}\\n what_SD = \\\"SD\\\" if what == \\\"Mean\\\" else what + \\\"_SD\\\"\\n\\n for k in list(results.keys()):\\n res = results[k]\\n meanValues[k] = [\\n None if res.get(tc, None) == None else res[tc].__dict__.get(what, None)\\n for tc in threadCounts\\n ]\\n if minName != None and maxName != None:\\n sds[k] = [\\n None\\n if res.get(tc, None) == None\\n else convertMinMaxIntoError(res[tc], what, minName, maxName)\\n for tc in threadCounts\\n ]\\n else:\\n sds[k] = [\\n None\\n if res.get(tc, None) == None\\n else res[tc].__dict__.get(what_SD, None)\\n for tc in threadCounts\\n ]\\n return (threadCounts, meanValues, sds)\",\n \"def sum(app, args):\\n if not args.key:\\n db = get_db(app)\\n notrans = db.transient.count()\\n print(\\\"No Transient records: \\\", notrans)\\n if notrans > 0:\\n print(\\\"Total data Transient: \\\", nicesize(\\n list(db.transient.aggregate([\\n {\\\"$group\\\": {\\\"_id\\\": None,\\n \\\"total\\\": {\\\"$sum\\\": \\\"$size\\\"}}}]))[0]['total']))\\n print(\\\" No Core records: \\\", db.transient.count())\\n return\\n\\n kname, kinfo = key_info(app.conf, args.key)\\n res = _single_sum(app, group_by=kname, force=args.force)\\n total_size = int(0)\\n total_count = 0\\n mgn = len(\\\"Total\\\")\\n for reshost in res:\\n gid = reshost['_id']\\n if gid is None:\\n mgn = max(4, mgn)\\n else:\\n mgn = max(len(str(reshost['_id'])), mgn)\\n\\n fms = \\\"{:\\\" + str(mgn) + \\\"}\\\\t{:>10}\\\\t{:>9}\\\"\\n if args.human:\\n print(\\\"# {}:\\\".format(kname))\\n for reshost in res:\\n total = reshost['total']\\n count = reshost['count']\\n total_size += int(total)\\n total_count += count\\n if args.human:\\n total_human = nicesize(total)\\n count_human = nicenumber(count)\\n categ = reshost['_id']\\n if categ is None:\\n categ = \\\"<undefined>\\\"\\n\\n print(fms.format(\\n categ, total_human, count_human))\\n else:\\n print(\\\"{}\\\\t{}\\\\t{}\\\".format(\\n reshost['_id'], total, count))\\n\\n if args.human:\\n total_size_human = nicesize(total_size)\\n total_count_human = nicenumber(total_count)\\n print(fms.format('', '-'*10, '-'*9))\\n print(fms.format(\\n \\\"Total\\\", total_size_human, total_count_human))\\n else:\\n print(\\\"Total\\\\t{}\\\\t{}\\\".format(total_size, total_count))\",\n \"def process_result_dict(\\n the_dict, names=[\\\"metric\\\", \\\"phase\\\", \\\"epoch\\\", \\\"performance\\\"]\\n ):\\n result = (\\n pd.DataFrame(the_dict)\\n .reset_index()\\n .melt(id_vars=\\\"index\\\")\\n .set_index([\\\"index\\\", \\\"variable\\\"])\\n .value.apply(pd.Series)\\n .stack()\\n .reset_index()\\n )\\n result.columns = names\\n return result\",\n \"def get_job_metrics_summary_for_task(query):\\n metric_list = ['hs06sec', 'gco2_global']\\n metrics = {}\\n for m in metric_list:\\n metrics[m] = {'finished': 0, 'failed': 0, 'total': 0}\\n\\n hquery = copy.deepcopy(query)\\n hquery['jobstatus__in'] = ('finished', 'failed')\\n\\n if 'jeditaskid' in hquery:\\n\\n hs06sec_sum = []\\n # getting jobs. Can not use the .annotate() as there can be duplicates\\n jobs = []\\n jvalues = ['pandaid', 'jobstatus', ] + metric_list\\n jobs.extend(Jobsarchived4.objects.filter(**hquery).values(*jvalues))\\n jobs.extend(Jobsarchived.objects.filter(**hquery).values(*jvalues))\\n jobs = drop_duplicates(jobs)\\n\\n for job in jobs:\\n for m in metric_list:\\n metrics[m]['total'] += job[m] if m in job and job[m] is not None else 0\\n if job['jobstatus'] == 'finished':\\n metrics[m]['finished'] += job[m] if m in job and job[m] is not None else 0\\n elif job['jobstatus'] == 'failed':\\n metrics[m]['failed'] += job[m] if m in job and job[m] is not None else 0\\n\\n # getting data from ATLARC DB, only hs06s\\n pj_models = get_pandajob_arch_models_by_year(query['modificationtime__castdate__range'])\\n if len(pj_models) > 0:\\n for pjm in pj_models:\\n try:\\n hs06sec_sum.extend(pjm.objects.filter(**hquery).values('jobstatus').annotate(hs06secsum=Sum('hs06sec')))\\n except Exception as ex:\\n _logger.exception('Failed to get hs06sec from {} at ATLARC DB:\\\\n{}'.format(pjm, ex))\\n\\n if len(hs06sec_sum) > 0:\\n for hs in hs06sec_sum:\\n metrics['hs06sec']['total'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\\n if hs['jobstatus'] == 'finished':\\n metrics['hs06sec']['finished'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\\n elif hs['jobstatus'] == 'failed':\\n metrics['hs06sec']['failed'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\\n\\n\\n return metrics\",\n \"def calc_data(self):\\n\\n circ_counts = {}\\n for trialidx in range(self._ntrials):\\n for _, depth in enumerate(self._depths):\\n circ_name = 'qv_depth_%d_trial_%d' % (depth, trialidx)\\n\\n # get the counts form ALL executed circuits\\n count_list = []\\n for result in self._result_list:\\n try:\\n count_list.append(result.get_counts(circ_name))\\n except (QiskitError, KeyError):\\n pass\\n\\n circ_counts[circ_name] = \\\\\\n build_counts_dict_from_list(count_list)\\n\\n self._circ_shots[circ_name] = \\\\\\n sum(circ_counts[circ_name].values())\\n\\n # calculate the heavy output probability\\n self._heavy_output_counts[circ_name] = \\\\\\n self._subset_probability(\\n self._heavy_outputs[circ_name],\\n circ_counts[circ_name])\",\n \"def aggregator(index_keynames, value_keynames, ts_keyname, func, interval = 60 * 5):\\n data = {}\\n ts = None\\n #print ts_keyname\\n for parsts, parsdata in func():\\n #print parsdata\\n #print parsdata[\\\"log_timestamp\\\"]\\n if ts is None:\\n ts = parsts\\n key = tuple((parsdata[key] for key in index_keynames))\\n values = tuple((int(parsdata[key]) for key in value_keynames))\\n if key not in data:\\n data[key] = values\\n else:\\n data[key] = tuple((data[key][index] + int(values[index]) for index in range(len(values))))\\n if parsts > (ts + interval):\\n for keys, values in data.items():\\n yield \\\"%s\\\\t%s\\\\t%s\\\" % (ts, \\\"\\\\t\\\".join((str(index_key) for index_key in keys)), \\\"\\\\t\\\".join((str(value_key) for value_key in values)))\\n ts = None\\n data = {}\",\n \"def _print_aggregate_results(\\n task: Task, task_results: Dict[Task, List[List[Dict[str, Any]]]]\\n) -> None:\\n aggregate_task_result = aggregate_nvs_results(task_results[task])\\n print(\\\"\\\")\\n print(f\\\"Aggregate results for task={task}:\\\")\\n pretty_print_nvs_metrics(aggregate_task_result)\\n print(\\\"\\\")\",\n \"def get_test_cases_coverage(session_id):\\n tc_stats={}\\n tc_stats_list=[]\\n total_executed=0\\n sql='SELECT DISTINCT(test_id) FROM stats WHERE session_id=:sid AND test_id!=\\\"null\\\"'\\n params={\\\"sid\\\":session_id}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n tests=c.fetchall()\\n conn.close()\\n if len(tests)>0:\\n for t in tests:\\n total_executed=0\\n sql=\\\"SELECT DISTINCT(file_id) FROM stats WHERE session_id=:sid AND test_id=:tid\\\"\\n params={\\\"sid\\\":session_id,\\\"tid\\\":t[0]}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n files=c.fetchall()\\n conn.close()\\n for f in files:\\n line_count=get_executable_lines_count_for_file(f[0])\\n # get executions\\n sql=\\\"SELECT COUNT(DISTINCT line_guid) FROM stats WHERE session_id= :sid AND file_id= :fid AND test_id=:tid\\\"\\n params={\\\"sid\\\":session_id,\\\"tid\\\":t[0],\\\"fid\\\":f[0]}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n executed=c.fetchone()\\n conn.close()\\n total_executed+=executed[0]\\n # save test case and it's executions\\n tc_stats={}\\n tc_stats[\\\"test_id\\\"]=t[0]\\n tc_stats[\\\"total_executed\\\"]=total_executed\\n tc_stats[\\\"total_executed\\\"]\\n \\n tc_stats_list.append(tc_stats)\\n return tc_stats_list\",\n \"def gather_results(dataset: Dataset,\\n conf: Namespace\\n ) -> \\\"dict[str, dict[str, any]]\\\":\\n\\n data = {}\\n\\n for k in np.copy(dataset.folds):\\n print(f\\\"\\\\nFold {k}\\\", '~'*60)\\n\\n dataset.set_fold(k)\\n calibrated_scores = APPROACHES[conf.approach](dataset=dataset, conf=conf)\\n\\n data[f'fold{k}'] = {\\n 'scores': calibrated_scores,\\n 'metrics': get_metrics(calibrated_scores, dataset, conf)\\n }\\n\\n return data\",\n \"def compute_session_status(self):\\n if self.passed is None:\\n raise AttributeError('passed is None; compute QC first')\\n # Get mean passed of each check, or None if passed is None or all NaN\\n results = {k: None if v is None or np.isnan(v).all() else np.nanmean(v)\\n for k, v in self.passed.items()}\\n session_outcome, outcomes = self.compute_session_status_from_dict(results)\\n return session_outcome, results, outcomes\",\n \"def calculates_results_stats(results_dic): \\n # Creates empty dictionary for results_stats_dic\\n results_stats_dic = dict()\\n \\n # Sets all counters to initial values of zero so that they can \\n # be incremented while processing through the images in results_dic \\n results_stats_dic['n_dogs_img'] = 0\\n results_stats_dic['n_match'] = 0\\n results_stats_dic['n_correct_dogs'] = 0\\n results_stats_dic['n_correct_notdogs'] = 0\\n results_stats_dic['n_correct_breed'] = 0\\n \\n # process through the results dictionary\\n for key in results_dic:\\n \\n # Labels Match Exactly\\n if results_dic[key][2] == 1:\\n results_stats_dic['n_match'] += 1\\n\\n # TODO: 5a. REPLACE pass with CODE that counts how many pet images of\\n # dogs had their breed correctly classified. This happens \\n # when the pet image label indicates the image is-a-dog AND \\n # the pet image label and the classifier label match. You \\n # will need to write a conditional statement that determines\\n # when the dog breed is correctly classified and then \\n # increments 'n_correct_breed' by 1. Recall 'n_correct_breed' \\n # is a key in the results_stats_dic dictionary with it's value \\n # representing the number of correctly classified dog breeds.\\n # \\n # Pet Image Label is a Dog AND Labels match- counts Correct Breed\\n if results_dic[key][3] == 1 and results_dic[key][2] == 1:\\n results_stats_dic['n_correct_breed'] += 1\\n \\n # Pet Image Label is a Dog - counts number of dog images\\n if results_dic[key][3] == 1:\\n results_stats_dic['n_dogs_img'] += 1\\n \\n # Classifier classifies image as Dog (& pet image is a dog)\\n # counts number of correct dog classifications\\n if results_dic[key][4] == 1:\\n results_stats_dic['n_correct_dogs'] += 1\\n\\n # TODO: 5b. REPLACE pass with CODE that counts how many pet images \\n # that are NOT dogs were correctly classified. This happens \\n # when the pet image label indicates the image is-NOT-a-dog \\n # AND the classifier label indicates the images is-NOT-a-dog.\\n # You will need to write a conditional statement that \\n # determines when the classifier label indicates the image \\n # is-NOT-a-dog and then increments 'n_correct_notdogs' by 1. \\n # Recall the 'else:' above 'pass' already indicates that the \\n # pet image label indicates the image is-NOT-a-dog and \\n # 'n_correct_notdogs' is a key in the results_stats_dic dictionary \\n # with it's value representing the number of correctly \\n # classified NOT-a-dog images.\\n # \\n # Pet Image Label is NOT a Dog\\n else:\\n # Classifier classifies image as NOT a Dog(& pet image isn't a dog)\\n # counts number of correct NOT dog clasifications.\\n if results_dic[key][3] == 0 and results_dic[key][4] == 0:\\n results_stats_dic['n_correct_notdogs'] += 1\\n\\n\\n # Calculates run statistics (counts & percentages) below that are calculated\\n # using the counters from above.\\n\\n # calculates number of total images\\n results_stats_dic['n_images'] = len(results_dic)\\n\\n # calculates number of not-a-dog images using - images & dog images counts\\n results_stats_dic['n_notdogs_img'] = (results_stats_dic['n_images'] - \\n results_stats_dic['n_dogs_img']) \\n\\n # TODO: 5c. REPLACE zero(0.0) with CODE that calculates the % of correctly\\n # matched images. Recall that this can be calculated by the\\n # number of correctly matched images ('n_match') divided by the \\n # number of images('n_images'). This result will need to be \\n # multiplied by 100.0 to provide the percentage.\\n # \\n # Calculates % correct for matches\\n results_stats_dic['pct_match'] = (results_stats_dic['n_match'] / results_stats_dic['n_images']) * 100\\n\\n # TODO: 5d. REPLACE zero(0.0) with CODE that calculates the % of correctly\\n # classified dog images. Recall that this can be calculated by \\n # the number of correctly classified dog images('n_correct_dogs')\\n # divided by the number of dog images('n_dogs_img'). This result \\n # will need to be multiplied by 100.0 to provide the percentage.\\n # \\n # Calculates % correct dogs\\n results_stats_dic['pct_correct_dogs'] = (results_stats_dic['n_correct_dogs'] / results_stats_dic['n_dogs_img']) * 100\\n\\n # TODO: 5e. REPLACE zero(0.0) with CODE that calculates the % of correctly\\n # classified breeds of dogs. Recall that this can be calculated \\n # by the number of correctly classified breeds of dog('n_correct_breed') \\n # divided by the number of dog images('n_dogs_img'). This result \\n # will need to be multiplied by 100.0 to provide the percentage.\\n # \\n # Calculates % correct breed of dog\\n results_stats_dic['pct_correct_breed'] = (results_stats_dic['n_correct_breed'] / results_stats_dic['n_dogs_img']) * 100\\n\\n # Calculates % correct not-a-dog images\\n # Uses conditional statement for when no 'not a dog' images were submitted \\n if results_stats_dic['n_notdogs_img'] > 0:\\n results_stats_dic['pct_correct_notdogs'] = (results_stats_dic['n_correct_notdogs'] /\\n results_stats_dic['n_notdogs_img']) * 100.0\\n else:\\n results_stats_dic['pct_correct_notdogs'] = 0.0\\n\\n \\n # TODO 5f. REPLACE None with the results_stats_dic dictionary that you \\n # created with this function \\n return results_stats_dic\",\n \"def extract_score(results):\\n total_score = 0;\\n total_possible_score = 0;\\n for k in results.keys():\\n total_score = total_score + results[k][0]\\n total_possible_score = total_possible_score + results[k][1]\\n return (total_score, total_possible_score)\",\n \"def get_DFGs_result_summary(DFGs):\\n DFGs_summary = dict()\\n for DFG_name in DFGs:\\n DFGs_summary[DFG] = {}\\n for res in jenkins_const.RESULTS:\\n DFGs_summary[DFG_name][res] = Job.count(\\n name='DFG-{}'.format(DFG_name),\\n last_build_res=res)\\n return DFGs_summary\",\n \"def totalize_measurement(conts_dict, si_model):\\n print('######## BEGIN CHECKING TOTAL ########')\\n for cont_measure, doc_measure in [\\n ['packages', 'total_packages'],\\n ['container_weight', 'total_weight'],\\n ['container_measurement', 'total_measurement']\\n ]:\\n doc_qua, doc_unit = split_quantity_unit(si_model[doc_measure])\\n if not doc_qua:\\n doc_qua = '0'\\n if floatable(doc_qua.replace(',', '')):\\n doc_qua = float(doc_qua.replace(',', ''))\\n else:\\n doc_qua = 0\\n conts_detail = [\\n split_quantity_unit(cont.get(cont_measure, '0'))\\n for cont in conts_dict\\n ]\\n\\n print(cont_measure, ':', conts_detail, '|', doc_qua, '-', doc_unit)\\n\\n conts_unit = list(set([\\n cont_unit\\n for cont_qua, cont_unit in conts_detail\\n ]))\\n if len(conts_unit) == 1:\\n conts_sum = sum([\\n float(cont_qua.replace(',', ''))\\n for cont_qua, cont_unit in conts_detail\\n if floatable(cont_qua.replace(',', ''))\\n ])\\n conts_unit = conts_unit[0]\\n else:\\n conts_sum = 0\\n conts_unit = ''\\n\\n if conts_sum != doc_qua and conts_unit and conts_sum > 0:\\n print('### Containers', cont_measure, conts_sum,\\n '=/= SI', doc_measure, doc_qua, '###')\\n if doc_measure == 'total_packages':\\n si_model[doc_measure] = f\\\"{conts_sum:,.0f}\\\" + conts_unit\\n else:\\n si_model[doc_measure] = f\\\"{conts_sum:,.3f}\\\" + conts_unit\\n\\n return si_model\",\n \"def results(key):\\n poll = repository.get_poll(key)\\n poll.calculate_stats()\\n return render_template(\\n 'results.jade',\\n title='Results',\\n year=datetime.now().year,\\n poll=poll,\\n )\",\n \"def legal_universal_search_results():\\n advisory_opinions = advisory_opinions_search_results()\\n regulations = regulations_search_results()\\n total_count = advisory_opinions['total_advisory_opinions'] + regulations['total_regulations']\\n results = {\\\"total_all\\\": total_count}\\n results.update(advisory_opinions)\\n results.update(regulations)\\n return results\",\n \"def mean_accuracy_per_setting(results):\\n ###TODO\\n min_freq = {}\\n feature = {}\\n punct = {}\\n \\n #step 1 -> loop over results to get list of values for particular \\n # setting of punct, features,min_freq \\n #keys = ['punct','features','min_freq','accuracy']\\n \\n for d in results:\\n \\n if d['min_freq'] not in min_freq.keys():\\n min_freq.setdefault(d['min_freq'],[]).append(d['accuracy'])\\n else :\\n min_freq[d['min_freq']].append(d['accuracy'])\\n \\n if d['punct'] not in punct.keys():\\n punct.setdefault(d['punct'],[]).append(d['accuracy'])\\n else :\\n punct[d['punct']].append(d['accuracy'])\\n \\n if d['features'] not in feature.keys(): \\n feature.setdefault(d['features'],[]).append(d['accuracy'])\\n else : \\n feature[d['features']].append(d['accuracy'])\\n \\n \\n #print('min_freq = ',min_freq)\\n #print('feature = ',feature)\\n #print('punct = ',punct) \\n \\n # step 2 -> find average for each setting\\n tuple_list = [] \\n for fet in feature.keys():\\n \\n t1 = 'features='\\n for f in fet:\\n t1 += f.__name__ + ' '\\n \\n #print(t1)\\n avg = np.mean(feature[fet],dtype=np.float64) \\n tuple_list.append((avg,t1))\\n\\n\\n #print('After features result = ',result) \\n \\n for freq in min_freq.keys():\\n t1 = 'min_freq=' + str(freq)\\n avg = np.mean(min_freq[freq],dtype=np.float64) \\n tuple_list.append((avg,t1))\\n \\n #print('After mean_freq result = ',result) \\n \\n for pun in punct.keys():\\n t1 = 'punct=' + str(pun)\\n avg = np.mean(punct[pun],dtype=np.float64) \\n tuple_list.append((avg,t1))\\n \\n #print('After punct result = ',result) \\n \\n \\n tuple_list.sort(key=lambda x:(-x[0]))\\n #print('2.Sorted result = ',result) \\n \\n \\n return(tuple_list) \\n \\n pass\",\n \"def _compute_traj_stats(traj_obs_dict):\\n traj_stats = { k : {} for k in traj_obs_dict }\\n for k in traj_obs_dict:\\n traj_stats[k][\\\"n\\\"] = traj_obs_dict[k].shape[0]\\n traj_stats[k][\\\"mean\\\"] = traj_obs_dict[k].mean(axis=0, keepdims=True) # [1, ...]\\n traj_stats[k][\\\"sqdiff\\\"] = ((traj_obs_dict[k] - traj_stats[k][\\\"mean\\\"]) ** 2).sum(axis=0, keepdims=True) # [1, ...]\\n return traj_stats\",\n \"def evalRun(rerankRun, qrelsDict, metricFunc, debug=False):\\n resArr = []\\n\\n for qid, scoreDict in rerankRun.items():\\n relsSortedByScores = []\\n\\n val = 0\\n\\n if qid in qrelsDict:\\n queryQrelDict = qrelsDict[qid]\\n\\n for did, score in getSorteScoresFromScoreDict(scoreDict):\\n rel_score = 0\\n if did in queryQrelDict:\\n rel_score = queryQrelDict[did]\\n\\n relsSortedByScores.append(rel_score)\\n\\n val = metricFunc(relsSortedByScores, queryQrelDict) if queryQrelDict else 0\\n\\n if debug:\\n print('%s %g' % (qid, val))\\n\\n resArr.append(val)\\n\\n res = np.mean(resArr)\\n if debug:\\n print('mean %g' % res)\\n\\n return res\",\n \"def result(self) -> Dict[int, float]:\\n return {k: v.result() for k, v in self._topk_acc_dict.items()}\",\n \"def calc_stats(results, number, concurrency):\\n\\n all_res = results.all_res\\n count = len(all_res)\\n\\n amax = np.amax(all_res)\\n amin = np.amin(all_res)\\n\\n return {\\n \\\"rps\\\": len(all_res) / float(results.total_time),\\n \\\"mean\\\": np.mean(all_res),\\n \\\"min\\\": amin,\\n \\\"max\\\": amax,\\n \\\"amp\\\": float(amax - amin),\\n \\\"median\\\": np.median(all_res),\\n \\\"stdev\\\": np.std(all_res),\\n \\\"perc_95\\\": np.percentile(all_res, 95),\\n \\\"perc_80\\\": np.percentile(all_res, 80),\\n \\\"failed\\\": number - count,\\n \\\"total_time\\\": results.total_time,\\n \\\"count\\\": count,\\n \\\"number\\\": number,\\n \\\"concurrency\\\": concurrency,\\n \\\"server\\\": results.server,\\n }\",\n \"def evaluate(out_dict, n):\\n out = dict()\\n for key, entry in out_dict.items():\\n out[key] = dict()\\n for it_count, data in entry.items():\\n total = 0.\\n count = 0\\n for x_list in data.values():\\n total += analytic_value_VaR(x_list[-1])\\n count += 1\\n out[key][it_count] = total / count\\n np.save('normal_out_all_cvar_%d.npy' % n, out)\\n print(out)\",\n \"def session_counting (self, target_dict, IEI_timeRange = (0, 900, 1), cal_IEI = True, cal_duration = True, cal_latency = True, cal_inputDistribution = True, num_bins = 10, **kwards):\\r\\n if len(self.df) == 0:\\r\\n #if empty then pass without analysis\\r\\n pass\\r\\n else:\\r\\n get_kwards = lambda x: (\\\"\\\",\\\"\\\") if x == None else x\\r\\n input1OnOff = get_kwards(kwards.get('Input1OnOff'))\\r\\n input2OnOff = get_kwards(kwards.get('Input2OnOff'))\\r\\n input3OnOff = get_kwards(kwards.get('Input3OnOff'))\\r\\n input4OnOff = get_kwards(kwards.get('Input4OnOff'))\\r\\n \\r\\n #get a start and end time point\\r\\n if 'Start' in self.df['States'].values:\\r\\n start = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Start')]['Time']\\r\\n else:\\r\\n start = pd.Series({'Start': self.df['Time'].values[0]-1})\\r\\n \\r\\n if 'Finish' in self.df['States'].values:\\r\\n end = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Finish')]['Time']\\r\\n else:\\r\\n end = pd.Series({'Finish': self.df['Time'].values[-1]+1}) #plus 1 second\\r\\n \\r\\n #get data from each event window\\r\\n event = self.df[(self.df['Time']>= start.iloc[0])&(self.df['Time']<= end.iloc[0])]\\r\\n \\r\\n result_dict = {}\\r\\n for k, v in target_dict.items():\\r\\n \\r\\n if k == 'Input1':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input1OnOff)\\r\\n elif k == 'Input2':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input2OnOff)\\r\\n elif k == 'Input3':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input3OnOff)\\r\\n elif k == 'Input4':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input4OnOff)\\r\\n else:\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject)\\r\\n \\r\\n return result_dict\",\n \"def compute_key_value(self) -> Dict[str, float]:\\n # @TODO: ddp hotfix, could be done better\\n if self._is_ddp:\\n for key in self.statistics:\\n value: List[np.ndarray] = all_gather(self.statistics[key])\\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\\n self.statistics[key] = value\\n\\n per_class, micro, macro, weighted = self.compute()\\n metrics = self._convert_metrics_to_kv(\\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\\n )\\n return metrics\",\n \"def _merge_test_results(test_results_dict, test_error_dict):\\n merged_test_results = {}\\n for testtype, testresults in test_results_dict.items():\\n for name, val in testresults.items():\\n if name == 'stats':\\n if isinstance(val, dict):\\n for n, v in val.items():\\n merged_test_results['%s_%s' % (n, testtype.upper())] = v\\n else:\\n continue\\n else:\\n merged_test_results['%s_%s' % (name, testtype.upper())] = val\\n\\n merged_test_results['error_code_test'] = test_error_dict['error_code_test']\\n\\n return merged_test_results\",\n \"def __calculate_agg_shap_scores(self):\\n self.agg_stats_timer = SimbaTimer(start=True)\\n for clf_state, clf_state_name in zip(range(2), [\\\"ABSENT\\\", \\\"PRESENT\\\"]):\\n self.results = {}\\n self.df_save_path = os.path.join(\\n self.shap_logs_path,\\n \\\"SHAP_summary_{}_{}_{}.csv\\\".format(\\n self.classifier_name, clf_state_name, self.datetime\\n ),\\n )\\n shap_clf_sliced = self.shap_df[\\n self.shap_df[self.classifier_name] == clf_state\\n ]\\n for feature_category, feature_time_bin in itertools.product(\\n self.unique_feature_category_names, self.unique_time_bin_names\\n ):\\n if feature_category not in self.results.keys():\\n self.results[feature_category] = {}\\n feature_names_sliced = list(\\n self.feature_categories_df.loc[\\n :, (feature_category, feature_time_bin)\\n ]\\n )\\n feature_names_sliced = [\\n x\\n for x in feature_names_sliced\\n if str(x) != \\\"nan\\\" and x in shap_clf_sliced\\n ]\\n self.results[feature_category][feature_time_bin] = round(\\n shap_clf_sliced[feature_names_sliced].sum(axis=1).mean() * 100, 6\\n )\\n self.__save_aggregate_scores()\\n self.agg_stats_timer.stop_timer()\\n self.visualization_timer = SimbaTimer(start=True)\\n\\n stdout_success(\\n msg=f\\\"Aggregate SHAP statistics saved in {self.shap_logs_path} directory\\\",\\n elapsed_time=self.agg_stats_timer.elapsed_time_str,\\n )\",\n \"def selectedComparisons(samples_dict):\\n sectors=\\\"peripherals\\\",\\\"intermediaries\\\",\\\"hubs\\\"\\n ks_measures={}\\n for analyses_type in samples_dict[sectors[0]]:\\n ks_measures[analyses_type]={}\\n for analysis_grouping in samples_dict[sectors[0]][analyses_type]:\\n ks_measures[analyses_type][analysis_grouping]={}\\n if samples_dict[sectors[0]][analyses_type][analysis_grouping]==dict:\\n ks_measures[analyses_type][analysis_grouping]={}\\n for analysis in samples_dict[sectors[0]][analyses_type][analysis_grouping]:\\n for var in samples_dict[sectors[0]][analyses_type][analysis_grouping][analysis]:\\n samples_peripherals=samples_dict[sectors[0]][analyses_type][analysis_grouping][analysis]\\n samples_intermediaries=samples_dict[sectors[1]][analyses_type][analysis_grouping][analysis]\\n samples_hubs=samples_dict[sectors[2]][analyses_type][analysis_grouping][analysis]\\n ks_measures[analysis][\\\"peripherals_intermediaries\\\"]=P.kolmogorovSmirnovTest(samples_peripherals,samples_intermediaries)\\n ks_measures[analysis][\\\"peripherals_hubs\\\"]=P.kolmogorovSmirnovTest(samples_peripherals,samples_hubs)\\n ks_measures[analysis][\\\"hubs_intermediaries\\\"]=P.kolmogorovSmirnovTest(samples_hubs,samples_intermediaries)\\n else:\\n for var in samples_dict[sectors[0]][analyses_type][analysis_grouping]:\\n samples_peripherals=samples_dict[sectors[0]][analyses_type][analysis_grouping]\\n samples_intermediaries=samples_dict[sectors[1]][analyses_type][analysis_grouping]\\n samples_hubs=samples_dict[sectors[2]][analyses_type][analysis_grouping]\\n\\n\\n\\n samples[sector][analyses][analysis_grouping]=updateDict(samples[sector][analyses][analysis_grouping],getSamples(authors_analysis[analyses][author][analysis_grouping]))\",\n \"def format_results(self, results_dict, data, cached_data):\\n new_results = {}\\n status = self.STATUS_MAP[results_dict['info']['exitFlag']]\\n new_results[s.STATUS] = status\\n\\n # Timing data\\n new_results[s.SOLVE_TIME] = results_dict[\\\"info\\\"][\\\"timing\\\"][\\\"tsolve\\\"]\\n new_results[s.SETUP_TIME] = results_dict[\\\"info\\\"][\\\"timing\\\"][\\\"tsetup\\\"]\\n new_results[s.NUM_ITERS] = results_dict[\\\"info\\\"][\\\"iter\\\"]\\n\\n if new_results[s.STATUS] in s.SOLUTION_PRESENT:\\n primal_val = results_dict['info']['pcost']\\n new_results[s.VALUE] = primal_val + data[s.OFFSET]\\n new_results[s.PRIMAL] = results_dict['x']\\n new_results[s.EQ_DUAL] = results_dict['y']\\n new_results[s.INEQ_DUAL] = results_dict['z']\\n\\n return new_results\",\n \"def compute_query_summary_statistics(data):\\n return {\\n nameserver: _compute_summary_stats(entries)\\n for nameserver, entries in data.items()\\n }\",\n \"def computeStats(results, independentVariable):\\n common = {}\\n\\n # Collect lists of the values\\n for v in results:\\n test = v.__dict__[independentVariable]\\n try:\\n common[test].append(v)\\n except:\\n common[test] = [v]\\n\\n result = []\\n # Sanity check for number of data items being summarized\\n # print (\\\"Computing stats on \\\" + str(len(common.values()[0])))\\n for measurements in list(common.values()):\\n resultValues = {}\\n resultValues[independentVariable] = measurements[0].__dict__[\\n independentVariable\\n ]\\n # print (\\\"Measurement[\\\\\\\"\\\"+independentVariable+\\\"\\\\\\\"] : \\\" + str(resultValues[independentVariable]))\\n fieldnames = list(measurements[0].__dict__.keys())\\n fieldnames.remove(independentVariable)\\n for stat in fieldnames:\\n values = [m.__dict__[stat] for m in measurements]\\n resultValues[stat] = mean(values)\\n resultValues[stat + \\\"_SD\\\"] = standardDeviation(values, resultValues[stat])\\n result.append(\\n measurement(list(resultValues.keys()), list(resultValues.values()))\\n )\\n # print (\\\"Result: \\\" + str(result))\\n return result\",\n \"def collect(results, **kwargs):\\n l = kwargs.get('logger')\\n l.info(\\n u'#{} Collect ADD.'.format(u'-' * 8)\\n )\\n\\n l.info(\\n u'#{} {} results from {} total items.'.format(\\n u'-' * 12, len(results), sum([x['items_processed'] for x in results])\\n )\\n )\\n \\n final_result = sum([x['result'] for x in results])\\n\\n l.info(\\n u'#{} Final result: {}.'.format(\\n u'-' * 12, final_result\\n )\\n )\\n\\n return final_result\",\n \"def summarize_results(folder, ruleset):\\n systems_folder = os.path.join(folder, 'systems')\\n results_folder = os.path.join(folder, 'results')\\n\\n rows = {}\\n for system_folder in _get_sub_folders(results_folder):\\n folder_parts = system_folder.split('/')\\n system = folder_parts[-1]\\n\\n # Load corresponding system description.\\n system_file = os.path.join(\\n systems_folder, '{}.json'.format(system))\\n if not os.path.exists(system_file):\\n print('ERROR: Missing {}'.format(system_file))\\n continue\\n try:\\n desc = _read_json_file(system_file)\\n except:\\n print('ERROR: Could not decode JSON struct in {}'.format(system_file))\\n continue\\n\\n # Construct prefix portion of the row.\\n row = ''\\n if 'submitter' not in desc:\\n print('ERROR: \\\"submitter\\\" field missing in {}'.format(system_file))\\n continue\\n row += '\\\"{}\\\",'.format(desc['submitter'])\\n if 'system_name' not in desc:\\n print('ERROR: \\\"system_name\\\" field missing in {}'.format(system_file))\\n continue\\n row += '\\\"{}\\\",'.format(_pretty_system_name(desc))\\n if 'host_processor_model_name' not in desc:\\n print('ERROR: \\\"host_processor_model_name\\\" field missing in {}'.format(system_file))\\n continue\\n row += '\\\"{}\\\",'.format(desc['host_processor_model_name'])\\n if 'host_processor_core_count' not in desc:\\n print('ERROR: \\\"host_processor_core_count\\\" field missing in {}'.format(system_file))\\n continue\\n row += '{},'.format(desc['host_processor_core_count'])\\n if 'accelerator_model_name' not in desc:\\n print('ERROR: \\\"accelerator_model_name\\\" field missing in {}'.format(system_file))\\n continue\\n row += '\\\"{}\\\",'.format(_pretty_accelerator_model_name(desc))\\n if 'accelerators_per_node' not in desc:\\n print('ERROR: \\\"accelerators_per_node\\\" field missing in {}'.format(system_file))\\n continue\\n row += '{},'.format(desc['accelerators_per_node'])\\n if 'framework' not in desc:\\n print('ERROR: \\\"framework\\\" field missing in {}'.format(system_file))\\n continue\\n row += '\\\"{}\\\",'.format(_pretty_framework(desc))\\n\\n # Collect scores for benchmarks.\\n benchmark_scores = {}\\n for benchmark_folder in _get_sub_folders(system_folder):\\n folder_parts = benchmark_folder.split('/')\\n benchmark = _benchmark_alias(folder_parts[-1])\\n\\n # Read scores from result files.\\n pattern = '{folder}/result_*.txt'.format(folder=benchmark_folder)\\n result_files = glob.glob(pattern, recursive=True)\\n scores = []\\n dropped_scores = 0\\n for result_file in result_files:\\n score = _read_mlperf_score(result_file, ruleset)\\n if score is None:\\n dropped_scores += 1\\n else:\\n scores.append(score)\\n if dropped_scores > 1:\\n print('CRITICAL ERROR: Too many non-converging runs for {} {}/{}'.\\n format(desc['submitter'], system, benchmark))\\n print('** CRITICAL ERROR ** Results in the table for {} {}/{} are NOT correct'.\\n format(desc['submitter'], system, benchmark))\\n if dropped_scores == 1:\\n print('NOTICE: Dropping non-converged run for {} {}/{} using olympic scoring.'\\n .format(desc['submitter'], system, benchmark))\\n\\n benchmark_scores[benchmark] = _compute_olympic_average(scores, dropped_scores)\\n\\n # Construct scores portion of the row.\\n if ruleset == '0.6.0':\\n allowed_benchmarks = _ALLOWED_BENCHMARKS_V06\\n elif ruleset == '0.7.0':\\n allowed_benchmarks = _ALLOWED_BENCHMARKS_V07\\n for benchmark in allowed_benchmarks:\\n if benchmark in benchmark_scores:\\n row += '{:.2f},'.format(benchmark_scores[benchmark])\\n else:\\n row += ','\\n\\n # Construct postfix portion of the row.\\n row += '{},'.format(_details_url(desc, ruleset))\\n row += '{},'.format(_code_url(desc, ruleset))\\n\\n rows[_row_key(desc)] = row\\n\\n # Print rows in order of the sorted keys.\\n for key in sorted(rows):\\n print(rows[key])\",\n \"def do_report(input):\\n for (session_id, group) in itertools.groupby(input, get_session_id):\\n group = list(group)\\n elapsed = [finfo.elapsed for finfo in group]\\n n = float(len(elapsed))\\n mean = sum(elapsed) / n\\n s = math.sqrt(\\n (1 / (n - 1)) * sum((e - mean) ** 2 for e in elapsed)\\n )\\n yield SummaryData(\\n session_id,\\n group[0].message,\\n min(elapsed),\\n max(elapsed),\\n mean,\\n s\\n )\",\n \"def compute_metrics(self, results: list) -> dict:\\n dump(results, self.out_file_path)\\n print_log(\\n f'Results has been saved to {self.out_file_path}.',\\n logger='current')\\n return {}\",\n \"def calc_overall_evaluation(count_by_type_dict: dict):\\n assert len(count_by_type_dict) > 0, \\\"count by domain class should not be empty!\\\"\\n for domain_name, domain_cnt in count_by_type_dict.items():\\n print('domain_cnt', domain_cnt)\\n for mode, res in OverallEval[domain_name].items():\\n OverallEval[domain_name][mode]['precision'] = res['precision'] / domain_cnt\\n OverallEval[domain_name][mode]['recall'] = res['recall'] / domain_cnt\\n OverallEval[domain_name][mode]['f1_score'] = res['f1_score'] / domain_cnt\\n log = \\\"Domain:{}, mode:{}, P:{:.3f}, R:{:.3f}, f1:{:.3f}\\\".format(\\n domain_name, mode, OverallEval[domain_name][mode]['precision'],\\n OverallEval[domain_name][mode]['recall'],\\n OverallEval[domain_name][mode]['f1_score'])\\n print(log)\\n #logger.info(log)\\n return OverallEval\",\n \"def compute_metrics(self, results: list) -> Dict[str, float]:\\n logger: MMLogger = MMLogger.get_current_instance()\\n\\n # pred_coords: [N, K, D]\\n pred_coords = np.concatenate(\\n [result['pred_coords'] for result in results])\\n if pred_coords.ndim == 4 and pred_coords.shape[1] == 1:\\n pred_coords = np.squeeze(pred_coords, axis=1)\\n # gt_coords: [N, K, D]\\n gt_coords = np.stack([result['gt_coords'] for result in results])\\n # mask: [N, K]\\n mask = np.concatenate([result['mask'] for result in results])\\n # action_category_indices: Dict[List[int]]\\n action_category_indices = defaultdict(list)\\n for idx, result in enumerate(results):\\n action_category = result['action'].split('_')[0]\\n action_category_indices[action_category].append(idx)\\n\\n error_name = self.mode.upper()\\n\\n logger.info(f'Evaluating {self.mode.upper()}...')\\n metrics = dict()\\n\\n metrics[error_name] = keypoint_mpjpe(pred_coords, gt_coords, mask,\\n self.ALIGNMENT[self.mode])\\n\\n for action_category, indices in action_category_indices.items():\\n metrics[f'{error_name}_{action_category}'] = keypoint_mpjpe(\\n pred_coords[indices], gt_coords[indices], mask[indices])\\n\\n return metrics\",\n \"def get_results(self):\\n d = {}\\n# r = {}\\n for analyser in self.xml_tree.getroot():\\n for child in analyser:\\n if child.tag == 'all-records':\\n for record in child:\\n attributes = record.attrib\\n sample = attributes['sampleId']\\n assay_id = attributes['assayId']\\n genotype = attributes['genotypeId']\\n quality = attributes['description'].split('.')[0]\\n if re.match(r'rs\\\\d+', assay_id):\\n if sample in d:\\n if assay_id in d[sample]:\\n for allele in list(genotype):\\n if allele not in d[sample][assay_id]['genotype']:\\n d[sample][assay_id]['genotype'] += allele\\n if quality not in d[sample][assay_id]['quality']:\\n d[sample][assay_id]['quality'].append(quality)\\n else:\\n d[sample][assay_id] = {'genotype': genotype, 'quality': [quality]}\\n else:\\n d[sample] = {assay_id: {'genotype': genotype, 'quality': [quality]}}\\n# if sample in r:\\n# if assay_id in r[sample]:\\n# for allele in list(genotype):\\n# if allele not in r[sample][assay_id]:\\n# r[sample][assay_id] += allele\\n# else:\\n# r[sample][assay_id] = genotype\\n# else:\\n# r[sample] = {assay_id: genotype}\\n# for k, v in r.items():\\n# for k1, v1, in v.items():\\n# if len(v1) == 1:\\n# v[k1] += v1\\n# pprint.pprint(r)\\n# df = pd.DataFrame.from_dict(r).transpose()\\n# print(df)\\n# df.to_excel('snpcheck.xlsx')\\n return d\",\n \"def mean(self) -> \\\"Results\\\":\\n results = Results()\\n for mode, result in self.items():\\n index = result.index\\n kwargs = {}\\n for key, value in list(result.items())[1:]:\\n if value.ndim == 1:\\n series = pd.Series(value, index=index)\\n value = series.groupby(level=0).mean()\\n else:\\n df = pd.DataFrame(value)\\n df[\\\"index\\\"] = index\\n value = df.groupby(\\\"index\\\").mean()\\n value.sort_index(inplace=True)\\n kwargs[key] = value.to_numpy()\\n kwargs[\\\"index\\\"] = value.index.to_numpy()\\n dict = ivory.core.collections.Dict()\\n results[mode] = dict(**kwargs)\\n return results\",\n \"def aggregate(self):\\n data_to_track = {}\\n for possession in self.possessions_to_track_aggregate:\\n data_to_track[possession] = self._haves[possession]\\n\\n for variable in self.variables_to_track_aggregate:\\n try:\\n data_to_track[variable] = self.__dict__[variable]\\n except KeyError:\\n pass\\n self.database_connection.put([\\\"aggregate\\\",\\n data_to_track,\\n self.group,\\n self.round])\",\n \"def _compute_global_stats():\\n global_stats = []\\n \\n wmt16_group = Group.objects.filter(name='WMT16')\\n wmt16_users = _get_active_users_for_group(wmt16_group)\\n \\n # Check how many HITs have been completed. We now consider a HIT to be\\n # completed once it has been annotated by one or more annotators.\\n #\\n # Before we required `hit.users.count() >= 3` for greater overlap.\\n hits_completed = HIT.objects.filter(mturk_only=False, completed=True).count()\\n \\n # Check any remaining active HITs which are not yet marked complete.\\n for hit in HIT.objects.filter(active=True, mturk_only=False, completed=False):\\n if hit.users.count() >= 1:\\n hits_completed = hits_completed + 1\\n hit.completed = True\\n hit.save()\\n \\n # Compute remaining HITs for all language pairs.\\n hits_remaining = HIT.compute_remaining_hits()\\n \\n # Compute number of results contributed so far.\\n ranking_results = RankingResult.objects.filter(\\n item__hit__completed=True, item__hit__mturk_only=False)\\n \\n from math import factorial\\n system_comparisons = 0\\n for result in ranking_results:\\n result.reload_dynamic_fields()\\n # TODO: this implicitly counts A=B comparisons for multi systems.\\n # Basically, inflating the number of pairwise comparisons... Fix!\\n combinations = factorial(result.systems)/(factorial(result.systems-2) * 2) if result.systems > 2 else 0\\n system_comparisons = system_comparisons + combinations\\n \\n # Aggregate information about participating groups.\\n groups = set()\\n for user in wmt16_users:\\n for group in _identify_groups_for_user(user):\\n groups.add(group)\\n \\n # Compute average/total duration over all results.\\n durations = RankingResult.objects.all().values_list('duration', flat=True)\\n total_time = sum([datetime_to_seconds(x) for x in durations])\\n avg_time = total_time / float(hits_completed or 1)\\n avg_user_time = total_time / float(3 * hits_completed or 1)\\n \\n global_stats.append(('Users', len(wmt16_users)))\\n global_stats.append(('Groups', len(groups)))\\n global_stats.append(('HITs completed', '{0:,}'.format(hits_completed)))\\n global_stats.append(('HITs remaining', '{0:,}'.format(hits_remaining)))\\n global_stats.append(('Ranking results', '{0:,}'.format(ranking_results.count())))\\n global_stats.append(('System comparisons', '{0:,}'.format(system_comparisons)))\\n global_stats.append(('Average duration (per HIT)', seconds_to_timedelta(avg_time)))\\n global_stats.append(('Average duration (per task)', seconds_to_timedelta(avg_user_time)))\\n global_stats.append(('Total duration', seconds_to_timedelta(total_time)))\\n \\n # Create new status data snapshot\\n TimedKeyValueData.update_status_if_changed('users', str(len(wmt16_users)))\\n TimedKeyValueData.update_status_if_changed('groups', str(len(groups)))\\n TimedKeyValueData.update_status_if_changed('hits_completed', str(hits_completed))\\n TimedKeyValueData.update_status_if_changed('hits_remaining', str(hits_remaining))\\n TimedKeyValueData.update_status_if_changed('ranking_results', str(ranking_results.count()))\\n TimedKeyValueData.update_status_if_changed('system_comparisons', str(system_comparisons))\\n TimedKeyValueData.update_status_if_changed('duration_per_hit', str(seconds_to_timedelta(avg_time)))\\n TimedKeyValueData.update_status_if_changed('duration_per_task', str(seconds_to_timedelta(avg_user_time)))\\n TimedKeyValueData.update_status_if_changed('duration_total', str(seconds_to_timedelta(total_time)))\\n \\n return global_stats\",\n \"def execute(self):\\r\\n factors = self.factors\\r\\n variables = list(self.variables)\\r\\n variables.remove(self.query)\\r\\n\\r\\n for fac in factors:\\r\\n self.set_observations(fac)\\r\\n\\r\\n for var in variables:\\r\\n if var not in self.obs:\\r\\n factors = self.eliminate_variable(var, factors)\\r\\n\\r\\n result = factor_module.multiply_batch(self.query, factors)\\r\\n denominator = sum(result.get_cpt())\\r\\n print(denominator)\\r\\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}\",\n \"def summarize_hits(df_hsps, option_cov=\\\"mean\\\", option_pid=\\\"mean\\\"):\\n\\n # Sort HSPs by query start position\\n df_hsps = np.sort(df_hsps, order=\\\"qstart\\\")\\n\\n # N-term delta between query and subject\\n delta_lg = np.abs(df_hsps[\\\"qstart\\\"] - df_hsps[\\\"sstart\\\"])\\n\\n # C-term delta between query and subject and add to length difference between aligned sequences\\n delta_lg += np.abs(\\n (df_hsps[\\\"qlen\\\"][0] - df_hsps[\\\"qend\\\"][-1])\\n - (df_hsps[\\\"slen\\\"][0] - df_hsps[\\\"send\\\"])\\n )\\n\\n # Internal gaps\\n query_starts = df_hsps[\\\"qstart\\\"][1:]\\n query_ends = df_hsps[\\\"qend\\\"][:-1]\\n subject_starts = df_hsps[\\\"sstart\\\"][1:]\\n subject_ends = df_hsps[\\\"send\\\"][:-1]\\n\\n delta_lg += np.sum(\\n np.abs((query_starts - query_ends) - (subject_starts - subject_ends))\\n )\\n\\n # Calculate total length, score, Identities and Positives :\\n length_total = np.sum(df_hsps[\\\"lgHSP\\\"])\\n pos_total = np.sum(df_hsps[\\\"pos\\\"])\\n # id_total = np.sum(df_hsps.id.values)\\n\\n # Cumulative length of HSPs / shortest seq. length = % coverage\\n frac_HSPshlen = calculate_coverage(\\n length_total=length_total,\\n length_query=df_hsps[\\\"qlen\\\"][0],\\n length_subject=df_hsps[\\\"slen\\\"][0],\\n option_cov=option_cov,\\n )\\n\\n # Number of positives / shortest seq. length = percentage of identity\\n pospercentsh = calculate_percid(\\n pos_total=pos_total,\\n length_query=df_hsps[\\\"qlen\\\"][0],\\n length_subject=df_hsps[\\\"slen\\\"][0],\\n length_total=length_total,\\n option_pid=option_pid,\\n )\\n\\n evalue = max(df_hsps[\\\"evalue\\\"])\\n\\n return (\\n delta_lg,\\n frac_HSPshlen,\\n pospercentsh,\\n evalue,\\n df_hsps[\\\"stitle\\\"][0].decode(\\\"utf-8\\\"),\\n )\",\n \"def dataExtract(queryResults):\\n days = ['MondayCollect',\\n 'TuesdayCollect',\\n 'WednesdayCollect',\\n 'ThursdayCollect',\\n 'FridayCollect',\\n 'SaturdayCollect',\\n 'SundayCollect']\\n\\n #counting the instances of bin collections\\n parkCount = 0\\n roadingCount = 0\\n otherCount = 0\\n\\n #output totals of bin collections\\n parkOutput = []\\n roadingOutput = []\\n otherOutput = []\\n \\n #iterate over each day\\n for day in days:\\n \\n #iterate over the number of bins\\n for i in range(len(queryResults)):\\n \\n #check if the bin was collected on the day...\\n if str(queryResults[i]['attributes'][day]).strip().lower() == 'yes':\\n \\n #unknown formatting issue with the data, these lines fix it\\n strResult = str(queryResults[i]['attributes']['Owner'])\\n strResultForm = strResult.lower().strip()\\n \\n #update the counts if True\\n if strResultForm == 'roading':\\n roadingCount += 1\\n elif strResultForm == 'parks':\\n parkCount += 1\\n elif strResultForm == 'private':\\n otherCount += 1\\n else:\\n otherCount +=1\\n\\n #print \\\"Day: {} \\\\nparkCount: {} \\\\nroadingCount: {} \\\\notherCount: {} \\\\n\\\\n\\\".format(day,parkCount,roadingCount,otherCount)\\n \\n parkOutput.append(parkCount)\\n roadingOutput.append(roadingCount)\\n otherOutput.append(otherCount)\\n \\n parkCount = 0\\n roadingCount =0\\n otherCount =0\\n \\n return parkOutput,roadingOutput,otherOutput\",\n \"def transformResults(threadCounts, values, function):\\n res = {}\\n for bm in list(values.keys()):\\n res[bm] = []\\n for (nThreads, v) in zip(threadCounts, values[bm]):\\n res[bm].append(None if v == None else function(v, nThreads))\\n return res\",\n \"def rankResults(self, results:set, queryVec: dict):\\n rankedResults = {}\\n for result in results:\\n cosineSim = 0.0\\n for word in queryVec.keys():\\n if result in self.invertedIndex[word]:\\n cosineSim += queryVec[word]*self.invertedIndex[word][result]\\n cosineSim += self.boostScore(result, queryVec.keys())\\n rankedResults[result] = cosineSim\\n\\n return rankedResults\",\n \"def mean_accuracy_per_setting(results):\\n dict_ans = defaultdict(lambda: 0)\\n dict_count = defaultdict(lambda: 0)\\n for setting in results:\\n if setting['punct'] == True:\\n dict_ans['punct=True'] = dict_ans['punct=True'] + setting['accuracy']\\n dict_count['punct=True'] = dict_count['punct=True'] + 1\\n else:\\n dict_ans['punct=False'] = dict_ans['punct=False'] + setting['accuracy']\\n dict_count['punct=False'] = dict_count['punct=False'] + 1\\n dict_ans['min_freq=' + str(setting['min_freq'])] = dict_ans['min_freq=' + str(setting['min_freq'])] + setting['accuracy']\\n dict_count['min_freq=' + str(setting['min_freq'])] =dict_count['min_freq=' + str(setting['min_freq'])] + 1\\n finalFeatureName = 'feature='\\n for featureName in setting['features']:\\n finalFeatureName = finalFeatureName + str(featureName).split()[1] + ' '\\n dict_ans[finalFeatureName] = dict_ans[finalFeatureName] + setting['accuracy']\\n dict_count[finalFeatureName] = dict_count[finalFeatureName] + 1\\n listOfAaccurracy = [(v, k) for k, v in dict_ans.items()]\\n meanAccuracyList = []\\n for item in listOfAaccurracy:\\n meanAccuracy = item[0] / dict_count[item[1]]\\n meanAccuracyList.append((meanAccuracy, item[1]))\\n return sorted(meanAccuracyList, key =lambda tup: -tup[0])\",\n \"def count_results(self):\\n for record in self._traced_records:\\n if self._statistical_results.get(record.name) == None:\\n self._statistical_results[record.name] = StatisticalResult(\\n record.name)\\n self._statistical_results[record.name].insert_record(\\n record.kernel_time)\\n self._total_time_ms += record.kernel_time\\n self._statistical_results = {\\n k: v\\n for k, v in sorted(self._statistical_results.items(),\\n key=lambda item: item[1],\\n reverse=True)\\n }\",\n \"def compute_metrics(self, results: Sequence[Dict]) -> Dict:\\n\\n preds = []\\n gts = []\\n for result in results:\\n preds.append(result['pred_labels'])\\n gts.append(result['gt_labels'])\\n preds = torch.cat(preds)\\n gts = torch.cat(gts)\\n\\n assert preds.max() < self.num_classes\\n assert gts.max() < self.num_classes\\n\\n cared_labels = preds.new_tensor(self.cared_labels, dtype=torch.long)\\n\\n hits = (preds == gts)[None, :]\\n preds_per_label = cared_labels[:, None] == preds[None, :]\\n gts_per_label = cared_labels[:, None] == gts[None, :]\\n\\n tp = (hits * preds_per_label).float()\\n fp = (~hits * preds_per_label).float()\\n fn = (~hits * gts_per_label).float()\\n\\n result = {}\\n if 'macro' in self.mode:\\n result['macro_f1'] = self._compute_f1(\\n tp.sum(-1), fp.sum(-1), fn.sum(-1))\\n if 'micro' in self.mode:\\n result['micro_f1'] = self._compute_f1(tp.sum(), fp.sum(), fn.sum())\\n\\n return result\",\n \"def prcp():\\n \\\"\\\"\\\"Return the JSON representation of your dictionary.\\\"\\\"\\\"\\n session = Session(engine)\\n results_prcp = session.query(Measurement.date, Measurement.prcp).all()\\n session.close()\\n\\n prcp_scores = []\\n for p in prcp_query:\\n my_dict = {}\\n my_dict[prcp_query[0]] = prcp_query[1]\\n prcp_scores.append(my_dict)\\n\\n return jsonify(prcp_scores)\",\n \"def display_results(self, metrics):\\n\\n for k, v in self.cv_results_.items():\\n# sorted_results = sort_results(v)\\n print(f'Results for {k} metric:')\\n print()\\n print(v.sort_values(by=['Metric mean'], ascending=False))\\n print()\",\n \"def calc_stats(results):\\r\\n all_res = []\\r\\n count = 0\\r\\n for values in results.status_code_counter.values():\\r\\n all_res += values\\r\\n count += len(values)\\r\\n\\r\\n cum_time = sum(all_res)\\r\\n\\r\\n if cum_time == 0 or len(all_res) == 0:\\r\\n rps = avg = min_ = max_ = amp = 0\\r\\n else:\\r\\n if results.total_time == 0:\\r\\n rps = 0\\r\\n else:\\r\\n rps = len(all_res) / float(results.total_time)\\r\\n avg = sum(all_res) / len(all_res)\\r\\n max_ = max(all_res)\\r\\n min_ = min(all_res)\\r\\n amp = max(all_res) - min(all_res)\\r\\n stdev = math.sqrt(sum((x-avg)**2 for x in all_res) / count)\\r\\n\\r\\n return (\\r\\n RunStats(count, results.total_time, rps, avg, min_, max_, amp, stdev)\\r\\n )\",\n \"def calculate_overall_results(pContestGroup, pContestsRequired, pYear):\\n # Find out how many contests each band has done\\n lCursor = connection.cursor()\\n lCursor.execute(\\\"SELECT r.band_id, count(*) FROM contests_contestresult r, contests_contestevent e, contests_contest c WHERE r.contest_event_id = e.id AND e.contest_id = c.id AND c.group_id = %(groupid)s AND r.results_position < 9996 AND extract(year from e.date_of_event) = %(year)s AND c.exclude_from_group_results = false GROUP BY r.band_id\\\", {'groupid': pContestGroup.id, 'year' : pYear})\\n lRows = lCursor.fetchall()\\n lResults = {}\\n for row in lRows:\\n lBandId = row[0]\\n lResultCount = int(row[1])\\n if lResultCount >= pContestsRequired:\\n lResults[str(lBandId)] = lResultCount\\n lCursor.close()\\n \\n lBandIds = \\\",\\\".join(lResults.keys())\\n \\n if len(lBandIds) == 0:\\n return []\\n\\n lCursor = connection.cursor()\\n lCursor.execute(\\\"SELECT r.results_position, b.slug, r.band_name FROM bands_band b, contests_contestresult r, contests_contestevent e, contests_contest c WHERE b.id = r.band_id AND r.contest_event_id = e.id AND e.contest_id = c.id AND c.group_id = %s AND r.results_position < 9999 AND r.band_id IN (%s) AND extract(year from e.date_of_event) = %s AND c.exclude_from_group_results = false\\\" % (pContestGroup.id, lBandIds, pYear))\\n lRows = lCursor.fetchall()\\n lBands = {}\\n lBandResults = {}\\n for row in lRows:\\n lPosition = row[0]\\n if int(lPosition) == 0 or int(lPosition) > 9900:\\n continue\\n lBandSlug = row[1]\\n lBandName = row[2]\\n \\n lBands[lBandSlug] = lBandName\\n try:\\n lExistingResults = lBandResults[lBandSlug]\\n lExistingResults.append(lPosition)\\n except KeyError:\\n lExistingResults = []\\n lExistingResults.append(lPosition)\\n lBandResults[lBandSlug] = lExistingResults\\n \\n # Get total points for each band\\n lBandTotals = {}\\n lBandTotalsWithTieBreak = {}\\n lBandSeventhResult = {}\\n lFirstSixBandResults = {}\\n for band_slug in lBandResults.keys():\\n lFirstSixBandResults[band_slug] = sorted(lBandResults[band_slug])[:pContestsRequired]\\n try:\\n lBandSeventhResult[band_slug] = sorted(lBandResults[band_slug])[pContestsRequired]\\n except IndexError:\\n # band didn't compete in a seventh contest, so the results is worse than if they did\\n lBandSeventhResult[band_slug] = 9999 \\n lTotalPoints = sum(lFirstSixBandResults[band_slug])\\n lTotalPointsPlusTieBreak = lTotalPoints + (1 - (1.0 / lBandSeventhResult[band_slug]))\\n lBandTotals[band_slug] = lTotalPoints\\n lBandTotalsWithTieBreak[band_slug] = lTotalPointsPlusTieBreak \\n \\n lDecoratedList = [(points, slug) for slug, points in lBandTotalsWithTieBreak.items()]\\n lDecoratedList.sort()\\n lSortedResults = [{'slug':slug, 'points':points} for points, slug in lDecoratedList]\\n lPosition = 1\\n for row in lSortedResults:\\n row['band'] = lBands[row['slug']] \\n row['position'] = lPosition\\n row['display_points'] = lBandTotals[row['slug']]\\n row['tiebreak'] = lBandSeventhResult[row['slug']]\\n lPosition += 1\\n\\n return lSortedResults\",\n \"def _summarize_results(df, metrics):\\n def return_cm(x):\\n if isinstance(x, int):\\n return (0, 0, 0)\\n\\n elif len(x) > 3:\\n return x[1:]\\n\\n return x\\n\\n def get_status(x):\\n return {\\n \\\"OK\\\": 0,\\n \\\"ERROR\\\": 1\\n }[x]\\n\\n df['status'] = df['status'].apply(get_status)\\n df['confusion_matrix'] = df['confusion_matrix'].apply(ast.literal_eval)\\n df['confusion_matrix'] = df['confusion_matrix'].apply(return_cm)\\n df[['fp', 'fn', 'tp']] = pd.DataFrame(df['confusion_matrix'].tolist(), index=df.index)\\n\\n # calculate f1 score\\n df_ = df.groupby(['dataset', 'pipeline'])[['fp', 'fn', 'tp']].sum().reset_index()\\n\\n precision = df_['tp'] / (df_['tp'] + df_['fp'])\\n recall = df_['tp'] / (df_['tp'] + df_['fn'])\\n df_['f1'] = 2 * (precision * recall) / (precision + recall)\\n\\n result = dict()\\n\\n # number of wins over ARIMA\\n arima_pipeline = 'arima'\\n intermediate = df_.set_index(['pipeline', 'dataset'])['f1'].unstack().T\\n arima = intermediate.pop(arima_pipeline)\\n\\n result['# Wins'] = (intermediate.T > arima).sum(axis=1)\\n result['# Wins'][arima_pipeline] = None\\n\\n # number of anomalies detected\\n result['# Anomalies'] = df_.groupby('pipeline')[['tp', 'fp']].sum().sum(axis=1).to_dict()\\n\\n # average f1 score\\n result['Average F1 Score'] = df_.groupby('pipeline')['f1'].mean().to_dict()\\n\\n # failure rate\\n result['Failure Rate'] = df.groupby(\\n ['dataset', 'pipeline'])['status'].mean().unstack('pipeline').T.mean(axis=1)\\n\\n result = pd.DataFrame(result)\\n result.index.name = 'pipeline'\\n result.reset_index(inplace=True)\\n\\n rank = 'Average F1 Score'\\n result = _sort_leaderboard(result, rank, metrics)\\n result = result.drop('rank', axis=1).set_index('pipeline')\\n\\n return result\",\n \"def get_aggregated_values(self):\\n if not self._initialized:\\n raise Exception(\\\"To readout you must first initialize, then\\\"\\n \\\"process batches!\\\")\\n else:\\n ret_vals = [q.readout() for q in self.quantities]\\n return dict(zip(self.quantity_names, ret_vals))\",\n \"def extract_results_test(self):\\n assert len(self.results.keys()) != 0\\n TESTS = [\\n {\\n \\\"input\\\": {\\\"molecules\\\": [\\\"DDSPDLPK\\\"], \\\"score_threshold\\\": 0.95},\\n \\\"output\\\": {\\n \\\"formula\\\": \\\"C(37)H(59)N(9)O(16)\\\",\\n \\\"file_name\\\": \\\"BSA1.mzML\\\",\\n \\\"scaling_factor\\\": 100,\\n \\\"spec_id\\\": 1337,\\n },\\n }\\n ]\\n for test_dict in TESTS:\\n for key, n, entry in self.results.extract_results(**test_dict[\\\"input\\\"]):\\n print(key, entry)\\n assert key.formula == test_dict[\\\"output\\\"][\\\"formula\\\"]\\n assert key.file_name == test_dict[\\\"output\\\"][\\\"file_name\\\"]\\n assert entry.scaling_factor == test_dict[\\\"output\\\"][\\\"scaling_factor\\\"]\\n assert entry.spec_id == test_dict[\\\"output\\\"][\\\"spec_id\\\"]\\n # print(self.results)\\n # print(self.results.lookup)\\n assert n == 0\",\n \"def conlleval_overall_results(documents):\\n counts = conlleval_evaluate(documents)\\n overall, by_type = metrics(counts)\\n return overall\",\n \"def get_qps_as_dict(folder):\\n df = process_oldisim_results(folder)\\n return df.groupby(\\\"machine_type\\\").mean().QPS.to_dict()\",\n \"def generate_metrics_data(metricsquery: List, resultsquery: Dict, deltaminutes: int = 5, Region_name: str = None) -> Dict:\\r\\n cloudwatch=client('cloudwatch', region_name=Region_name) \\r\\n paginator = cloudwatch.get_paginator('get_metric_data')\\r\\n metricsgroup=grouper(metricsquery)\\r\\n resultsquery['ApiCalls']=0 \\r\\n for mqs in metricsgroup:\\r\\n for response in paginator.paginate(MetricDataQueries=mqs, StartTime=datetime.now()-timedelta(minutes=deltaminutes),EndTime=datetime.now()):\\r\\n for results in response['MetricDataResults']:\\r\\n resultsquery[results['Id']].append({'results':results})\\r\\n resultsquery['ApiCalls']+=1\\r\\n return resultsquery\",\n \"def calculate_score(label_dict, queries, results):\\n\\n total_score = 0.0\\n\\n log_header('Individual image scores')\\n\\n # Calculate score for all images\\n for image_id in queries:\\n if image_id in results.keys():\\n # Run the score function\\n image_score = score(\\n label_dict=label_dict, target=image_id, selection=results[image_id]\\n )\\n else:\\n logging.error('No result generated for %s' % image_id)\\n\\n image_score = 0.0\\n\\n total_score += image_score\\n\\n logging.info('%s: %8.6f' % (image_id, image_score))\\n\\n log_header('Average score over %d images: %10.8f' % (\\n len(queries), total_score / len(queries)\\n ))\\n\\n return total_score\",\n \"def _rouge_score_compute(sentence_results: Dict[str, List[Tensor]]) ->Dict[str, Tensor]:\\n results: Dict[str, Tensor] = {}\\n if sentence_results == {}:\\n return results\\n for rouge_key, scores in sentence_results.items():\\n results[rouge_key] = torch.tensor(scores).mean()\\n return results\",\n \"def aggregate_results(scores, stds):\\n\\n scores = pd.DataFrame(scores.values(),\\n index=scores.keys(),\\n columns=[\\\"SCORE MEAN\\\", ])\\n stds = pd.DataFrame(stds.values(),\\n index=stds.keys(),\\n columns=[\\\"SCORE STD\\\", ])\\n scores.index.name = param_names\\n stds.index.name = param_names\\n data = []\\n for param_gropby_levels in ((0,), (1,), (2,), (3, 4), (5,)):\\n aggregate_scores = scores.groupby(level=param_gropby_levels).mean()\\n aggregate_stds = scores.groupby(level=param_gropby_levels).std()\\n data.append((aggregate_scores, aggregate_stds))\\n return data\",\n \"def compileQcewStats(lid):\\n\\n\\tregion = re.match('(^[a-zA-Z]+)', basename(lid)).group(1)\\n\\tlid_rows = selectQcewNearLid(lid, region)\\n\\n\\tlists = defaultdict(list)\\n\\tcounts = defaultdict(float)\\n\\tprf_keys = ('NAME', 'NAICS')\\n\\tagg_keys = ('NAME', 'AVGEMP', 'TOTPAY', 'MEEI')\\n\\t\\n\\tfor lr in lid_rows:\\n\\t\\t# non-profit\\n\\t\\tif re.match('82.*|813.*', lr['NAICS']):\\n\\t\\t\\tcounts['np_emp'] += lr['AVGEMP']\\n\\t\\t\\tcounts['np_pay'] += lr['TOTPAY']\\n\\n\\t\\t\\tnp_row = OrderedDict((k, lr[k]) for k in prf_keys)\\n\\t\\t\\tlists['np'].append(np_row)\\n\\n\\t\\t\\t# reporting is for multiple locations (aggregated)\\n\\t\\t\\tif re.match('.*2.*|.*4.*', lr['MEEI']):\\n\\t\\t\\t\\tagg_row = OrderedDict((k, lr[k]) for k in agg_keys)\\n\\t\\t\\t\\tlists['agg'].append(agg_row)\\n\\t\\t# for-profit\\n\\t\\telse:\\n\\t\\t\\tcounts['fp_emp'] += lr['AVGEMP']\\n\\t\\t\\tcounts['fp_pay'] += lr['TOTPAY']\\n\\t\\t\\tcounts['fp_bus'] += 1\\n\\n\\t\\t\\tp_row = OrderedDict((k, lr[k]) for k in prf_keys)\\n\\t\\t\\tlists['fp'].append(p_row)\\n\\n\\t\\t\\t# reporting is for multiple locations (aggregated)\\n\\t\\t\\tif re.match('.*2.*|.*4.*', lr['MEEI']):\\n\\t\\t\\t\\tcounts['agg_fp_emp'] += lr['AVGEMP']\\n\\t\\t\\t\\tcounts['agg_fp_pay'] += lr['TOTPAY']\\n\\t\\t\\t\\tcounts['agg_fp_bus'] += 1\\n\\n\\t\\t\\t\\tagg_row = OrderedDict((k, lr[k]) for k in agg_keys)\\n\\t\\t\\t\\tlists['agg'].append(agg_row)\\n\\t\\t\\t# reporting address used is not physical address\\n\\t\\t\\tif lr['ATYPE'] != 'P':\\n\\t\\t\\t\\tcounts['nph_fp_emp'] += lr['AVGEMP']\\n\\t\\t\\t\\tcounts['nph_fp_pay'] += lr['TOTPAY']\\n\\t\\t\\t\\tcounts['nph_fp_bus'] += 1\\n\\n\\t\\tcounts['emp'] += lr['AVGEMP']\\n\\t\\tcounts['pay'] += lr['TOTPAY']\\n\\n\\t# write the lists to csv\\n\\tcsv_template = '{0}_{1}_employers_{2}.csv'\\n\\tfor grp, l in lists.iteritems():\\n\\t\\tcsv_name = csv_template.format(region, grp, yr)\\n\\t\\tcsv_path = join(csv_dir, csv_name)\\n\\n\\t\\twith open(csv_path, 'wb') as csv_file:\\n\\t\\t\\tfields = [k for k in l[0]]\\n\\t\\t\\twriter = csv.DictWriter(csv_file, fields)\\n\\t\\t\\twriter.writeheader()\\n\\n\\t\\t\\t# sort list (in some cases by multiple fields)\\n\\t\\t\\trsort = {('NAICS', 'NAME'): ['fp', 'np'], ('NAME',): ['agg']}\\n\\t\\t\\tsort = {i:k for k,v in rsort.iteritems() for i in v}\\n\\t\\t\\tfor row in sorted(l, key=lambda d: [d[k] for k in sort[grp]]):\\n\\t\\t\\t\\twriter.writerow(row)\\n\\n\\t# prep 'opverview' and 'for-profit' stats for writing\\n\\tstats = {}\\n\\tov_keys = ('fp_emp', 'np_emp', 'emp', 'fp_pay', 'np_pay', 'pay')\\n\\toverview = {k: int(counts[k]) for k in ov_keys}\\n\\tstats['overview'] = {'stats': overview, 'keys': ov_keys}\\n\\n\\tp_emp = counts['fp_emp']\\n\\tp_pay = counts['fp_pay']\\n\\tp_bus = counts['fp_bus']\\n\\tfor_profit = OrderedDict([\\n\\t\\t('for-prof emps', p_emp),\\n\\t\\t('agg for-prof emp pct', \\n\\t\\t\\tround(counts['agg_fp_emp'] / p_emp, 4)),\\n\\t\\t('non-phys addr for-prof emp pct', \\n\\t\\t\\tround(counts['nph_fp_emp'] / p_emp, 4)),\\n\\t\\t\\n\\t\\t('prof pay', p_pay),\\n\\t\\t('agg for-prof pay pct', \\n\\t\\t\\tround(counts['agg_fp_pay'] / p_pay, 4)),\\n\\t\\t('non-phys addr for-prof pay pct', \\n\\t\\t\\tround(counts['nph_fp_pay'] / p_pay, 4)),\\n\\t\\t\\n\\t\\t('agg for-prof bus pct', \\n\\t\\t\\tround(counts['agg_fp_bus'] / p_bus, 4)), \\n\\t\\t('non-phys addr for-prof bus pct', \\n\\t\\t\\tround(counts['nph_fp_bus'] / p_bus, 4))])\\n\\tfp_keys = [k for k in for_profit]\\n\\tstats['for_profit'] = {'stats': for_profit, 'keys': fp_keys}\\n\\n\\t# write stats to csv\\n\\tfor grp, d in stats.iteritems():\\n\\t\\tcsv_name = '{0}_{1}_stats_{2}.csv'.format(region, grp, yr)\\n\\t\\tcsv_path = join(csv_dir, csv_name)\\n\\t\\twith open(csv_path, 'wb') as csv_file:\\n\\t\\t\\twriter = csv.DictWriter(csv_file, d['keys'])\\n\\t\\t\\twriter.writeheader()\\n\\t\\t\\twriter.writerow(d['stats'])\",\n \"def output_result(self):\\n output = {}\\n output['draw'] = str(int(self.params['draw']))\\n output['recordsTotal'] = str(self.cardinality)\\n output['recordsFiltered'] = str(self.cardinality_filtered)\\n if self.error:\\n output['error'] = self.error\\n return output\\n\\n output['data'] = self.results\\n for k, v in self.yadcf_params:\\n output[k] = v\\n return output\",\n \"def summary(data, key=itemgetter(0), value=itemgetter(1)):\\n\\n for k, group in groupby(data, key):\\n yield (k, sum(value(row) for row in group))\",\n \"def profile_group(func, args, kwargs, func_result):\\n (collection, key, condition, initial, reduce) = args[:5]\\n report_kvs = _profile_query(collection)\\n\\n if key:\\n report_kvs['Group_Key'] = _to_json(key)\\n\\n if condition:\\n report_kvs['Group_Condition'] = _to_json(condition)\\n\\n if initial:\\n report_kvs['Group_Initial'] = _to_json(initial)\\n\\n if reduce:\\n report_kvs['Group_Reduce'] = reduce\\n\\n return report_kvs\",\n \"def print_metrics(result):\\n logging.log(LOG_LEVEL_OUTPUT_INFO,\\n '------------------------------------------------')\\n logging.log(LOG_LEVEL_OUTPUT_INFO, ' KEY METRICS: ')\\n logging.log(LOG_LEVEL_OUTPUT_INFO,\\n '------------------------------------------------')\\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* pages_count: %d',\\n get_counter_metric(result, 'pages_count'))\\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* revisions_count: %d',\\n get_counter_metric(result, 'revisions_count'))\\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* very_long_page_histories_count: %d',\\n get_counter_metric(result, 'very_long_page_histories_count'))\\n revisions_per_page_distr = get_distributions_metric(\\n result, 'revisions_per_page_distr')\\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* revisions_per_page_distr.mean: %d',\\n revisions_per_page_distr.mean)\\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* revisions_per_page_distr.sum: %d',\\n revisions_per_page_distr.sum)\\n cumulative_page_rev_size_distr = get_distributions_metric(\\n result, 'cumulative_page_rev_size_distr')\\n logging.log(LOG_LEVEL_OUTPUT_INFO,\\n '* cumulative_page_rev_size_distr.mean: %d',\\n cumulative_page_rev_size_distr.mean)\\n logging.log(LOG_LEVEL_OUTPUT_INFO, '* cumulative_page_rev_size_distr.sum: %d',\\n cumulative_page_rev_size_distr.sum)\",\n \"def class_stats_sums(self, job_classes):\\n\\n # --------------------------- initialisation ---------------------------\\n\\n # init class stats sum structure\\n per_class_stats_sums = {}\\n\\n # add a key that contains metric rates from all the classes\\n _all_class_stats_dict = {stat_metric: {field: 0.0 for field in kresults_stats_info[stat_metric][\\\"to_sum\\\"]}\\n for stat_metric in kresults_stats_info.keys()}\\n # ----------------------------------------------------------------------\\n\\n # calculate all the stats for each job class (per_class_stats is a list of lists - one list per job..)\\n per_class_stats = self.class_stats(job_classes)\\n\\n # loop over statistics per class\\n for class_name, stats_list in per_class_stats.items():\\n\\n # initialize all the requested sums..\\n _class_stats_dict = {stat_metric: {field: 0.0 for field in kresults_stats_info[stat_metric][\\\"to_sum\\\"]}\\n for stat_metric in kresults_stats_info.keys()}\\n\\n # loop over stats (per job) and make the sums\\n for job_stats in stats_list:\\n for stat_entry in job_stats:\\n for stat_metric in stat_entry.keys():\\n if stat_metric not in kresults_stats_info:\\n print(f\\\"Warning: skipping unknown metric {stat_metric!r}\\\")\\n continue\\n\\n for field in kresults_stats_info[stat_metric][\\\"to_sum\\\"]:\\n\\n if field in kresults_stats_info[stat_metric].get(\\\"per_process\\\", []):\\n n_procs = len(job_stats)\\n val = float(stat_entry[stat_metric][field])/float(n_procs)\\n else:\\n val = float(stat_entry[stat_metric][field])\\n\\n # add the summable metrics to class stats\\n _class_stats_dict[stat_metric][field] += val\\n\\n # add the summable metrics to all-class stats\\n _all_class_stats_dict[stat_metric][field] += val\\n\\n # Filter the fields for which aggregated time is still 0 (no operations have been summed up)\\n for stat_metric in list(_class_stats_dict.keys()):\\n if _class_stats_dict[stat_metric][\\\"elapsed\\\"] == 0.0:\\n _class_stats_dict.pop(stat_metric)\\n\\n # also calculate the rates (according to the fields defined in kresults_stats_info)\\n for stat_metric in _class_stats_dict.keys():\\n\\n # numerator and denominator for rate calculation\\n num, den = kresults_stats_info[stat_metric][\\\"def_rate\\\"]\\n\\n # conversion factor\\n fc = kresults_stats_info[stat_metric][\\\"conv\\\"]\\n\\n # get the rate\\n rate = fc * _class_stats_dict[stat_metric][num] / _class_stats_dict[stat_metric][den]\\n\\n _class_stats_dict[stat_metric][\\\"rate\\\"] = rate\\n\\n # collect and store per-class stats\\n per_class_stats_sums[class_name] = _class_stats_dict\\n\\n # ------- clean-up the all-class data -------\\n # Filter the fields for which aggregated time is still 0 (no operations have been summed up)\\n for stat_metric in list(_all_class_stats_dict.keys()):\\n if _all_class_stats_dict[stat_metric][\\\"elapsed\\\"] == 0.0:\\n _all_class_stats_dict.pop(stat_metric)\\n\\n # also calculate the rates (according to the fields defined in kresults_stats_info)\\n for stat_metric in _all_class_stats_dict.keys():\\n\\n # numerator and denominator for rate calculation\\n num, den = kresults_stats_info[stat_metric][\\\"def_rate\\\"]\\n\\n # conversion factor\\n fc = kresults_stats_info[stat_metric][\\\"conv\\\"]\\n\\n # get the rate\\n rate = fc * _all_class_stats_dict[stat_metric][num] / _all_class_stats_dict[stat_metric][den]\\n\\n _all_class_stats_dict[stat_metric][\\\"rate\\\"] = rate\\n\\n # collect and store the all-class stats\\n per_class_stats_sums[\\\"all_classes\\\"] = _all_class_stats_dict\\n\\n return per_class_stats_sums\",\n \"def home():\\n\\n connection = pypyodbc.connect(connectionString)\\n \\n cursor = connection.cursor()\\n\\n cachedResults['avgAgePerState'] = runQuery(cursor, avgAgePerStateCommand)\\n cachedResults['avgAgePerTown'] = runQuery(cursor, avgAgePerTownCommand)\\n cachedResults['avgAgePerProvince'] = runQuery(cursor, avgAgePerProvinceCommand)\\n cachedResults['avgAgePerFacilityName'] = runQuery(cursor, avgAgePerFacilityNameCommand)\\n cachedResults['avgAgePerFacilityType'] = runQuery(cursor, avgAgePerFacilityTypeCommand)\\n\\n cachedResults['eidTestResultTotal'] = runQuery(cursor, eidTestResultTotalCommand)\\n cachedResults['eidTestResultAIDSTFacilityType'] = runQuery(cursor, eidTestResultAIDSTFacilityTypeCommand)\\n cachedResults['eidTestResultAMIFacilityType'] = runQuery(cursor, eidTestResultAMIFacilityTypeCommand)\\n cachedResults['eidTestResultDisHFacilityType'] = runQuery(cursor, eidTestResultDisHFacilityTypeCommand)\\n cachedResults['eidTestResultGenHFacilityType'] = runQuery(cursor, eidTestResultGenHFacilityTypeCommand)\\n cachedResults['eidTestResultMSFHFacilityType'] = runQuery(cursor, eidTestResultMSFHFacilityTypeCommand)\\n cachedResults['eidTestResultNHLFacilityType'] = runQuery(cursor, eidTestResultNHLFacilityTypeCommand)\\n cachedResults['eidTestResultSpHFacilityType'] = runQuery(cursor, eidTestResultSpHFacilityTypeCommand)\\n cachedResults['eidTestResultSRHFacilityType'] = runQuery(cursor, eidTestResultSRHFacilityTypeCommand)\\n cachedResults['eidTestResultTHFacilityType'] = runQuery(cursor, eidTestResultTHFacilityTypeCommand)\\n\\n cachedResults['avgTatTotal'] = runQuery(cursor, avgTatTotalCommand)\\n cachedResults['avgTatAIDSTFacilityType'] = runQuery(cursor, avgTatAIDSTFacilityTypeCommand)\\n cachedResults['avgTatAMIFacilityType'] = runQuery(cursor, avgTatAMIFacilityTypeCommand)\\n cachedResults['avgTatDisHFacilityType'] = runQuery(cursor, avgTatDisHFacilityTypeCommand)\\n cachedResults['avgTatGenHFacilityType'] = runQuery(cursor, avgTatGenHFacilityTypeCommand)\\n cachedResults['avgTatMSFHFacilityType'] = runQuery(cursor, avgTatMSFHFacilityTypeCommand)\\n cachedResults['avgTatNHLFacilityType'] = runQuery(cursor, avgTatNHLFacilityTypeCommand)\\n cachedResults['avgTatSpHFacilityType'] = runQuery(cursor, avgTatSpHFacilityTypeCommand)\\n cachedResults['avgTatSRHFacilityType'] = runQuery(cursor, avgTatSRHFacilityTypeCommand)\\n cachedResults['avgTatTHFacilityType'] = runQuery(cursor, avgTatTHFacilityTypeCommand)\\n\\n cachedResults['trackSample'] = runQuery(cursor, trackSampleCommand)\\n\\n cachedResults['avgAgeNHL'] = runQuery(cursor, avgAgeNHLCommand)\\n cachedResults['avgAgePHL'] = runQuery(cursor, avgAgePHLCommand)\\n cachedResults['avgAgeUNION'] = runQuery(cursor, avgAgeUNIONCommand)\\n\\n cachedResults['eidTestResultNHLLab'] = runQuery(cursor, eidTestResultNHLLabCommand)\\n cachedResults['eidTestResultPHLLab'] = runQuery(cursor, eidTestResultPHLLabCommand)\\n cachedResults['eidTestResultUNIONLab'] = runQuery(cursor, eidTestResultUNIONLabCommand)\\n\\n cachedResults['avgTatNHLLab'] = runQuery(cursor, avgTatNHLLabCommand)\\n cachedResults['avgTatPHLLab'] = runQuery(cursor, avgTatPHLLabCommand)\\n cachedResults['avgTatUNIONLab'] = runQuery(cursor, avgTatUNIONLabCommand)\\n\\n connection.close()\\n\\n return render_template('index.html')\",\n \"def qasmCircuitResults(self):\\n returnedDictionary={}\\n self.circutDrawing = self.draw()\\n self.blochSpheres=self.separatedBlochSpheres()\\n returnedDictionary[\\\"wires\\\"]=self.num_qubits\\n returnedDictionary[\\\"probabilities\\\"] = self.separatedProbabilities()\\n #returnedDictionary[\\\"blochSpheres\\\"] = self.separatedBlochSpheres()\\n returnedDictionary[\\\"diracNotation\\\"] = self.diracNotation()\\n returnedDictionary['chart'] = self.graph()\\n returnedDictionary[\\\"link\\\"] = \\\"\\\"\\n #returnedDictionary[\\\"qasmRows\\\"] = np.transpose(cols).tolist()\\n \\n if self.API_TOKEN != \\\"\\\":\\n returnedDictionary[\\\"link\\\"] = self.runOnIBMQ()\\n \\n return returnedDictionary\",\n \"def set_results(self, results, unique_keys):\\n self._results = results\\n self._compute_logic()\\n\\n for _, query in enumerate(self._results):\\n\\n flat = query.flatten_results(unique_keys)\\n filename = 'flattened_{0}.csv'.format('_'.join(sorted(query.in_sets)))\\n flat.to_csv(\\n os.path.join(\\n Configuration().csv.output_directory,\\n '{0}'.format(filename)\\n ),\\n sep='\\\\t'\\n )\",\n \"def calc_metrics(data, sampled_data_list, dataset_type):\\n result={}\\n for sampled_data in sampled_data_list:\\n c2st_roc_auc_metric = c2st_roc_auc(data, sampled_data)\\n if \\\"c2st_roc_auc\\\" in result:\\n result[\\\"c2st_roc_auc\\\"].append(c2st_roc_auc_metric)\\n else:\\n result[\\\"c2st_roc_auc\\\"] = [c2st_roc_auc_metric]\\n mmd_p_val, mmd_stat = rbf_mmd_test(data.values, sampled_data.values)\\n if \\\"mmd_p_val\\\" in result:\\n result[\\\"mmd_p_val\\\"].append(mmd_p_val)\\n result[\\\"mmd_stat\\\"].append(mmd_stat)\\n else:\\n result[\\\"mmd_p_val\\\"] = [mmd_p_val]\\n result[\\\"mmd_stat\\\"] = [mmd_stat]\\n ks_p_val, ks_stat, ks_n, ks_p_val_list, ks_stat_list = ks_test(data, sampled_data)\\n if dataset_type != \\\"norm_dataset\\\":\\n ks_p_val = ks_permutation(ks_stat_list, data, sampled_data)\\n if \\\"ks_p_val\\\" in result:\\n result[\\\"ks_p_val\\\"].append(ks_p_val)\\n result[\\\"ks_stat\\\"].append(ks_stat)\\n else:\\n result[\\\"ks_p_val\\\"] = [ks_p_val]\\n result[\\\"ks_stat\\\"] = [ks_stat]\\n acc_r, acc_g = c2st_accuracy(data, sampled_data)\\n if \\\"c2st_acc_r\\\" in result:\\n result[\\\"c2st_acc_r\\\"].append(acc_r)\\n result[\\\"c2st_acc_g\\\"].append(acc_g)\\n else:\\n result[\\\"c2st_acc_r\\\"] = [acc_r]\\n result[\\\"c2st_acc_g\\\"] = [acc_g]\\n return result\",\n \"def evaluate(self, click_model, search_sessions):\\n\\n # Only use queries that occur more than MINUMUM_OCCURENCES times and have a true relevance\\n counter = collections.Counter([session.query for session in search_sessions])\\n useful_sessions = [query_id for query_id in counter if counter[query_id] >= self.minimum_occurences and query_id in self.relevances]\\n\\n # Group sessions by query\\n sessions_dict = self._group_sessions_if_useful(search_sessions, useful_sessions)\\n total_ndcg = 0\\n not_useful = 0\\n\\n # For every useful query get the predicted relevance and compute NDCG\\n for query_id in useful_sessions:\\n \\n rel = self.relevances[query_id]\\n ideal_ranking = sorted(rel.values(),reverse = True)[:5]\\n \\n # Only use query if there is a document with a positive ranking. (Otherwise IDCG will be 0 -> NDCG undetermined.)\\n if not any(ideal_ranking):\\n not_useful += 1\\n continue\\n \\n current_sessions = sessions_dict[query_id]\\n pred_rels = dict()\\n for session in current_sessions:\\n for rank, result in enumerate(session.web_results):\\n if not result.id in pred_rels:\\n pred_rels[result.id] = click_model.predict_relevance(session.query, result.id)\\n ranking = sorted([doc for doc in pred_rels],key = lambda doc : pred_rels[doc], reverse = True)\\n \\n ranking_relevances = self.get_relevances(query_id, ranking[:5])\\n \\n dcg = self.dcg(ranking_relevances)\\n idcg = self.dcg(ideal_ranking) \\n ndcg = dcg / idcg\\n total_ndcg += ndcg\\n\\n # If too few queries there might not be any useful queries that also have a ranking in the true_relevances.\\n assert not len(useful_sessions)-not_useful is 0\\n\\n # Average NDCG over all queries\\n return total_ndcg / (len(useful_sessions)-not_useful)\",\n \"def collect_data(self):\\n exp_conf: ec.ExperimentConfiguration\\n # Disabled multiprocess run because of huge memory usage\\n processes_number = 1 # self._campaign_configuration['General']['j']\\n if processes_number == 1:\\n self._logger.info(\\\"-->Evaluate experiments (sequentially)\\\")\\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\\n exp_conf.evaluate()\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n exp_conf.generate_plots()\\n self._logger.info(\\\"<--\\\")\\n else:\\n self._logger.info(\\\"-->Evaluate experiments (in parallel)\\\")\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n self._logger.info(\\\"<--\\\")\\n\\n self.raw_results = {}\\n for exp_conf in self._exp_confs:\\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes\",\n \"def aggregate_log_dict(agg_dict, new_dict) -> dict:\\n for k in new_dict:\\n # init new if not present\\n if k not in agg_dict:\\n agg_dict[k] = {\\n 'n': 0,\\n 'sum': 0.0,\\n 'max': new_dict[k],\\n 'min': new_dict[k],\\n }\\n # aggregate\\n agg_dict[k]['n'] += 1\\n agg_dict[k]['sum'] += new_dict[k]\\n agg_dict[k]['max'] = max(new_dict[k], agg_dict[k]['max'])\\n agg_dict[k]['min'] = min(new_dict[k], agg_dict[k]['min'])\\n # TODO: add more stats (e.g. stdev, max, minin the future)\\n\\n return agg_dict\",\n \"def get_benchmark_aggregated_cov_df(coverage_dict, benchmark):\\n dict_to_transform = {'fuzzer': [], 'aggregated_edges_covered': []}\\n for key_pair, covered_regions in coverage_dict.items():\\n current_fuzzer, current_benchmark = key_pair.split()\\n if current_benchmark == benchmark:\\n dict_to_transform['fuzzer'].append(current_fuzzer)\\n dict_to_transform['aggregated_edges_covered'].append(\\n len(covered_regions))\\n return pd.DataFrame(dict_to_transform)\",\n \"def apply(self):\\n counter = {}\\n for act in self.activities:\\n freq = []\\n for trace in self.log:\\n freq.append(len(self.project_trace(trace, [act])))\\n if not len(freq) == 0:\\n counter[act] = {'sum': sum(freq), 'min': min(freq),\\n 'max': max(freq)}\\n return counter\",\n \"def convert(self, data, *args, **kwargs):\\n\\n # all of this is still quite ugly and verrrry specific...\\n json_data = {}\\n for hit in data[\\\"hits\\\"][\\\"hits\\\"]:\\n # pprint(hit)\\n\\n # get the PQ\\n pq = hit.get(\\\"_source\\\", {}).get(\\\"metadata\\\", {}).get(\\\"PanDAQueue\\\", None)\\n if not pq:\\n continue\\n\\n # get the list of all benchmark results\\n latest_list = (\\n hit.get(\\\"inner_hits\\\", {})\\n .get(\\\"most_recent\\\", {})\\n .get(\\\"hits\\\", {})\\n .get(\\\"hits\\\", [])\\n )\\n if len(latest_list) == 0:\\n continue\\n\\n # get the average of the latest benchmark results.\\n # Only results not older than 7d, and a maximum of 50 results (whichever value is hit first).\\n # If we have no values more recent than 7d, simply use the last available one (that PQ is probably not online anymore anyway)\\n values = []\\n for d in latest_list:\\n date = datetime.datetime.strptime(\\n d.get(\\\"_source\\\", {}).get(\\\"timestamp\\\", \\\"\\\"), \\\"%Y-%m-%dT%H:%M:%SZ\\\"\\n )\\n two_days_ago = datetime.datetime.now() - datetime.timedelta(days=2)\\n seven_days_ago = datetime.datetime.now() - datetime.timedelta(days=7)\\n\\n if date > two_days_ago:\\n # we are within the last two days, so we take all the measurements we can get!\\n values.append(d)\\n elif (date < two_days_ago) and (date > seven_days_ago):\\n # we are between 2 and 7 days ago, so take only values if we don't have 25 values already\\n if len(values) < 30:\\n values.append(d)\\n elif date < seven_days_ago:\\n # we are further away than 7 days, so take a maximum of 5 values from here if we don't have 5 yet\\n if len(values) < 10:\\n values.append(d)\\n\\n to_average = [\\n i.get(\\\"_source\\\", {})\\n .get(\\\"profiles\\\", {})\\n .get(\\\"fastBmk\\\", {})\\n .get(\\\"value\\\", 0.0)\\n for i in values\\n ]\\n json_data[pq] = {\\n \\\"avg_value\\\": float(sum(to_average)) / len(to_average),\\n \\\"measurements\\\": len(to_average),\\n }\\n # print(len(to_average))\\n\\n return json_data\",\n \"def organize_results(result_dicts_list, config_fn):\\n\\n metric_id = config_fn.get_metric_fn_id()[1]\\n organized_results = []\\n for results_list in result_dicts_list:\\n for result_dict in results_list:\\n dict_ = {}\\n for key, value in result_dict.items():\\n dict_[key] = value\\n organized_results.append(dict_)\\n pass\\n\\n return organized_results\",\n \"def process_input_items(args):\\n return dict(sum([Counter({sku: value * SCORES[k] for sku, value in\\n Counter(args[k].split(',')).items()}) or Counter() for k in\\n set(SCORES.keys()) & set(args.keys())], Counter()))\",\n \"def get_results(self):\\r\\n r ={\\r\\n 'Gp_s' :np.array(self.Gp_guess_s), #Means of the posteriors\\r\\n 'Gm_s' :np.array(self.Gm_guess_s), #Means of the posteriors\\r\\n 'eGp_s':np.array(self.eGp_guess_s) , #Standard deviations of the posteriors\\r\\n 'eGm_s':np.array(self.eGm_guess_s) , #Standard deviations of the posteriors\\r\\n 'covGpGm_s':np.array(self.cov_GpGm_s) , #Covariances of the posteriors\\r\\n 't_tot_pulseSequences_s':np.array(self.t_tot_pulseSequences_s), #Time it takes for each batch of pulse sequences\\r\\n 't_tot_process_s':np.array(self.t_tot_process_s), #CPU time it takes for processing the Bayes stuff at each iteration\\r\\n 't_probe_p_s':np.array(self.t_probe_p_s), # Times probed for the diff p\\r\\n 't_probe_m_s':np.array(self.t_probe_m_s), # Times probed for the diff m\\r\\n 't_pulseSequences_s':np.array(self.t_pulseSequences_s),\\r\\n 't_process_s':np.array(self.t_process_s),\\r\\n 'iteration_s':np.array(self.nb_iteration_s), #Number of iterations performed\\r\\n 'R_tot_s':np.array(self.R_tot_s) #Total number of readout performed\\r\\n }\\r\\n return r\",\n \"def iterate_results(results, extract_fn):\\n outputs = {}\\n for environment, environment_results in results.items():\\n if environment not in outputs:\\n outputs[environment] = {}\\n for experimental_setting, setting_results in environment_results.items():\\n outputs[environment][experimental_setting] = []\\n for config, seeds_results in setting_results.items():\\n for seed, actual_results in seeds_results.items():\\n output = extract_fn(actual_results)\\n outputs[environment][experimental_setting].append(output)\\n outputs[environment][experimental_setting] = np.array(outputs[environment][experimental_setting])\\n return outputs\",\n \"def _aggregate(self, row):\\n if not self._head:\\n self._head = self._create_head(row)\\n if self._args.head:\\n return\\n\\n if 'key' not in self._state:\\n self._state['key'] = self._replace_fields(self._args.key)\\n\\n if 'begin' not in self._state:\\n self._state['begin'] = eval(self._replace_fields(self._args.begin))\\n\\n if 'reduce' not in self._state:\\n self._state['reduce'] = self._replace_fields(self._args.reduce)\\n\\n if 'result_map' not in self._state:\\n self._state['result_map'] = {}\\n\\n r = list(map(self._convert, row))\\n\\n key = eval(self._state['key'])\\n\\n if key not in self._state['result_map']:\\n self._state['result_map'][key] = len(self._result)\\n entry = deepcopy(self._state['begin'])\\n self._result.append([key, entry])\\n\\n index = self._state['result_map'][key]\\n\\n ns = {\\n '__result__': self._result[index][1],\\n 'r': r\\n }\\n exec(self._state['reduce'], ns)\\n self._result[index][1] = ns['__result__']\",\n \"def _build_eval_metrics(self, results, features, labels):\\n metrics = {}\\n for metric in self.metrics:\\n metrics[metric.IDENTIFIER] = getters.get_metric(\\n metric.IDENTIFIER, results, labels, **metric.to_dict())\\n return metrics\",\n \"def store_results(main_dico, attempts_dico, temp_probas_dico, verbose_dico, review_strat, param, run_id, stud_id, t,\\n mean_recall, sum_attempts, recall_probs, relative_mean_recall, attempts_per_skill, B, item_strategy):\\n main_dico[\\\"skill_strategy\\\"].append(review_strat)\\n main_dico[\\\"item_strategy\\\"].append(item_strategy)\\n main_dico[\\\"param\\\"].append(param)\\n main_dico[\\\"run_id\\\"].append(run_id)\\n main_dico[\\\"stud_id\\\"].append(stud_id)\\n main_dico[\\\"t\\\"].append(t)\\n main_dico[\\\"mean_recall\\\"].append(np.around(mean_recall,5))\\n main_dico[\\\"relative_mean_recall\\\"].append(relative_mean_recall)\\n main_dico[\\\"sum_attempts\\\"].append(sum_attempts)\\n for b in range(B):\\n if (t < B) and (review_strat != \\\"no_review\\\"):\\n attempts_dico[review_strat][param][item_strategy][t][\\\"att_skill_\\\"+str(b)] += attempts_per_skill[b]\\n if t < B:\\n temp_probas_dico[review_strat][param][item_strategy][\\\"learning\\\"].append(recall_probs)\\n verbose_dico[item_strategy][review_strat][param][\\\"learning\\\"].append(mean_recall)\\n else:\\n temp_probas_dico[review_strat][param][item_strategy][\\\"retention\\\"].append(recall_probs)\\n verbose_dico[item_strategy][review_strat][param][\\\"retention\\\"].append(mean_recall)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6222572","0.60406405","0.5990933","0.5945015","0.58555114","0.5849532","0.5788227","0.57747865","0.5715895","0.5701647","0.56428385","0.5619109","0.5589009","0.55545366","0.5523717","0.5481006","0.5478383","0.545642","0.54334474","0.53829503","0.5372924","0.5372085","0.53708786","0.5342637","0.53384066","0.53200006","0.5300919","0.5294238","0.52901095","0.5288867","0.5287864","0.5283018","0.5265103","0.5264481","0.52636063","0.5260003","0.52451485","0.52399635","0.52323365","0.52313155","0.5227371","0.5226496","0.51910704","0.51874346","0.5179128","0.5162459","0.51617527","0.5150505","0.5145547","0.51427877","0.5136994","0.51319736","0.5126571","0.51265323","0.5125455","0.5114716","0.5107153","0.5103611","0.5096862","0.5089028","0.5074569","0.5067158","0.50584584","0.5056512","0.5056117","0.5046236","0.5031496","0.5030554","0.50286585","0.5023797","0.502054","0.5016998","0.5010157","0.4996956","0.49933574","0.49910495","0.4988251","0.49827927","0.49693274","0.4968255","0.49604493","0.49603117","0.49514675","0.49500126","0.4939167","0.49221027","0.49213254","0.4920852","0.49042252","0.4903085","0.49015683","0.4895901","0.48905113","0.48874","0.4882825","0.48794743","0.48771796","0.4869297","0.48667958","0.4862935"],"string":"[\n \"0.6222572\",\n \"0.60406405\",\n \"0.5990933\",\n \"0.5945015\",\n \"0.58555114\",\n \"0.5849532\",\n \"0.5788227\",\n \"0.57747865\",\n \"0.5715895\",\n \"0.5701647\",\n \"0.56428385\",\n \"0.5619109\",\n \"0.5589009\",\n \"0.55545366\",\n \"0.5523717\",\n \"0.5481006\",\n \"0.5478383\",\n \"0.545642\",\n \"0.54334474\",\n \"0.53829503\",\n \"0.5372924\",\n \"0.5372085\",\n \"0.53708786\",\n \"0.5342637\",\n \"0.53384066\",\n \"0.53200006\",\n \"0.5300919\",\n \"0.5294238\",\n \"0.52901095\",\n \"0.5288867\",\n \"0.5287864\",\n \"0.5283018\",\n \"0.5265103\",\n \"0.5264481\",\n \"0.52636063\",\n \"0.5260003\",\n \"0.52451485\",\n \"0.52399635\",\n \"0.52323365\",\n \"0.52313155\",\n \"0.5227371\",\n \"0.5226496\",\n \"0.51910704\",\n \"0.51874346\",\n \"0.5179128\",\n \"0.5162459\",\n \"0.51617527\",\n \"0.5150505\",\n \"0.5145547\",\n \"0.51427877\",\n \"0.5136994\",\n \"0.51319736\",\n \"0.5126571\",\n \"0.51265323\",\n \"0.5125455\",\n \"0.5114716\",\n \"0.5107153\",\n \"0.5103611\",\n \"0.5096862\",\n \"0.5089028\",\n \"0.5074569\",\n \"0.5067158\",\n \"0.50584584\",\n \"0.5056512\",\n \"0.5056117\",\n \"0.5046236\",\n \"0.5031496\",\n \"0.5030554\",\n \"0.50286585\",\n \"0.5023797\",\n \"0.502054\",\n \"0.5016998\",\n \"0.5010157\",\n \"0.4996956\",\n \"0.49933574\",\n \"0.49910495\",\n \"0.4988251\",\n \"0.49827927\",\n \"0.49693274\",\n \"0.4968255\",\n \"0.49604493\",\n \"0.49603117\",\n \"0.49514675\",\n \"0.49500126\",\n \"0.4939167\",\n \"0.49221027\",\n \"0.49213254\",\n \"0.4920852\",\n \"0.49042252\",\n \"0.4903085\",\n \"0.49015683\",\n \"0.4895901\",\n \"0.48905113\",\n \"0.48874\",\n \"0.4882825\",\n \"0.48794743\",\n \"0.48771796\",\n \"0.4869297\",\n \"0.48667958\",\n \"0.4862935\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6752876"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21498,"cells":{"query":{"kind":"string","value":"Computes the overall session QC for each key and aggregates in a single value"},"document":{"kind":"string","value":"def compute_session_status(self):\n if self.passed is None:\n raise AttributeError('passed is None; compute QC first')\n # Get mean passed of each check, or None if passed is None or all NaN\n results = {k: None if v is None or np.isnan(v).all() else np.nanmean(v)\n for k, v in self.passed.items()}\n session_outcome, outcomes = self.compute_session_status_from_dict(results)\n return session_outcome, results, outcomes"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def aggregate(self):\n data_to_track = {}\n for possession in self.possessions_to_track_aggregate:\n data_to_track[possession] = self._haves[possession]\n\n for variable in self.variables_to_track_aggregate:\n try:\n data_to_track[variable] = self.__dict__[variable]\n except KeyError:\n pass\n self.database_connection.put([\"aggregate\",\n data_to_track,\n self.group,\n self.round])","def compute_session_status_from_dict(results):\n indices = np.zeros(len(results), dtype=int)\n for i, k in enumerate(results):\n if k in TaskQC.criteria.keys():\n indices[i] = TaskQC._thresholding(results[k], thresholds=TaskQC.criteria[k])\n else:\n indices[i] = TaskQC._thresholding(results[k], thresholds=TaskQC.criteria['default'])\n\n def key_map(x):\n return 'NOT_SET' if x < 0 else list(TaskQC.criteria['default'].keys())[x]\n # Criteria map is in order of severity so the max index is our overall QC outcome\n session_outcome = key_map(max(indices))\n outcomes = dict(zip(results.keys(), map(key_map, indices)))\n return session_outcome, outcomes","def calc_data(self):\n\n circ_counts = {}\n for trialidx in range(self._ntrials):\n for _, depth in enumerate(self._depths):\n circ_name = 'qv_depth_%d_trial_%d' % (depth, trialidx)\n\n # get the counts form ALL executed circuits\n count_list = []\n for result in self._result_list:\n try:\n count_list.append(result.get_counts(circ_name))\n except (QiskitError, KeyError):\n pass\n\n circ_counts[circ_name] = \\\n build_counts_dict_from_list(count_list)\n\n self._circ_shots[circ_name] = \\\n sum(circ_counts[circ_name].values())\n\n # calculate the heavy output probability\n self._heavy_output_counts[circ_name] = \\\n self._subset_probability(\n self._heavy_outputs[circ_name],\n circ_counts[circ_name])","def run_faqc(self, **kwargs):\n if self.qc is True:\n build([FaQC.SummarizeQC(fastq_dic=self.fastq_dic,\n num_cpus=self.num_cpus,\n workdir=self.workdir)],\n local_scheduler=self.local_scheduler,\n workers=1)\n qc_dic = {}\n for samp, path in self.fastq_dic.items():\n trim_dir = os.path.join(self.workdir, \"processes\", \"qc\", samp)\n qc_dic[samp] = trim_dir + \"/\" + samp + \".1.trimmed.fastq\" + \":\" + \\\n trim_dir + \"/\" + samp + \".2.trimmed.fastq\" \n return qc_dic\n\n else:\n return self.fastq_dic","def get_test_cases_coverage(session_id):\n tc_stats={}\n tc_stats_list=[]\n total_executed=0\n sql='SELECT DISTINCT(test_id) FROM stats WHERE session_id=:sid AND test_id!=\"null\"'\n params={\"sid\":session_id}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n tests=c.fetchall()\n conn.close()\n if len(tests)>0:\n for t in tests:\n total_executed=0\n sql=\"SELECT DISTINCT(file_id) FROM stats WHERE session_id=:sid AND test_id=:tid\"\n params={\"sid\":session_id,\"tid\":t[0]}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n files=c.fetchall()\n conn.close()\n for f in files:\n line_count=get_executable_lines_count_for_file(f[0])\n # get executions\n sql=\"SELECT COUNT(DISTINCT line_guid) FROM stats WHERE session_id= :sid AND file_id= :fid AND test_id=:tid\"\n params={\"sid\":session_id,\"tid\":t[0],\"fid\":f[0]}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n executed=c.fetchone()\n conn.close()\n total_executed+=executed[0]\n # save test case and it's executions\n tc_stats={}\n tc_stats[\"test_id\"]=t[0]\n tc_stats[\"total_executed\"]=total_executed\n tc_stats[\"total_executed\"]\n \n tc_stats_list.append(tc_stats)\n return tc_stats_list","def sum(app, args):\n if not args.key:\n db = get_db(app)\n notrans = db.transient.count()\n print(\"No Transient records: \", notrans)\n if notrans > 0:\n print(\"Total data Transient: \", nicesize(\n list(db.transient.aggregate([\n {\"$group\": {\"_id\": None,\n \"total\": {\"$sum\": \"$size\"}}}]))[0]['total']))\n print(\" No Core records: \", db.transient.count())\n return\n\n kname, kinfo = key_info(app.conf, args.key)\n res = _single_sum(app, group_by=kname, force=args.force)\n total_size = int(0)\n total_count = 0\n mgn = len(\"Total\")\n for reshost in res:\n gid = reshost['_id']\n if gid is None:\n mgn = max(4, mgn)\n else:\n mgn = max(len(str(reshost['_id'])), mgn)\n\n fms = \"{:\" + str(mgn) + \"}\\t{:>10}\\t{:>9}\"\n if args.human:\n print(\"# {}:\".format(kname))\n for reshost in res:\n total = reshost['total']\n count = reshost['count']\n total_size += int(total)\n total_count += count\n if args.human:\n total_human = nicesize(total)\n count_human = nicenumber(count)\n categ = reshost['_id']\n if categ is None:\n categ = \"<undefined>\"\n\n print(fms.format(\n categ, total_human, count_human))\n else:\n print(\"{}\\t{}\\t{}\".format(\n reshost['_id'], total, count))\n\n if args.human:\n total_size_human = nicesize(total_size)\n total_count_human = nicenumber(total_count)\n print(fms.format('', '-'*10, '-'*9))\n print(fms.format(\n \"Total\", total_size_human, total_count_human))\n else:\n print(\"Total\\t{}\\t{}\".format(total_size, total_count))","def get_aggregated_values(self):\n if not self._initialized:\n raise Exception(\"To readout you must first initialize, then\"\n \"process batches!\")\n else:\n ret_vals = [q.readout() for q in self.quantities]\n return dict(zip(self.quantity_names, ret_vals))","def session_counting (self, target_dict, IEI_timeRange = (0, 900, 1), cal_IEI = True, cal_duration = True, cal_latency = True, cal_inputDistribution = True, num_bins = 10, **kwards):\r\n if len(self.df) == 0:\r\n #if empty then pass without analysis\r\n pass\r\n else:\r\n get_kwards = lambda x: (\"\",\"\") if x == None else x\r\n input1OnOff = get_kwards(kwards.get('Input1OnOff'))\r\n input2OnOff = get_kwards(kwards.get('Input2OnOff'))\r\n input3OnOff = get_kwards(kwards.get('Input3OnOff'))\r\n input4OnOff = get_kwards(kwards.get('Input4OnOff'))\r\n \r\n #get a start and end time point\r\n if 'Start' in self.df['States'].values:\r\n start = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Start')]['Time']\r\n else:\r\n start = pd.Series({'Start': self.df['Time'].values[0]-1})\r\n \r\n if 'Finish' in self.df['States'].values:\r\n end = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Finish')]['Time']\r\n else:\r\n end = pd.Series({'Finish': self.df['Time'].values[-1]+1}) #plus 1 second\r\n \r\n #get data from each event window\r\n event = self.df[(self.df['Time']>= start.iloc[0])&(self.df['Time']<= end.iloc[0])]\r\n \r\n result_dict = {}\r\n for k, v in target_dict.items():\r\n \r\n if k == 'Input1':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input1OnOff)\r\n elif k == 'Input2':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input2OnOff)\r\n elif k == 'Input3':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input3OnOff)\r\n elif k == 'Input4':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input4OnOff)\r\n else:\r\n result_dict [v[1]] = self.__counting (event, v, self.subject)\r\n \r\n return result_dict","def aggregate_results(results):\n\n for (config,con,dec),folds in results.iteritems():\n m = MODEL_PATTERN.match(config)\n if m:\n mode = m.groupdict()['mode'] # mle, rl, mrt, ...\n model = m.groupdict()['model'] # haem, hacm, hard, ...\n align = m.groupdict()['align'] # crp, cls ...\n else:\n mode, model, align = '', '', ''\n # mean accuracies across seeds for each fold\n foldaccuracies = []\n # we count number of models over folds and seeds\n num_individual_models = 0\n\n for foldname,fold in folds.items():\n if 'Q' in options.mode:\n seedaccurracies = fold.values()[:1] if fold.values() else [] # pick one\n# SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\n else:\n seedaccurracies = []\n for seed_acc in fold.values():\n seedaccurracies.append(seed_acc)\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\n # aggregate on fold level\n fold['__MEAN__'] = float(np.mean(seedaccurracies))\n fold['__SD__'] = float(np.std(seedaccurracies))\n l = len(seedaccurracies)\n num_individual_models += l\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__MEAN__')] += l\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__SD__')] += l\n\n # statistics over seeds for this fold\n fold['__STATS__'] = fold['__MEAN__'], fold['__SD__'], l\n foldaccuracies.append(fold['__MEAN__'])\n # aggregate on (config, condition, decoding) level\n folds['__MEAN__'] = float(np.mean(foldaccuracies))\n folds['__SD__'] = float(np.std(foldaccuracies))\n # statistics over folds for this (config, condition, decoding)\n folds['__STATS__'] = folds['__MEAN__'], folds['__SD__'], num_individual_models","def __calculate_agg_shap_scores(self):\n self.agg_stats_timer = SimbaTimer(start=True)\n for clf_state, clf_state_name in zip(range(2), [\"ABSENT\", \"PRESENT\"]):\n self.results = {}\n self.df_save_path = os.path.join(\n self.shap_logs_path,\n \"SHAP_summary_{}_{}_{}.csv\".format(\n self.classifier_name, clf_state_name, self.datetime\n ),\n )\n shap_clf_sliced = self.shap_df[\n self.shap_df[self.classifier_name] == clf_state\n ]\n for feature_category, feature_time_bin in itertools.product(\n self.unique_feature_category_names, self.unique_time_bin_names\n ):\n if feature_category not in self.results.keys():\n self.results[feature_category] = {}\n feature_names_sliced = list(\n self.feature_categories_df.loc[\n :, (feature_category, feature_time_bin)\n ]\n )\n feature_names_sliced = [\n x\n for x in feature_names_sliced\n if str(x) != \"nan\" and x in shap_clf_sliced\n ]\n self.results[feature_category][feature_time_bin] = round(\n shap_clf_sliced[feature_names_sliced].sum(axis=1).mean() * 100, 6\n )\n self.__save_aggregate_scores()\n self.agg_stats_timer.stop_timer()\n self.visualization_timer = SimbaTimer(start=True)\n\n stdout_success(\n msg=f\"Aggregate SHAP statistics saved in {self.shap_logs_path} directory\",\n elapsed_time=self.agg_stats_timer.elapsed_time_str,\n )","def generate_stats(results, ads, vmid, session_date, export_folder, process_ex_time):\n try:\n os.makedirs(export_folder)\n except OSError:\n pass\n\n # to be read and inserted into db\n totalads = 0 # total number of ads seen during this session\n totaluniqads = len(ads) # does not support multicategories at this point\n\n # for each category, for each test site, count total number of ads seen\n totalad_category = {} \n # for each category, for each test site, count total number of uniq ads seen\n uniqad_category = {}\n \n with open(os.path.join(export_folder, 'session_bugs.csv'), 'w') as bugs_wtr:\n bugs_wtr.write('#Ad-UID, Website-URL, Refresh-Num, Training-Topic,\\\n Site-Context, BugCount, BugSrc\\n')\n for train_category, cat_dict in results.items():\n totalad_category[train_category] = {}\n uniqad_category[train_category] = {}\n for test_site, bug_dict_list in cat_dict.items():\n total_ads = 0 # for each site\n uniq_ads = [] # for each site\n for refresh_num in range(len(bug_dict_list)):\n bug_dict = bug_dict_list[refresh_num]\n for bug, bugcount in bug_dict.items():\n if bug.is_ad():\n uuid = bug.get_uuid()\n bugs_wtr.write('{0}, {1}, {2}, {3}, {4}, {5}, {6}\\n'.format(uuid, test_site,\n refresh_num, train_category, 'N/A', bugcount, bug.get_src()))\n total_ads += bugcount\n if bug not in uniq_ads:\n uniq_ads.append(bug)\n totalad_category[train_category][test_site] = total_ads\n uniqad_category[train_category][test_site] = len(uniq_ads)\n totalads += total_ads # global count for total ads\n\n with open(os.path.join(export_folder, 'session_stats.csv'), 'w') as ses_wtr:\n # write some metadata information about this session\n ses_wtr.write('#VMID: %s\\n' % vmid)\n ses_wtr.write('#Session-Date: %s\\n' % session_date)\n ses_wtr.write('#Time to complete: %s\\n' % process_ex_time)\n ses_wtr.write('#Training Categories: %s\\n' % str(results.keys()))\n ses_wtr.write('#Total Number of ads: %d\\n' % totalads)\n ses_wtr.write('#Total Uniq ads: %d\\n\\n' % totaluniqads)\n ses_wtr.write('#TrainingTopic, Test-Site, NumberOfVisit, TotalAds, UniqAds\\n')\n\n for train_category, cat_dict in results.items(): \n for test_site, bug_dict_list in cat_dict.items():\n num_of_visit = len(bug_dict_list)\n ses_wtr.write('{0}, {1}, {2}, {3}, {4}\\n'.format(train_category,\n test_site, num_of_visit, totalad_category[train_category][test_site],\n uniqad_category[train_category][test_site]))","def do_report(input):\n for (session_id, group) in itertools.groupby(input, get_session_id):\n group = list(group)\n elapsed = [finfo.elapsed for finfo in group]\n n = float(len(elapsed))\n mean = sum(elapsed) / n\n s = math.sqrt(\n (1 / (n - 1)) * sum((e - mean) ** 2 for e in elapsed)\n )\n yield SummaryData(\n session_id,\n group[0].message,\n min(elapsed),\n max(elapsed),\n mean,\n s\n )","def aggregator(index_keynames, value_keynames, ts_keyname, func, interval = 60 * 5):\n data = {}\n ts = None\n #print ts_keyname\n for parsts, parsdata in func():\n #print parsdata\n #print parsdata[\"log_timestamp\"]\n if ts is None:\n ts = parsts\n key = tuple((parsdata[key] for key in index_keynames))\n values = tuple((int(parsdata[key]) for key in value_keynames))\n if key not in data:\n data[key] = values\n else:\n data[key] = tuple((data[key][index] + int(values[index]) for index in range(len(values))))\n if parsts > (ts + interval):\n for keys, values in data.items():\n yield \"%s\\t%s\\t%s\" % (ts, \"\\t\".join((str(index_key) for index_key in keys)), \"\\t\".join((str(value_key) for value_key in values)))\n ts = None\n data = {}","def qc_metrics(\n data: AnnData,\n mito_prefix: str = \"MT-\",\n min_genes: int = 500,\n max_genes: int = 6000,\n min_umis: int = 100,\n max_umis: int = 600000,\n percent_mito: float = 10.0,\n percent_cells: float = 0.05,\n) -> None:\n\n data.obs[\"passed_qc\"] = False\n\n data.obs[\"n_genes\"] = data.X.getnnz(axis=1)\n data.obs[\"n_counts\"] = data.X.sum(axis=1).A1\n\n mito_prefixes = mito_prefix.split(\",\")\n\n def startswith(name):\n for prefix in mito_prefixes:\n if name.startswith(prefix):\n return True\n return False\n\n mito_genes = data.var_names.map(startswith).values.nonzero()[0]\n data.obs[\"percent_mito\"] = (data.X[:, mito_genes].sum(axis=1).A1 / np.maximum(\n data.obs[\"n_counts\"].values, 1.0\n )) * 100\n\n # Assign passed_qc\n filters = [\n data.obs[\"n_genes\"] >= min_genes,\n data.obs[\"n_genes\"] < max_genes,\n data.obs[\"n_counts\"] >= min_umis,\n data.obs[\"n_counts\"] < max_umis,\n data.obs[\"percent_mito\"] < percent_mito,\n ]\n\n data.obs.loc[np.logical_and.reduce(filters), \"passed_qc\"] = True\n\n var = data.var\n data = data[\n data.obs[\"passed_qc\"]\n ] # compute gene stats in space of filtered cells only\n\n var[\"n_cells\"] = data.X.getnnz(axis=0)\n var[\"percent_cells\"] = (var[\"n_cells\"] / data.shape[0]) * 100\n var[\"robust\"] = var[\"percent_cells\"] >= percent_cells\n var[\"highly_variable_features\"] = var[\n \"robust\"\n ] # default all robust genes are \"highly\" variable","def aggregate_results(self):\n\n raise NotImplementedError","def compute(self, download_data=None):\n if self.extractor is None:\n # If download_data is None, decide based on whether eid or session path was provided\n ensure_data = self.download_data if download_data is None else download_data\n self.load_data(download_data=ensure_data)\n self.log.info(f\"Session {self.session_path}: Running QC on habituation data...\")\n\n # Initialize checks\n prefix = '_task_'\n data = self.extractor.data\n metrics = {}\n passed = {}\n\n # Check all reward volumes == 3.0ul\n check = prefix + 'reward_volumes'\n metrics[check] = data['rewardVolume']\n passed[check] = metrics[check] == 3.0\n\n # Check session durations are increasing in steps >= 12 minutes\n check = prefix + 'habituation_time'\n if not self.one or not self.session_path:\n self.log.warning('unable to determine session trials without ONE')\n metrics[check] = passed[check] = None\n else:\n subject, session_date = self.session_path.parts[-3:-1]\n # compute from the date specified\n date_minus_week = (\n datetime.strptime(session_date, '%Y-%m-%d') - timedelta(days=7)\n ).strftime('%Y-%m-%d')\n sessions = self.one.alyx.rest('sessions', 'list', subject=subject,\n date_range=[date_minus_week, session_date],\n task_protocol='habituation')\n # Remove the current session if already registered\n if sessions and sessions[0]['start_time'].startswith(session_date):\n sessions = sessions[1:]\n metric = ([0, data['intervals'][-1, 1] - data['intervals'][0, 0]] +\n [(datetime.fromisoformat(x['end_time']) -\n datetime.fromisoformat(x['start_time'])).total_seconds() / 60\n for x in [self.one.alyx.get(s['url']) for s in sessions]])\n\n # The duration from raw trial data\n # duration = map(float, self.extractor.raw_data[-1]['elapsed_time'].split(':'))\n # duration = timedelta(**dict(zip(('hours', 'minutes', 'seconds'),\n # duration))).total_seconds() / 60\n metrics[check] = np.array(metric)\n passed[check] = np.diff(metric) >= 12\n\n # Check event orders: trial_start < stim on < stim center < feedback < stim off\n check = prefix + 'trial_event_sequence'\n nans = (\n np.isnan(data[\"intervals\"][:, 0]) | # noqa\n np.isnan(data[\"stimOn_times\"]) | # noqa\n np.isnan(data[\"stimCenter_times\"]) |\n np.isnan(data[\"valveOpen_times\"]) | # noqa\n np.isnan(data[\"stimOff_times\"])\n )\n a = np.less(data[\"intervals\"][:, 0], data[\"stimOn_times\"], where=~nans)\n b = np.less(data[\"stimOn_times\"], data[\"stimCenter_times\"], where=~nans)\n c = np.less(data[\"stimCenter_times\"], data[\"valveOpen_times\"], where=~nans)\n d = np.less(data[\"valveOpen_times\"], data[\"stimOff_times\"], where=~nans)\n\n metrics[check] = a & b & c & d & ~nans\n passed[check] = metrics[check].astype(float)\n\n # Check that the time difference between the visual stimulus center-command being\n # triggered and the stimulus effectively appearing in the center is smaller than 150 ms.\n check = prefix + 'stimCenter_delays'\n metric = np.nan_to_num(data[\"stimCenter_times\"] - data[\"stimCenterTrigger_times\"],\n nan=np.inf)\n passed[check] = (metric <= 0.15) & (metric > 0)\n metrics[check] = metric\n\n # Phase check\n check = prefix + 'phase'\n metric = data['phase']\n passed[check] = (metric <= 2 * np.pi) & (metric >= 0)\n metrics[check] = metric\n\n check = prefix + 'phase_distribution'\n metric, _ = np.histogram(data['phase'])\n _, p = chisquare(metric)\n passed[check] = p < 0.05\n metrics[check] = metric\n\n # Checks common to training QC\n checks = [check_goCue_delays, check_stimOn_goCue_delays,\n check_stimOn_delays, check_stimOff_delays]\n for fcn in checks:\n check = prefix + fcn.__name__[6:]\n metrics[check], passed[check] = fcn(data)\n\n self.metrics, self.passed = (metrics, passed)","def calc_sim_collector(self, key, values):\r\n (rest1, rest2), common_ratings = key, values\r\n\t #your code here\r\n yield (rest1, rest2), (rho, n_common)","def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\n hist = {k: {} for k in {\"mks0\", \"mks1\", \"mks2\", \"l\"}} # pylint: disable=C0208\n wei = {k: {} for k in hist}\n res[\"hist\"] = hist\n res[\"histnow\"] = wei\n\n for el, _ in self.enumerate_test_metric(qset):\n le = len(el.value)\n w = el.weight\n res[\"mks0\"] += w * el.mks0\n res[\"mks1\"] += w * el.mks1\n res[\"mks2\"] += w * el.mks2\n res[\"sum_weights\"] += w\n res[\"sum_wlen\"] += w * le\n res[\"n\"] += 1\n\n if el.mks0 not in hist[\"mks0\"]:\n hist[\"mks0\"][el.mks0] = w\n wei[\"mks0\"][el.mks0] = 1\n else:\n hist[\"mks0\"][el.mks0] += w\n wei[\"mks0\"][el.mks0] += 1\n if el.mks1 not in hist[\"mks1\"]:\n hist[\"mks1\"][el.mks1] = w\n wei[\"mks1\"][el.mks1] = 1\n else:\n hist[\"mks1\"][el.mks1] += w\n wei[\"mks1\"][el.mks1] += 1\n if el.mks2 not in hist[\"mks2\"]:\n hist[\"mks2\"][el.mks2] = w\n wei[\"mks2\"][el.mks2] = 1\n else:\n hist[\"mks2\"][el.mks2] += w\n wei[\"mks2\"][el.mks2] += 1\n if le not in hist[\"l\"]:\n hist[\"l\"][le] = w\n wei[\"l\"][le] = 1\n else:\n hist[\"l\"][le] += w\n wei[\"l\"][le] += 1\n return res","def _group_sessions(self, sessions):\n session_dict = collections.defaultdict(list)\n for session in sessions:\n session_dict[session.query].append(session)\n return session_dict","def aggregate_data(mts, feature, target):\r\n set_dict = dict()\r\n set_dict['mt'] = mts\r\n set_dict['feature'] = feature\r\n set_dict['target'] = target\r\n \r\n return set_dict","def summary(data, key=itemgetter(0), value=itemgetter(1)):\n\n for k, group in groupby(data, key):\n yield (k, sum(value(row) for row in group))","def get_job_metrics_summary_for_task(query):\n metric_list = ['hs06sec', 'gco2_global']\n metrics = {}\n for m in metric_list:\n metrics[m] = {'finished': 0, 'failed': 0, 'total': 0}\n\n hquery = copy.deepcopy(query)\n hquery['jobstatus__in'] = ('finished', 'failed')\n\n if 'jeditaskid' in hquery:\n\n hs06sec_sum = []\n # getting jobs. Can not use the .annotate() as there can be duplicates\n jobs = []\n jvalues = ['pandaid', 'jobstatus', ] + metric_list\n jobs.extend(Jobsarchived4.objects.filter(**hquery).values(*jvalues))\n jobs.extend(Jobsarchived.objects.filter(**hquery).values(*jvalues))\n jobs = drop_duplicates(jobs)\n\n for job in jobs:\n for m in metric_list:\n metrics[m]['total'] += job[m] if m in job and job[m] is not None else 0\n if job['jobstatus'] == 'finished':\n metrics[m]['finished'] += job[m] if m in job and job[m] is not None else 0\n elif job['jobstatus'] == 'failed':\n metrics[m]['failed'] += job[m] if m in job and job[m] is not None else 0\n\n # getting data from ATLARC DB, only hs06s\n pj_models = get_pandajob_arch_models_by_year(query['modificationtime__castdate__range'])\n if len(pj_models) > 0:\n for pjm in pj_models:\n try:\n hs06sec_sum.extend(pjm.objects.filter(**hquery).values('jobstatus').annotate(hs06secsum=Sum('hs06sec')))\n except Exception as ex:\n _logger.exception('Failed to get hs06sec from {} at ATLARC DB:\\n{}'.format(pjm, ex))\n\n if len(hs06sec_sum) > 0:\n for hs in hs06sec_sum:\n metrics['hs06sec']['total'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\n if hs['jobstatus'] == 'finished':\n metrics['hs06sec']['finished'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\n elif hs['jobstatus'] == 'failed':\n metrics['hs06sec']['failed'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\n\n\n return metrics","def compute_key_value(self) -> Dict[str, float]:\n # @TODO: ddp hotfix, could be done better\n if self._is_ddp:\n for key in self.statistics:\n value: List[np.ndarray] = all_gather(self.statistics[key])\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\n self.statistics[key] = value\n\n per_class, micro, macro, weighted = self.compute()\n metrics = self._convert_metrics_to_kv(\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\n )\n return metrics","def metrics_group():","def association_rules_baseline(train_sessions):\n comatrix = collections.defaultdict(list)\n for session in train_sessions:\n for (x, y) in itertools.permutations(session, 2):\n comatrix[x].append(y)\n return comatrix","def selectedComparisons(samples_dict):\n sectors=\"peripherals\",\"intermediaries\",\"hubs\"\n ks_measures={}\n for analyses_type in samples_dict[sectors[0]]:\n ks_measures[analyses_type]={}\n for analysis_grouping in samples_dict[sectors[0]][analyses_type]:\n ks_measures[analyses_type][analysis_grouping]={}\n if samples_dict[sectors[0]][analyses_type][analysis_grouping]==dict:\n ks_measures[analyses_type][analysis_grouping]={}\n for analysis in samples_dict[sectors[0]][analyses_type][analysis_grouping]:\n for var in samples_dict[sectors[0]][analyses_type][analysis_grouping][analysis]:\n samples_peripherals=samples_dict[sectors[0]][analyses_type][analysis_grouping][analysis]\n samples_intermediaries=samples_dict[sectors[1]][analyses_type][analysis_grouping][analysis]\n samples_hubs=samples_dict[sectors[2]][analyses_type][analysis_grouping][analysis]\n ks_measures[analysis][\"peripherals_intermediaries\"]=P.kolmogorovSmirnovTest(samples_peripherals,samples_intermediaries)\n ks_measures[analysis][\"peripherals_hubs\"]=P.kolmogorovSmirnovTest(samples_peripherals,samples_hubs)\n ks_measures[analysis][\"hubs_intermediaries\"]=P.kolmogorovSmirnovTest(samples_hubs,samples_intermediaries)\n else:\n for var in samples_dict[sectors[0]][analyses_type][analysis_grouping]:\n samples_peripherals=samples_dict[sectors[0]][analyses_type][analysis_grouping]\n samples_intermediaries=samples_dict[sectors[1]][analyses_type][analysis_grouping]\n samples_hubs=samples_dict[sectors[2]][analyses_type][analysis_grouping]\n\n\n\n samples[sector][analyses][analysis_grouping]=updateDict(samples[sector][analyses][analysis_grouping],getSamples(authors_analysis[analyses][author][analysis_grouping]))","def evaluate(self, click_model, search_sessions):\n\n # Only use queries that occur more than MINUMUM_OCCURENCES times and have a true relevance\n counter = collections.Counter([session.query for session in search_sessions])\n useful_sessions = [query_id for query_id in counter if counter[query_id] >= self.minimum_occurences and query_id in self.relevances]\n\n # Group sessions by query\n sessions_dict = self._group_sessions_if_useful(search_sessions, useful_sessions)\n total_ndcg = 0\n not_useful = 0\n\n # For every useful query get the predicted relevance and compute NDCG\n for query_id in useful_sessions:\n \n rel = self.relevances[query_id]\n ideal_ranking = sorted(rel.values(),reverse = True)[:5]\n \n # Only use query if there is a document with a positive ranking. (Otherwise IDCG will be 0 -> NDCG undetermined.)\n if not any(ideal_ranking):\n not_useful += 1\n continue\n \n current_sessions = sessions_dict[query_id]\n pred_rels = dict()\n for session in current_sessions:\n for rank, result in enumerate(session.web_results):\n if not result.id in pred_rels:\n pred_rels[result.id] = click_model.predict_relevance(session.query, result.id)\n ranking = sorted([doc for doc in pred_rels],key = lambda doc : pred_rels[doc], reverse = True)\n \n ranking_relevances = self.get_relevances(query_id, ranking[:5])\n \n dcg = self.dcg(ranking_relevances)\n idcg = self.dcg(ideal_ranking) \n ndcg = dcg / idcg\n total_ndcg += ndcg\n\n # If too few queries there might not be any useful queries that also have a ranking in the true_relevances.\n assert not len(useful_sessions)-not_useful is 0\n\n # Average NDCG over all queries\n return total_ndcg / (len(useful_sessions)-not_useful)","def test_get_qc_metrics(integrated_ff):\n\n key, ff_env = integrated_ff['ff_key'], integrated_ff['ff_env']\n uuid = '331106bc-8535-3338-903e-854af460b544'\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, key=key, ff_env=ff_env)\n assert len(qc_metrics.keys()) == 1\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\n target_qc = qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']\n assert 'QualityMetric' in target_qc['values']['@type']\n assert target_qc['organism'] == 'human'\n assert target_qc['experiment_type'] == 'Dilution Hi-C'\n assert target_qc['experiment_subclass'] == 'Hi-C'\n assert target_qc['source_file_association'] == 'processed_files'\n assert target_qc['source_experiment'] == '4DNEXO67APV1'\n assert target_qc['source_experimentSet'] == '4DNESOPFAAA1'\n assert target_qc['biosource_summary'] == \"GM12878\"\n\n kwargs = { # do same as above w/ kwargs, specify to include raw files this time\n 'key': key,\n 'ff_env': ff_env,\n 'include_raw_files': True\n }\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, **kwargs)\n assert len(qc_metrics.keys()) == 2\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\n assert '4c9dabc6-61d6-4054-a951-c4fdd0023800' in qc_metrics\n assert 'QualityMetric' in qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']['values']['@type']\n assert 'QualityMetric' in qc_metrics['4c9dabc6-61d6-4054-a951-c4fdd0023800']['values']['@type']","def qasmCircuitResults(self):\n returnedDictionary={}\n self.circutDrawing = self.draw()\n self.blochSpheres=self.separatedBlochSpheres()\n returnedDictionary[\"wires\"]=self.num_qubits\n returnedDictionary[\"probabilities\"] = self.separatedProbabilities()\n #returnedDictionary[\"blochSpheres\"] = self.separatedBlochSpheres()\n returnedDictionary[\"diracNotation\"] = self.diracNotation()\n returnedDictionary['chart'] = self.graph()\n returnedDictionary[\"link\"] = \"\"\n #returnedDictionary[\"qasmRows\"] = np.transpose(cols).tolist()\n \n if self.API_TOKEN != \"\":\n returnedDictionary[\"link\"] = self.runOnIBMQ()\n \n return returnedDictionary","def execute(self):\r\n factors = self.factors\r\n variables = list(self.variables)\r\n variables.remove(self.query)\r\n\r\n for fac in factors:\r\n self.set_observations(fac)\r\n\r\n for var in variables:\r\n if var not in self.obs:\r\n factors = self.eliminate_variable(var, factors)\r\n\r\n result = factor_module.multiply_batch(self.query, factors)\r\n denominator = sum(result.get_cpt())\r\n print(denominator)\r\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}","def summarize_hits(df_hsps, option_cov=\"mean\", option_pid=\"mean\"):\n\n # Sort HSPs by query start position\n df_hsps = np.sort(df_hsps, order=\"qstart\")\n\n # N-term delta between query and subject\n delta_lg = np.abs(df_hsps[\"qstart\"] - df_hsps[\"sstart\"])\n\n # C-term delta between query and subject and add to length difference between aligned sequences\n delta_lg += np.abs(\n (df_hsps[\"qlen\"][0] - df_hsps[\"qend\"][-1])\n - (df_hsps[\"slen\"][0] - df_hsps[\"send\"])\n )\n\n # Internal gaps\n query_starts = df_hsps[\"qstart\"][1:]\n query_ends = df_hsps[\"qend\"][:-1]\n subject_starts = df_hsps[\"sstart\"][1:]\n subject_ends = df_hsps[\"send\"][:-1]\n\n delta_lg += np.sum(\n np.abs((query_starts - query_ends) - (subject_starts - subject_ends))\n )\n\n # Calculate total length, score, Identities and Positives :\n length_total = np.sum(df_hsps[\"lgHSP\"])\n pos_total = np.sum(df_hsps[\"pos\"])\n # id_total = np.sum(df_hsps.id.values)\n\n # Cumulative length of HSPs / shortest seq. length = % coverage\n frac_HSPshlen = calculate_coverage(\n length_total=length_total,\n length_query=df_hsps[\"qlen\"][0],\n length_subject=df_hsps[\"slen\"][0],\n option_cov=option_cov,\n )\n\n # Number of positives / shortest seq. length = percentage of identity\n pospercentsh = calculate_percid(\n pos_total=pos_total,\n length_query=df_hsps[\"qlen\"][0],\n length_subject=df_hsps[\"slen\"][0],\n length_total=length_total,\n option_pid=option_pid,\n )\n\n evalue = max(df_hsps[\"evalue\"])\n\n return (\n delta_lg,\n frac_HSPshlen,\n pospercentsh,\n evalue,\n df_hsps[\"stitle\"][0].decode(\"utf-8\"),\n )","def query_sessions(task='all', stable=False, as_dataframe=False,\r\n force_30nov=False, criterion='biased'):\r\n\r\n # Query sessions\r\n if force_30nov is True:\r\n use_subjects = query_subjects(criterion=criterion).proj('subject_uuid')\r\n else:\r\n use_subjects = query_subjects().proj('subject_uuid')\r\n\r\n # Query all sessions or only training or biased if required\r\n if task == 'all':\r\n sessions = (acquisition.Session * subject.Subject * subject.SubjectLab * reference.Lab\r\n * use_subjects * behavior_analysis.SessionTrainingStatus\r\n & 'task_protocol LIKE \"%training%\" OR task_protocol LIKE \"%biased%\"').proj(\r\n 'session_uuid', 'subject_uuid', 'subject_nickname', 'institution_short',\r\n 'task_protocol', 'training_status')\r\n elif task == 'training':\r\n sessions = (acquisition.Session * subject.Subject * subject.SubjectLab * reference.Lab\r\n * use_subjects * behavior_analysis.SessionTrainingStatus\r\n & 'task_protocol LIKE \"%training%\"').proj(\r\n 'session_uuid', 'subject_uuid', 'subject_nickname', 'institution_short',\r\n 'task_protocol', 'training_status')\r\n elif task == 'biased':\r\n sessions = (acquisition.Session * subject.Subject * subject.SubjectLab * reference.Lab\r\n * use_subjects * behavior_analysis.SessionTrainingStatus\r\n & 'task_protocol LIKE \"%biased%\"').proj(\r\n 'session_uuid', 'subject_uuid', 'subject_nickname', 'institution_short',\r\n 'task_protocol', 'training_status')\r\n else:\r\n raise Exception('task must be all, training or biased')\r\n\r\n # Only use sessions up until the end of December\r\n sessions = sessions & 'date(session_start_time) <= \"2020-03-23\"'\r\n\r\n # If required only output sessions with stable hardware\r\n if stable is True:\r\n sessions = sessions & 'date(session_start_time) > \"2019-06-10\"'\r\n\r\n # Transform into pandas Dataframe if requested\r\n if as_dataframe is True:\r\n sessions = sessions.fetch(\r\n order_by='institution_short, subject_nickname, session_start_time', format='frame')\r\n sessions = sessions.reset_index()\r\n\r\n return sessions","def _compute_global_stats():\n global_stats = []\n \n wmt16_group = Group.objects.filter(name='WMT16')\n wmt16_users = _get_active_users_for_group(wmt16_group)\n \n # Check how many HITs have been completed. We now consider a HIT to be\n # completed once it has been annotated by one or more annotators.\n #\n # Before we required `hit.users.count() >= 3` for greater overlap.\n hits_completed = HIT.objects.filter(mturk_only=False, completed=True).count()\n \n # Check any remaining active HITs which are not yet marked complete.\n for hit in HIT.objects.filter(active=True, mturk_only=False, completed=False):\n if hit.users.count() >= 1:\n hits_completed = hits_completed + 1\n hit.completed = True\n hit.save()\n \n # Compute remaining HITs for all language pairs.\n hits_remaining = HIT.compute_remaining_hits()\n \n # Compute number of results contributed so far.\n ranking_results = RankingResult.objects.filter(\n item__hit__completed=True, item__hit__mturk_only=False)\n \n from math import factorial\n system_comparisons = 0\n for result in ranking_results:\n result.reload_dynamic_fields()\n # TODO: this implicitly counts A=B comparisons for multi systems.\n # Basically, inflating the number of pairwise comparisons... Fix!\n combinations = factorial(result.systems)/(factorial(result.systems-2) * 2) if result.systems > 2 else 0\n system_comparisons = system_comparisons + combinations\n \n # Aggregate information about participating groups.\n groups = set()\n for user in wmt16_users:\n for group in _identify_groups_for_user(user):\n groups.add(group)\n \n # Compute average/total duration over all results.\n durations = RankingResult.objects.all().values_list('duration', flat=True)\n total_time = sum([datetime_to_seconds(x) for x in durations])\n avg_time = total_time / float(hits_completed or 1)\n avg_user_time = total_time / float(3 * hits_completed or 1)\n \n global_stats.append(('Users', len(wmt16_users)))\n global_stats.append(('Groups', len(groups)))\n global_stats.append(('HITs completed', '{0:,}'.format(hits_completed)))\n global_stats.append(('HITs remaining', '{0:,}'.format(hits_remaining)))\n global_stats.append(('Ranking results', '{0:,}'.format(ranking_results.count())))\n global_stats.append(('System comparisons', '{0:,}'.format(system_comparisons)))\n global_stats.append(('Average duration (per HIT)', seconds_to_timedelta(avg_time)))\n global_stats.append(('Average duration (per task)', seconds_to_timedelta(avg_user_time)))\n global_stats.append(('Total duration', seconds_to_timedelta(total_time)))\n \n # Create new status data snapshot\n TimedKeyValueData.update_status_if_changed('users', str(len(wmt16_users)))\n TimedKeyValueData.update_status_if_changed('groups', str(len(groups)))\n TimedKeyValueData.update_status_if_changed('hits_completed', str(hits_completed))\n TimedKeyValueData.update_status_if_changed('hits_remaining', str(hits_remaining))\n TimedKeyValueData.update_status_if_changed('ranking_results', str(ranking_results.count()))\n TimedKeyValueData.update_status_if_changed('system_comparisons', str(system_comparisons))\n TimedKeyValueData.update_status_if_changed('duration_per_hit', str(seconds_to_timedelta(avg_time)))\n TimedKeyValueData.update_status_if_changed('duration_per_task', str(seconds_to_timedelta(avg_user_time)))\n TimedKeyValueData.update_status_if_changed('duration_total', str(seconds_to_timedelta(total_time)))\n \n return global_stats","def compute_subj_metrics():\n\t# each participant does task 1,2,3 with method A,B = 3*2*N\n\t# likert data includes age, gender, Q1 - Q10 = 2+10\n\n\t# set up data structure\n\tsubj_metrics = {}\n\tfor ID in range(10):\n\t\tfor method in [\"A\",\"B\"]:\n\t\t\t# sanity checks\n\t\t\tif ID not in subj_metrics:\n\t\t\t\tsubj_metrics[ID] = {}\n\t\t\tif method not in subj_metrics[ID]:\n\t\t\t\tsubj_metrics[ID][method] = [None]*12\n\n\there = os.path.dirname(os.path.realpath(__file__))\n\tsubdir = \"/data/experimental/\"\n\tdatapath = here + subdir + \"Likert_Responses.csv\"\n\n\tdata = {}\n\tfirstline = True\n\twith open(datapath, 'r') as f:\n\t\tfor line in f:\n\t\t\tif firstline:\n\t\t\t\tfirstline = False\n\t\t\t\tcontinue\n\t\t\tvalues = line.split(',')\n\t\t\tinfo = values[1:len(values)]\n\t\t\tID = int(info[9])\n\t\t\tmethod = info[10]\n\t\t\tage = info[11]\n\t\t\tgender = info[12]\n\t\t\t# store age\n\t\t\tsubj_metrics[ID][method][0] = age\n\t\t\tsubj_metrics[ID][method][1] = gender\n\t\t\t# parse likert data\n\t\t\tfor i in range(8):\n\t\t\t\tsubj_metrics[ID][method][i+2] = info[i]\n\t\t\tsubj_metrics[ID][method][10] = info[14]\n\t\t\tsubj_metrics[ID][method][11] = info[15]\n\n\treturn subj_metrics","def qcs(self):\n return self.aggregation","def itersessions(self):\n for x in np.unique(self.sessions):\n yield x, self.loc[self.sessions == x, :]","def get_results(self):\n d = {}\n# r = {}\n for analyser in self.xml_tree.getroot():\n for child in analyser:\n if child.tag == 'all-records':\n for record in child:\n attributes = record.attrib\n sample = attributes['sampleId']\n assay_id = attributes['assayId']\n genotype = attributes['genotypeId']\n quality = attributes['description'].split('.')[0]\n if re.match(r'rs\\d+', assay_id):\n if sample in d:\n if assay_id in d[sample]:\n for allele in list(genotype):\n if allele not in d[sample][assay_id]['genotype']:\n d[sample][assay_id]['genotype'] += allele\n if quality not in d[sample][assay_id]['quality']:\n d[sample][assay_id]['quality'].append(quality)\n else:\n d[sample][assay_id] = {'genotype': genotype, 'quality': [quality]}\n else:\n d[sample] = {assay_id: {'genotype': genotype, 'quality': [quality]}}\n# if sample in r:\n# if assay_id in r[sample]:\n# for allele in list(genotype):\n# if allele not in r[sample][assay_id]:\n# r[sample][assay_id] += allele\n# else:\n# r[sample][assay_id] = genotype\n# else:\n# r[sample] = {assay_id: genotype}\n# for k, v in r.items():\n# for k1, v1, in v.items():\n# if len(v1) == 1:\n# v[k1] += v1\n# pprint.pprint(r)\n# df = pd.DataFrame.from_dict(r).transpose()\n# print(df)\n# df.to_excel('snpcheck.xlsx')\n return d","def gather_results(dataset: Dataset,\n conf: Namespace\n ) -> \"dict[str, dict[str, any]]\":\n\n data = {}\n\n for k in np.copy(dataset.folds):\n print(f\"\\nFold {k}\", '~'*60)\n\n dataset.set_fold(k)\n calibrated_scores = APPROACHES[conf.approach](dataset=dataset, conf=conf)\n\n data[f'fold{k}'] = {\n 'scores': calibrated_scores,\n 'metrics': get_metrics(calibrated_scores, dataset, conf)\n }\n\n return data","def get_qps_as_dict(folder):\n df = process_oldisim_results(folder)\n return df.groupby(\"machine_type\").mean().QPS.to_dict()","def totalize_measurement(conts_dict, si_model):\n print('######## BEGIN CHECKING TOTAL ########')\n for cont_measure, doc_measure in [\n ['packages', 'total_packages'],\n ['container_weight', 'total_weight'],\n ['container_measurement', 'total_measurement']\n ]:\n doc_qua, doc_unit = split_quantity_unit(si_model[doc_measure])\n if not doc_qua:\n doc_qua = '0'\n if floatable(doc_qua.replace(',', '')):\n doc_qua = float(doc_qua.replace(',', ''))\n else:\n doc_qua = 0\n conts_detail = [\n split_quantity_unit(cont.get(cont_measure, '0'))\n for cont in conts_dict\n ]\n\n print(cont_measure, ':', conts_detail, '|', doc_qua, '-', doc_unit)\n\n conts_unit = list(set([\n cont_unit\n for cont_qua, cont_unit in conts_detail\n ]))\n if len(conts_unit) == 1:\n conts_sum = sum([\n float(cont_qua.replace(',', ''))\n for cont_qua, cont_unit in conts_detail\n if floatable(cont_qua.replace(',', ''))\n ])\n conts_unit = conts_unit[0]\n else:\n conts_sum = 0\n conts_unit = ''\n\n if conts_sum != doc_qua and conts_unit and conts_sum > 0:\n print('### Containers', cont_measure, conts_sum,\n '=/= SI', doc_measure, doc_qua, '###')\n if doc_measure == 'total_packages':\n si_model[doc_measure] = f\"{conts_sum:,.0f}\" + conts_unit\n else:\n si_model[doc_measure] = f\"{conts_sum:,.3f}\" + conts_unit\n\n return si_model","def sector_metrics_fx():\r\n global df_sector_metrics\r\n \r\n df_sector_metrics = df_co_metrics\r\n drop_company = ['company_ref']\r\n df_sector_metrics.drop(labels = drop_company, axis = 1, inplace = True)\r\n df_sector_metrics = df_sector_metrics.groupby(['date_list', 'sector']).agg({'co_inv_overall': 'sum', 'co_inv_50k': 'sum', 'co_inv_100k': 'sum', 'co_inv_manager': 'sum', 'co_inv_sales': 'sum', 'co_inv_key_roles': 'sum', 'co_inv_it': 'sum', 'co_inv_hourly': 'sum','co_fut_cost_overall': 'sum', 'co_fut_cost_50k': 'sum', 'co_fut_cost_100k': 'sum', 'co_fut_cost_manager': 'sum', 'co_fut_cost_sales': 'sum', 'co_fut_cost_key_roles': 'sum', 'co_fut_cost_it': 'sum', 'co_fut_cost_hourly': 'sum','co_inv_overall_28d': 'sum', 'co_inv_50k_28d': 'sum', 'co_inv_100k_28d': 'sum', 'co_inv_manager_28d': 'sum', 'co_inv_sales_28d': 'sum', 'co_inv_key_roles_28d': 'sum', 'co_inv_it_28d': 'sum', 'co_inv_hourly_28d': 'sum','co_fut_cost_overall_28d': 'sum', 'co_fut_cost_50k_28d': 'sum', 'co_fut_cost_100k_28d': 'sum', 'co_fut_cost_manager_28d': 'sum', 'co_fut_cost_sales_28d': 'sum', 'co_fut_cost_key_roles_28d': 'sum', 'co_fut_cost_it_28d': 'sum', 'co_fut_cost_hourly_28d': 'sum'})","def profile_group(func, args, kwargs, func_result):\n (collection, key, condition, initial, reduce) = args[:5]\n report_kvs = _profile_query(collection)\n\n if key:\n report_kvs['Group_Key'] = _to_json(key)\n\n if condition:\n report_kvs['Group_Condition'] = _to_json(condition)\n\n if initial:\n report_kvs['Group_Initial'] = _to_json(initial)\n\n if reduce:\n report_kvs['Group_Reduce'] = reduce\n\n return report_kvs","def summarize(\n self,\n key: Callable[['Classification'], Union[Iterable[str], str]] = None,\n top_k: int = None,\n ):\n ctr = Counter(sorted(filter(None, flatmap(key, self.values()))))\n return [elt for elt, _ in ctr.most_common(top_k)]","def summarize_data(data, summary_keys):\n summary = {}\n latest_iteration_number = len(data.keys())\n current_value = None\n\n for key in summary_keys:\n summary[key] = []\n # Compute per-iteration average of the given key.\n for i in range(latest_iteration_number):\n iter_key = '{}{}'.format(ITERATION_PREFIX, i)\n # We allow reporting the same value multiple times when data is missing.\n # If there is no data for this iteration, use the previous'.\n if iter_key in data:\n current_value = np.mean(data[iter_key][key])\n summary[key].append(current_value)\n\n return summary","def co_metrics_fx():\r\n global co_metric_dict, df_co_metrics\r\n co_metric_dict = OrderedDict()\r\n intermediate_date_list = []\r\n intermediate_company_list = []\r\n intermediate_industry_list = []\r\n intermediate_inv_count_list = []\r\n intermediate_inv_50k_list = []\r\n intermediate_inv_100k_list = []\r\n intermediate_inv_manager_list = []\r\n intermediate_inv_sales_list = []\r\n intermediate_inv_key_roles_list = []\r\n intermediate_inv_it_list = []\r\n intermediate_inv_hourly_list = []\r\n intermediate_cost_count_list = []\r\n intermediate_cost_50k_list = []\r\n intermediate_cost_100k_list = []\r\n intermediate_cost_manager_list = []\r\n intermediate_cost_sales_list = []\r\n intermediate_cost_key_roles_list = []\r\n intermediate_cost_it_list = []\r\n intermediate_cost_hourly_list = []\r\n for x in range(len(unique_companies)):\r\n chosen_company = unique_companies[x]\r\n df_company = df_final[df_final['company_ref'] == chosen_company]\r\n sector_index_list = df_company.index.tolist()\r\n company_sector = df_final.at[sector_index_list[0], 'Sector']\r\n print(x)\r\n for y in range(len(date_list)):\r\n chosen_date = date_list[y]\r\n \r\n df_count = df_company[(df_company['post_date'] <= chosen_date) & (df_company['remove_date'] >= chosen_date)]\r\n inv_count_value = df_count['job_id'].count()\r\n co_inv_overall = inv_count_value\r\n \r\n df_50k = df_count[df_count['salary'] > 50000]\r\n salary_50k_count_value = df_50k['job_id'].count()\r\n co_inv_50k = salary_50k_count_value\r\n \r\n df_100k = df_count[df_count['salary'] > 100000]\r\n salary_100k_count_value = df_100k['job_id'].count()\r\n co_inv_100k = salary_100k_count_value\r\n \r\n df_manager = df_count[df_count['manager_role'] == 1]\r\n manager_count_value = df_manager['job_id'].count()\r\n co_inv_manager = manager_count_value\r\n \r\n df_sales = df_count[df_count['sales_role'] == 1]\r\n sales_count_value = df_sales['job_id'].count()\r\n co_inv_sales = sales_count_value\r\n \r\n df_key_roles = df_count[df_count['key_roles_role'] == 1]\r\n key_roles_count_value = df_key_roles['job_id'].count()\r\n co_inv_key_roles = key_roles_count_value\r\n \r\n df_it = df_count[df_count['it_role'] == 1]\r\n it_count_value = df_it['job_id'].count()\r\n co_inv_it = it_count_value\r\n \r\n df_hourly = df_count[df_count['hourly_role'] == 1]\r\n hourly_count_value = df_hourly['job_id'].count()\r\n co_inv_hourly = hourly_count_value\r\n\r\n df_count = df_company[(df_company['post_date'] <= chosen_date) & (df_company['remove_date'] >= chosen_date)]\r\n cost_count_value = df_count['salary'].sum()\r\n co_cost_overall = cost_count_value\r\n \r\n df_50k = df_count[df_count['salary'] > 50000]\r\n salary_50k_cost_value = df_50k['salary'].sum()\r\n co_cost_50k = salary_50k_cost_value\r\n \r\n df_100k = df_count[df_count['salary'] > 100000]\r\n salary_100k_cost_value = df_100k['salary'].sum()\r\n co_cost_100k = salary_100k_cost_value\r\n \r\n df_manager = df_count[df_count['manager_role'] == 1]\r\n manager_cost_value = df_manager['salary'].sum()\r\n co_cost_manager = manager_cost_value\r\n \r\n df_sales = df_count[df_count['sales_role'] == 1]\r\n sales_cost_value = df_sales['salary'].sum()\r\n co_cost_sales = sales_cost_value\r\n \r\n df_key_roles = df_count[df_count['key_roles_role'] == 1]\r\n key_roles_cost_value = df_key_roles['salary'].sum()\r\n co_cost_key_roles = key_roles_cost_value\r\n \r\n df_it = df_count[df_count['it_role'] == 1]\r\n it_cost_value = df_it['salary'].sum()\r\n co_cost_it = it_cost_value\r\n \r\n df_hourly = df_count[df_count['hourly_role'] == 1]\r\n hourly_cost_value = df_hourly['salary'].sum()\r\n co_cost_hourly = hourly_cost_value\r\n \r\n \r\n \r\n intermediate_date_list.append(chosen_date)\r\n intermediate_company_list.append(chosen_company)\r\n intermediate_industry_list.append(company_sector)\r\n intermediate_inv_count_list.append(co_inv_overall)\r\n intermediate_inv_50k_list.append(co_inv_50k)\r\n intermediate_inv_100k_list.append(co_inv_100k)\r\n intermediate_inv_manager_list.append(co_inv_manager)\r\n intermediate_inv_sales_list.append(co_inv_sales)\r\n intermediate_inv_key_roles_list.append(co_inv_key_roles)\r\n intermediate_inv_it_list.append(co_inv_it)\r\n intermediate_inv_hourly_list.append(co_inv_hourly)\r\n\r\n intermediate_cost_count_list.append(co_cost_overall)\r\n intermediate_cost_50k_list.append(co_cost_50k)\r\n intermediate_cost_100k_list.append(co_cost_100k)\r\n intermediate_cost_manager_list.append(co_cost_manager)\r\n intermediate_cost_sales_list.append(co_cost_sales)\r\n intermediate_cost_key_roles_list.append(co_cost_key_roles)\r\n intermediate_cost_it_list.append(co_cost_it)\r\n intermediate_cost_hourly_list.append(co_cost_hourly)\r\n \r\n co_metric_dict['date_list'] = intermediate_date_list\r\n co_metric_dict['company_ref'] = intermediate_company_list\r\n co_metric_dict['sector'] = intermediate_industry_list\r\n co_metric_dict['co_inv_overall'] = intermediate_inv_count_list\r\n co_metric_dict['co_inv_50k'] = intermediate_inv_50k_list\r\n co_metric_dict['co_inv_100k'] = intermediate_inv_100k_list\r\n co_metric_dict['co_inv_manager'] = intermediate_inv_manager_list\r\n co_metric_dict['co_inv_sales'] = intermediate_inv_sales_list\r\n co_metric_dict['co_inv_key_roles'] = intermediate_inv_key_roles_list\r\n co_metric_dict['co_inv_it'] = intermediate_inv_it_list\r\n co_metric_dict['co_inv_hourly'] = intermediate_inv_hourly_list\r\n \r\n co_metric_dict['co_fut_cost_overall'] = intermediate_cost_count_list\r\n co_metric_dict['co_fut_cost_50k'] = intermediate_cost_50k_list\r\n co_metric_dict['co_fut_cost_100k'] = intermediate_cost_100k_list\r\n co_metric_dict['co_fut_cost_manager'] = intermediate_cost_manager_list\r\n co_metric_dict['co_fut_cost_sales'] = intermediate_cost_sales_list\r\n co_metric_dict['co_fut_cost_key_roles'] = intermediate_cost_key_roles_list\r\n co_metric_dict['co_fut_cost_it'] = intermediate_cost_it_list\r\n co_metric_dict['co_fut_cost_hourly'] = intermediate_cost_hourly_list\r\n\r\n df_co_metrics = pd.DataFrame(co_metric_dict, columns=co_metric_dict.keys())","def calculate_metrics(self):\n self.data_stats = self.sqlContext.read.format(\"org.apache.spark.sql.cassandra\").options(table=self.cassandra_trip_table, keyspace=self.cassandra_keyspace).load()\n self.data_stats = self.data_stats.groupBy(['time_block','day','month','borough_name']).agg(func.avg('num_trips').alias('mean'))","def aggregate_batch_evals(result_dict: dict, all_runs: list) -> dict:\n # Loop over all evals (e.g. b_1_eval_0) and merge + aggregate data\n new_results_dict = {}\n for eval in all_runs:\n all_seeds_for_run = list(result_dict[eval].keys())\n eval_dict = aggregate_single_eval(result_dict[eval], all_seeds_for_run, eval)\n new_results_dict[eval] = eval_dict[eval]\n return new_results_dict","def measure(self, qubit_expr, key=None):\n qubit = self.qr.get(qubit_expr)\n self.append(cirq.measure(qubit, key=key))","def analyze_count(data):\n\n dsct_vk = pd.unique(data['vk'])\n dsct_itemid = pd.unique(data['itemid'])\n\n print 'number of user:', dsct_vk.shape\n print 'number of items:', dsct_itemid.shape\n print 'the number of ratings:', data.shape\n\n print 'unique actions:', pd.unique(data['action'])\n print 'the number of action 0:', np.sum(data['action'] == 0)\n print 'the number of action 1:', np.sum(data['action'] == 1)\n print 'the number of action 2:', np.sum(data['action'] == 2)\n print 'the number of action 3:', np.sum(data['action'] == 3)\n print 'the number of action 4:', np.sum(data['action'] == 4)\n \n time_range_item = data.groupby('itemid')['real_time'].aggregate(sum_unique)\n print 'Max Range:', np.max(time_range_item)\n print 'Mean Range:', np.mean(time_range_item)\n print 'Median Range:', np.median(time_range_item)","def summary(self):\n summary = defaultdict(int)\n\n for r in self.results:\n summary[r.result] += 1\n\n return summary","def aggregate_qcdata(qcdata):\n\n # DD\n log.debug('Aggregating daily DD QC Data')\n curr_ts, last_ts = datetime.strptime(qcdata['TIMESTAMP_START'][0], '%Y%m%d%H%M'), datetime.strptime(qcdata['TIMESTAMP_START'][-1], '%Y%m%d%H%M')\n curr_y, first_y, last_y = curr_ts.year, curr_ts.year, last_ts.year\n entries_dd = 0\n while curr_y <= last_y:\n days_in_year = 366 if calendar.isleap(curr_y) else 365\n entries_dd += days_in_year\n curr_y += 1\n dtype = [(vlabel, 'f8') for vlabel in NEW_METEO_VARS if vlabel in qcdata.dtype.names]\n dtype_ext = dtype + [(vlabel + PERC_LABEL, 'f8') for vlabel, _ in dtype]\n dtype_dd = TIMESTAMP_DTYPE_BY_RESOLUTION['dd'] + dtype_ext\n data_dd = numpy.empty(entries_dd, dtype=dtype_dd)\n data_dd.fill(-9999)\n day_diff = timedelta(hours=24)\n curr_idx = 0\n while curr_ts <= last_ts:\n if curr_idx % 300 == 0:\n log.debug(\"Aggregating day {d}\".format(d=curr_idx))\n dd = curr_ts.strftime('%Y%m%d')\n data_dd['TIMESTAMP'][curr_idx] = dd\n mask_dd = numpy.char.startswith(qcdata['TIMESTAMP_START'], dd)\n for vlabel, _ in dtype:\n values = qcdata[vlabel][mask_dd]\n perc = float(values[values > -9999].size) / float(values.size)\n if perc > 0.5:\n mean = numpy.mean(values[values > -9999])\n else:\n mean = -9999\n perc = -9999\n data_dd[vlabel][curr_idx] = mean\n data_dd[vlabel + PERC_LABEL][curr_idx] = perc\n curr_idx += 1\n curr_ts += day_diff\n\n # WW\n log.debug('Aggregating weekly WW QC Data')\n recs_ww = 52\n dtype_ww = TIMESTAMP_DTYPE_BY_RESOLUTION['ww'] + dtype_ext\n data_ww = numpy.empty((last_y - first_y + 1) * recs_ww, dtype=dtype_ww)\n data_ww.fill(-9999)\n for idx, year in enumerate(range(first_y, last_y + 1)):\n first_rec = idx * recs_ww\n curr_rec = first_rec\n last_rec = first_rec + recs_ww\n f = datetime(year, 1, 1, 0, 0)\n data_ww['TIMESTAMP_START'][first_rec:last_rec] = [(f + timedelta(days=i * 7)).strftime('%Y%m%d') for i in xrange(0, recs_ww)]\n data_ww['TIMESTAMP_END'][first_rec:last_rec] = [(datetime.strptime(i, '%Y%m%d') + timedelta(days=6)).strftime('%Y%m%d') for i in data_ww['TIMESTAMP_START'][first_rec:last_rec]]\n data_ww['TIMESTAMP_END'][last_rec - 1] = datetime(year, 12, 31, 0, 0).strftime('%Y%m%d')\n while curr_rec < last_rec:\n first_idx, last_idx = numpy.where(data_dd['TIMESTAMP'] == data_ww['TIMESTAMP_START'][curr_rec])[0][0], numpy.where(data_dd['TIMESTAMP'] == data_ww['TIMESTAMP_END'][curr_rec])[0][0]\n for vlabel, _ in dtype:\n values = data_dd[vlabel][first_idx:last_idx]\n values_perc = data_dd[vlabel + PERC_LABEL][first_idx:last_idx]\n values_perc[values_perc <= -9999] = 0.0\n perc = numpy.mean(values_perc)\n if perc > 0.5:\n mean = numpy.mean(values[values > -9999])\n else:\n mean = -9999\n perc = -9999\n data_ww[vlabel][curr_rec] = mean\n data_ww[vlabel + PERC_LABEL][curr_rec] = perc\n curr_rec += 1\n\n\n # MM\n log.debug('Aggregating monthly MM QC Data')\n recs_mm = 12\n dtype_mm = TIMESTAMP_DTYPE_BY_RESOLUTION['mm'] + dtype_ext\n data_mm = numpy.empty((last_y - first_y + 1) * recs_mm, dtype=dtype_mm)\n data_mm.fill(-9999)\n data_mm['TIMESTAMP'] = [str(y) + str(m).zfill(2) for y in range(first_y, last_y + 1) for m in range(1, recs_mm + 1)]\n for idx, mm in enumerate(data_mm['TIMESTAMP']):\n mask_mm = numpy.char.startswith(data_dd['TIMESTAMP'], mm)\n for vlabel, _ in dtype:\n values = data_dd[vlabel][mask_mm]\n values_perc = data_dd[vlabel + PERC_LABEL][mask_mm]\n values_perc[values_perc <= -9999] = 0.0\n perc = numpy.mean(values_perc)\n if perc > 0.5:\n mean = numpy.mean(values[values > -9999])\n else:\n mean = -9999\n perc = -9999\n data_mm[vlabel][idx] = mean\n data_mm[vlabel + PERC_LABEL][idx] = perc\n\n # YY\n log.debug('Aggregating yearly YY QC Data')\n dtype_yy = TIMESTAMP_DTYPE_BY_RESOLUTION['yy'] + dtype_ext\n data_yy = numpy.empty((last_y - first_y + 1), dtype=dtype_yy)\n data_yy.fill(-9999)\n data_yy['TIMESTAMP'] = [str(y) for y in range(first_y, last_y + 1)]\n for idx, yy in enumerate(data_yy['TIMESTAMP']):\n mask_yy = numpy.char.startswith(data_dd['TIMESTAMP'], yy)\n for vlabel, _ in dtype:\n values = data_dd[vlabel][mask_yy]\n values_perc = data_dd[vlabel + PERC_LABEL][mask_yy]\n values_perc[values_perc <= -9999] = 0.0\n perc = numpy.mean(values_perc)\n if perc > 0.5:\n mean = numpy.mean(values[values > -9999])\n else:\n mean = -9999\n perc = -9999\n data_yy[vlabel][idx] = mean\n data_yy[vlabel + PERC_LABEL][idx] = perc\n\n return data_dd, data_ww, data_mm, data_yy","def collect_data(self):\n exp_conf: ec.ExperimentConfiguration\n # Disabled multiprocess run because of huge memory usage\n processes_number = 1 # self._campaign_configuration['General']['j']\n if processes_number == 1:\n self._logger.info(\"-->Evaluate experiments (sequentially)\")\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\n exp_conf.evaluate()\n if bool(self._campaign_configuration['General']['generate_plots']):\n exp_conf.generate_plots()\n self._logger.info(\"<--\")\n else:\n self._logger.info(\"-->Evaluate experiments (in parallel)\")\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\n if bool(self._campaign_configuration['General']['generate_plots']):\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\n self._logger.info(\"<--\")\n\n self.raw_results = {}\n for exp_conf in self._exp_confs:\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes","def mean_accuracy_per_setting(results):\n ###TODO\n min_freq = {}\n feature = {}\n punct = {}\n \n #step 1 -> loop over results to get list of values for particular \n # setting of punct, features,min_freq \n #keys = ['punct','features','min_freq','accuracy']\n \n for d in results:\n \n if d['min_freq'] not in min_freq.keys():\n min_freq.setdefault(d['min_freq'],[]).append(d['accuracy'])\n else :\n min_freq[d['min_freq']].append(d['accuracy'])\n \n if d['punct'] not in punct.keys():\n punct.setdefault(d['punct'],[]).append(d['accuracy'])\n else :\n punct[d['punct']].append(d['accuracy'])\n \n if d['features'] not in feature.keys(): \n feature.setdefault(d['features'],[]).append(d['accuracy'])\n else : \n feature[d['features']].append(d['accuracy'])\n \n \n #print('min_freq = ',min_freq)\n #print('feature = ',feature)\n #print('punct = ',punct) \n \n # step 2 -> find average for each setting\n tuple_list = [] \n for fet in feature.keys():\n \n t1 = 'features='\n for f in fet:\n t1 += f.__name__ + ' '\n \n #print(t1)\n avg = np.mean(feature[fet],dtype=np.float64) \n tuple_list.append((avg,t1))\n\n\n #print('After features result = ',result) \n \n for freq in min_freq.keys():\n t1 = 'min_freq=' + str(freq)\n avg = np.mean(min_freq[freq],dtype=np.float64) \n tuple_list.append((avg,t1))\n \n #print('After mean_freq result = ',result) \n \n for pun in punct.keys():\n t1 = 'punct=' + str(pun)\n avg = np.mean(punct[pun],dtype=np.float64) \n tuple_list.append((avg,t1))\n \n #print('After punct result = ',result) \n \n \n tuple_list.sort(key=lambda x:(-x[0]))\n #print('2.Sorted result = ',result) \n \n \n return(tuple_list) \n \n pass","def algorithm(df, params):\n\n output = {}\n\n # PUT YOUR OWN IMPLEMENTATION HERE\n # STORE YOUR ANALYSIS OUTPUT IN OUTPUT\n\n return output","def _cv_results(self, metrics):\n\n param_keys = self.param_combs[0].keys()\n param_dict = {k: [comb[k] for comb in self.param_combs]\n for k in param_keys}\n df_metric_result = {k: pd.DataFrame({'Metric mean': self.mean[k],\n 'Std. dev.': self.std[k],\n **param_dict})\n for k in metrics.keys()}\n self.cv_results_ = df_metric_result","def score_aggregate(results):\n scores = []\n truth_count = detected_count = segment_count = 0\n\n for res in results:\n scores.append(res[\"scores\"])\n truth_count += len(res[\"labels\"])\n detected_count += len(res[\"detected\"])\n segment_count += len(res[\"scores\"][\"segments\"])\n\n ret = dict()\n ret[\"scores\"] = sum_scores(scores)\n ret[\"stats\"] = dict(truth_count=truth_count, detected_count=detected_count, segment_count=segment_count)\n return ret","def get_params_dist_single_subject(raw_path, results_path):\n if type(results_path) == str:\n res_df = pd.read_csv(results_path, index_col=0)\n else:\n res_df = results_path\n\n au_top, au_top_acc = [], []\n fe_top, fe_top_acc = [], []\n pca_dims, pca_dims_acc = [], []\n\n for test_type in range(1, 6):\n res_test = res_df[res_df.test_type == '[' + str(test_type) + ']']\n\n # AU top-n options and their mean accuracies\n au_top_opts = res_df.au_top.unique().tolist()\n au_mean_accs = []\n\n for au_top_opt in au_top_opts:\n au_mean_accs.append(res_test[res_test.au_top == au_top_opt].mean_test_score.mean())\n\n au_top.append(au_top_opts)\n au_top_acc.append(au_mean_accs)\n\n # Features top-n options and their mean accuracies\n fe_top_opts = res_df.fe_top.unique().tolist()\n fe_mean_accs = []\n\n for fe_top_opt in fe_top_opts:\n fe_mean_accs.append(res_test[res_test.fe_top == fe_top_opt].mean_test_score.mean())\n\n fe_top.append(fe_top_opts)\n fe_top_acc.append(fe_mean_accs)\n\n # PCA dimension options and their mean accuracies\n pca_dim_opts = res_df.pca_dim.unique().tolist()\n pca_dim_mean_accs = []\n\n for pca_dim_opt in pca_dim_opts:\n pca_dim_mean_accs.append(res_test[res_test.pca_dim == pca_dim_opt].mean_test_score.mean())\n\n pca_dims.append(pca_dim_opts)\n pca_dims_acc.append(pca_dim_mean_accs)\n\n return au_top, au_top_acc, fe_top, fe_top_acc, pca_dims, pca_dims_acc","def aggregate_single_eval( # noqa: C901\n result_dict: dict, all_seeds_for_run: list, eval_name: str\n) -> dict:\n new_results_dict = {}\n data_temp = result_dict[all_seeds_for_run[0]]\n # Get all main data source keys (\"meta\", \"stats\", \"time\")\n data_sources = list(data_temp.keys())\n # Get all variables within the data sources\n data_items = {\n data_sources[i]: list(data_temp[data_sources[i]].keys())\n for i in range(len(data_sources))\n }\n # Collect all runs together - data at this point is not modified\n source_to_store = {key: {} for key in data_sources}\n for ds in data_sources:\n data_to_store = {key: [] for key in data_items[ds]}\n for i, o_name in enumerate(data_items[ds]):\n for i, seed_id in enumerate(all_seeds_for_run):\n seed_run = result_dict[seed_id]\n data_to_store[o_name].append(seed_run[ds][o_name][:])\n source_to_store[ds] = data_to_store\n new_results_dict[eval_name] = source_to_store\n\n # Aggregate over the collected runs\n aggregate_sources = {key: {} for key in data_sources}\n for ds in data_sources:\n if ds in [\"time\"]:\n aggregate_dict = {key: {} for key in data_items[ds]}\n for i, o_name in enumerate(data_items[ds]):\n aggregate_dict[o_name] = new_results_dict[eval_name][ds][o_name][0]\n # Mean over stats data\n elif ds in [\"stats\"]:\n aggregate_dict = {key: {} for key in data_items[ds]}\n for i, o_name in enumerate(data_items[ds]):\n if type(new_results_dict[eval_name][ds][o_name][0][0]) not in [\n str,\n bytes,\n np.bytes_,\n np.str_,\n ]:\n # Compute mean and standard deviation over seeds\n mean_tol, std_tol = tolerant_mean(\n new_results_dict[eval_name][ds][o_name]\n )\n aggregate_dict[o_name][\"mean\"] = mean_tol\n aggregate_dict[o_name][\"std\"] = std_tol\n\n # Compute 10, 25, 50, 75, 90 percentiles over seeds\n p50, p10, p25, p75, p90 = tolerant_median(\n new_results_dict[eval_name][ds][o_name]\n )\n aggregate_dict[o_name][\"p50\"] = p50\n aggregate_dict[o_name][\"p10\"] = p10\n aggregate_dict[o_name][\"p25\"] = p25\n aggregate_dict[o_name][\"p75\"] = p75\n aggregate_dict[o_name][\"p90\"] = p90\n else:\n aggregate_dict[o_name] = new_results_dict[eval_name][ds][o_name]\n # Append over all meta data (strings, seeds nothing to mean)\n elif ds == \"meta\":\n aggregate_dict = {}\n for i, o_name in enumerate(data_items[ds]):\n temp = (\n np.array(new_results_dict[eval_name][ds][o_name])\n .squeeze()\n .astype(\"U200\")\n )\n # Get rid of duplicate experiment dir strings\n if o_name in [\n \"experiment_dir\",\n \"eval_id\",\n \"config_fname\",\n \"model_type\",\n ]:\n aggregate_dict[o_name] = str(np.unique(temp)[0])\n else:\n aggregate_dict[o_name] = temp\n\n # Add seeds as clean array of integers to dict\n aggregate_dict[\"seeds\"] = [int(s.split(\"_\")[1]) for s in all_seeds_for_run]\n else:\n raise ValueError\n aggregate_sources[ds] = aggregate_dict\n new_results_dict[eval_name] = aggregate_sources\n return new_results_dict","def _group_sessions_if_useful(self, sessions, useful):\n sessions_dict = dict()\n for session in sessions:\n if session.query in useful:\n if not session.query in sessions_dict:\n sessions_dict[session.query] = []\n sessions_dict[session.query].append(session)\n return sessions_dict","def keys(self):\n # This function implements the heart of the table logic. We manually\n # combine keys using the operators indicated by FactorExprNode objects.\n # The reason this method is part of DataCube and not implemented in\n # FactorExprNode is because the latter is meant to be a purely\n # declarative representation of the expression graph, not an imperative\n # utility class.\n \n if self._expr is None:\n # We are being asked for the keys of some raw underlying data.\n # If this is a numpy array, just return integer indices. If this\n # is a Pandas DataFrame, we can return its index.\n if isinstance(self._data, np.ndarray):\n return range(self._data.shape[0])\n elif hasattr(self._data, \"index\"):\n return self._data.index\n else:\n # TODO: For now, all faceting operations require that we have a \n # pandas DataFrame to compute the factors/levels. Integrate Bryan's\n # Level DType stuff to make this support regular ndarrays.\n if not hasattr(self._data, \"groupby\"):\n raise RuntimeError(\"Data needs to support group-by functionality\")\n op = self._expr.op\n if op is None:\n # Do a simple group-by\n return self._data.groupby(self._expr.factors)\n\n elif op == \"blend\":\n # Set union of keys from the two operands of the blend\n left, right = self._expr.factors\n keys = set.union(set(self._data.groupby(left).keys()), set(self._data.groupby(right).keys()))\n return keys\n \n elif op == \"cross\":\n return [self._data.groupby(left).keys(), self._data.groupby(right).keys()]\n\n elif op == \"nest\":\n # Nested group-by. In effect like a cross that rejects null\n # intersections between its input dimensions.\n # We need to loop over the keyspace of our left operand and\n # then do a group-by according to the factor named in the\n # right operand. If the left operand is a cross, then we\n # need to do the outer product, and we return two lists.\n # TODO\n raise NotImplementedError","def aggregate_counties(self, parent):\n data = {}\n for division in tqdm(\n Division.objects.filter(level=self.COUNTY_LEVEL, parent=parent)\n ):\n fips = division.code\n aggregated_labels = [] # Keep track of already agg'ed variables\n for estimate in division.census_estimates.all():\n series = estimate.variable.table.series\n year = estimate.variable.table.year\n table = estimate.variable.table.code\n label = estimate.variable.label.label\n table_label = '{}{}'.format(table, label)\n code = estimate.variable.code\n if series not in data:\n data[series] = {}\n if year not in data[series]:\n data[series][year] = {}\n if table not in data[series][year]:\n data[series][year][table] = {}\n if fips not in data[series][year][table]:\n data[series][year][table][fips] = {}\n if label is not None:\n if table_label not in aggregated_labels:\n aggregated_labels.append(table_label)\n data[series][year][table][fips][label] \\\n = self.aggregate_variable(estimate, fips)\n else:\n data[series][year][table][division.code][code] \\\n = estimate.estimate\n return data","def test_result(data, seq_test, **kwargs):\n if isinstance(data, list) == False:\n \n pred,consum, ind_con = seq_test(data, **kwargs)\n result = {'acc': np.mean(pred[:,1] == data[:,1]),\n 'sens': recall_score(data[:,1], pred[:,1]),\n 'spec': specificity_score(data[:,1], pred[:,1]),\n 'PPV': precision_score(data[:, 1], pred[:,1]),\n 'NPV': npv_score(data[:, 1], pred[:,1]),\n 'test_consum': consum,\n 'ind_consum': ind_con,\n 'batch_consum': consum - ind_con}\n return result\n else:\n length = len(data)\n acc = np.zeros(length)\n sens = np.zeros(length)\n spec = np.zeros(length)\n ppv = np.zeros(length)\n npv = np.zeros(length)\n test_consum = np.zeros(length)\n ind_consum = np.zeros(length)\n batch_consum = np.zeros(length)\n for i in range(length):\n \n pred,consum, ind_con = seq_test(data[i], **kwargs)\n \n acc[i] = np.mean(pred[:,1] == data[i][:,1])\n sens[i] = recall_score(data[i][:,1], pred[:,1])\n spec[i] = specificity_score(data[i][:,1], pred[:,1])\n ppv[i] = precision_score(data[i][:,1], pred[:,1])\n npv[i] = npv_score(data[i][:,1], pred[:,1])\n test_consum[i] = consum\n ind_consum[i] = ind_con\n batch_consum[i] = consum-ind_con\n\n result = {'acc': acc,\n 'sens': sens,\n 'spec': spec,\n 'PPV': ppv,\n 'NPV': npv,\n 'test_consum': test_consum,\n 'ind_consum': ind_consum,\n 'batch_consum': batch_consum}\n return pd.DataFrame(result)","def __save_aggregate_scores(self):\n results = pd.DataFrame(\n columns=self.results[list(self.results.keys())[0]],\n index=self.results.keys(),\n )\n for row_name, time_bins in self.results.items():\n for column_name, value in time_bins.items():\n results.loc[row_name, column_name] = value\n results.reindex(sorted(results.columns, reverse=True), axis=1).to_csv(\n self.df_save_path\n )","def evaluation(self):\n rows_list = []\n for name in self.single_classifier_best.keys():\n row = {}\n row['algorithm'] = name \n row[self.scoring_metric] = self.single_classifier_best[name].best_score_\n rows_list.append(row)\n \n scoring_df = pd.DataFrame(rows_list)\n scoring_sorted = scoring_df.sort_values(self.scoring_metric, ascending=False)\n print()\n print('*'*shutil.get_terminal_size().columns)\n print(scoring_sorted)\n print('*'*shutil.get_terminal_size().columns)\n self.evaluation_scores = scoring_sorted","def qc_metrics(self, files_in, qc_files):\n self.cmd(\"{samtools} index {bam_in}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in=files_in[0],\n ),\n shell=True)\n self.cmd(\"{samtools} idxstats {bam_in} | tee {qc_file}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in = files_in[0],\n qc_file = qc_files[0],\n ),\n shell=True,\n log_output=True)\n self.cmd(\"{samtools} flagstat {bam_in} | tee {qc_file}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in = files_in[0],\n qc_file = qc_files[1],\n ),\n shell=True,\n log_output=True)\n \n self.checkpoint(qc_files[0])\n self.checkpoint(qc_files[1])\n self.checkpoint(qc_files[2])","def reduce_result(results):\n agg = OrderedDict()\n for result in results:\n # Keys by model and explore, adds additional values for `passed` to a set\n agg.setdefault((result[\"model\"], result[\"explore\"]), set()).add(\n result[\"passed\"]\n )\n reduced = [\n {\"model\": k[0], \"explore\": k[1], \"passed\": min(v)}\n for k, v in agg.items()\n ]\n return reduced","def cross_valid_key(model,x,key,preds,target,metric,verbose=True): \r\n\r\n score=[]\r\n \r\n keys = x[key].unique().tolist()\r\n \r\n\r\n\r\n for idx, item in enumerate([1,2,3,4,5]):\r\n\r\n xtrain,xtest = split_camp(x,keys,0.2)\r\n \r\n model.fit(xtrain[feat],xtrain[target])\r\n\r\n ypred = model.predict(xtest[feat])\r\n \r\n ytrue= xtest[target].values \r\n \r\n if metric == 'mae':\r\n score.append(mae(ytrue,ypred))\r\n elif metric == 'mse':\r\n score.append(mse(ytrue,ypred))\r\n elif metric == 'rrmse':\r\n score.append(rrmse(ytrue,ypred))\r\n\r\n else:\r\n score.append(rmse(xtest[target].tolist(),ypred))\r\n\r\n if verbose:\r\n print('-'*30)\r\n print(f'\\nFold {idx} out of 5')\r\n print(f'Key {item}')\r\n print(f'{metric}: {score[idx]}')\r\n\r\n \r\n\r\n if verbose:\r\n print(f'\\n Overall Score:')\r\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\r\n\r\n\r\n return score","def usefulquantities(dffin):\n dffin['log_length_box'] = np.log(dffin['length_box_um'])\n dffin['time_min']=dffin['time_sec']/60\n dffin['pred_length_box_um'] = np.exp(dffin['pred_log_length'])\n dffin['unique_id'] = dffin['cell']+dffin['time_sec'].apply(lambda x:str(x))\n dffin['cv_gr']= dffin.groupby('cell')['pred_growth_rate'].transform(lambda x:\\\n np.std(x)/np.mean(x))\n dffin['std_gr']= dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.std(x))\n dffin['mean_gr'] = dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.mean(x))\n dffin['mean_len'] = dffin.groupby('cell')['pred_length_box_um'].transform(lambda x: np.mean(x))\n dffin['norm_pred_growth_rate'] = (dffin['pred_growth_rate']-dffin.groupby('cell')['pred_growth_rate'].transform(lambda\\\n x: np.mean(x)))/dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.mean(x))\n dffin = rl.genalogy(dffin,'parent_cell') #Create genealogy\n dffin = rl.genalogy(dffin,'g_parent_cell')\n dffin = rl.genalogy(dffin,'g_g_parent_cell')\n dffin = dffin.set_index('unique_id')\n qq= dffin.groupby('cell').apply(lambda x: (x['pred_length_box_um']-x['pred_length_box_um'].iloc[0])/(x['pred_length_box_um'].iloc[-1]-x['pred_length_box_um'].iloc[0])).rename('add_len')\n jj= dffin.groupby('cell').apply(lambda x: (x['time_sec']-x['time_sec'].iloc[0])/(x['time_sec'].iloc[-1]-x['time_sec'].iloc[0])).rename('cell_cycle')\n return pd.concat([dffin, qq.reset_index().set_index('unique_id')['add_len'], jj.reset_index().set_index('unique_id')['cell_cycle']], axis=1, join='inner')","def calc_metrics(data, sampled_data_list, dataset_type):\n result={}\n for sampled_data in sampled_data_list:\n c2st_roc_auc_metric = c2st_roc_auc(data, sampled_data)\n if \"c2st_roc_auc\" in result:\n result[\"c2st_roc_auc\"].append(c2st_roc_auc_metric)\n else:\n result[\"c2st_roc_auc\"] = [c2st_roc_auc_metric]\n mmd_p_val, mmd_stat = rbf_mmd_test(data.values, sampled_data.values)\n if \"mmd_p_val\" in result:\n result[\"mmd_p_val\"].append(mmd_p_val)\n result[\"mmd_stat\"].append(mmd_stat)\n else:\n result[\"mmd_p_val\"] = [mmd_p_val]\n result[\"mmd_stat\"] = [mmd_stat]\n ks_p_val, ks_stat, ks_n, ks_p_val_list, ks_stat_list = ks_test(data, sampled_data)\n if dataset_type != \"norm_dataset\":\n ks_p_val = ks_permutation(ks_stat_list, data, sampled_data)\n if \"ks_p_val\" in result:\n result[\"ks_p_val\"].append(ks_p_val)\n result[\"ks_stat\"].append(ks_stat)\n else:\n result[\"ks_p_val\"] = [ks_p_val]\n result[\"ks_stat\"] = [ks_stat]\n acc_r, acc_g = c2st_accuracy(data, sampled_data)\n if \"c2st_acc_r\" in result:\n result[\"c2st_acc_r\"].append(acc_r)\n result[\"c2st_acc_g\"].append(acc_g)\n else:\n result[\"c2st_acc_r\"] = [acc_r]\n result[\"c2st_acc_g\"] = [acc_g]\n return result","def MCS(n,k):\n\tglobal dict_all\n\tdict_val=copy.deepcopy(dict_all)\n\t#start_time = time.time()\n\tfinal = {}\t\t\t\t\t # Store all result with the count as key. For example final[1]=[[1,0,0],[0,1,1]]\n\tseq = []\t\t\t\t\t\t# Store the count with no duplication\n\tfor i in range(n):\n\t\tleaf={}\t\t\t\t\t\t# leaf is the dictionary to store the random value of each leaf\n\t\t#count=0\n\t\tfor i in leaves:\n\t\t\tleaf[i] = choice([0,1])\n\t\t\tdict_val[i]=leaf[i]\n\t\t\t#count += leaf[i]\n\t\tresult = Cal_FT(dict_val)\t\n\t\t'''\n\t\tif result:\n\t\t\tcutset = []\n\t\t\tfor i in leaves:\n\t\t\t\tcutset.append(str(leaf[i]))\n\t\t\tcutset=\"\".join(cutset)\n\t\t\tif cutset not in final:\n\t\t\t\tfinal[cutset]=count\n\tfinal_sorted=sorted(zip(final.values(),final.keys())) \t\t\t\t#Order the cutset by its count\n\tfor i in range(k):\t\t\t\t\t\t\t\t\t\t\t\t\t#Print the first k result\n\t\tcutset=list(final_sorted[i][1])\n\t\tresult=[]\n\t\tfor index in range(len(cutset)):\n\t\t\tif cutset[index] is \"1\":\n\t\t\t\tresult.append(leaves[index])\n\t\tprint result\n\t#end_time=time.time()\n\t#print \"Running time is\", end_time-start_time\n\t'''","def compute_query_summary_statistics(data):\n return {\n nameserver: _compute_summary_stats(entries)\n for nameserver, entries in data.items()\n }","def analysis():\r\n data_frame = load_from_mysql('core', 'BDFMHQAA_D')\r\n data_frame.registerTempTable('business')\r\n gd = data_frame.select('AA03CSNO', 'AA08PRON')\r\n\r\n def merge_count(a, b):\r\n r = {}\r\n for p, c in a.items():\r\n if p in r:\r\n r[p] += c\r\n else:\r\n r[p] = c\r\n for p, c in b.items():\r\n if p in r:\r\n r[p] += c\r\n else:\r\n r[p] = c\r\n return r\r\n result = gd.map(lambda row: (row.AA03CSNO, {row.AA08PRON: 1})).reduceByKey(merge_count)\r\n pron_count = gd.map(lambda row: (row.AA08PRON, 1)).reduceByKey(lambda a, b: a + b)\r\n\r\n # result = gd.map(lambda row: (row.AA03CSNO, row.AA08PRON))\r\n print(result.take(10))\r\n print('----------------pron count-----------------')\r\n print(pron_count.collect())\r\n\r\n print(gd)","def transform_to_sessions(events, uid):\n \n class Sessions:\n values = {\n 'id': [], 'size_ts': [],\n 'interruptions': [], 'n_inte': [], 'n_events': [], 'start_time': [], 'end_time': [],\n 'user': [], 'edition': [], 'text_nav': [], 'high_nav': [], 'file': [], 'refactoring': [],\n 'clean_build': [], 'debug': [], 'tools': [], 'control': [], 'testing': [], 'search': []\n\n }\n\n lists = {\n 'l_interruptions': [], 'l_edition': [], 'l_text_nav': [], 'l_high_nav': [], 'l_file': [],\n 'l_refactoring': [], 'l_clean_build': [], 'l_debug': [], 'l_tools': [], 'l_control': [],\n 'l_testing': [], 'l_search': [], 'size_ts': [], 'n_inte': [], 'id': []\n }\n\n def __init__(self):\n pass\n\n def create_dataframe(self):\n \"\"\"\n Creates a dataframe with the sessions of the user\n \"\"\"\n sessions = pandas.DataFrame().from_dict(self.values)\n sessions_lists = pandas.DataFrame().from_dict(self.lists)\n return sessions, sessions_lists\n \n so = Sessions()\n\n s = set(events['session_id'])\n\n count = 0 # count of sessions\n\n # process all the sessions of the user\n for i in s:\n user_sessions = events[events['session_id'] == i]\n #user_sessions.to_csv(PATH_SESSIONS + '/' + str(uid) + '-' + str(count) + '.csv', index=False)\n\n split_session = [user_sessions]\n\n # if breaking points are found, the session splits into subsessions\n bp = break_points(user_sessions['interval'], user_sessions['minute'])\n if len(bp) > 0:\n bp.append(len(user_sessions))\n split_session = []\n index = 0\n for k in range(0,len(bp)):\n sub_session = user_sessions.iloc[index:(bp[k]+1)]\n split_session.append(sub_session)\n index = bp[k]+1\n\n count += 1\n\n for session in split_session:\n\n minutes = np.unique(np.array(session['minute']))\n l_edits = []\n l_text_nav = []\n l_high_nav = []\n l_refactoring = []\n l_debug = []\n l_file = []\n l_build = []\n l_tools = []\n l_control = []\n l_testing = []\n l_search = []\n l_inte = []\n dur = len(minutes)\n ni = 0\n\n for m in minutes:\n # for every minute of the session, count the number of edition and\n # selection events and the duration of the interruptions (among other types of events)\n subset = session[session['minute'] == m]\n l_edits.append(len(subset[subset['detailed_type'] == 'edit-text']))\n l_high_nav.append(len(subset[subset['detailed_type'] == 'high-nav']))\n l_text_nav.append(len(subset[subset['detailed_type'] == 'text-nav']))\n l_refactoring.append(len(subset[subset['detailed_type'] == 'refactoring']))\n l_debug.append(len(subset[subset['detailed_type'] == 'debug']))\n l_file.append(len(subset[subset['detailed_type'] == 'file']))\n l_build.append(len(subset[subset['detailed_type'] == 'clean-build']))\n l_tools.append(len(subset[subset['detailed_type'] == 'tools']))\n l_control.append(len(subset[subset['detailed_type'] == 'control']))\n l_testing.append(len(subset[subset['detailed_type'] == 'testing']))\n l_search.append(len(subset[subset['detailed_type'] == 'search']))\n\n if subset.iloc[len(subset)-1]['is_interruption']:\n l_inte.append(subset.iloc[len(subset)-1]['interval']//60)\n ni += 1\n else:\n l_inte.append(0)\n\n so.values['id'].append(str(uid) + '-' + str(count))\n so.lists['id'].append(str(uid) + '-' + str(count))\n # print (str(uid) + '-' + str(count))\n so.values['size_ts'].append(dur)\n so.lists['size_ts'].append(dur)\n\n # convert the lists to string\n str_edits = ' '.join(str(e) for e in l_edits)\n str_high_nav = ' '.join(str(e) for e in l_high_nav)\n str_text_nav = ' '.join(str(e) for e in l_text_nav)\n str_refactoring = ' '.join(str(e) for e in l_refactoring)\n str_debug = ' '.join(str(e) for e in l_debug)\n str_file = ' '.join(str(e) for e in l_file)\n str_build = ' '.join(str(e) for e in l_build)\n str_tools = ' '.join(str(e) for e in l_tools)\n str_control = ' '.join(str(e) for e in l_control)\n str_testing = ' '.join(str(e) for e in l_testing)\n str_search = ' '.join(str(e) for e in l_search)\n str_inte = ' '.join(str(e) for e in l_inte)\n\n so.values['edition'].append(str_edits)\n so.values['high_nav'].append(str_high_nav)\n so.values['text_nav'].append(str_text_nav)\n so.values['refactoring'].append(str_refactoring)\n so.values['debug'].append(str_debug)\n so.values['file'].append(str_file)\n so.values['clean_build'].append(str_build)\n so.values['tools'].append(str_tools)\n so.values['control'].append(str_control)\n so.values['testing'].append(str_testing)\n so.values['search'].append(str_search)\n so.values['interruptions'].append(str_inte)\n\n so.lists['l_interruptions'].append(l_inte)\n so.lists['l_edition'].append(l_edits)\n so.lists['l_high_nav'].append(l_high_nav)\n so.lists['l_text_nav'].append(l_text_nav)\n so.lists['l_refactoring'].append(l_refactoring)\n so.lists['l_debug'].append(l_debug)\n so.lists['l_file'].append(l_file)\n so.lists['l_clean_build'].append(l_build)\n so.lists['l_tools'].append(l_tools)\n so.lists['l_control'].append(l_control)\n so.lists['l_testing'].append(l_testing)\n so.lists['l_search'].append(l_search)\n so.lists['n_inte'].append(ni)\n \n so.values['n_inte'].append(ni)\n so.values['start_time'].append(session.iloc[0]['datetime'])\n so.values['end_time'].append(session.iloc[len(session) - 1]['datetime'])\n so.values['user'].append(session.iloc[0][0])\n so.values['n_events'].append(len(session[session['detailed_type'] != ' ']))\n\n result, lists = so.create_dataframe()\n return result, lists","def gather(self):\n\n sacct_fields = [\n \"Account\",\n \"AllocNodes\",\n \"AllocTRES\",\n \"ConsumedEnergyRaw\",\n \"CPUTimeRaw\",\n \"Elapsed\",\n \"End\",\n \"ExitCode\",\n \"JobID\",\n \"JobName\",\n \"NCPUS\",\n \"NNodes\",\n \"QOS\",\n \"ReqMem\",\n \"ReqNodes\",\n \"Start\",\n \"State\",\n \"Submit\",\n \"UID\",\n \"User\",\n \"WorkDir\",\n ]\n\n query = f\"sacct -j {self.jobid} -X -n -P -o ExitCode,Workdir\"\n if self.cluster:\n query += f\" --clusters={self.cluster}\"\n\n cmd = BuildTestCommand(query)\n cmd.execute()\n\n logger.debug(\n f\"Querying JobID: '{self.jobid}' ExitCode and Workdir by running: '{query}'\"\n )\n\n out = \"\".join(cmd.get_output()).rstrip()\n\n exitcode, workdir = out.split(\"|\")\n # Exit Code field is in format <ExitCode>:<Signal> for now we care only about first number\n self._exitcode = int(exitcode.split(\":\")[0])\n self._workdir = workdir\n\n query = f\"sacct -j {self.jobid} -X -n -P -o {','.join(sacct_fields)}\"\n\n # to query jobs from another cluster we must add -M <cluster> to sacct\n if self.cluster:\n query += f\" --clusters={self.cluster}\"\n\n logger.debug(f\"Gather slurm job data by running: {query}\")\n cmd = BuildTestCommand(query)\n cmd.execute()\n out = \"\".join(cmd.get_output())\n # split by | since\n out = out.split(\"|\")\n job_data = {}\n for field, value in zip(sacct_fields, out):\n job_data[field] = value\n\n return job_data","def accumulate_study_results(ids, prob):\n sum_result = {}\n cnt_result = {}\n size = prob.shape[0]\n for i in range(size):\n study_id = ids[i]\n idx = int(study_id)\n if idx not in cnt_result:\n cnt_result[idx] = 0.\n sum_result[idx] = np.zeros((1, prob.shape[1]), dtype=np.float32)\n cnt_result[idx] += 1\n sum_result[idx] += prob[i, :]\n for i in cnt_result.keys():\n sum_result[i][:] /= cnt_result[i]\n return sum_result","def _per_cls_summarize(self):\n per_class_result = {}\n for catId in range(len(self.cats)):\n resultDet = self._summarize_with_cat(f1=False, catIdx=catId)\n\n if catId in self.FPParams.catsWithAttributes:\n results = self._summarize_with_cat(catIdx=catId)\n resultF1 = self._summarize_with_cat(iou=False, catIdx=catId)\n\n per_class_result[self.cats[catId][\"name\"]] = {\n \"iou_f1\": results, \"f1\": resultF1, \"iou\": resultDet,\n }\n else:\n per_class_result[self.cats[catId][\"name\"]] = {\"iou\": resultDet}\n\n return per_class_result","def query(self):\n self._measurements[self.KEY_USAGE].df = self.fetch_data_usage()","def summarize(self):\n self.smalltalk += \"\\n Data IDs in this bundle: \\n\"\n self._files = {}\n inv_dict = {}\n # sort IDs to make sure pdfs are printed in same oder as they were\n # taken\n for k, v in self.stage_summaries.items():\n for qc_id in flatten_list(v):\n inv_dict[qc_id] = k\n sorted_ids = list(flatten_list(self.stage_summaries.values()))\n sorted_ids.sort(key=int)\n # for stage, value in self.stage_summaries.items():\n for qc_run_id in sorted_ids:\n # stage = inv_dict[qc_run_id]\n # if stage[0:7] == 'failed_':\n # stage = stage[7:]\n # try:\n # s = self.comments[qc_run_id]\n # except KeyError:\n # s = ''\n # self.comments[qc_run_id] = 'Classified as poor result.\\n' + s\n ds = Dataset(qc_run_id, self.db_name)\n device_name = ds.device_name\n f_folder = os.path.join(self.db_folder, \"tuning_results\", device_name)\n # for qc_run_id in flatten_list(value):\n self.smalltalk += str(qc_run_id) + \", \"\n\n # filename = stage + '_fit_ds'\n # filename += str(qc_run_id) + '.png'\n filename = os.path.join(f_folder, str(ds.ds.guid) + \".png\")\n\n self._files[str(qc_run_id)] = filename","def compute_statistics(self):","def run_csls_metrics(self, sess, batch_size=512):\n top_matches = []\n score = self.calc_csls_score(sess)\n avg1, avg2 = self.calc_avg_dist(sess)\n csls_scores = 2 * score - (avg1[self.src_ind][:, None] + avg2[None, :])\n # Calculate top matches\n for i in range(0, len(self.src_ind), batch_size):\n scores = [csls_scores[x] for x in range(i, min(i + batch_size, len(self.src_ind)))]\n top_matches_val = sess.run(\n self.csls_subgraphs[\"Top100\"], feed_dict={self.score_ph: scores}\n )[1]\n top_matches.append(top_matches_val)\n top_matches = np.concatenate(top_matches)\n print(\"Accuracy using CSLS is\")\n self.calc_accuracy(top_matches)\n self.calc_csls(sess)","def compute_scores(self, keys: Tensor, queries: Tensor) -> Tensor:\n raise NotImplementedError","def test_measure_deterministic_multi_qubit_with_sampling(self):\n shots = 100\n qobj = ref_measure.measure_circuits_qobj_deterministic(allow_sampling=True)\n qobj.config.shots = shots\n circuits = [experiment.header.name for experiment in qobj.experiments]\n targets = ref_measure.measure_counts_qobj_deterministic(shots)\n job = QasmSimulator().run(qobj)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0)","def process_input_items(args):\n return dict(sum([Counter({sku: value * SCORES[k] for sku, value in\n Counter(args[k].split(',')).items()}) or Counter() for k in\n set(SCORES.keys()) & set(args.keys())], Counter()))","def aggregate_query(self):\n raise NotImplementedError","def craw_all():\n\n # min_kdb_id = 16_000 # 2021-06-06 16_392 is highest\n min_kdb_id = 4_000 # 4007 is actual lowest but rounding! https://www.db.yugioh-card.com/yugiohdb/card_search.action?ope=2&cid=4007\n base_query = \"[[Medium::TCG]]\"\n\n final_output = []\n has_res = True\n kdb_id = min_kdb_id\n step = 400\n\n num_req = 0\n while has_res:\n query = \"%s [[Database ID::>%s]] [[Database ID::<%s]]\" % (\n base_query,\n kdb_id,\n kdb_id + step,\n )\n num_req += 1\n print(num_req, query)\n\n data = ask_yugipedia(query, ALL_DISPLAYS, limit=500, do_sleep=10)\n check(data, ALL_DISPLAYS)\n has_res = bool(data)\n\n data[\"query\"] = query\n data[\"disp\"] = ALL_DISPLAYS\n if has_res:\n final_output.append(data)\n\n kdb_id += step + 1\n\n return final_output","def home():\n\n connection = pypyodbc.connect(connectionString)\n \n cursor = connection.cursor()\n\n cachedResults['avgAgePerState'] = runQuery(cursor, avgAgePerStateCommand)\n cachedResults['avgAgePerTown'] = runQuery(cursor, avgAgePerTownCommand)\n cachedResults['avgAgePerProvince'] = runQuery(cursor, avgAgePerProvinceCommand)\n cachedResults['avgAgePerFacilityName'] = runQuery(cursor, avgAgePerFacilityNameCommand)\n cachedResults['avgAgePerFacilityType'] = runQuery(cursor, avgAgePerFacilityTypeCommand)\n\n cachedResults['eidTestResultTotal'] = runQuery(cursor, eidTestResultTotalCommand)\n cachedResults['eidTestResultAIDSTFacilityType'] = runQuery(cursor, eidTestResultAIDSTFacilityTypeCommand)\n cachedResults['eidTestResultAMIFacilityType'] = runQuery(cursor, eidTestResultAMIFacilityTypeCommand)\n cachedResults['eidTestResultDisHFacilityType'] = runQuery(cursor, eidTestResultDisHFacilityTypeCommand)\n cachedResults['eidTestResultGenHFacilityType'] = runQuery(cursor, eidTestResultGenHFacilityTypeCommand)\n cachedResults['eidTestResultMSFHFacilityType'] = runQuery(cursor, eidTestResultMSFHFacilityTypeCommand)\n cachedResults['eidTestResultNHLFacilityType'] = runQuery(cursor, eidTestResultNHLFacilityTypeCommand)\n cachedResults['eidTestResultSpHFacilityType'] = runQuery(cursor, eidTestResultSpHFacilityTypeCommand)\n cachedResults['eidTestResultSRHFacilityType'] = runQuery(cursor, eidTestResultSRHFacilityTypeCommand)\n cachedResults['eidTestResultTHFacilityType'] = runQuery(cursor, eidTestResultTHFacilityTypeCommand)\n\n cachedResults['avgTatTotal'] = runQuery(cursor, avgTatTotalCommand)\n cachedResults['avgTatAIDSTFacilityType'] = runQuery(cursor, avgTatAIDSTFacilityTypeCommand)\n cachedResults['avgTatAMIFacilityType'] = runQuery(cursor, avgTatAMIFacilityTypeCommand)\n cachedResults['avgTatDisHFacilityType'] = runQuery(cursor, avgTatDisHFacilityTypeCommand)\n cachedResults['avgTatGenHFacilityType'] = runQuery(cursor, avgTatGenHFacilityTypeCommand)\n cachedResults['avgTatMSFHFacilityType'] = runQuery(cursor, avgTatMSFHFacilityTypeCommand)\n cachedResults['avgTatNHLFacilityType'] = runQuery(cursor, avgTatNHLFacilityTypeCommand)\n cachedResults['avgTatSpHFacilityType'] = runQuery(cursor, avgTatSpHFacilityTypeCommand)\n cachedResults['avgTatSRHFacilityType'] = runQuery(cursor, avgTatSRHFacilityTypeCommand)\n cachedResults['avgTatTHFacilityType'] = runQuery(cursor, avgTatTHFacilityTypeCommand)\n\n cachedResults['trackSample'] = runQuery(cursor, trackSampleCommand)\n\n cachedResults['avgAgeNHL'] = runQuery(cursor, avgAgeNHLCommand)\n cachedResults['avgAgePHL'] = runQuery(cursor, avgAgePHLCommand)\n cachedResults['avgAgeUNION'] = runQuery(cursor, avgAgeUNIONCommand)\n\n cachedResults['eidTestResultNHLLab'] = runQuery(cursor, eidTestResultNHLLabCommand)\n cachedResults['eidTestResultPHLLab'] = runQuery(cursor, eidTestResultPHLLabCommand)\n cachedResults['eidTestResultUNIONLab'] = runQuery(cursor, eidTestResultUNIONLabCommand)\n\n cachedResults['avgTatNHLLab'] = runQuery(cursor, avgTatNHLLabCommand)\n cachedResults['avgTatPHLLab'] = runQuery(cursor, avgTatPHLLabCommand)\n cachedResults['avgTatUNIONLab'] = runQuery(cursor, avgTatUNIONLabCommand)\n\n connection.close()\n\n return render_template('index.html')","def getkeytimestats(s,refconvdf):\r\n df=refconvdf[refconvdf.convid==s]\r\n \r\n #first response\r\n firstrsp=df[df.idx_conv==1]\r\n if firstrsp.empty:\r\n firstrsp=None\r\n else: \r\n firstrsp=firstrsp.created_at.iloc[0]\r\n \r\n #closed part types \r\n clsparts=df[df.part_type=='close']\r\n \r\n #first closed\r\n firstcls=clsparts.head(1)\r\n if firstcls.empty:\r\n firstcls=None \r\n else: \r\n firstcls=firstcls.created_at.iloc[0]\r\n \r\n #clast closed\r\n lastcls=clsparts.tail(1)\r\n if lastcls.empty:\r\n lastcls=None\r\n else: \r\n lastcls=lastcls.created_at.iloc[0]\r\n return pd.Series(dict(first_response=firstrsp,first_closed=firstcls,last_closed=lastcls))","def test_evaluate(self):\n # test normalized by 'bbox_size'\n jhmdb_pck_metric = JhmdbPCKAccuracy(thr=0.5, norm_item='bbox')\n jhmdb_pck_metric.process(self.data_batch, self.data_samples)\n pck_results = jhmdb_pck_metric.evaluate(self.batch_size)\n target = {\n 'Head PCK': 1.0,\n 'Sho PCK': 1.0,\n 'Elb PCK': 1.0,\n 'Wri PCK': 1.0,\n 'Hip PCK': 1.0,\n 'Knee PCK': 1.0,\n 'Ank PCK': 1.0,\n 'PCK': 1.0,\n }\n self.assertDictEqual(pck_results, target)\n\n # test normalized by 'torso_size'\n jhmdb_tpck_metric = JhmdbPCKAccuracy(thr=0.2, norm_item='torso')\n jhmdb_tpck_metric.process(self.data_batch, self.data_samples)\n tpck_results = jhmdb_tpck_metric.evaluate(self.batch_size)\n target = {\n 'Head tPCK': 1.0,\n 'Sho tPCK': 1.0,\n 'Elb tPCK': 1.0,\n 'Wri tPCK': 1.0,\n 'Hip tPCK': 1.0,\n 'Knee tPCK': 1.0,\n 'Ank tPCK': 1.0,\n 'tPCK': 1.0,\n }\n self.assertDictEqual(tpck_results, target)","def upgrade_to_17():\n\n pipeline = [\n {'$group' : { '_id' : {'pid': '$project', 'code': '$subject.code'}, 'sids': {'$push': '$_id' }}}\n ]\n\n subjects = config.db.command('aggregate', 'sessions', pipeline=pipeline)\n for subject in subjects['result']:\n\n # Subjects without a code and sessions without a subject\n # will be returned grouped together, but all need unique IDs\n if subject['_id'].get('code') is None:\n for session_id in subject['sids']:\n subject_id = bson.ObjectId()\n config.db.sessions.update_one({'_id': session_id},{'$set': {'subject._id': subject_id}})\n else:\n subject_id = bson.ObjectId()\n query = {'_id': {'$in': subject['sids']}}\n update = {'$set': {'subject._id': subject_id}}\n config.db.sessions.update_many(query, update)","def quant(input_folder,fastq_dict,species_kmers,output_folder,transcriptome_folder,bsub_out=\"bsub_out\"):\n print(\"Starting new quantification run for batch of %d samples from %s\"%(len(fastq_dict),input_folder))\n mkdir_p(bsub_out)\n #no subfolders needed for SRA data\n print(\"bsub logs stored in %s folder\"%bsub_out)\n mkdir_p(output_folder)\n print(\"kallisto output in %s\"%output_folder)\n for i in fastq_dict:\n print(\"===processing fastq files from sample ID: %s===\"%i)\n outdir = path.join(output_folder,i) #separate folder for each fastq, within the output folder\n mkdir_p(outdir)\n cmd = kw.CMD_BASE.format(fastq_id=i,bsub_out=bsub_out)\n cmd = shlex.split(cmd) #convert to list of arguments\n species = fastq_dict[i][\"species\"]\n t_index = path.join(transcriptome_folder,kw.species2transcriptomeindex(species,kmer_size=species_kmers[species]))\n f1 = [path.join(input_folder,r+\"_1.fastq.gz\") for r in fastq_dict[i][\"fastq_list\"]]\n if fastq_dict[i][\"is_paired_end\"]:\n f2 = [path.join(input_folder,r+\"_2.fastq.gz\") for r in fastq_dict[i][\"fastq_list\"]]\n flist = \" \".join(imap(lambda x,y: x+\" \"+y,f1,f2))\n cmd.append(\"kallisto quant -i {ti} -o {out} {flist}\".format(ti=t_index,out=outdir,flist = flist))\n else: #case of single end reads\n flen = median(array(fastq_dict[i][\"avgLengths\"]))\n flist = \" \".join(f1)\n cmd.append(\"kallisto quant --single -i {ti} -o {out} -l {flen} -s {fsd} {flist}\".format(ti=t_index,out=outdir,flen=flen,fsd=flen/5.0,flist = flist))\n #note, fsd is the standard deviation of the fragment length distribution. flen/5 is just a placeholder. We should actually estimate this in the future!\n #print(cmd)\n subprocess.call(cmd)","def compute_and_report(data, scorer):\n sim = sorted([(scorer(data, a, b), a, b)\n for a, b in combinations(data.keys(), 2)],\n reverse=True)\n\n for s, a, b in sim:\n print(\"%.2f\" % s, a, b)","def runGenericTests():\n possibleK = [10, 15, 25]\n #possibleK = [15]\n #smalldata = [1, 5, 10]\n mediumdata = [10, 25, 50, 75, 100, 200, 300, 400, 500]\n #largedata = [100, 500, 1000, 5000]\n print(\"Running Generic Tests...\")\n resulttimes = {}\n for k in possibleK:\n print(\"Testing Top K Words algorithm on 400MB file.\")\n testtimes = []\n for test in mediumdata:\n print(\"Starting Test on 400MB file: Finding Top {} Words with {} Shards...\".format(k, test))\n start = time()\n findTopKViaSharding(\"dataset-400MB.txt\", k, test)\n end = time()\n print(\"Test Complete.\")\n print(\"Total Time: {}\".format(end - start))\n testtimes.append(end-start)\n resulttimes[k] = testtimes\n print(\"Generic Tests Complete.\")\n return mediumdata, resulttimes","def result(self) -> Dict[int, float]:\n return {k: v.result() for k, v in self._topk_acc_dict.items()}","def __summarize_seq(self, stud_seq, time_gap):\r\n\r\n current_action_endtime = Series(stud_seq['endTime'])\r\n next_action_starttime = Series(stud_seq['startTime']).shift(-1)\r\n\r\n diff = (next_action_starttime - current_action_endtime).dropna()\r\n\r\n session_end_ix = np.where(diff > time_gap)[0]\r\n session_start_end_ix = np.insert(session_end_ix, 0, 0)\r\n session_start_end_ix = np.insert(session_start_end_ix, len(session_start_end_ix), len(stud_seq) - 1)\r\n session_lengths = np.diff(session_start_end_ix)\r\n session_lengths[0] = session_lengths[\r\n 0] + 1 # correct the length of first session by adding 1 because of zero index\r\n session_index = np.repeat(np.array(range(len(session_start_end_ix) - 1)), session_lengths)\r\n\r\n sorted_seq_with_sess_ix = stud_seq.assign(seq_ix=session_index)\r\n min_seq = sorted_seq_with_sess_ix.groupby('seq_ix').min().add_prefix('min_')\r\n max_seq = sorted_seq_with_sess_ix.groupby('seq_ix').max().add_prefix('max_')\r\n mean_seq = sorted_seq_with_sess_ix.groupby('seq_ix').mean().add_prefix('mean_')\r\n sum_seq = sorted_seq_with_sess_ix.groupby('seq_ix').sum().add_prefix('sum_')\r\n\r\n summarized_features = pd.concat([min_seq, max_seq, mean_seq, sum_seq], axis=1)\r\n\r\n return summarized_features","def getMeasures(unique_name=None):","def index():\n import numpy as np\n import random\n\n total_gender = {}\n total_gender['Male'] = db(db.patient.sex == 'Male').count()\n total_gender['Female'] = db(db.patient.sex == 'Female').count()\n total_gender['Undeclared'] = db(db.patient.sex == 'Undeclared').count()\n\n groups = db(db.groups).select()\n freq_groups = {}\n grp_gender = {}\n for g in groups:\n freq_groups[g.code] = db(db.patient.groups.contains(g.id)).count()\n grp_gender[g.code] = {}\n grp_gender[g.code]['Male'] = db(db.patient.groups.contains(g.id) & (db.patient.sex == 'Male')).count()\n grp_gender[g.code]['Female'] = db(db.patient.groups.contains(g.id) & (db.patient.sex == 'Female')).count()\n grp_gender[g.code]['Undeclared'] = db(db.patient.groups.contains(g.id) & (db.patient.sex == 'Undeclared')).count()\n\n experiments = db(db.experiments).select()\n freq_experiments = {}\n exp_gender = {}\n for e in experiments:\n freq_experiments[e.code] = db(db.patient.experiments.contains(e.id)).count()\n exp_gender[e.code] = {}\n exp_gender[e.code]['Male'] = db(db.patient.experiments.contains(e.id) & (db.patient.sex == 'Male')).count()\n exp_gender[e.code]['Female'] = db(db.patient.experiments.contains(e.id) & (db.patient.sex == 'Female')).count()\n exp_gender[e.code]['Undeclared'] = db(db.patient.experiments.contains(e.id) & (db.patient.sex == 'Undeclared')).count()\n\n grp_exp = {}\n for e in experiments:\n grp_exp[e.code] = {}\n for g in groups:\n grp_exp[e.code][g.code] = db(db.patient.experiments.contains(e.id) & db.patient.groups.contains(g.id)).count()\n\n return dict(message=T('Pain Network: A web-based tool for diagnosis of the Chronic Pain.'),\n freq_gender=total_gender,freq_groups=freq_groups,freq_experiments=freq_experiments,\n exp_gender=exp_gender,grp_gender=grp_gender,grp_exp=grp_exp)","def _calculate_scores(self, query, key):\n if self.hyperbolc_input:\n scores = self.manifold.single_query_attn_scores(query, key, self.c)\n else:\n scores = tf.linalg.matmul(query, key, transpose_b=True)\n\n if self.scale is not None:\n scores *= self.scale\n\n return scores","def getMeasures():","def _aggregate_log_values(self, source, dest):\n remove = []\n for key, item in source.items():\n if \"data\" not in item:\n # Assume it's a sub-group\n dest[key] = {}\n self._aggregate_log_values(item, dest[key])\n else:\n aggregator = self._get_aggregator_for_key(key, item['agg'])\n value = aggregator(item['data'])\n if item['precision'] is not None:\n value = round(value, item['precision'])\n dest[key] = value\n if item['scope'] == 'get':\n remove.append(key)\n for key in remove:\n del source[key]","def get_query_info():\n all_rt_heat_metric_list = get_rt_query_count()\n # 有查询的数据\n query_dataset_dict = {}\n for each_rt in all_rt_heat_metric_list:\n query_dataset_dict[each_rt[\"key\"]] = each_rt[\"doc_count\"]\n return query_dataset_dict"],"string":"[\n \"def aggregate(self):\\n data_to_track = {}\\n for possession in self.possessions_to_track_aggregate:\\n data_to_track[possession] = self._haves[possession]\\n\\n for variable in self.variables_to_track_aggregate:\\n try:\\n data_to_track[variable] = self.__dict__[variable]\\n except KeyError:\\n pass\\n self.database_connection.put([\\\"aggregate\\\",\\n data_to_track,\\n self.group,\\n self.round])\",\n \"def compute_session_status_from_dict(results):\\n indices = np.zeros(len(results), dtype=int)\\n for i, k in enumerate(results):\\n if k in TaskQC.criteria.keys():\\n indices[i] = TaskQC._thresholding(results[k], thresholds=TaskQC.criteria[k])\\n else:\\n indices[i] = TaskQC._thresholding(results[k], thresholds=TaskQC.criteria['default'])\\n\\n def key_map(x):\\n return 'NOT_SET' if x < 0 else list(TaskQC.criteria['default'].keys())[x]\\n # Criteria map is in order of severity so the max index is our overall QC outcome\\n session_outcome = key_map(max(indices))\\n outcomes = dict(zip(results.keys(), map(key_map, indices)))\\n return session_outcome, outcomes\",\n \"def calc_data(self):\\n\\n circ_counts = {}\\n for trialidx in range(self._ntrials):\\n for _, depth in enumerate(self._depths):\\n circ_name = 'qv_depth_%d_trial_%d' % (depth, trialidx)\\n\\n # get the counts form ALL executed circuits\\n count_list = []\\n for result in self._result_list:\\n try:\\n count_list.append(result.get_counts(circ_name))\\n except (QiskitError, KeyError):\\n pass\\n\\n circ_counts[circ_name] = \\\\\\n build_counts_dict_from_list(count_list)\\n\\n self._circ_shots[circ_name] = \\\\\\n sum(circ_counts[circ_name].values())\\n\\n # calculate the heavy output probability\\n self._heavy_output_counts[circ_name] = \\\\\\n self._subset_probability(\\n self._heavy_outputs[circ_name],\\n circ_counts[circ_name])\",\n \"def run_faqc(self, **kwargs):\\n if self.qc is True:\\n build([FaQC.SummarizeQC(fastq_dic=self.fastq_dic,\\n num_cpus=self.num_cpus,\\n workdir=self.workdir)],\\n local_scheduler=self.local_scheduler,\\n workers=1)\\n qc_dic = {}\\n for samp, path in self.fastq_dic.items():\\n trim_dir = os.path.join(self.workdir, \\\"processes\\\", \\\"qc\\\", samp)\\n qc_dic[samp] = trim_dir + \\\"/\\\" + samp + \\\".1.trimmed.fastq\\\" + \\\":\\\" + \\\\\\n trim_dir + \\\"/\\\" + samp + \\\".2.trimmed.fastq\\\" \\n return qc_dic\\n\\n else:\\n return self.fastq_dic\",\n \"def get_test_cases_coverage(session_id):\\n tc_stats={}\\n tc_stats_list=[]\\n total_executed=0\\n sql='SELECT DISTINCT(test_id) FROM stats WHERE session_id=:sid AND test_id!=\\\"null\\\"'\\n params={\\\"sid\\\":session_id}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n tests=c.fetchall()\\n conn.close()\\n if len(tests)>0:\\n for t in tests:\\n total_executed=0\\n sql=\\\"SELECT DISTINCT(file_id) FROM stats WHERE session_id=:sid AND test_id=:tid\\\"\\n params={\\\"sid\\\":session_id,\\\"tid\\\":t[0]}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n files=c.fetchall()\\n conn.close()\\n for f in files:\\n line_count=get_executable_lines_count_for_file(f[0])\\n # get executions\\n sql=\\\"SELECT COUNT(DISTINCT line_guid) FROM stats WHERE session_id= :sid AND file_id= :fid AND test_id=:tid\\\"\\n params={\\\"sid\\\":session_id,\\\"tid\\\":t[0],\\\"fid\\\":f[0]}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n executed=c.fetchone()\\n conn.close()\\n total_executed+=executed[0]\\n # save test case and it's executions\\n tc_stats={}\\n tc_stats[\\\"test_id\\\"]=t[0]\\n tc_stats[\\\"total_executed\\\"]=total_executed\\n tc_stats[\\\"total_executed\\\"]\\n \\n tc_stats_list.append(tc_stats)\\n return tc_stats_list\",\n \"def sum(app, args):\\n if not args.key:\\n db = get_db(app)\\n notrans = db.transient.count()\\n print(\\\"No Transient records: \\\", notrans)\\n if notrans > 0:\\n print(\\\"Total data Transient: \\\", nicesize(\\n list(db.transient.aggregate([\\n {\\\"$group\\\": {\\\"_id\\\": None,\\n \\\"total\\\": {\\\"$sum\\\": \\\"$size\\\"}}}]))[0]['total']))\\n print(\\\" No Core records: \\\", db.transient.count())\\n return\\n\\n kname, kinfo = key_info(app.conf, args.key)\\n res = _single_sum(app, group_by=kname, force=args.force)\\n total_size = int(0)\\n total_count = 0\\n mgn = len(\\\"Total\\\")\\n for reshost in res:\\n gid = reshost['_id']\\n if gid is None:\\n mgn = max(4, mgn)\\n else:\\n mgn = max(len(str(reshost['_id'])), mgn)\\n\\n fms = \\\"{:\\\" + str(mgn) + \\\"}\\\\t{:>10}\\\\t{:>9}\\\"\\n if args.human:\\n print(\\\"# {}:\\\".format(kname))\\n for reshost in res:\\n total = reshost['total']\\n count = reshost['count']\\n total_size += int(total)\\n total_count += count\\n if args.human:\\n total_human = nicesize(total)\\n count_human = nicenumber(count)\\n categ = reshost['_id']\\n if categ is None:\\n categ = \\\"<undefined>\\\"\\n\\n print(fms.format(\\n categ, total_human, count_human))\\n else:\\n print(\\\"{}\\\\t{}\\\\t{}\\\".format(\\n reshost['_id'], total, count))\\n\\n if args.human:\\n total_size_human = nicesize(total_size)\\n total_count_human = nicenumber(total_count)\\n print(fms.format('', '-'*10, '-'*9))\\n print(fms.format(\\n \\\"Total\\\", total_size_human, total_count_human))\\n else:\\n print(\\\"Total\\\\t{}\\\\t{}\\\".format(total_size, total_count))\",\n \"def get_aggregated_values(self):\\n if not self._initialized:\\n raise Exception(\\\"To readout you must first initialize, then\\\"\\n \\\"process batches!\\\")\\n else:\\n ret_vals = [q.readout() for q in self.quantities]\\n return dict(zip(self.quantity_names, ret_vals))\",\n \"def session_counting (self, target_dict, IEI_timeRange = (0, 900, 1), cal_IEI = True, cal_duration = True, cal_latency = True, cal_inputDistribution = True, num_bins = 10, **kwards):\\r\\n if len(self.df) == 0:\\r\\n #if empty then pass without analysis\\r\\n pass\\r\\n else:\\r\\n get_kwards = lambda x: (\\\"\\\",\\\"\\\") if x == None else x\\r\\n input1OnOff = get_kwards(kwards.get('Input1OnOff'))\\r\\n input2OnOff = get_kwards(kwards.get('Input2OnOff'))\\r\\n input3OnOff = get_kwards(kwards.get('Input3OnOff'))\\r\\n input4OnOff = get_kwards(kwards.get('Input4OnOff'))\\r\\n \\r\\n #get a start and end time point\\r\\n if 'Start' in self.df['States'].values:\\r\\n start = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Start')]['Time']\\r\\n else:\\r\\n start = pd.Series({'Start': self.df['Time'].values[0]-1})\\r\\n \\r\\n if 'Finish' in self.df['States'].values:\\r\\n end = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Finish')]['Time']\\r\\n else:\\r\\n end = pd.Series({'Finish': self.df['Time'].values[-1]+1}) #plus 1 second\\r\\n \\r\\n #get data from each event window\\r\\n event = self.df[(self.df['Time']>= start.iloc[0])&(self.df['Time']<= end.iloc[0])]\\r\\n \\r\\n result_dict = {}\\r\\n for k, v in target_dict.items():\\r\\n \\r\\n if k == 'Input1':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input1OnOff)\\r\\n elif k == 'Input2':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input2OnOff)\\r\\n elif k == 'Input3':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input3OnOff)\\r\\n elif k == 'Input4':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input4OnOff)\\r\\n else:\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject)\\r\\n \\r\\n return result_dict\",\n \"def aggregate_results(results):\\n\\n for (config,con,dec),folds in results.iteritems():\\n m = MODEL_PATTERN.match(config)\\n if m:\\n mode = m.groupdict()['mode'] # mle, rl, mrt, ...\\n model = m.groupdict()['model'] # haem, hacm, hard, ...\\n align = m.groupdict()['align'] # crp, cls ...\\n else:\\n mode, model, align = '', '', ''\\n # mean accuracies across seeds for each fold\\n foldaccuracies = []\\n # we count number of models over folds and seeds\\n num_individual_models = 0\\n\\n for foldname,fold in folds.items():\\n if 'Q' in options.mode:\\n seedaccurracies = fold.values()[:1] if fold.values() else [] # pick one\\n# SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\\n else:\\n seedaccurracies = []\\n for seed_acc in fold.values():\\n seedaccurracies.append(seed_acc)\\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\\n # aggregate on fold level\\n fold['__MEAN__'] = float(np.mean(seedaccurracies))\\n fold['__SD__'] = float(np.std(seedaccurracies))\\n l = len(seedaccurracies)\\n num_individual_models += l\\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__MEAN__')] += l\\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__SD__')] += l\\n\\n # statistics over seeds for this fold\\n fold['__STATS__'] = fold['__MEAN__'], fold['__SD__'], l\\n foldaccuracies.append(fold['__MEAN__'])\\n # aggregate on (config, condition, decoding) level\\n folds['__MEAN__'] = float(np.mean(foldaccuracies))\\n folds['__SD__'] = float(np.std(foldaccuracies))\\n # statistics over folds for this (config, condition, decoding)\\n folds['__STATS__'] = folds['__MEAN__'], folds['__SD__'], num_individual_models\",\n \"def __calculate_agg_shap_scores(self):\\n self.agg_stats_timer = SimbaTimer(start=True)\\n for clf_state, clf_state_name in zip(range(2), [\\\"ABSENT\\\", \\\"PRESENT\\\"]):\\n self.results = {}\\n self.df_save_path = os.path.join(\\n self.shap_logs_path,\\n \\\"SHAP_summary_{}_{}_{}.csv\\\".format(\\n self.classifier_name, clf_state_name, self.datetime\\n ),\\n )\\n shap_clf_sliced = self.shap_df[\\n self.shap_df[self.classifier_name] == clf_state\\n ]\\n for feature_category, feature_time_bin in itertools.product(\\n self.unique_feature_category_names, self.unique_time_bin_names\\n ):\\n if feature_category not in self.results.keys():\\n self.results[feature_category] = {}\\n feature_names_sliced = list(\\n self.feature_categories_df.loc[\\n :, (feature_category, feature_time_bin)\\n ]\\n )\\n feature_names_sliced = [\\n x\\n for x in feature_names_sliced\\n if str(x) != \\\"nan\\\" and x in shap_clf_sliced\\n ]\\n self.results[feature_category][feature_time_bin] = round(\\n shap_clf_sliced[feature_names_sliced].sum(axis=1).mean() * 100, 6\\n )\\n self.__save_aggregate_scores()\\n self.agg_stats_timer.stop_timer()\\n self.visualization_timer = SimbaTimer(start=True)\\n\\n stdout_success(\\n msg=f\\\"Aggregate SHAP statistics saved in {self.shap_logs_path} directory\\\",\\n elapsed_time=self.agg_stats_timer.elapsed_time_str,\\n )\",\n \"def generate_stats(results, ads, vmid, session_date, export_folder, process_ex_time):\\n try:\\n os.makedirs(export_folder)\\n except OSError:\\n pass\\n\\n # to be read and inserted into db\\n totalads = 0 # total number of ads seen during this session\\n totaluniqads = len(ads) # does not support multicategories at this point\\n\\n # for each category, for each test site, count total number of ads seen\\n totalad_category = {} \\n # for each category, for each test site, count total number of uniq ads seen\\n uniqad_category = {}\\n \\n with open(os.path.join(export_folder, 'session_bugs.csv'), 'w') as bugs_wtr:\\n bugs_wtr.write('#Ad-UID, Website-URL, Refresh-Num, Training-Topic,\\\\\\n Site-Context, BugCount, BugSrc\\\\n')\\n for train_category, cat_dict in results.items():\\n totalad_category[train_category] = {}\\n uniqad_category[train_category] = {}\\n for test_site, bug_dict_list in cat_dict.items():\\n total_ads = 0 # for each site\\n uniq_ads = [] # for each site\\n for refresh_num in range(len(bug_dict_list)):\\n bug_dict = bug_dict_list[refresh_num]\\n for bug, bugcount in bug_dict.items():\\n if bug.is_ad():\\n uuid = bug.get_uuid()\\n bugs_wtr.write('{0}, {1}, {2}, {3}, {4}, {5}, {6}\\\\n'.format(uuid, test_site,\\n refresh_num, train_category, 'N/A', bugcount, bug.get_src()))\\n total_ads += bugcount\\n if bug not in uniq_ads:\\n uniq_ads.append(bug)\\n totalad_category[train_category][test_site] = total_ads\\n uniqad_category[train_category][test_site] = len(uniq_ads)\\n totalads += total_ads # global count for total ads\\n\\n with open(os.path.join(export_folder, 'session_stats.csv'), 'w') as ses_wtr:\\n # write some metadata information about this session\\n ses_wtr.write('#VMID: %s\\\\n' % vmid)\\n ses_wtr.write('#Session-Date: %s\\\\n' % session_date)\\n ses_wtr.write('#Time to complete: %s\\\\n' % process_ex_time)\\n ses_wtr.write('#Training Categories: %s\\\\n' % str(results.keys()))\\n ses_wtr.write('#Total Number of ads: %d\\\\n' % totalads)\\n ses_wtr.write('#Total Uniq ads: %d\\\\n\\\\n' % totaluniqads)\\n ses_wtr.write('#TrainingTopic, Test-Site, NumberOfVisit, TotalAds, UniqAds\\\\n')\\n\\n for train_category, cat_dict in results.items(): \\n for test_site, bug_dict_list in cat_dict.items():\\n num_of_visit = len(bug_dict_list)\\n ses_wtr.write('{0}, {1}, {2}, {3}, {4}\\\\n'.format(train_category,\\n test_site, num_of_visit, totalad_category[train_category][test_site],\\n uniqad_category[train_category][test_site]))\",\n \"def do_report(input):\\n for (session_id, group) in itertools.groupby(input, get_session_id):\\n group = list(group)\\n elapsed = [finfo.elapsed for finfo in group]\\n n = float(len(elapsed))\\n mean = sum(elapsed) / n\\n s = math.sqrt(\\n (1 / (n - 1)) * sum((e - mean) ** 2 for e in elapsed)\\n )\\n yield SummaryData(\\n session_id,\\n group[0].message,\\n min(elapsed),\\n max(elapsed),\\n mean,\\n s\\n )\",\n \"def aggregator(index_keynames, value_keynames, ts_keyname, func, interval = 60 * 5):\\n data = {}\\n ts = None\\n #print ts_keyname\\n for parsts, parsdata in func():\\n #print parsdata\\n #print parsdata[\\\"log_timestamp\\\"]\\n if ts is None:\\n ts = parsts\\n key = tuple((parsdata[key] for key in index_keynames))\\n values = tuple((int(parsdata[key]) for key in value_keynames))\\n if key not in data:\\n data[key] = values\\n else:\\n data[key] = tuple((data[key][index] + int(values[index]) for index in range(len(values))))\\n if parsts > (ts + interval):\\n for keys, values in data.items():\\n yield \\\"%s\\\\t%s\\\\t%s\\\" % (ts, \\\"\\\\t\\\".join((str(index_key) for index_key in keys)), \\\"\\\\t\\\".join((str(value_key) for value_key in values)))\\n ts = None\\n data = {}\",\n \"def qc_metrics(\\n data: AnnData,\\n mito_prefix: str = \\\"MT-\\\",\\n min_genes: int = 500,\\n max_genes: int = 6000,\\n min_umis: int = 100,\\n max_umis: int = 600000,\\n percent_mito: float = 10.0,\\n percent_cells: float = 0.05,\\n) -> None:\\n\\n data.obs[\\\"passed_qc\\\"] = False\\n\\n data.obs[\\\"n_genes\\\"] = data.X.getnnz(axis=1)\\n data.obs[\\\"n_counts\\\"] = data.X.sum(axis=1).A1\\n\\n mito_prefixes = mito_prefix.split(\\\",\\\")\\n\\n def startswith(name):\\n for prefix in mito_prefixes:\\n if name.startswith(prefix):\\n return True\\n return False\\n\\n mito_genes = data.var_names.map(startswith).values.nonzero()[0]\\n data.obs[\\\"percent_mito\\\"] = (data.X[:, mito_genes].sum(axis=1).A1 / np.maximum(\\n data.obs[\\\"n_counts\\\"].values, 1.0\\n )) * 100\\n\\n # Assign passed_qc\\n filters = [\\n data.obs[\\\"n_genes\\\"] >= min_genes,\\n data.obs[\\\"n_genes\\\"] < max_genes,\\n data.obs[\\\"n_counts\\\"] >= min_umis,\\n data.obs[\\\"n_counts\\\"] < max_umis,\\n data.obs[\\\"percent_mito\\\"] < percent_mito,\\n ]\\n\\n data.obs.loc[np.logical_and.reduce(filters), \\\"passed_qc\\\"] = True\\n\\n var = data.var\\n data = data[\\n data.obs[\\\"passed_qc\\\"]\\n ] # compute gene stats in space of filtered cells only\\n\\n var[\\\"n_cells\\\"] = data.X.getnnz(axis=0)\\n var[\\\"percent_cells\\\"] = (var[\\\"n_cells\\\"] / data.shape[0]) * 100\\n var[\\\"robust\\\"] = var[\\\"percent_cells\\\"] >= percent_cells\\n var[\\\"highly_variable_features\\\"] = var[\\n \\\"robust\\\"\\n ] # default all robust genes are \\\"highly\\\" variable\",\n \"def aggregate_results(self):\\n\\n raise NotImplementedError\",\n \"def compute(self, download_data=None):\\n if self.extractor is None:\\n # If download_data is None, decide based on whether eid or session path was provided\\n ensure_data = self.download_data if download_data is None else download_data\\n self.load_data(download_data=ensure_data)\\n self.log.info(f\\\"Session {self.session_path}: Running QC on habituation data...\\\")\\n\\n # Initialize checks\\n prefix = '_task_'\\n data = self.extractor.data\\n metrics = {}\\n passed = {}\\n\\n # Check all reward volumes == 3.0ul\\n check = prefix + 'reward_volumes'\\n metrics[check] = data['rewardVolume']\\n passed[check] = metrics[check] == 3.0\\n\\n # Check session durations are increasing in steps >= 12 minutes\\n check = prefix + 'habituation_time'\\n if not self.one or not self.session_path:\\n self.log.warning('unable to determine session trials without ONE')\\n metrics[check] = passed[check] = None\\n else:\\n subject, session_date = self.session_path.parts[-3:-1]\\n # compute from the date specified\\n date_minus_week = (\\n datetime.strptime(session_date, '%Y-%m-%d') - timedelta(days=7)\\n ).strftime('%Y-%m-%d')\\n sessions = self.one.alyx.rest('sessions', 'list', subject=subject,\\n date_range=[date_minus_week, session_date],\\n task_protocol='habituation')\\n # Remove the current session if already registered\\n if sessions and sessions[0]['start_time'].startswith(session_date):\\n sessions = sessions[1:]\\n metric = ([0, data['intervals'][-1, 1] - data['intervals'][0, 0]] +\\n [(datetime.fromisoformat(x['end_time']) -\\n datetime.fromisoformat(x['start_time'])).total_seconds() / 60\\n for x in [self.one.alyx.get(s['url']) for s in sessions]])\\n\\n # The duration from raw trial data\\n # duration = map(float, self.extractor.raw_data[-1]['elapsed_time'].split(':'))\\n # duration = timedelta(**dict(zip(('hours', 'minutes', 'seconds'),\\n # duration))).total_seconds() / 60\\n metrics[check] = np.array(metric)\\n passed[check] = np.diff(metric) >= 12\\n\\n # Check event orders: trial_start < stim on < stim center < feedback < stim off\\n check = prefix + 'trial_event_sequence'\\n nans = (\\n np.isnan(data[\\\"intervals\\\"][:, 0]) | # noqa\\n np.isnan(data[\\\"stimOn_times\\\"]) | # noqa\\n np.isnan(data[\\\"stimCenter_times\\\"]) |\\n np.isnan(data[\\\"valveOpen_times\\\"]) | # noqa\\n np.isnan(data[\\\"stimOff_times\\\"])\\n )\\n a = np.less(data[\\\"intervals\\\"][:, 0], data[\\\"stimOn_times\\\"], where=~nans)\\n b = np.less(data[\\\"stimOn_times\\\"], data[\\\"stimCenter_times\\\"], where=~nans)\\n c = np.less(data[\\\"stimCenter_times\\\"], data[\\\"valveOpen_times\\\"], where=~nans)\\n d = np.less(data[\\\"valveOpen_times\\\"], data[\\\"stimOff_times\\\"], where=~nans)\\n\\n metrics[check] = a & b & c & d & ~nans\\n passed[check] = metrics[check].astype(float)\\n\\n # Check that the time difference between the visual stimulus center-command being\\n # triggered and the stimulus effectively appearing in the center is smaller than 150 ms.\\n check = prefix + 'stimCenter_delays'\\n metric = np.nan_to_num(data[\\\"stimCenter_times\\\"] - data[\\\"stimCenterTrigger_times\\\"],\\n nan=np.inf)\\n passed[check] = (metric <= 0.15) & (metric > 0)\\n metrics[check] = metric\\n\\n # Phase check\\n check = prefix + 'phase'\\n metric = data['phase']\\n passed[check] = (metric <= 2 * np.pi) & (metric >= 0)\\n metrics[check] = metric\\n\\n check = prefix + 'phase_distribution'\\n metric, _ = np.histogram(data['phase'])\\n _, p = chisquare(metric)\\n passed[check] = p < 0.05\\n metrics[check] = metric\\n\\n # Checks common to training QC\\n checks = [check_goCue_delays, check_stimOn_goCue_delays,\\n check_stimOn_delays, check_stimOff_delays]\\n for fcn in checks:\\n check = prefix + fcn.__name__[6:]\\n metrics[check], passed[check] = fcn(data)\\n\\n self.metrics, self.passed = (metrics, passed)\",\n \"def calc_sim_collector(self, key, values):\\r\\n (rest1, rest2), common_ratings = key, values\\r\\n\\t #your code here\\r\\n yield (rest1, rest2), (rho, n_common)\",\n \"def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\\n hist = {k: {} for k in {\\\"mks0\\\", \\\"mks1\\\", \\\"mks2\\\", \\\"l\\\"}} # pylint: disable=C0208\\n wei = {k: {} for k in hist}\\n res[\\\"hist\\\"] = hist\\n res[\\\"histnow\\\"] = wei\\n\\n for el, _ in self.enumerate_test_metric(qset):\\n le = len(el.value)\\n w = el.weight\\n res[\\\"mks0\\\"] += w * el.mks0\\n res[\\\"mks1\\\"] += w * el.mks1\\n res[\\\"mks2\\\"] += w * el.mks2\\n res[\\\"sum_weights\\\"] += w\\n res[\\\"sum_wlen\\\"] += w * le\\n res[\\\"n\\\"] += 1\\n\\n if el.mks0 not in hist[\\\"mks0\\\"]:\\n hist[\\\"mks0\\\"][el.mks0] = w\\n wei[\\\"mks0\\\"][el.mks0] = 1\\n else:\\n hist[\\\"mks0\\\"][el.mks0] += w\\n wei[\\\"mks0\\\"][el.mks0] += 1\\n if el.mks1 not in hist[\\\"mks1\\\"]:\\n hist[\\\"mks1\\\"][el.mks1] = w\\n wei[\\\"mks1\\\"][el.mks1] = 1\\n else:\\n hist[\\\"mks1\\\"][el.mks1] += w\\n wei[\\\"mks1\\\"][el.mks1] += 1\\n if el.mks2 not in hist[\\\"mks2\\\"]:\\n hist[\\\"mks2\\\"][el.mks2] = w\\n wei[\\\"mks2\\\"][el.mks2] = 1\\n else:\\n hist[\\\"mks2\\\"][el.mks2] += w\\n wei[\\\"mks2\\\"][el.mks2] += 1\\n if le not in hist[\\\"l\\\"]:\\n hist[\\\"l\\\"][le] = w\\n wei[\\\"l\\\"][le] = 1\\n else:\\n hist[\\\"l\\\"][le] += w\\n wei[\\\"l\\\"][le] += 1\\n return res\",\n \"def _group_sessions(self, sessions):\\n session_dict = collections.defaultdict(list)\\n for session in sessions:\\n session_dict[session.query].append(session)\\n return session_dict\",\n \"def aggregate_data(mts, feature, target):\\r\\n set_dict = dict()\\r\\n set_dict['mt'] = mts\\r\\n set_dict['feature'] = feature\\r\\n set_dict['target'] = target\\r\\n \\r\\n return set_dict\",\n \"def summary(data, key=itemgetter(0), value=itemgetter(1)):\\n\\n for k, group in groupby(data, key):\\n yield (k, sum(value(row) for row in group))\",\n \"def get_job_metrics_summary_for_task(query):\\n metric_list = ['hs06sec', 'gco2_global']\\n metrics = {}\\n for m in metric_list:\\n metrics[m] = {'finished': 0, 'failed': 0, 'total': 0}\\n\\n hquery = copy.deepcopy(query)\\n hquery['jobstatus__in'] = ('finished', 'failed')\\n\\n if 'jeditaskid' in hquery:\\n\\n hs06sec_sum = []\\n # getting jobs. Can not use the .annotate() as there can be duplicates\\n jobs = []\\n jvalues = ['pandaid', 'jobstatus', ] + metric_list\\n jobs.extend(Jobsarchived4.objects.filter(**hquery).values(*jvalues))\\n jobs.extend(Jobsarchived.objects.filter(**hquery).values(*jvalues))\\n jobs = drop_duplicates(jobs)\\n\\n for job in jobs:\\n for m in metric_list:\\n metrics[m]['total'] += job[m] if m in job and job[m] is not None else 0\\n if job['jobstatus'] == 'finished':\\n metrics[m]['finished'] += job[m] if m in job and job[m] is not None else 0\\n elif job['jobstatus'] == 'failed':\\n metrics[m]['failed'] += job[m] if m in job and job[m] is not None else 0\\n\\n # getting data from ATLARC DB, only hs06s\\n pj_models = get_pandajob_arch_models_by_year(query['modificationtime__castdate__range'])\\n if len(pj_models) > 0:\\n for pjm in pj_models:\\n try:\\n hs06sec_sum.extend(pjm.objects.filter(**hquery).values('jobstatus').annotate(hs06secsum=Sum('hs06sec')))\\n except Exception as ex:\\n _logger.exception('Failed to get hs06sec from {} at ATLARC DB:\\\\n{}'.format(pjm, ex))\\n\\n if len(hs06sec_sum) > 0:\\n for hs in hs06sec_sum:\\n metrics['hs06sec']['total'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\\n if hs['jobstatus'] == 'finished':\\n metrics['hs06sec']['finished'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\\n elif hs['jobstatus'] == 'failed':\\n metrics['hs06sec']['failed'] += hs['hs06secsum'] if hs['hs06secsum'] is not None else 0\\n\\n\\n return metrics\",\n \"def compute_key_value(self) -> Dict[str, float]:\\n # @TODO: ddp hotfix, could be done better\\n if self._is_ddp:\\n for key in self.statistics:\\n value: List[np.ndarray] = all_gather(self.statistics[key])\\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\\n self.statistics[key] = value\\n\\n per_class, micro, macro, weighted = self.compute()\\n metrics = self._convert_metrics_to_kv(\\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\\n )\\n return metrics\",\n \"def metrics_group():\",\n \"def association_rules_baseline(train_sessions):\\n comatrix = collections.defaultdict(list)\\n for session in train_sessions:\\n for (x, y) in itertools.permutations(session, 2):\\n comatrix[x].append(y)\\n return comatrix\",\n \"def selectedComparisons(samples_dict):\\n sectors=\\\"peripherals\\\",\\\"intermediaries\\\",\\\"hubs\\\"\\n ks_measures={}\\n for analyses_type in samples_dict[sectors[0]]:\\n ks_measures[analyses_type]={}\\n for analysis_grouping in samples_dict[sectors[0]][analyses_type]:\\n ks_measures[analyses_type][analysis_grouping]={}\\n if samples_dict[sectors[0]][analyses_type][analysis_grouping]==dict:\\n ks_measures[analyses_type][analysis_grouping]={}\\n for analysis in samples_dict[sectors[0]][analyses_type][analysis_grouping]:\\n for var in samples_dict[sectors[0]][analyses_type][analysis_grouping][analysis]:\\n samples_peripherals=samples_dict[sectors[0]][analyses_type][analysis_grouping][analysis]\\n samples_intermediaries=samples_dict[sectors[1]][analyses_type][analysis_grouping][analysis]\\n samples_hubs=samples_dict[sectors[2]][analyses_type][analysis_grouping][analysis]\\n ks_measures[analysis][\\\"peripherals_intermediaries\\\"]=P.kolmogorovSmirnovTest(samples_peripherals,samples_intermediaries)\\n ks_measures[analysis][\\\"peripherals_hubs\\\"]=P.kolmogorovSmirnovTest(samples_peripherals,samples_hubs)\\n ks_measures[analysis][\\\"hubs_intermediaries\\\"]=P.kolmogorovSmirnovTest(samples_hubs,samples_intermediaries)\\n else:\\n for var in samples_dict[sectors[0]][analyses_type][analysis_grouping]:\\n samples_peripherals=samples_dict[sectors[0]][analyses_type][analysis_grouping]\\n samples_intermediaries=samples_dict[sectors[1]][analyses_type][analysis_grouping]\\n samples_hubs=samples_dict[sectors[2]][analyses_type][analysis_grouping]\\n\\n\\n\\n samples[sector][analyses][analysis_grouping]=updateDict(samples[sector][analyses][analysis_grouping],getSamples(authors_analysis[analyses][author][analysis_grouping]))\",\n \"def evaluate(self, click_model, search_sessions):\\n\\n # Only use queries that occur more than MINUMUM_OCCURENCES times and have a true relevance\\n counter = collections.Counter([session.query for session in search_sessions])\\n useful_sessions = [query_id for query_id in counter if counter[query_id] >= self.minimum_occurences and query_id in self.relevances]\\n\\n # Group sessions by query\\n sessions_dict = self._group_sessions_if_useful(search_sessions, useful_sessions)\\n total_ndcg = 0\\n not_useful = 0\\n\\n # For every useful query get the predicted relevance and compute NDCG\\n for query_id in useful_sessions:\\n \\n rel = self.relevances[query_id]\\n ideal_ranking = sorted(rel.values(),reverse = True)[:5]\\n \\n # Only use query if there is a document with a positive ranking. (Otherwise IDCG will be 0 -> NDCG undetermined.)\\n if not any(ideal_ranking):\\n not_useful += 1\\n continue\\n \\n current_sessions = sessions_dict[query_id]\\n pred_rels = dict()\\n for session in current_sessions:\\n for rank, result in enumerate(session.web_results):\\n if not result.id in pred_rels:\\n pred_rels[result.id] = click_model.predict_relevance(session.query, result.id)\\n ranking = sorted([doc for doc in pred_rels],key = lambda doc : pred_rels[doc], reverse = True)\\n \\n ranking_relevances = self.get_relevances(query_id, ranking[:5])\\n \\n dcg = self.dcg(ranking_relevances)\\n idcg = self.dcg(ideal_ranking) \\n ndcg = dcg / idcg\\n total_ndcg += ndcg\\n\\n # If too few queries there might not be any useful queries that also have a ranking in the true_relevances.\\n assert not len(useful_sessions)-not_useful is 0\\n\\n # Average NDCG over all queries\\n return total_ndcg / (len(useful_sessions)-not_useful)\",\n \"def test_get_qc_metrics(integrated_ff):\\n\\n key, ff_env = integrated_ff['ff_key'], integrated_ff['ff_env']\\n uuid = '331106bc-8535-3338-903e-854af460b544'\\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, key=key, ff_env=ff_env)\\n assert len(qc_metrics.keys()) == 1\\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\\n target_qc = qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']\\n assert 'QualityMetric' in target_qc['values']['@type']\\n assert target_qc['organism'] == 'human'\\n assert target_qc['experiment_type'] == 'Dilution Hi-C'\\n assert target_qc['experiment_subclass'] == 'Hi-C'\\n assert target_qc['source_file_association'] == 'processed_files'\\n assert target_qc['source_experiment'] == '4DNEXO67APV1'\\n assert target_qc['source_experimentSet'] == '4DNESOPFAAA1'\\n assert target_qc['biosource_summary'] == \\\"GM12878\\\"\\n\\n kwargs = { # do same as above w/ kwargs, specify to include raw files this time\\n 'key': key,\\n 'ff_env': ff_env,\\n 'include_raw_files': True\\n }\\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, **kwargs)\\n assert len(qc_metrics.keys()) == 2\\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\\n assert '4c9dabc6-61d6-4054-a951-c4fdd0023800' in qc_metrics\\n assert 'QualityMetric' in qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']['values']['@type']\\n assert 'QualityMetric' in qc_metrics['4c9dabc6-61d6-4054-a951-c4fdd0023800']['values']['@type']\",\n \"def qasmCircuitResults(self):\\n returnedDictionary={}\\n self.circutDrawing = self.draw()\\n self.blochSpheres=self.separatedBlochSpheres()\\n returnedDictionary[\\\"wires\\\"]=self.num_qubits\\n returnedDictionary[\\\"probabilities\\\"] = self.separatedProbabilities()\\n #returnedDictionary[\\\"blochSpheres\\\"] = self.separatedBlochSpheres()\\n returnedDictionary[\\\"diracNotation\\\"] = self.diracNotation()\\n returnedDictionary['chart'] = self.graph()\\n returnedDictionary[\\\"link\\\"] = \\\"\\\"\\n #returnedDictionary[\\\"qasmRows\\\"] = np.transpose(cols).tolist()\\n \\n if self.API_TOKEN != \\\"\\\":\\n returnedDictionary[\\\"link\\\"] = self.runOnIBMQ()\\n \\n return returnedDictionary\",\n \"def execute(self):\\r\\n factors = self.factors\\r\\n variables = list(self.variables)\\r\\n variables.remove(self.query)\\r\\n\\r\\n for fac in factors:\\r\\n self.set_observations(fac)\\r\\n\\r\\n for var in variables:\\r\\n if var not in self.obs:\\r\\n factors = self.eliminate_variable(var, factors)\\r\\n\\r\\n result = factor_module.multiply_batch(self.query, factors)\\r\\n denominator = sum(result.get_cpt())\\r\\n print(denominator)\\r\\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}\",\n \"def summarize_hits(df_hsps, option_cov=\\\"mean\\\", option_pid=\\\"mean\\\"):\\n\\n # Sort HSPs by query start position\\n df_hsps = np.sort(df_hsps, order=\\\"qstart\\\")\\n\\n # N-term delta between query and subject\\n delta_lg = np.abs(df_hsps[\\\"qstart\\\"] - df_hsps[\\\"sstart\\\"])\\n\\n # C-term delta between query and subject and add to length difference between aligned sequences\\n delta_lg += np.abs(\\n (df_hsps[\\\"qlen\\\"][0] - df_hsps[\\\"qend\\\"][-1])\\n - (df_hsps[\\\"slen\\\"][0] - df_hsps[\\\"send\\\"])\\n )\\n\\n # Internal gaps\\n query_starts = df_hsps[\\\"qstart\\\"][1:]\\n query_ends = df_hsps[\\\"qend\\\"][:-1]\\n subject_starts = df_hsps[\\\"sstart\\\"][1:]\\n subject_ends = df_hsps[\\\"send\\\"][:-1]\\n\\n delta_lg += np.sum(\\n np.abs((query_starts - query_ends) - (subject_starts - subject_ends))\\n )\\n\\n # Calculate total length, score, Identities and Positives :\\n length_total = np.sum(df_hsps[\\\"lgHSP\\\"])\\n pos_total = np.sum(df_hsps[\\\"pos\\\"])\\n # id_total = np.sum(df_hsps.id.values)\\n\\n # Cumulative length of HSPs / shortest seq. length = % coverage\\n frac_HSPshlen = calculate_coverage(\\n length_total=length_total,\\n length_query=df_hsps[\\\"qlen\\\"][0],\\n length_subject=df_hsps[\\\"slen\\\"][0],\\n option_cov=option_cov,\\n )\\n\\n # Number of positives / shortest seq. length = percentage of identity\\n pospercentsh = calculate_percid(\\n pos_total=pos_total,\\n length_query=df_hsps[\\\"qlen\\\"][0],\\n length_subject=df_hsps[\\\"slen\\\"][0],\\n length_total=length_total,\\n option_pid=option_pid,\\n )\\n\\n evalue = max(df_hsps[\\\"evalue\\\"])\\n\\n return (\\n delta_lg,\\n frac_HSPshlen,\\n pospercentsh,\\n evalue,\\n df_hsps[\\\"stitle\\\"][0].decode(\\\"utf-8\\\"),\\n )\",\n \"def query_sessions(task='all', stable=False, as_dataframe=False,\\r\\n force_30nov=False, criterion='biased'):\\r\\n\\r\\n # Query sessions\\r\\n if force_30nov is True:\\r\\n use_subjects = query_subjects(criterion=criterion).proj('subject_uuid')\\r\\n else:\\r\\n use_subjects = query_subjects().proj('subject_uuid')\\r\\n\\r\\n # Query all sessions or only training or biased if required\\r\\n if task == 'all':\\r\\n sessions = (acquisition.Session * subject.Subject * subject.SubjectLab * reference.Lab\\r\\n * use_subjects * behavior_analysis.SessionTrainingStatus\\r\\n & 'task_protocol LIKE \\\"%training%\\\" OR task_protocol LIKE \\\"%biased%\\\"').proj(\\r\\n 'session_uuid', 'subject_uuid', 'subject_nickname', 'institution_short',\\r\\n 'task_protocol', 'training_status')\\r\\n elif task == 'training':\\r\\n sessions = (acquisition.Session * subject.Subject * subject.SubjectLab * reference.Lab\\r\\n * use_subjects * behavior_analysis.SessionTrainingStatus\\r\\n & 'task_protocol LIKE \\\"%training%\\\"').proj(\\r\\n 'session_uuid', 'subject_uuid', 'subject_nickname', 'institution_short',\\r\\n 'task_protocol', 'training_status')\\r\\n elif task == 'biased':\\r\\n sessions = (acquisition.Session * subject.Subject * subject.SubjectLab * reference.Lab\\r\\n * use_subjects * behavior_analysis.SessionTrainingStatus\\r\\n & 'task_protocol LIKE \\\"%biased%\\\"').proj(\\r\\n 'session_uuid', 'subject_uuid', 'subject_nickname', 'institution_short',\\r\\n 'task_protocol', 'training_status')\\r\\n else:\\r\\n raise Exception('task must be all, training or biased')\\r\\n\\r\\n # Only use sessions up until the end of December\\r\\n sessions = sessions & 'date(session_start_time) <= \\\"2020-03-23\\\"'\\r\\n\\r\\n # If required only output sessions with stable hardware\\r\\n if stable is True:\\r\\n sessions = sessions & 'date(session_start_time) > \\\"2019-06-10\\\"'\\r\\n\\r\\n # Transform into pandas Dataframe if requested\\r\\n if as_dataframe is True:\\r\\n sessions = sessions.fetch(\\r\\n order_by='institution_short, subject_nickname, session_start_time', format='frame')\\r\\n sessions = sessions.reset_index()\\r\\n\\r\\n return sessions\",\n \"def _compute_global_stats():\\n global_stats = []\\n \\n wmt16_group = Group.objects.filter(name='WMT16')\\n wmt16_users = _get_active_users_for_group(wmt16_group)\\n \\n # Check how many HITs have been completed. We now consider a HIT to be\\n # completed once it has been annotated by one or more annotators.\\n #\\n # Before we required `hit.users.count() >= 3` for greater overlap.\\n hits_completed = HIT.objects.filter(mturk_only=False, completed=True).count()\\n \\n # Check any remaining active HITs which are not yet marked complete.\\n for hit in HIT.objects.filter(active=True, mturk_only=False, completed=False):\\n if hit.users.count() >= 1:\\n hits_completed = hits_completed + 1\\n hit.completed = True\\n hit.save()\\n \\n # Compute remaining HITs for all language pairs.\\n hits_remaining = HIT.compute_remaining_hits()\\n \\n # Compute number of results contributed so far.\\n ranking_results = RankingResult.objects.filter(\\n item__hit__completed=True, item__hit__mturk_only=False)\\n \\n from math import factorial\\n system_comparisons = 0\\n for result in ranking_results:\\n result.reload_dynamic_fields()\\n # TODO: this implicitly counts A=B comparisons for multi systems.\\n # Basically, inflating the number of pairwise comparisons... Fix!\\n combinations = factorial(result.systems)/(factorial(result.systems-2) * 2) if result.systems > 2 else 0\\n system_comparisons = system_comparisons + combinations\\n \\n # Aggregate information about participating groups.\\n groups = set()\\n for user in wmt16_users:\\n for group in _identify_groups_for_user(user):\\n groups.add(group)\\n \\n # Compute average/total duration over all results.\\n durations = RankingResult.objects.all().values_list('duration', flat=True)\\n total_time = sum([datetime_to_seconds(x) for x in durations])\\n avg_time = total_time / float(hits_completed or 1)\\n avg_user_time = total_time / float(3 * hits_completed or 1)\\n \\n global_stats.append(('Users', len(wmt16_users)))\\n global_stats.append(('Groups', len(groups)))\\n global_stats.append(('HITs completed', '{0:,}'.format(hits_completed)))\\n global_stats.append(('HITs remaining', '{0:,}'.format(hits_remaining)))\\n global_stats.append(('Ranking results', '{0:,}'.format(ranking_results.count())))\\n global_stats.append(('System comparisons', '{0:,}'.format(system_comparisons)))\\n global_stats.append(('Average duration (per HIT)', seconds_to_timedelta(avg_time)))\\n global_stats.append(('Average duration (per task)', seconds_to_timedelta(avg_user_time)))\\n global_stats.append(('Total duration', seconds_to_timedelta(total_time)))\\n \\n # Create new status data snapshot\\n TimedKeyValueData.update_status_if_changed('users', str(len(wmt16_users)))\\n TimedKeyValueData.update_status_if_changed('groups', str(len(groups)))\\n TimedKeyValueData.update_status_if_changed('hits_completed', str(hits_completed))\\n TimedKeyValueData.update_status_if_changed('hits_remaining', str(hits_remaining))\\n TimedKeyValueData.update_status_if_changed('ranking_results', str(ranking_results.count()))\\n TimedKeyValueData.update_status_if_changed('system_comparisons', str(system_comparisons))\\n TimedKeyValueData.update_status_if_changed('duration_per_hit', str(seconds_to_timedelta(avg_time)))\\n TimedKeyValueData.update_status_if_changed('duration_per_task', str(seconds_to_timedelta(avg_user_time)))\\n TimedKeyValueData.update_status_if_changed('duration_total', str(seconds_to_timedelta(total_time)))\\n \\n return global_stats\",\n \"def compute_subj_metrics():\\n\\t# each participant does task 1,2,3 with method A,B = 3*2*N\\n\\t# likert data includes age, gender, Q1 - Q10 = 2+10\\n\\n\\t# set up data structure\\n\\tsubj_metrics = {}\\n\\tfor ID in range(10):\\n\\t\\tfor method in [\\\"A\\\",\\\"B\\\"]:\\n\\t\\t\\t# sanity checks\\n\\t\\t\\tif ID not in subj_metrics:\\n\\t\\t\\t\\tsubj_metrics[ID] = {}\\n\\t\\t\\tif method not in subj_metrics[ID]:\\n\\t\\t\\t\\tsubj_metrics[ID][method] = [None]*12\\n\\n\\there = os.path.dirname(os.path.realpath(__file__))\\n\\tsubdir = \\\"/data/experimental/\\\"\\n\\tdatapath = here + subdir + \\\"Likert_Responses.csv\\\"\\n\\n\\tdata = {}\\n\\tfirstline = True\\n\\twith open(datapath, 'r') as f:\\n\\t\\tfor line in f:\\n\\t\\t\\tif firstline:\\n\\t\\t\\t\\tfirstline = False\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tvalues = line.split(',')\\n\\t\\t\\tinfo = values[1:len(values)]\\n\\t\\t\\tID = int(info[9])\\n\\t\\t\\tmethod = info[10]\\n\\t\\t\\tage = info[11]\\n\\t\\t\\tgender = info[12]\\n\\t\\t\\t# store age\\n\\t\\t\\tsubj_metrics[ID][method][0] = age\\n\\t\\t\\tsubj_metrics[ID][method][1] = gender\\n\\t\\t\\t# parse likert data\\n\\t\\t\\tfor i in range(8):\\n\\t\\t\\t\\tsubj_metrics[ID][method][i+2] = info[i]\\n\\t\\t\\tsubj_metrics[ID][method][10] = info[14]\\n\\t\\t\\tsubj_metrics[ID][method][11] = info[15]\\n\\n\\treturn subj_metrics\",\n \"def qcs(self):\\n return self.aggregation\",\n \"def itersessions(self):\\n for x in np.unique(self.sessions):\\n yield x, self.loc[self.sessions == x, :]\",\n \"def get_results(self):\\n d = {}\\n# r = {}\\n for analyser in self.xml_tree.getroot():\\n for child in analyser:\\n if child.tag == 'all-records':\\n for record in child:\\n attributes = record.attrib\\n sample = attributes['sampleId']\\n assay_id = attributes['assayId']\\n genotype = attributes['genotypeId']\\n quality = attributes['description'].split('.')[0]\\n if re.match(r'rs\\\\d+', assay_id):\\n if sample in d:\\n if assay_id in d[sample]:\\n for allele in list(genotype):\\n if allele not in d[sample][assay_id]['genotype']:\\n d[sample][assay_id]['genotype'] += allele\\n if quality not in d[sample][assay_id]['quality']:\\n d[sample][assay_id]['quality'].append(quality)\\n else:\\n d[sample][assay_id] = {'genotype': genotype, 'quality': [quality]}\\n else:\\n d[sample] = {assay_id: {'genotype': genotype, 'quality': [quality]}}\\n# if sample in r:\\n# if assay_id in r[sample]:\\n# for allele in list(genotype):\\n# if allele not in r[sample][assay_id]:\\n# r[sample][assay_id] += allele\\n# else:\\n# r[sample][assay_id] = genotype\\n# else:\\n# r[sample] = {assay_id: genotype}\\n# for k, v in r.items():\\n# for k1, v1, in v.items():\\n# if len(v1) == 1:\\n# v[k1] += v1\\n# pprint.pprint(r)\\n# df = pd.DataFrame.from_dict(r).transpose()\\n# print(df)\\n# df.to_excel('snpcheck.xlsx')\\n return d\",\n \"def gather_results(dataset: Dataset,\\n conf: Namespace\\n ) -> \\\"dict[str, dict[str, any]]\\\":\\n\\n data = {}\\n\\n for k in np.copy(dataset.folds):\\n print(f\\\"\\\\nFold {k}\\\", '~'*60)\\n\\n dataset.set_fold(k)\\n calibrated_scores = APPROACHES[conf.approach](dataset=dataset, conf=conf)\\n\\n data[f'fold{k}'] = {\\n 'scores': calibrated_scores,\\n 'metrics': get_metrics(calibrated_scores, dataset, conf)\\n }\\n\\n return data\",\n \"def get_qps_as_dict(folder):\\n df = process_oldisim_results(folder)\\n return df.groupby(\\\"machine_type\\\").mean().QPS.to_dict()\",\n \"def totalize_measurement(conts_dict, si_model):\\n print('######## BEGIN CHECKING TOTAL ########')\\n for cont_measure, doc_measure in [\\n ['packages', 'total_packages'],\\n ['container_weight', 'total_weight'],\\n ['container_measurement', 'total_measurement']\\n ]:\\n doc_qua, doc_unit = split_quantity_unit(si_model[doc_measure])\\n if not doc_qua:\\n doc_qua = '0'\\n if floatable(doc_qua.replace(',', '')):\\n doc_qua = float(doc_qua.replace(',', ''))\\n else:\\n doc_qua = 0\\n conts_detail = [\\n split_quantity_unit(cont.get(cont_measure, '0'))\\n for cont in conts_dict\\n ]\\n\\n print(cont_measure, ':', conts_detail, '|', doc_qua, '-', doc_unit)\\n\\n conts_unit = list(set([\\n cont_unit\\n for cont_qua, cont_unit in conts_detail\\n ]))\\n if len(conts_unit) == 1:\\n conts_sum = sum([\\n float(cont_qua.replace(',', ''))\\n for cont_qua, cont_unit in conts_detail\\n if floatable(cont_qua.replace(',', ''))\\n ])\\n conts_unit = conts_unit[0]\\n else:\\n conts_sum = 0\\n conts_unit = ''\\n\\n if conts_sum != doc_qua and conts_unit and conts_sum > 0:\\n print('### Containers', cont_measure, conts_sum,\\n '=/= SI', doc_measure, doc_qua, '###')\\n if doc_measure == 'total_packages':\\n si_model[doc_measure] = f\\\"{conts_sum:,.0f}\\\" + conts_unit\\n else:\\n si_model[doc_measure] = f\\\"{conts_sum:,.3f}\\\" + conts_unit\\n\\n return si_model\",\n \"def sector_metrics_fx():\\r\\n global df_sector_metrics\\r\\n \\r\\n df_sector_metrics = df_co_metrics\\r\\n drop_company = ['company_ref']\\r\\n df_sector_metrics.drop(labels = drop_company, axis = 1, inplace = True)\\r\\n df_sector_metrics = df_sector_metrics.groupby(['date_list', 'sector']).agg({'co_inv_overall': 'sum', 'co_inv_50k': 'sum', 'co_inv_100k': 'sum', 'co_inv_manager': 'sum', 'co_inv_sales': 'sum', 'co_inv_key_roles': 'sum', 'co_inv_it': 'sum', 'co_inv_hourly': 'sum','co_fut_cost_overall': 'sum', 'co_fut_cost_50k': 'sum', 'co_fut_cost_100k': 'sum', 'co_fut_cost_manager': 'sum', 'co_fut_cost_sales': 'sum', 'co_fut_cost_key_roles': 'sum', 'co_fut_cost_it': 'sum', 'co_fut_cost_hourly': 'sum','co_inv_overall_28d': 'sum', 'co_inv_50k_28d': 'sum', 'co_inv_100k_28d': 'sum', 'co_inv_manager_28d': 'sum', 'co_inv_sales_28d': 'sum', 'co_inv_key_roles_28d': 'sum', 'co_inv_it_28d': 'sum', 'co_inv_hourly_28d': 'sum','co_fut_cost_overall_28d': 'sum', 'co_fut_cost_50k_28d': 'sum', 'co_fut_cost_100k_28d': 'sum', 'co_fut_cost_manager_28d': 'sum', 'co_fut_cost_sales_28d': 'sum', 'co_fut_cost_key_roles_28d': 'sum', 'co_fut_cost_it_28d': 'sum', 'co_fut_cost_hourly_28d': 'sum'})\",\n \"def profile_group(func, args, kwargs, func_result):\\n (collection, key, condition, initial, reduce) = args[:5]\\n report_kvs = _profile_query(collection)\\n\\n if key:\\n report_kvs['Group_Key'] = _to_json(key)\\n\\n if condition:\\n report_kvs['Group_Condition'] = _to_json(condition)\\n\\n if initial:\\n report_kvs['Group_Initial'] = _to_json(initial)\\n\\n if reduce:\\n report_kvs['Group_Reduce'] = reduce\\n\\n return report_kvs\",\n \"def summarize(\\n self,\\n key: Callable[['Classification'], Union[Iterable[str], str]] = None,\\n top_k: int = None,\\n ):\\n ctr = Counter(sorted(filter(None, flatmap(key, self.values()))))\\n return [elt for elt, _ in ctr.most_common(top_k)]\",\n \"def summarize_data(data, summary_keys):\\n summary = {}\\n latest_iteration_number = len(data.keys())\\n current_value = None\\n\\n for key in summary_keys:\\n summary[key] = []\\n # Compute per-iteration average of the given key.\\n for i in range(latest_iteration_number):\\n iter_key = '{}{}'.format(ITERATION_PREFIX, i)\\n # We allow reporting the same value multiple times when data is missing.\\n # If there is no data for this iteration, use the previous'.\\n if iter_key in data:\\n current_value = np.mean(data[iter_key][key])\\n summary[key].append(current_value)\\n\\n return summary\",\n \"def co_metrics_fx():\\r\\n global co_metric_dict, df_co_metrics\\r\\n co_metric_dict = OrderedDict()\\r\\n intermediate_date_list = []\\r\\n intermediate_company_list = []\\r\\n intermediate_industry_list = []\\r\\n intermediate_inv_count_list = []\\r\\n intermediate_inv_50k_list = []\\r\\n intermediate_inv_100k_list = []\\r\\n intermediate_inv_manager_list = []\\r\\n intermediate_inv_sales_list = []\\r\\n intermediate_inv_key_roles_list = []\\r\\n intermediate_inv_it_list = []\\r\\n intermediate_inv_hourly_list = []\\r\\n intermediate_cost_count_list = []\\r\\n intermediate_cost_50k_list = []\\r\\n intermediate_cost_100k_list = []\\r\\n intermediate_cost_manager_list = []\\r\\n intermediate_cost_sales_list = []\\r\\n intermediate_cost_key_roles_list = []\\r\\n intermediate_cost_it_list = []\\r\\n intermediate_cost_hourly_list = []\\r\\n for x in range(len(unique_companies)):\\r\\n chosen_company = unique_companies[x]\\r\\n df_company = df_final[df_final['company_ref'] == chosen_company]\\r\\n sector_index_list = df_company.index.tolist()\\r\\n company_sector = df_final.at[sector_index_list[0], 'Sector']\\r\\n print(x)\\r\\n for y in range(len(date_list)):\\r\\n chosen_date = date_list[y]\\r\\n \\r\\n df_count = df_company[(df_company['post_date'] <= chosen_date) & (df_company['remove_date'] >= chosen_date)]\\r\\n inv_count_value = df_count['job_id'].count()\\r\\n co_inv_overall = inv_count_value\\r\\n \\r\\n df_50k = df_count[df_count['salary'] > 50000]\\r\\n salary_50k_count_value = df_50k['job_id'].count()\\r\\n co_inv_50k = salary_50k_count_value\\r\\n \\r\\n df_100k = df_count[df_count['salary'] > 100000]\\r\\n salary_100k_count_value = df_100k['job_id'].count()\\r\\n co_inv_100k = salary_100k_count_value\\r\\n \\r\\n df_manager = df_count[df_count['manager_role'] == 1]\\r\\n manager_count_value = df_manager['job_id'].count()\\r\\n co_inv_manager = manager_count_value\\r\\n \\r\\n df_sales = df_count[df_count['sales_role'] == 1]\\r\\n sales_count_value = df_sales['job_id'].count()\\r\\n co_inv_sales = sales_count_value\\r\\n \\r\\n df_key_roles = df_count[df_count['key_roles_role'] == 1]\\r\\n key_roles_count_value = df_key_roles['job_id'].count()\\r\\n co_inv_key_roles = key_roles_count_value\\r\\n \\r\\n df_it = df_count[df_count['it_role'] == 1]\\r\\n it_count_value = df_it['job_id'].count()\\r\\n co_inv_it = it_count_value\\r\\n \\r\\n df_hourly = df_count[df_count['hourly_role'] == 1]\\r\\n hourly_count_value = df_hourly['job_id'].count()\\r\\n co_inv_hourly = hourly_count_value\\r\\n\\r\\n df_count = df_company[(df_company['post_date'] <= chosen_date) & (df_company['remove_date'] >= chosen_date)]\\r\\n cost_count_value = df_count['salary'].sum()\\r\\n co_cost_overall = cost_count_value\\r\\n \\r\\n df_50k = df_count[df_count['salary'] > 50000]\\r\\n salary_50k_cost_value = df_50k['salary'].sum()\\r\\n co_cost_50k = salary_50k_cost_value\\r\\n \\r\\n df_100k = df_count[df_count['salary'] > 100000]\\r\\n salary_100k_cost_value = df_100k['salary'].sum()\\r\\n co_cost_100k = salary_100k_cost_value\\r\\n \\r\\n df_manager = df_count[df_count['manager_role'] == 1]\\r\\n manager_cost_value = df_manager['salary'].sum()\\r\\n co_cost_manager = manager_cost_value\\r\\n \\r\\n df_sales = df_count[df_count['sales_role'] == 1]\\r\\n sales_cost_value = df_sales['salary'].sum()\\r\\n co_cost_sales = sales_cost_value\\r\\n \\r\\n df_key_roles = df_count[df_count['key_roles_role'] == 1]\\r\\n key_roles_cost_value = df_key_roles['salary'].sum()\\r\\n co_cost_key_roles = key_roles_cost_value\\r\\n \\r\\n df_it = df_count[df_count['it_role'] == 1]\\r\\n it_cost_value = df_it['salary'].sum()\\r\\n co_cost_it = it_cost_value\\r\\n \\r\\n df_hourly = df_count[df_count['hourly_role'] == 1]\\r\\n hourly_cost_value = df_hourly['salary'].sum()\\r\\n co_cost_hourly = hourly_cost_value\\r\\n \\r\\n \\r\\n \\r\\n intermediate_date_list.append(chosen_date)\\r\\n intermediate_company_list.append(chosen_company)\\r\\n intermediate_industry_list.append(company_sector)\\r\\n intermediate_inv_count_list.append(co_inv_overall)\\r\\n intermediate_inv_50k_list.append(co_inv_50k)\\r\\n intermediate_inv_100k_list.append(co_inv_100k)\\r\\n intermediate_inv_manager_list.append(co_inv_manager)\\r\\n intermediate_inv_sales_list.append(co_inv_sales)\\r\\n intermediate_inv_key_roles_list.append(co_inv_key_roles)\\r\\n intermediate_inv_it_list.append(co_inv_it)\\r\\n intermediate_inv_hourly_list.append(co_inv_hourly)\\r\\n\\r\\n intermediate_cost_count_list.append(co_cost_overall)\\r\\n intermediate_cost_50k_list.append(co_cost_50k)\\r\\n intermediate_cost_100k_list.append(co_cost_100k)\\r\\n intermediate_cost_manager_list.append(co_cost_manager)\\r\\n intermediate_cost_sales_list.append(co_cost_sales)\\r\\n intermediate_cost_key_roles_list.append(co_cost_key_roles)\\r\\n intermediate_cost_it_list.append(co_cost_it)\\r\\n intermediate_cost_hourly_list.append(co_cost_hourly)\\r\\n \\r\\n co_metric_dict['date_list'] = intermediate_date_list\\r\\n co_metric_dict['company_ref'] = intermediate_company_list\\r\\n co_metric_dict['sector'] = intermediate_industry_list\\r\\n co_metric_dict['co_inv_overall'] = intermediate_inv_count_list\\r\\n co_metric_dict['co_inv_50k'] = intermediate_inv_50k_list\\r\\n co_metric_dict['co_inv_100k'] = intermediate_inv_100k_list\\r\\n co_metric_dict['co_inv_manager'] = intermediate_inv_manager_list\\r\\n co_metric_dict['co_inv_sales'] = intermediate_inv_sales_list\\r\\n co_metric_dict['co_inv_key_roles'] = intermediate_inv_key_roles_list\\r\\n co_metric_dict['co_inv_it'] = intermediate_inv_it_list\\r\\n co_metric_dict['co_inv_hourly'] = intermediate_inv_hourly_list\\r\\n \\r\\n co_metric_dict['co_fut_cost_overall'] = intermediate_cost_count_list\\r\\n co_metric_dict['co_fut_cost_50k'] = intermediate_cost_50k_list\\r\\n co_metric_dict['co_fut_cost_100k'] = intermediate_cost_100k_list\\r\\n co_metric_dict['co_fut_cost_manager'] = intermediate_cost_manager_list\\r\\n co_metric_dict['co_fut_cost_sales'] = intermediate_cost_sales_list\\r\\n co_metric_dict['co_fut_cost_key_roles'] = intermediate_cost_key_roles_list\\r\\n co_metric_dict['co_fut_cost_it'] = intermediate_cost_it_list\\r\\n co_metric_dict['co_fut_cost_hourly'] = intermediate_cost_hourly_list\\r\\n\\r\\n df_co_metrics = pd.DataFrame(co_metric_dict, columns=co_metric_dict.keys())\",\n \"def calculate_metrics(self):\\n self.data_stats = self.sqlContext.read.format(\\\"org.apache.spark.sql.cassandra\\\").options(table=self.cassandra_trip_table, keyspace=self.cassandra_keyspace).load()\\n self.data_stats = self.data_stats.groupBy(['time_block','day','month','borough_name']).agg(func.avg('num_trips').alias('mean'))\",\n \"def aggregate_batch_evals(result_dict: dict, all_runs: list) -> dict:\\n # Loop over all evals (e.g. b_1_eval_0) and merge + aggregate data\\n new_results_dict = {}\\n for eval in all_runs:\\n all_seeds_for_run = list(result_dict[eval].keys())\\n eval_dict = aggregate_single_eval(result_dict[eval], all_seeds_for_run, eval)\\n new_results_dict[eval] = eval_dict[eval]\\n return new_results_dict\",\n \"def measure(self, qubit_expr, key=None):\\n qubit = self.qr.get(qubit_expr)\\n self.append(cirq.measure(qubit, key=key))\",\n \"def analyze_count(data):\\n\\n dsct_vk = pd.unique(data['vk'])\\n dsct_itemid = pd.unique(data['itemid'])\\n\\n print 'number of user:', dsct_vk.shape\\n print 'number of items:', dsct_itemid.shape\\n print 'the number of ratings:', data.shape\\n\\n print 'unique actions:', pd.unique(data['action'])\\n print 'the number of action 0:', np.sum(data['action'] == 0)\\n print 'the number of action 1:', np.sum(data['action'] == 1)\\n print 'the number of action 2:', np.sum(data['action'] == 2)\\n print 'the number of action 3:', np.sum(data['action'] == 3)\\n print 'the number of action 4:', np.sum(data['action'] == 4)\\n \\n time_range_item = data.groupby('itemid')['real_time'].aggregate(sum_unique)\\n print 'Max Range:', np.max(time_range_item)\\n print 'Mean Range:', np.mean(time_range_item)\\n print 'Median Range:', np.median(time_range_item)\",\n \"def summary(self):\\n summary = defaultdict(int)\\n\\n for r in self.results:\\n summary[r.result] += 1\\n\\n return summary\",\n \"def aggregate_qcdata(qcdata):\\n\\n # DD\\n log.debug('Aggregating daily DD QC Data')\\n curr_ts, last_ts = datetime.strptime(qcdata['TIMESTAMP_START'][0], '%Y%m%d%H%M'), datetime.strptime(qcdata['TIMESTAMP_START'][-1], '%Y%m%d%H%M')\\n curr_y, first_y, last_y = curr_ts.year, curr_ts.year, last_ts.year\\n entries_dd = 0\\n while curr_y <= last_y:\\n days_in_year = 366 if calendar.isleap(curr_y) else 365\\n entries_dd += days_in_year\\n curr_y += 1\\n dtype = [(vlabel, 'f8') for vlabel in NEW_METEO_VARS if vlabel in qcdata.dtype.names]\\n dtype_ext = dtype + [(vlabel + PERC_LABEL, 'f8') for vlabel, _ in dtype]\\n dtype_dd = TIMESTAMP_DTYPE_BY_RESOLUTION['dd'] + dtype_ext\\n data_dd = numpy.empty(entries_dd, dtype=dtype_dd)\\n data_dd.fill(-9999)\\n day_diff = timedelta(hours=24)\\n curr_idx = 0\\n while curr_ts <= last_ts:\\n if curr_idx % 300 == 0:\\n log.debug(\\\"Aggregating day {d}\\\".format(d=curr_idx))\\n dd = curr_ts.strftime('%Y%m%d')\\n data_dd['TIMESTAMP'][curr_idx] = dd\\n mask_dd = numpy.char.startswith(qcdata['TIMESTAMP_START'], dd)\\n for vlabel, _ in dtype:\\n values = qcdata[vlabel][mask_dd]\\n perc = float(values[values > -9999].size) / float(values.size)\\n if perc > 0.5:\\n mean = numpy.mean(values[values > -9999])\\n else:\\n mean = -9999\\n perc = -9999\\n data_dd[vlabel][curr_idx] = mean\\n data_dd[vlabel + PERC_LABEL][curr_idx] = perc\\n curr_idx += 1\\n curr_ts += day_diff\\n\\n # WW\\n log.debug('Aggregating weekly WW QC Data')\\n recs_ww = 52\\n dtype_ww = TIMESTAMP_DTYPE_BY_RESOLUTION['ww'] + dtype_ext\\n data_ww = numpy.empty((last_y - first_y + 1) * recs_ww, dtype=dtype_ww)\\n data_ww.fill(-9999)\\n for idx, year in enumerate(range(first_y, last_y + 1)):\\n first_rec = idx * recs_ww\\n curr_rec = first_rec\\n last_rec = first_rec + recs_ww\\n f = datetime(year, 1, 1, 0, 0)\\n data_ww['TIMESTAMP_START'][first_rec:last_rec] = [(f + timedelta(days=i * 7)).strftime('%Y%m%d') for i in xrange(0, recs_ww)]\\n data_ww['TIMESTAMP_END'][first_rec:last_rec] = [(datetime.strptime(i, '%Y%m%d') + timedelta(days=6)).strftime('%Y%m%d') for i in data_ww['TIMESTAMP_START'][first_rec:last_rec]]\\n data_ww['TIMESTAMP_END'][last_rec - 1] = datetime(year, 12, 31, 0, 0).strftime('%Y%m%d')\\n while curr_rec < last_rec:\\n first_idx, last_idx = numpy.where(data_dd['TIMESTAMP'] == data_ww['TIMESTAMP_START'][curr_rec])[0][0], numpy.where(data_dd['TIMESTAMP'] == data_ww['TIMESTAMP_END'][curr_rec])[0][0]\\n for vlabel, _ in dtype:\\n values = data_dd[vlabel][first_idx:last_idx]\\n values_perc = data_dd[vlabel + PERC_LABEL][first_idx:last_idx]\\n values_perc[values_perc <= -9999] = 0.0\\n perc = numpy.mean(values_perc)\\n if perc > 0.5:\\n mean = numpy.mean(values[values > -9999])\\n else:\\n mean = -9999\\n perc = -9999\\n data_ww[vlabel][curr_rec] = mean\\n data_ww[vlabel + PERC_LABEL][curr_rec] = perc\\n curr_rec += 1\\n\\n\\n # MM\\n log.debug('Aggregating monthly MM QC Data')\\n recs_mm = 12\\n dtype_mm = TIMESTAMP_DTYPE_BY_RESOLUTION['mm'] + dtype_ext\\n data_mm = numpy.empty((last_y - first_y + 1) * recs_mm, dtype=dtype_mm)\\n data_mm.fill(-9999)\\n data_mm['TIMESTAMP'] = [str(y) + str(m).zfill(2) for y in range(first_y, last_y + 1) for m in range(1, recs_mm + 1)]\\n for idx, mm in enumerate(data_mm['TIMESTAMP']):\\n mask_mm = numpy.char.startswith(data_dd['TIMESTAMP'], mm)\\n for vlabel, _ in dtype:\\n values = data_dd[vlabel][mask_mm]\\n values_perc = data_dd[vlabel + PERC_LABEL][mask_mm]\\n values_perc[values_perc <= -9999] = 0.0\\n perc = numpy.mean(values_perc)\\n if perc > 0.5:\\n mean = numpy.mean(values[values > -9999])\\n else:\\n mean = -9999\\n perc = -9999\\n data_mm[vlabel][idx] = mean\\n data_mm[vlabel + PERC_LABEL][idx] = perc\\n\\n # YY\\n log.debug('Aggregating yearly YY QC Data')\\n dtype_yy = TIMESTAMP_DTYPE_BY_RESOLUTION['yy'] + dtype_ext\\n data_yy = numpy.empty((last_y - first_y + 1), dtype=dtype_yy)\\n data_yy.fill(-9999)\\n data_yy['TIMESTAMP'] = [str(y) for y in range(first_y, last_y + 1)]\\n for idx, yy in enumerate(data_yy['TIMESTAMP']):\\n mask_yy = numpy.char.startswith(data_dd['TIMESTAMP'], yy)\\n for vlabel, _ in dtype:\\n values = data_dd[vlabel][mask_yy]\\n values_perc = data_dd[vlabel + PERC_LABEL][mask_yy]\\n values_perc[values_perc <= -9999] = 0.0\\n perc = numpy.mean(values_perc)\\n if perc > 0.5:\\n mean = numpy.mean(values[values > -9999])\\n else:\\n mean = -9999\\n perc = -9999\\n data_yy[vlabel][idx] = mean\\n data_yy[vlabel + PERC_LABEL][idx] = perc\\n\\n return data_dd, data_ww, data_mm, data_yy\",\n \"def collect_data(self):\\n exp_conf: ec.ExperimentConfiguration\\n # Disabled multiprocess run because of huge memory usage\\n processes_number = 1 # self._campaign_configuration['General']['j']\\n if processes_number == 1:\\n self._logger.info(\\\"-->Evaluate experiments (sequentially)\\\")\\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\\n exp_conf.evaluate()\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n exp_conf.generate_plots()\\n self._logger.info(\\\"<--\\\")\\n else:\\n self._logger.info(\\\"-->Evaluate experiments (in parallel)\\\")\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n self._logger.info(\\\"<--\\\")\\n\\n self.raw_results = {}\\n for exp_conf in self._exp_confs:\\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes\",\n \"def mean_accuracy_per_setting(results):\\n ###TODO\\n min_freq = {}\\n feature = {}\\n punct = {}\\n \\n #step 1 -> loop over results to get list of values for particular \\n # setting of punct, features,min_freq \\n #keys = ['punct','features','min_freq','accuracy']\\n \\n for d in results:\\n \\n if d['min_freq'] not in min_freq.keys():\\n min_freq.setdefault(d['min_freq'],[]).append(d['accuracy'])\\n else :\\n min_freq[d['min_freq']].append(d['accuracy'])\\n \\n if d['punct'] not in punct.keys():\\n punct.setdefault(d['punct'],[]).append(d['accuracy'])\\n else :\\n punct[d['punct']].append(d['accuracy'])\\n \\n if d['features'] not in feature.keys(): \\n feature.setdefault(d['features'],[]).append(d['accuracy'])\\n else : \\n feature[d['features']].append(d['accuracy'])\\n \\n \\n #print('min_freq = ',min_freq)\\n #print('feature = ',feature)\\n #print('punct = ',punct) \\n \\n # step 2 -> find average for each setting\\n tuple_list = [] \\n for fet in feature.keys():\\n \\n t1 = 'features='\\n for f in fet:\\n t1 += f.__name__ + ' '\\n \\n #print(t1)\\n avg = np.mean(feature[fet],dtype=np.float64) \\n tuple_list.append((avg,t1))\\n\\n\\n #print('After features result = ',result) \\n \\n for freq in min_freq.keys():\\n t1 = 'min_freq=' + str(freq)\\n avg = np.mean(min_freq[freq],dtype=np.float64) \\n tuple_list.append((avg,t1))\\n \\n #print('After mean_freq result = ',result) \\n \\n for pun in punct.keys():\\n t1 = 'punct=' + str(pun)\\n avg = np.mean(punct[pun],dtype=np.float64) \\n tuple_list.append((avg,t1))\\n \\n #print('After punct result = ',result) \\n \\n \\n tuple_list.sort(key=lambda x:(-x[0]))\\n #print('2.Sorted result = ',result) \\n \\n \\n return(tuple_list) \\n \\n pass\",\n \"def algorithm(df, params):\\n\\n output = {}\\n\\n # PUT YOUR OWN IMPLEMENTATION HERE\\n # STORE YOUR ANALYSIS OUTPUT IN OUTPUT\\n\\n return output\",\n \"def _cv_results(self, metrics):\\n\\n param_keys = self.param_combs[0].keys()\\n param_dict = {k: [comb[k] for comb in self.param_combs]\\n for k in param_keys}\\n df_metric_result = {k: pd.DataFrame({'Metric mean': self.mean[k],\\n 'Std. dev.': self.std[k],\\n **param_dict})\\n for k in metrics.keys()}\\n self.cv_results_ = df_metric_result\",\n \"def score_aggregate(results):\\n scores = []\\n truth_count = detected_count = segment_count = 0\\n\\n for res in results:\\n scores.append(res[\\\"scores\\\"])\\n truth_count += len(res[\\\"labels\\\"])\\n detected_count += len(res[\\\"detected\\\"])\\n segment_count += len(res[\\\"scores\\\"][\\\"segments\\\"])\\n\\n ret = dict()\\n ret[\\\"scores\\\"] = sum_scores(scores)\\n ret[\\\"stats\\\"] = dict(truth_count=truth_count, detected_count=detected_count, segment_count=segment_count)\\n return ret\",\n \"def get_params_dist_single_subject(raw_path, results_path):\\n if type(results_path) == str:\\n res_df = pd.read_csv(results_path, index_col=0)\\n else:\\n res_df = results_path\\n\\n au_top, au_top_acc = [], []\\n fe_top, fe_top_acc = [], []\\n pca_dims, pca_dims_acc = [], []\\n\\n for test_type in range(1, 6):\\n res_test = res_df[res_df.test_type == '[' + str(test_type) + ']']\\n\\n # AU top-n options and their mean accuracies\\n au_top_opts = res_df.au_top.unique().tolist()\\n au_mean_accs = []\\n\\n for au_top_opt in au_top_opts:\\n au_mean_accs.append(res_test[res_test.au_top == au_top_opt].mean_test_score.mean())\\n\\n au_top.append(au_top_opts)\\n au_top_acc.append(au_mean_accs)\\n\\n # Features top-n options and their mean accuracies\\n fe_top_opts = res_df.fe_top.unique().tolist()\\n fe_mean_accs = []\\n\\n for fe_top_opt in fe_top_opts:\\n fe_mean_accs.append(res_test[res_test.fe_top == fe_top_opt].mean_test_score.mean())\\n\\n fe_top.append(fe_top_opts)\\n fe_top_acc.append(fe_mean_accs)\\n\\n # PCA dimension options and their mean accuracies\\n pca_dim_opts = res_df.pca_dim.unique().tolist()\\n pca_dim_mean_accs = []\\n\\n for pca_dim_opt in pca_dim_opts:\\n pca_dim_mean_accs.append(res_test[res_test.pca_dim == pca_dim_opt].mean_test_score.mean())\\n\\n pca_dims.append(pca_dim_opts)\\n pca_dims_acc.append(pca_dim_mean_accs)\\n\\n return au_top, au_top_acc, fe_top, fe_top_acc, pca_dims, pca_dims_acc\",\n \"def aggregate_single_eval( # noqa: C901\\n result_dict: dict, all_seeds_for_run: list, eval_name: str\\n) -> dict:\\n new_results_dict = {}\\n data_temp = result_dict[all_seeds_for_run[0]]\\n # Get all main data source keys (\\\"meta\\\", \\\"stats\\\", \\\"time\\\")\\n data_sources = list(data_temp.keys())\\n # Get all variables within the data sources\\n data_items = {\\n data_sources[i]: list(data_temp[data_sources[i]].keys())\\n for i in range(len(data_sources))\\n }\\n # Collect all runs together - data at this point is not modified\\n source_to_store = {key: {} for key in data_sources}\\n for ds in data_sources:\\n data_to_store = {key: [] for key in data_items[ds]}\\n for i, o_name in enumerate(data_items[ds]):\\n for i, seed_id in enumerate(all_seeds_for_run):\\n seed_run = result_dict[seed_id]\\n data_to_store[o_name].append(seed_run[ds][o_name][:])\\n source_to_store[ds] = data_to_store\\n new_results_dict[eval_name] = source_to_store\\n\\n # Aggregate over the collected runs\\n aggregate_sources = {key: {} for key in data_sources}\\n for ds in data_sources:\\n if ds in [\\\"time\\\"]:\\n aggregate_dict = {key: {} for key in data_items[ds]}\\n for i, o_name in enumerate(data_items[ds]):\\n aggregate_dict[o_name] = new_results_dict[eval_name][ds][o_name][0]\\n # Mean over stats data\\n elif ds in [\\\"stats\\\"]:\\n aggregate_dict = {key: {} for key in data_items[ds]}\\n for i, o_name in enumerate(data_items[ds]):\\n if type(new_results_dict[eval_name][ds][o_name][0][0]) not in [\\n str,\\n bytes,\\n np.bytes_,\\n np.str_,\\n ]:\\n # Compute mean and standard deviation over seeds\\n mean_tol, std_tol = tolerant_mean(\\n new_results_dict[eval_name][ds][o_name]\\n )\\n aggregate_dict[o_name][\\\"mean\\\"] = mean_tol\\n aggregate_dict[o_name][\\\"std\\\"] = std_tol\\n\\n # Compute 10, 25, 50, 75, 90 percentiles over seeds\\n p50, p10, p25, p75, p90 = tolerant_median(\\n new_results_dict[eval_name][ds][o_name]\\n )\\n aggregate_dict[o_name][\\\"p50\\\"] = p50\\n aggregate_dict[o_name][\\\"p10\\\"] = p10\\n aggregate_dict[o_name][\\\"p25\\\"] = p25\\n aggregate_dict[o_name][\\\"p75\\\"] = p75\\n aggregate_dict[o_name][\\\"p90\\\"] = p90\\n else:\\n aggregate_dict[o_name] = new_results_dict[eval_name][ds][o_name]\\n # Append over all meta data (strings, seeds nothing to mean)\\n elif ds == \\\"meta\\\":\\n aggregate_dict = {}\\n for i, o_name in enumerate(data_items[ds]):\\n temp = (\\n np.array(new_results_dict[eval_name][ds][o_name])\\n .squeeze()\\n .astype(\\\"U200\\\")\\n )\\n # Get rid of duplicate experiment dir strings\\n if o_name in [\\n \\\"experiment_dir\\\",\\n \\\"eval_id\\\",\\n \\\"config_fname\\\",\\n \\\"model_type\\\",\\n ]:\\n aggregate_dict[o_name] = str(np.unique(temp)[0])\\n else:\\n aggregate_dict[o_name] = temp\\n\\n # Add seeds as clean array of integers to dict\\n aggregate_dict[\\\"seeds\\\"] = [int(s.split(\\\"_\\\")[1]) for s in all_seeds_for_run]\\n else:\\n raise ValueError\\n aggregate_sources[ds] = aggregate_dict\\n new_results_dict[eval_name] = aggregate_sources\\n return new_results_dict\",\n \"def _group_sessions_if_useful(self, sessions, useful):\\n sessions_dict = dict()\\n for session in sessions:\\n if session.query in useful:\\n if not session.query in sessions_dict:\\n sessions_dict[session.query] = []\\n sessions_dict[session.query].append(session)\\n return sessions_dict\",\n \"def keys(self):\\n # This function implements the heart of the table logic. We manually\\n # combine keys using the operators indicated by FactorExprNode objects.\\n # The reason this method is part of DataCube and not implemented in\\n # FactorExprNode is because the latter is meant to be a purely\\n # declarative representation of the expression graph, not an imperative\\n # utility class.\\n \\n if self._expr is None:\\n # We are being asked for the keys of some raw underlying data.\\n # If this is a numpy array, just return integer indices. If this\\n # is a Pandas DataFrame, we can return its index.\\n if isinstance(self._data, np.ndarray):\\n return range(self._data.shape[0])\\n elif hasattr(self._data, \\\"index\\\"):\\n return self._data.index\\n else:\\n # TODO: For now, all faceting operations require that we have a \\n # pandas DataFrame to compute the factors/levels. Integrate Bryan's\\n # Level DType stuff to make this support regular ndarrays.\\n if not hasattr(self._data, \\\"groupby\\\"):\\n raise RuntimeError(\\\"Data needs to support group-by functionality\\\")\\n op = self._expr.op\\n if op is None:\\n # Do a simple group-by\\n return self._data.groupby(self._expr.factors)\\n\\n elif op == \\\"blend\\\":\\n # Set union of keys from the two operands of the blend\\n left, right = self._expr.factors\\n keys = set.union(set(self._data.groupby(left).keys()), set(self._data.groupby(right).keys()))\\n return keys\\n \\n elif op == \\\"cross\\\":\\n return [self._data.groupby(left).keys(), self._data.groupby(right).keys()]\\n\\n elif op == \\\"nest\\\":\\n # Nested group-by. In effect like a cross that rejects null\\n # intersections between its input dimensions.\\n # We need to loop over the keyspace of our left operand and\\n # then do a group-by according to the factor named in the\\n # right operand. If the left operand is a cross, then we\\n # need to do the outer product, and we return two lists.\\n # TODO\\n raise NotImplementedError\",\n \"def aggregate_counties(self, parent):\\n data = {}\\n for division in tqdm(\\n Division.objects.filter(level=self.COUNTY_LEVEL, parent=parent)\\n ):\\n fips = division.code\\n aggregated_labels = [] # Keep track of already agg'ed variables\\n for estimate in division.census_estimates.all():\\n series = estimate.variable.table.series\\n year = estimate.variable.table.year\\n table = estimate.variable.table.code\\n label = estimate.variable.label.label\\n table_label = '{}{}'.format(table, label)\\n code = estimate.variable.code\\n if series not in data:\\n data[series] = {}\\n if year not in data[series]:\\n data[series][year] = {}\\n if table not in data[series][year]:\\n data[series][year][table] = {}\\n if fips not in data[series][year][table]:\\n data[series][year][table][fips] = {}\\n if label is not None:\\n if table_label not in aggregated_labels:\\n aggregated_labels.append(table_label)\\n data[series][year][table][fips][label] \\\\\\n = self.aggregate_variable(estimate, fips)\\n else:\\n data[series][year][table][division.code][code] \\\\\\n = estimate.estimate\\n return data\",\n \"def test_result(data, seq_test, **kwargs):\\n if isinstance(data, list) == False:\\n \\n pred,consum, ind_con = seq_test(data, **kwargs)\\n result = {'acc': np.mean(pred[:,1] == data[:,1]),\\n 'sens': recall_score(data[:,1], pred[:,1]),\\n 'spec': specificity_score(data[:,1], pred[:,1]),\\n 'PPV': precision_score(data[:, 1], pred[:,1]),\\n 'NPV': npv_score(data[:, 1], pred[:,1]),\\n 'test_consum': consum,\\n 'ind_consum': ind_con,\\n 'batch_consum': consum - ind_con}\\n return result\\n else:\\n length = len(data)\\n acc = np.zeros(length)\\n sens = np.zeros(length)\\n spec = np.zeros(length)\\n ppv = np.zeros(length)\\n npv = np.zeros(length)\\n test_consum = np.zeros(length)\\n ind_consum = np.zeros(length)\\n batch_consum = np.zeros(length)\\n for i in range(length):\\n \\n pred,consum, ind_con = seq_test(data[i], **kwargs)\\n \\n acc[i] = np.mean(pred[:,1] == data[i][:,1])\\n sens[i] = recall_score(data[i][:,1], pred[:,1])\\n spec[i] = specificity_score(data[i][:,1], pred[:,1])\\n ppv[i] = precision_score(data[i][:,1], pred[:,1])\\n npv[i] = npv_score(data[i][:,1], pred[:,1])\\n test_consum[i] = consum\\n ind_consum[i] = ind_con\\n batch_consum[i] = consum-ind_con\\n\\n result = {'acc': acc,\\n 'sens': sens,\\n 'spec': spec,\\n 'PPV': ppv,\\n 'NPV': npv,\\n 'test_consum': test_consum,\\n 'ind_consum': ind_consum,\\n 'batch_consum': batch_consum}\\n return pd.DataFrame(result)\",\n \"def __save_aggregate_scores(self):\\n results = pd.DataFrame(\\n columns=self.results[list(self.results.keys())[0]],\\n index=self.results.keys(),\\n )\\n for row_name, time_bins in self.results.items():\\n for column_name, value in time_bins.items():\\n results.loc[row_name, column_name] = value\\n results.reindex(sorted(results.columns, reverse=True), axis=1).to_csv(\\n self.df_save_path\\n )\",\n \"def evaluation(self):\\n rows_list = []\\n for name in self.single_classifier_best.keys():\\n row = {}\\n row['algorithm'] = name \\n row[self.scoring_metric] = self.single_classifier_best[name].best_score_\\n rows_list.append(row)\\n \\n scoring_df = pd.DataFrame(rows_list)\\n scoring_sorted = scoring_df.sort_values(self.scoring_metric, ascending=False)\\n print()\\n print('*'*shutil.get_terminal_size().columns)\\n print(scoring_sorted)\\n print('*'*shutil.get_terminal_size().columns)\\n self.evaluation_scores = scoring_sorted\",\n \"def qc_metrics(self, files_in, qc_files):\\n self.cmd(\\\"{samtools} index {bam_in}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in=files_in[0],\\n ),\\n shell=True)\\n self.cmd(\\\"{samtools} idxstats {bam_in} | tee {qc_file}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in = files_in[0],\\n qc_file = qc_files[0],\\n ),\\n shell=True,\\n log_output=True)\\n self.cmd(\\\"{samtools} flagstat {bam_in} | tee {qc_file}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in = files_in[0],\\n qc_file = qc_files[1],\\n ),\\n shell=True,\\n log_output=True)\\n \\n self.checkpoint(qc_files[0])\\n self.checkpoint(qc_files[1])\\n self.checkpoint(qc_files[2])\",\n \"def reduce_result(results):\\n agg = OrderedDict()\\n for result in results:\\n # Keys by model and explore, adds additional values for `passed` to a set\\n agg.setdefault((result[\\\"model\\\"], result[\\\"explore\\\"]), set()).add(\\n result[\\\"passed\\\"]\\n )\\n reduced = [\\n {\\\"model\\\": k[0], \\\"explore\\\": k[1], \\\"passed\\\": min(v)}\\n for k, v in agg.items()\\n ]\\n return reduced\",\n \"def cross_valid_key(model,x,key,preds,target,metric,verbose=True): \\r\\n\\r\\n score=[]\\r\\n \\r\\n keys = x[key].unique().tolist()\\r\\n \\r\\n\\r\\n\\r\\n for idx, item in enumerate([1,2,3,4,5]):\\r\\n\\r\\n xtrain,xtest = split_camp(x,keys,0.2)\\r\\n \\r\\n model.fit(xtrain[feat],xtrain[target])\\r\\n\\r\\n ypred = model.predict(xtest[feat])\\r\\n \\r\\n ytrue= xtest[target].values \\r\\n \\r\\n if metric == 'mae':\\r\\n score.append(mae(ytrue,ypred))\\r\\n elif metric == 'mse':\\r\\n score.append(mse(ytrue,ypred))\\r\\n elif metric == 'rrmse':\\r\\n score.append(rrmse(ytrue,ypred))\\r\\n\\r\\n else:\\r\\n score.append(rmse(xtest[target].tolist(),ypred))\\r\\n\\r\\n if verbose:\\r\\n print('-'*30)\\r\\n print(f'\\\\nFold {idx} out of 5')\\r\\n print(f'Key {item}')\\r\\n print(f'{metric}: {score[idx]}')\\r\\n\\r\\n \\r\\n\\r\\n if verbose:\\r\\n print(f'\\\\n Overall Score:')\\r\\n print(f'{metric}: Mean: {np.mean(score)} Std: {np.std(score)}')\\r\\n\\r\\n\\r\\n return score\",\n \"def usefulquantities(dffin):\\n dffin['log_length_box'] = np.log(dffin['length_box_um'])\\n dffin['time_min']=dffin['time_sec']/60\\n dffin['pred_length_box_um'] = np.exp(dffin['pred_log_length'])\\n dffin['unique_id'] = dffin['cell']+dffin['time_sec'].apply(lambda x:str(x))\\n dffin['cv_gr']= dffin.groupby('cell')['pred_growth_rate'].transform(lambda x:\\\\\\n np.std(x)/np.mean(x))\\n dffin['std_gr']= dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.std(x))\\n dffin['mean_gr'] = dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.mean(x))\\n dffin['mean_len'] = dffin.groupby('cell')['pred_length_box_um'].transform(lambda x: np.mean(x))\\n dffin['norm_pred_growth_rate'] = (dffin['pred_growth_rate']-dffin.groupby('cell')['pred_growth_rate'].transform(lambda\\\\\\n x: np.mean(x)))/dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.mean(x))\\n dffin = rl.genalogy(dffin,'parent_cell') #Create genealogy\\n dffin = rl.genalogy(dffin,'g_parent_cell')\\n dffin = rl.genalogy(dffin,'g_g_parent_cell')\\n dffin = dffin.set_index('unique_id')\\n qq= dffin.groupby('cell').apply(lambda x: (x['pred_length_box_um']-x['pred_length_box_um'].iloc[0])/(x['pred_length_box_um'].iloc[-1]-x['pred_length_box_um'].iloc[0])).rename('add_len')\\n jj= dffin.groupby('cell').apply(lambda x: (x['time_sec']-x['time_sec'].iloc[0])/(x['time_sec'].iloc[-1]-x['time_sec'].iloc[0])).rename('cell_cycle')\\n return pd.concat([dffin, qq.reset_index().set_index('unique_id')['add_len'], jj.reset_index().set_index('unique_id')['cell_cycle']], axis=1, join='inner')\",\n \"def calc_metrics(data, sampled_data_list, dataset_type):\\n result={}\\n for sampled_data in sampled_data_list:\\n c2st_roc_auc_metric = c2st_roc_auc(data, sampled_data)\\n if \\\"c2st_roc_auc\\\" in result:\\n result[\\\"c2st_roc_auc\\\"].append(c2st_roc_auc_metric)\\n else:\\n result[\\\"c2st_roc_auc\\\"] = [c2st_roc_auc_metric]\\n mmd_p_val, mmd_stat = rbf_mmd_test(data.values, sampled_data.values)\\n if \\\"mmd_p_val\\\" in result:\\n result[\\\"mmd_p_val\\\"].append(mmd_p_val)\\n result[\\\"mmd_stat\\\"].append(mmd_stat)\\n else:\\n result[\\\"mmd_p_val\\\"] = [mmd_p_val]\\n result[\\\"mmd_stat\\\"] = [mmd_stat]\\n ks_p_val, ks_stat, ks_n, ks_p_val_list, ks_stat_list = ks_test(data, sampled_data)\\n if dataset_type != \\\"norm_dataset\\\":\\n ks_p_val = ks_permutation(ks_stat_list, data, sampled_data)\\n if \\\"ks_p_val\\\" in result:\\n result[\\\"ks_p_val\\\"].append(ks_p_val)\\n result[\\\"ks_stat\\\"].append(ks_stat)\\n else:\\n result[\\\"ks_p_val\\\"] = [ks_p_val]\\n result[\\\"ks_stat\\\"] = [ks_stat]\\n acc_r, acc_g = c2st_accuracy(data, sampled_data)\\n if \\\"c2st_acc_r\\\" in result:\\n result[\\\"c2st_acc_r\\\"].append(acc_r)\\n result[\\\"c2st_acc_g\\\"].append(acc_g)\\n else:\\n result[\\\"c2st_acc_r\\\"] = [acc_r]\\n result[\\\"c2st_acc_g\\\"] = [acc_g]\\n return result\",\n \"def MCS(n,k):\\n\\tglobal dict_all\\n\\tdict_val=copy.deepcopy(dict_all)\\n\\t#start_time = time.time()\\n\\tfinal = {}\\t\\t\\t\\t\\t # Store all result with the count as key. For example final[1]=[[1,0,0],[0,1,1]]\\n\\tseq = []\\t\\t\\t\\t\\t\\t# Store the count with no duplication\\n\\tfor i in range(n):\\n\\t\\tleaf={}\\t\\t\\t\\t\\t\\t# leaf is the dictionary to store the random value of each leaf\\n\\t\\t#count=0\\n\\t\\tfor i in leaves:\\n\\t\\t\\tleaf[i] = choice([0,1])\\n\\t\\t\\tdict_val[i]=leaf[i]\\n\\t\\t\\t#count += leaf[i]\\n\\t\\tresult = Cal_FT(dict_val)\\t\\n\\t\\t'''\\n\\t\\tif result:\\n\\t\\t\\tcutset = []\\n\\t\\t\\tfor i in leaves:\\n\\t\\t\\t\\tcutset.append(str(leaf[i]))\\n\\t\\t\\tcutset=\\\"\\\".join(cutset)\\n\\t\\t\\tif cutset not in final:\\n\\t\\t\\t\\tfinal[cutset]=count\\n\\tfinal_sorted=sorted(zip(final.values(),final.keys())) \\t\\t\\t\\t#Order the cutset by its count\\n\\tfor i in range(k):\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t#Print the first k result\\n\\t\\tcutset=list(final_sorted[i][1])\\n\\t\\tresult=[]\\n\\t\\tfor index in range(len(cutset)):\\n\\t\\t\\tif cutset[index] is \\\"1\\\":\\n\\t\\t\\t\\tresult.append(leaves[index])\\n\\t\\tprint result\\n\\t#end_time=time.time()\\n\\t#print \\\"Running time is\\\", end_time-start_time\\n\\t'''\",\n \"def compute_query_summary_statistics(data):\\n return {\\n nameserver: _compute_summary_stats(entries)\\n for nameserver, entries in data.items()\\n }\",\n \"def analysis():\\r\\n data_frame = load_from_mysql('core', 'BDFMHQAA_D')\\r\\n data_frame.registerTempTable('business')\\r\\n gd = data_frame.select('AA03CSNO', 'AA08PRON')\\r\\n\\r\\n def merge_count(a, b):\\r\\n r = {}\\r\\n for p, c in a.items():\\r\\n if p in r:\\r\\n r[p] += c\\r\\n else:\\r\\n r[p] = c\\r\\n for p, c in b.items():\\r\\n if p in r:\\r\\n r[p] += c\\r\\n else:\\r\\n r[p] = c\\r\\n return r\\r\\n result = gd.map(lambda row: (row.AA03CSNO, {row.AA08PRON: 1})).reduceByKey(merge_count)\\r\\n pron_count = gd.map(lambda row: (row.AA08PRON, 1)).reduceByKey(lambda a, b: a + b)\\r\\n\\r\\n # result = gd.map(lambda row: (row.AA03CSNO, row.AA08PRON))\\r\\n print(result.take(10))\\r\\n print('----------------pron count-----------------')\\r\\n print(pron_count.collect())\\r\\n\\r\\n print(gd)\",\n \"def transform_to_sessions(events, uid):\\n \\n class Sessions:\\n values = {\\n 'id': [], 'size_ts': [],\\n 'interruptions': [], 'n_inte': [], 'n_events': [], 'start_time': [], 'end_time': [],\\n 'user': [], 'edition': [], 'text_nav': [], 'high_nav': [], 'file': [], 'refactoring': [],\\n 'clean_build': [], 'debug': [], 'tools': [], 'control': [], 'testing': [], 'search': []\\n\\n }\\n\\n lists = {\\n 'l_interruptions': [], 'l_edition': [], 'l_text_nav': [], 'l_high_nav': [], 'l_file': [],\\n 'l_refactoring': [], 'l_clean_build': [], 'l_debug': [], 'l_tools': [], 'l_control': [],\\n 'l_testing': [], 'l_search': [], 'size_ts': [], 'n_inte': [], 'id': []\\n }\\n\\n def __init__(self):\\n pass\\n\\n def create_dataframe(self):\\n \\\"\\\"\\\"\\n Creates a dataframe with the sessions of the user\\n \\\"\\\"\\\"\\n sessions = pandas.DataFrame().from_dict(self.values)\\n sessions_lists = pandas.DataFrame().from_dict(self.lists)\\n return sessions, sessions_lists\\n \\n so = Sessions()\\n\\n s = set(events['session_id'])\\n\\n count = 0 # count of sessions\\n\\n # process all the sessions of the user\\n for i in s:\\n user_sessions = events[events['session_id'] == i]\\n #user_sessions.to_csv(PATH_SESSIONS + '/' + str(uid) + '-' + str(count) + '.csv', index=False)\\n\\n split_session = [user_sessions]\\n\\n # if breaking points are found, the session splits into subsessions\\n bp = break_points(user_sessions['interval'], user_sessions['minute'])\\n if len(bp) > 0:\\n bp.append(len(user_sessions))\\n split_session = []\\n index = 0\\n for k in range(0,len(bp)):\\n sub_session = user_sessions.iloc[index:(bp[k]+1)]\\n split_session.append(sub_session)\\n index = bp[k]+1\\n\\n count += 1\\n\\n for session in split_session:\\n\\n minutes = np.unique(np.array(session['minute']))\\n l_edits = []\\n l_text_nav = []\\n l_high_nav = []\\n l_refactoring = []\\n l_debug = []\\n l_file = []\\n l_build = []\\n l_tools = []\\n l_control = []\\n l_testing = []\\n l_search = []\\n l_inte = []\\n dur = len(minutes)\\n ni = 0\\n\\n for m in minutes:\\n # for every minute of the session, count the number of edition and\\n # selection events and the duration of the interruptions (among other types of events)\\n subset = session[session['minute'] == m]\\n l_edits.append(len(subset[subset['detailed_type'] == 'edit-text']))\\n l_high_nav.append(len(subset[subset['detailed_type'] == 'high-nav']))\\n l_text_nav.append(len(subset[subset['detailed_type'] == 'text-nav']))\\n l_refactoring.append(len(subset[subset['detailed_type'] == 'refactoring']))\\n l_debug.append(len(subset[subset['detailed_type'] == 'debug']))\\n l_file.append(len(subset[subset['detailed_type'] == 'file']))\\n l_build.append(len(subset[subset['detailed_type'] == 'clean-build']))\\n l_tools.append(len(subset[subset['detailed_type'] == 'tools']))\\n l_control.append(len(subset[subset['detailed_type'] == 'control']))\\n l_testing.append(len(subset[subset['detailed_type'] == 'testing']))\\n l_search.append(len(subset[subset['detailed_type'] == 'search']))\\n\\n if subset.iloc[len(subset)-1]['is_interruption']:\\n l_inte.append(subset.iloc[len(subset)-1]['interval']//60)\\n ni += 1\\n else:\\n l_inte.append(0)\\n\\n so.values['id'].append(str(uid) + '-' + str(count))\\n so.lists['id'].append(str(uid) + '-' + str(count))\\n # print (str(uid) + '-' + str(count))\\n so.values['size_ts'].append(dur)\\n so.lists['size_ts'].append(dur)\\n\\n # convert the lists to string\\n str_edits = ' '.join(str(e) for e in l_edits)\\n str_high_nav = ' '.join(str(e) for e in l_high_nav)\\n str_text_nav = ' '.join(str(e) for e in l_text_nav)\\n str_refactoring = ' '.join(str(e) for e in l_refactoring)\\n str_debug = ' '.join(str(e) for e in l_debug)\\n str_file = ' '.join(str(e) for e in l_file)\\n str_build = ' '.join(str(e) for e in l_build)\\n str_tools = ' '.join(str(e) for e in l_tools)\\n str_control = ' '.join(str(e) for e in l_control)\\n str_testing = ' '.join(str(e) for e in l_testing)\\n str_search = ' '.join(str(e) for e in l_search)\\n str_inte = ' '.join(str(e) for e in l_inte)\\n\\n so.values['edition'].append(str_edits)\\n so.values['high_nav'].append(str_high_nav)\\n so.values['text_nav'].append(str_text_nav)\\n so.values['refactoring'].append(str_refactoring)\\n so.values['debug'].append(str_debug)\\n so.values['file'].append(str_file)\\n so.values['clean_build'].append(str_build)\\n so.values['tools'].append(str_tools)\\n so.values['control'].append(str_control)\\n so.values['testing'].append(str_testing)\\n so.values['search'].append(str_search)\\n so.values['interruptions'].append(str_inte)\\n\\n so.lists['l_interruptions'].append(l_inte)\\n so.lists['l_edition'].append(l_edits)\\n so.lists['l_high_nav'].append(l_high_nav)\\n so.lists['l_text_nav'].append(l_text_nav)\\n so.lists['l_refactoring'].append(l_refactoring)\\n so.lists['l_debug'].append(l_debug)\\n so.lists['l_file'].append(l_file)\\n so.lists['l_clean_build'].append(l_build)\\n so.lists['l_tools'].append(l_tools)\\n so.lists['l_control'].append(l_control)\\n so.lists['l_testing'].append(l_testing)\\n so.lists['l_search'].append(l_search)\\n so.lists['n_inte'].append(ni)\\n \\n so.values['n_inte'].append(ni)\\n so.values['start_time'].append(session.iloc[0]['datetime'])\\n so.values['end_time'].append(session.iloc[len(session) - 1]['datetime'])\\n so.values['user'].append(session.iloc[0][0])\\n so.values['n_events'].append(len(session[session['detailed_type'] != ' ']))\\n\\n result, lists = so.create_dataframe()\\n return result, lists\",\n \"def gather(self):\\n\\n sacct_fields = [\\n \\\"Account\\\",\\n \\\"AllocNodes\\\",\\n \\\"AllocTRES\\\",\\n \\\"ConsumedEnergyRaw\\\",\\n \\\"CPUTimeRaw\\\",\\n \\\"Elapsed\\\",\\n \\\"End\\\",\\n \\\"ExitCode\\\",\\n \\\"JobID\\\",\\n \\\"JobName\\\",\\n \\\"NCPUS\\\",\\n \\\"NNodes\\\",\\n \\\"QOS\\\",\\n \\\"ReqMem\\\",\\n \\\"ReqNodes\\\",\\n \\\"Start\\\",\\n \\\"State\\\",\\n \\\"Submit\\\",\\n \\\"UID\\\",\\n \\\"User\\\",\\n \\\"WorkDir\\\",\\n ]\\n\\n query = f\\\"sacct -j {self.jobid} -X -n -P -o ExitCode,Workdir\\\"\\n if self.cluster:\\n query += f\\\" --clusters={self.cluster}\\\"\\n\\n cmd = BuildTestCommand(query)\\n cmd.execute()\\n\\n logger.debug(\\n f\\\"Querying JobID: '{self.jobid}' ExitCode and Workdir by running: '{query}'\\\"\\n )\\n\\n out = \\\"\\\".join(cmd.get_output()).rstrip()\\n\\n exitcode, workdir = out.split(\\\"|\\\")\\n # Exit Code field is in format <ExitCode>:<Signal> for now we care only about first number\\n self._exitcode = int(exitcode.split(\\\":\\\")[0])\\n self._workdir = workdir\\n\\n query = f\\\"sacct -j {self.jobid} -X -n -P -o {','.join(sacct_fields)}\\\"\\n\\n # to query jobs from another cluster we must add -M <cluster> to sacct\\n if self.cluster:\\n query += f\\\" --clusters={self.cluster}\\\"\\n\\n logger.debug(f\\\"Gather slurm job data by running: {query}\\\")\\n cmd = BuildTestCommand(query)\\n cmd.execute()\\n out = \\\"\\\".join(cmd.get_output())\\n # split by | since\\n out = out.split(\\\"|\\\")\\n job_data = {}\\n for field, value in zip(sacct_fields, out):\\n job_data[field] = value\\n\\n return job_data\",\n \"def accumulate_study_results(ids, prob):\\n sum_result = {}\\n cnt_result = {}\\n size = prob.shape[0]\\n for i in range(size):\\n study_id = ids[i]\\n idx = int(study_id)\\n if idx not in cnt_result:\\n cnt_result[idx] = 0.\\n sum_result[idx] = np.zeros((1, prob.shape[1]), dtype=np.float32)\\n cnt_result[idx] += 1\\n sum_result[idx] += prob[i, :]\\n for i in cnt_result.keys():\\n sum_result[i][:] /= cnt_result[i]\\n return sum_result\",\n \"def _per_cls_summarize(self):\\n per_class_result = {}\\n for catId in range(len(self.cats)):\\n resultDet = self._summarize_with_cat(f1=False, catIdx=catId)\\n\\n if catId in self.FPParams.catsWithAttributes:\\n results = self._summarize_with_cat(catIdx=catId)\\n resultF1 = self._summarize_with_cat(iou=False, catIdx=catId)\\n\\n per_class_result[self.cats[catId][\\\"name\\\"]] = {\\n \\\"iou_f1\\\": results, \\\"f1\\\": resultF1, \\\"iou\\\": resultDet,\\n }\\n else:\\n per_class_result[self.cats[catId][\\\"name\\\"]] = {\\\"iou\\\": resultDet}\\n\\n return per_class_result\",\n \"def query(self):\\n self._measurements[self.KEY_USAGE].df = self.fetch_data_usage()\",\n \"def summarize(self):\\n self.smalltalk += \\\"\\\\n Data IDs in this bundle: \\\\n\\\"\\n self._files = {}\\n inv_dict = {}\\n # sort IDs to make sure pdfs are printed in same oder as they were\\n # taken\\n for k, v in self.stage_summaries.items():\\n for qc_id in flatten_list(v):\\n inv_dict[qc_id] = k\\n sorted_ids = list(flatten_list(self.stage_summaries.values()))\\n sorted_ids.sort(key=int)\\n # for stage, value in self.stage_summaries.items():\\n for qc_run_id in sorted_ids:\\n # stage = inv_dict[qc_run_id]\\n # if stage[0:7] == 'failed_':\\n # stage = stage[7:]\\n # try:\\n # s = self.comments[qc_run_id]\\n # except KeyError:\\n # s = ''\\n # self.comments[qc_run_id] = 'Classified as poor result.\\\\n' + s\\n ds = Dataset(qc_run_id, self.db_name)\\n device_name = ds.device_name\\n f_folder = os.path.join(self.db_folder, \\\"tuning_results\\\", device_name)\\n # for qc_run_id in flatten_list(value):\\n self.smalltalk += str(qc_run_id) + \\\", \\\"\\n\\n # filename = stage + '_fit_ds'\\n # filename += str(qc_run_id) + '.png'\\n filename = os.path.join(f_folder, str(ds.ds.guid) + \\\".png\\\")\\n\\n self._files[str(qc_run_id)] = filename\",\n \"def compute_statistics(self):\",\n \"def run_csls_metrics(self, sess, batch_size=512):\\n top_matches = []\\n score = self.calc_csls_score(sess)\\n avg1, avg2 = self.calc_avg_dist(sess)\\n csls_scores = 2 * score - (avg1[self.src_ind][:, None] + avg2[None, :])\\n # Calculate top matches\\n for i in range(0, len(self.src_ind), batch_size):\\n scores = [csls_scores[x] for x in range(i, min(i + batch_size, len(self.src_ind)))]\\n top_matches_val = sess.run(\\n self.csls_subgraphs[\\\"Top100\\\"], feed_dict={self.score_ph: scores}\\n )[1]\\n top_matches.append(top_matches_val)\\n top_matches = np.concatenate(top_matches)\\n print(\\\"Accuracy using CSLS is\\\")\\n self.calc_accuracy(top_matches)\\n self.calc_csls(sess)\",\n \"def compute_scores(self, keys: Tensor, queries: Tensor) -> Tensor:\\n raise NotImplementedError\",\n \"def test_measure_deterministic_multi_qubit_with_sampling(self):\\n shots = 100\\n qobj = ref_measure.measure_circuits_qobj_deterministic(allow_sampling=True)\\n qobj.config.shots = shots\\n circuits = [experiment.header.name for experiment in qobj.experiments]\\n targets = ref_measure.measure_counts_qobj_deterministic(shots)\\n job = QasmSimulator().run(qobj)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0)\",\n \"def process_input_items(args):\\n return dict(sum([Counter({sku: value * SCORES[k] for sku, value in\\n Counter(args[k].split(',')).items()}) or Counter() for k in\\n set(SCORES.keys()) & set(args.keys())], Counter()))\",\n \"def aggregate_query(self):\\n raise NotImplementedError\",\n \"def craw_all():\\n\\n # min_kdb_id = 16_000 # 2021-06-06 16_392 is highest\\n min_kdb_id = 4_000 # 4007 is actual lowest but rounding! https://www.db.yugioh-card.com/yugiohdb/card_search.action?ope=2&cid=4007\\n base_query = \\\"[[Medium::TCG]]\\\"\\n\\n final_output = []\\n has_res = True\\n kdb_id = min_kdb_id\\n step = 400\\n\\n num_req = 0\\n while has_res:\\n query = \\\"%s [[Database ID::>%s]] [[Database ID::<%s]]\\\" % (\\n base_query,\\n kdb_id,\\n kdb_id + step,\\n )\\n num_req += 1\\n print(num_req, query)\\n\\n data = ask_yugipedia(query, ALL_DISPLAYS, limit=500, do_sleep=10)\\n check(data, ALL_DISPLAYS)\\n has_res = bool(data)\\n\\n data[\\\"query\\\"] = query\\n data[\\\"disp\\\"] = ALL_DISPLAYS\\n if has_res:\\n final_output.append(data)\\n\\n kdb_id += step + 1\\n\\n return final_output\",\n \"def home():\\n\\n connection = pypyodbc.connect(connectionString)\\n \\n cursor = connection.cursor()\\n\\n cachedResults['avgAgePerState'] = runQuery(cursor, avgAgePerStateCommand)\\n cachedResults['avgAgePerTown'] = runQuery(cursor, avgAgePerTownCommand)\\n cachedResults['avgAgePerProvince'] = runQuery(cursor, avgAgePerProvinceCommand)\\n cachedResults['avgAgePerFacilityName'] = runQuery(cursor, avgAgePerFacilityNameCommand)\\n cachedResults['avgAgePerFacilityType'] = runQuery(cursor, avgAgePerFacilityTypeCommand)\\n\\n cachedResults['eidTestResultTotal'] = runQuery(cursor, eidTestResultTotalCommand)\\n cachedResults['eidTestResultAIDSTFacilityType'] = runQuery(cursor, eidTestResultAIDSTFacilityTypeCommand)\\n cachedResults['eidTestResultAMIFacilityType'] = runQuery(cursor, eidTestResultAMIFacilityTypeCommand)\\n cachedResults['eidTestResultDisHFacilityType'] = runQuery(cursor, eidTestResultDisHFacilityTypeCommand)\\n cachedResults['eidTestResultGenHFacilityType'] = runQuery(cursor, eidTestResultGenHFacilityTypeCommand)\\n cachedResults['eidTestResultMSFHFacilityType'] = runQuery(cursor, eidTestResultMSFHFacilityTypeCommand)\\n cachedResults['eidTestResultNHLFacilityType'] = runQuery(cursor, eidTestResultNHLFacilityTypeCommand)\\n cachedResults['eidTestResultSpHFacilityType'] = runQuery(cursor, eidTestResultSpHFacilityTypeCommand)\\n cachedResults['eidTestResultSRHFacilityType'] = runQuery(cursor, eidTestResultSRHFacilityTypeCommand)\\n cachedResults['eidTestResultTHFacilityType'] = runQuery(cursor, eidTestResultTHFacilityTypeCommand)\\n\\n cachedResults['avgTatTotal'] = runQuery(cursor, avgTatTotalCommand)\\n cachedResults['avgTatAIDSTFacilityType'] = runQuery(cursor, avgTatAIDSTFacilityTypeCommand)\\n cachedResults['avgTatAMIFacilityType'] = runQuery(cursor, avgTatAMIFacilityTypeCommand)\\n cachedResults['avgTatDisHFacilityType'] = runQuery(cursor, avgTatDisHFacilityTypeCommand)\\n cachedResults['avgTatGenHFacilityType'] = runQuery(cursor, avgTatGenHFacilityTypeCommand)\\n cachedResults['avgTatMSFHFacilityType'] = runQuery(cursor, avgTatMSFHFacilityTypeCommand)\\n cachedResults['avgTatNHLFacilityType'] = runQuery(cursor, avgTatNHLFacilityTypeCommand)\\n cachedResults['avgTatSpHFacilityType'] = runQuery(cursor, avgTatSpHFacilityTypeCommand)\\n cachedResults['avgTatSRHFacilityType'] = runQuery(cursor, avgTatSRHFacilityTypeCommand)\\n cachedResults['avgTatTHFacilityType'] = runQuery(cursor, avgTatTHFacilityTypeCommand)\\n\\n cachedResults['trackSample'] = runQuery(cursor, trackSampleCommand)\\n\\n cachedResults['avgAgeNHL'] = runQuery(cursor, avgAgeNHLCommand)\\n cachedResults['avgAgePHL'] = runQuery(cursor, avgAgePHLCommand)\\n cachedResults['avgAgeUNION'] = runQuery(cursor, avgAgeUNIONCommand)\\n\\n cachedResults['eidTestResultNHLLab'] = runQuery(cursor, eidTestResultNHLLabCommand)\\n cachedResults['eidTestResultPHLLab'] = runQuery(cursor, eidTestResultPHLLabCommand)\\n cachedResults['eidTestResultUNIONLab'] = runQuery(cursor, eidTestResultUNIONLabCommand)\\n\\n cachedResults['avgTatNHLLab'] = runQuery(cursor, avgTatNHLLabCommand)\\n cachedResults['avgTatPHLLab'] = runQuery(cursor, avgTatPHLLabCommand)\\n cachedResults['avgTatUNIONLab'] = runQuery(cursor, avgTatUNIONLabCommand)\\n\\n connection.close()\\n\\n return render_template('index.html')\",\n \"def getkeytimestats(s,refconvdf):\\r\\n df=refconvdf[refconvdf.convid==s]\\r\\n \\r\\n #first response\\r\\n firstrsp=df[df.idx_conv==1]\\r\\n if firstrsp.empty:\\r\\n firstrsp=None\\r\\n else: \\r\\n firstrsp=firstrsp.created_at.iloc[0]\\r\\n \\r\\n #closed part types \\r\\n clsparts=df[df.part_type=='close']\\r\\n \\r\\n #first closed\\r\\n firstcls=clsparts.head(1)\\r\\n if firstcls.empty:\\r\\n firstcls=None \\r\\n else: \\r\\n firstcls=firstcls.created_at.iloc[0]\\r\\n \\r\\n #clast closed\\r\\n lastcls=clsparts.tail(1)\\r\\n if lastcls.empty:\\r\\n lastcls=None\\r\\n else: \\r\\n lastcls=lastcls.created_at.iloc[0]\\r\\n return pd.Series(dict(first_response=firstrsp,first_closed=firstcls,last_closed=lastcls))\",\n \"def test_evaluate(self):\\n # test normalized by 'bbox_size'\\n jhmdb_pck_metric = JhmdbPCKAccuracy(thr=0.5, norm_item='bbox')\\n jhmdb_pck_metric.process(self.data_batch, self.data_samples)\\n pck_results = jhmdb_pck_metric.evaluate(self.batch_size)\\n target = {\\n 'Head PCK': 1.0,\\n 'Sho PCK': 1.0,\\n 'Elb PCK': 1.0,\\n 'Wri PCK': 1.0,\\n 'Hip PCK': 1.0,\\n 'Knee PCK': 1.0,\\n 'Ank PCK': 1.0,\\n 'PCK': 1.0,\\n }\\n self.assertDictEqual(pck_results, target)\\n\\n # test normalized by 'torso_size'\\n jhmdb_tpck_metric = JhmdbPCKAccuracy(thr=0.2, norm_item='torso')\\n jhmdb_tpck_metric.process(self.data_batch, self.data_samples)\\n tpck_results = jhmdb_tpck_metric.evaluate(self.batch_size)\\n target = {\\n 'Head tPCK': 1.0,\\n 'Sho tPCK': 1.0,\\n 'Elb tPCK': 1.0,\\n 'Wri tPCK': 1.0,\\n 'Hip tPCK': 1.0,\\n 'Knee tPCK': 1.0,\\n 'Ank tPCK': 1.0,\\n 'tPCK': 1.0,\\n }\\n self.assertDictEqual(tpck_results, target)\",\n \"def upgrade_to_17():\\n\\n pipeline = [\\n {'$group' : { '_id' : {'pid': '$project', 'code': '$subject.code'}, 'sids': {'$push': '$_id' }}}\\n ]\\n\\n subjects = config.db.command('aggregate', 'sessions', pipeline=pipeline)\\n for subject in subjects['result']:\\n\\n # Subjects without a code and sessions without a subject\\n # will be returned grouped together, but all need unique IDs\\n if subject['_id'].get('code') is None:\\n for session_id in subject['sids']:\\n subject_id = bson.ObjectId()\\n config.db.sessions.update_one({'_id': session_id},{'$set': {'subject._id': subject_id}})\\n else:\\n subject_id = bson.ObjectId()\\n query = {'_id': {'$in': subject['sids']}}\\n update = {'$set': {'subject._id': subject_id}}\\n config.db.sessions.update_many(query, update)\",\n \"def quant(input_folder,fastq_dict,species_kmers,output_folder,transcriptome_folder,bsub_out=\\\"bsub_out\\\"):\\n print(\\\"Starting new quantification run for batch of %d samples from %s\\\"%(len(fastq_dict),input_folder))\\n mkdir_p(bsub_out)\\n #no subfolders needed for SRA data\\n print(\\\"bsub logs stored in %s folder\\\"%bsub_out)\\n mkdir_p(output_folder)\\n print(\\\"kallisto output in %s\\\"%output_folder)\\n for i in fastq_dict:\\n print(\\\"===processing fastq files from sample ID: %s===\\\"%i)\\n outdir = path.join(output_folder,i) #separate folder for each fastq, within the output folder\\n mkdir_p(outdir)\\n cmd = kw.CMD_BASE.format(fastq_id=i,bsub_out=bsub_out)\\n cmd = shlex.split(cmd) #convert to list of arguments\\n species = fastq_dict[i][\\\"species\\\"]\\n t_index = path.join(transcriptome_folder,kw.species2transcriptomeindex(species,kmer_size=species_kmers[species]))\\n f1 = [path.join(input_folder,r+\\\"_1.fastq.gz\\\") for r in fastq_dict[i][\\\"fastq_list\\\"]]\\n if fastq_dict[i][\\\"is_paired_end\\\"]:\\n f2 = [path.join(input_folder,r+\\\"_2.fastq.gz\\\") for r in fastq_dict[i][\\\"fastq_list\\\"]]\\n flist = \\\" \\\".join(imap(lambda x,y: x+\\\" \\\"+y,f1,f2))\\n cmd.append(\\\"kallisto quant -i {ti} -o {out} {flist}\\\".format(ti=t_index,out=outdir,flist = flist))\\n else: #case of single end reads\\n flen = median(array(fastq_dict[i][\\\"avgLengths\\\"]))\\n flist = \\\" \\\".join(f1)\\n cmd.append(\\\"kallisto quant --single -i {ti} -o {out} -l {flen} -s {fsd} {flist}\\\".format(ti=t_index,out=outdir,flen=flen,fsd=flen/5.0,flist = flist))\\n #note, fsd is the standard deviation of the fragment length distribution. flen/5 is just a placeholder. We should actually estimate this in the future!\\n #print(cmd)\\n subprocess.call(cmd)\",\n \"def compute_and_report(data, scorer):\\n sim = sorted([(scorer(data, a, b), a, b)\\n for a, b in combinations(data.keys(), 2)],\\n reverse=True)\\n\\n for s, a, b in sim:\\n print(\\\"%.2f\\\" % s, a, b)\",\n \"def runGenericTests():\\n possibleK = [10, 15, 25]\\n #possibleK = [15]\\n #smalldata = [1, 5, 10]\\n mediumdata = [10, 25, 50, 75, 100, 200, 300, 400, 500]\\n #largedata = [100, 500, 1000, 5000]\\n print(\\\"Running Generic Tests...\\\")\\n resulttimes = {}\\n for k in possibleK:\\n print(\\\"Testing Top K Words algorithm on 400MB file.\\\")\\n testtimes = []\\n for test in mediumdata:\\n print(\\\"Starting Test on 400MB file: Finding Top {} Words with {} Shards...\\\".format(k, test))\\n start = time()\\n findTopKViaSharding(\\\"dataset-400MB.txt\\\", k, test)\\n end = time()\\n print(\\\"Test Complete.\\\")\\n print(\\\"Total Time: {}\\\".format(end - start))\\n testtimes.append(end-start)\\n resulttimes[k] = testtimes\\n print(\\\"Generic Tests Complete.\\\")\\n return mediumdata, resulttimes\",\n \"def result(self) -> Dict[int, float]:\\n return {k: v.result() for k, v in self._topk_acc_dict.items()}\",\n \"def __summarize_seq(self, stud_seq, time_gap):\\r\\n\\r\\n current_action_endtime = Series(stud_seq['endTime'])\\r\\n next_action_starttime = Series(stud_seq['startTime']).shift(-1)\\r\\n\\r\\n diff = (next_action_starttime - current_action_endtime).dropna()\\r\\n\\r\\n session_end_ix = np.where(diff > time_gap)[0]\\r\\n session_start_end_ix = np.insert(session_end_ix, 0, 0)\\r\\n session_start_end_ix = np.insert(session_start_end_ix, len(session_start_end_ix), len(stud_seq) - 1)\\r\\n session_lengths = np.diff(session_start_end_ix)\\r\\n session_lengths[0] = session_lengths[\\r\\n 0] + 1 # correct the length of first session by adding 1 because of zero index\\r\\n session_index = np.repeat(np.array(range(len(session_start_end_ix) - 1)), session_lengths)\\r\\n\\r\\n sorted_seq_with_sess_ix = stud_seq.assign(seq_ix=session_index)\\r\\n min_seq = sorted_seq_with_sess_ix.groupby('seq_ix').min().add_prefix('min_')\\r\\n max_seq = sorted_seq_with_sess_ix.groupby('seq_ix').max().add_prefix('max_')\\r\\n mean_seq = sorted_seq_with_sess_ix.groupby('seq_ix').mean().add_prefix('mean_')\\r\\n sum_seq = sorted_seq_with_sess_ix.groupby('seq_ix').sum().add_prefix('sum_')\\r\\n\\r\\n summarized_features = pd.concat([min_seq, max_seq, mean_seq, sum_seq], axis=1)\\r\\n\\r\\n return summarized_features\",\n \"def getMeasures(unique_name=None):\",\n \"def index():\\n import numpy as np\\n import random\\n\\n total_gender = {}\\n total_gender['Male'] = db(db.patient.sex == 'Male').count()\\n total_gender['Female'] = db(db.patient.sex == 'Female').count()\\n total_gender['Undeclared'] = db(db.patient.sex == 'Undeclared').count()\\n\\n groups = db(db.groups).select()\\n freq_groups = {}\\n grp_gender = {}\\n for g in groups:\\n freq_groups[g.code] = db(db.patient.groups.contains(g.id)).count()\\n grp_gender[g.code] = {}\\n grp_gender[g.code]['Male'] = db(db.patient.groups.contains(g.id) & (db.patient.sex == 'Male')).count()\\n grp_gender[g.code]['Female'] = db(db.patient.groups.contains(g.id) & (db.patient.sex == 'Female')).count()\\n grp_gender[g.code]['Undeclared'] = db(db.patient.groups.contains(g.id) & (db.patient.sex == 'Undeclared')).count()\\n\\n experiments = db(db.experiments).select()\\n freq_experiments = {}\\n exp_gender = {}\\n for e in experiments:\\n freq_experiments[e.code] = db(db.patient.experiments.contains(e.id)).count()\\n exp_gender[e.code] = {}\\n exp_gender[e.code]['Male'] = db(db.patient.experiments.contains(e.id) & (db.patient.sex == 'Male')).count()\\n exp_gender[e.code]['Female'] = db(db.patient.experiments.contains(e.id) & (db.patient.sex == 'Female')).count()\\n exp_gender[e.code]['Undeclared'] = db(db.patient.experiments.contains(e.id) & (db.patient.sex == 'Undeclared')).count()\\n\\n grp_exp = {}\\n for e in experiments:\\n grp_exp[e.code] = {}\\n for g in groups:\\n grp_exp[e.code][g.code] = db(db.patient.experiments.contains(e.id) & db.patient.groups.contains(g.id)).count()\\n\\n return dict(message=T('Pain Network: A web-based tool for diagnosis of the Chronic Pain.'),\\n freq_gender=total_gender,freq_groups=freq_groups,freq_experiments=freq_experiments,\\n exp_gender=exp_gender,grp_gender=grp_gender,grp_exp=grp_exp)\",\n \"def _calculate_scores(self, query, key):\\n if self.hyperbolc_input:\\n scores = self.manifold.single_query_attn_scores(query, key, self.c)\\n else:\\n scores = tf.linalg.matmul(query, key, transpose_b=True)\\n\\n if self.scale is not None:\\n scores *= self.scale\\n\\n return scores\",\n \"def getMeasures():\",\n \"def _aggregate_log_values(self, source, dest):\\n remove = []\\n for key, item in source.items():\\n if \\\"data\\\" not in item:\\n # Assume it's a sub-group\\n dest[key] = {}\\n self._aggregate_log_values(item, dest[key])\\n else:\\n aggregator = self._get_aggregator_for_key(key, item['agg'])\\n value = aggregator(item['data'])\\n if item['precision'] is not None:\\n value = round(value, item['precision'])\\n dest[key] = value\\n if item['scope'] == 'get':\\n remove.append(key)\\n for key in remove:\\n del source[key]\",\n \"def get_query_info():\\n all_rt_heat_metric_list = get_rt_query_count()\\n # 有查询的数据\\n query_dataset_dict = {}\\n for each_rt in all_rt_heat_metric_list:\\n query_dataset_dict[each_rt[\\\"key\\\"]] = each_rt[\\\"doc_count\\\"]\\n return query_dataset_dict\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5516195","0.5445356","0.5358602","0.5349585","0.5333742","0.5271777","0.52661145","0.5255679","0.5213781","0.5190634","0.51589733","0.51226103","0.51122093","0.50610095","0.5024973","0.501899","0.50044125","0.49149823","0.49074388","0.48728678","0.4871925","0.48680615","0.48478523","0.48456863","0.48396322","0.4832546","0.48309195","0.47907776","0.4782801","0.47802615","0.47794107","0.47786912","0.47665876","0.47427446","0.47363606","0.47356772","0.4714002","0.46838218","0.466122","0.46585292","0.46370757","0.46364745","0.46301624","0.46216607","0.46152475","0.46139374","0.4610843","0.4605627","0.46020666","0.45932955","0.45897743","0.45867878","0.458618","0.45837304","0.4569835","0.45652983","0.45630687","0.45623958","0.45543855","0.45536262","0.45443463","0.45416903","0.45397794","0.4537506","0.45368516","0.45347604","0.45296216","0.4518843","0.451133","0.45080972","0.45063388","0.45063126","0.45033535","0.4500649","0.44999576","0.44995615","0.44957685","0.4493433","0.4493189","0.44922101","0.44912767","0.44892728","0.44890285","0.44885492","0.44875753","0.44847658","0.44753504","0.44749752","0.44656962","0.44648114","0.4459713","0.44573513","0.44562984","0.445201","0.4450416","0.4447065","0.44448462","0.4444786","0.44435418","0.44405007"],"string":"[\n \"0.5516195\",\n \"0.5445356\",\n \"0.5358602\",\n \"0.5349585\",\n \"0.5333742\",\n \"0.5271777\",\n \"0.52661145\",\n \"0.5255679\",\n \"0.5213781\",\n \"0.5190634\",\n \"0.51589733\",\n \"0.51226103\",\n \"0.51122093\",\n \"0.50610095\",\n \"0.5024973\",\n \"0.501899\",\n \"0.50044125\",\n \"0.49149823\",\n \"0.49074388\",\n \"0.48728678\",\n \"0.4871925\",\n \"0.48680615\",\n \"0.48478523\",\n \"0.48456863\",\n \"0.48396322\",\n \"0.4832546\",\n \"0.48309195\",\n \"0.47907776\",\n \"0.4782801\",\n \"0.47802615\",\n \"0.47794107\",\n \"0.47786912\",\n \"0.47665876\",\n \"0.47427446\",\n \"0.47363606\",\n \"0.47356772\",\n \"0.4714002\",\n \"0.46838218\",\n \"0.466122\",\n \"0.46585292\",\n \"0.46370757\",\n \"0.46364745\",\n \"0.46301624\",\n \"0.46216607\",\n \"0.46152475\",\n \"0.46139374\",\n \"0.4610843\",\n \"0.4605627\",\n \"0.46020666\",\n \"0.45932955\",\n \"0.45897743\",\n \"0.45867878\",\n \"0.458618\",\n \"0.45837304\",\n \"0.4569835\",\n \"0.45652983\",\n \"0.45630687\",\n \"0.45623958\",\n \"0.45543855\",\n \"0.45536262\",\n \"0.45443463\",\n \"0.45416903\",\n \"0.45397794\",\n \"0.4537506\",\n \"0.45368516\",\n \"0.45347604\",\n \"0.45296216\",\n \"0.4518843\",\n \"0.451133\",\n \"0.45080972\",\n \"0.45063388\",\n \"0.45063126\",\n \"0.45033535\",\n \"0.4500649\",\n \"0.44999576\",\n \"0.44995615\",\n \"0.44957685\",\n \"0.4493433\",\n \"0.4493189\",\n \"0.44922101\",\n \"0.44912767\",\n \"0.44892728\",\n \"0.44890285\",\n \"0.44885492\",\n \"0.44875753\",\n \"0.44847658\",\n \"0.44753504\",\n \"0.44749752\",\n \"0.44656962\",\n \"0.44648114\",\n \"0.4459713\",\n \"0.44573513\",\n \"0.44562984\",\n \"0.445201\",\n \"0.4450416\",\n \"0.4447065\",\n \"0.44448462\",\n \"0.4444786\",\n \"0.44435418\",\n \"0.44405007\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5601444"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21499,"cells":{"query":{"kind":"string","value":"Compute and store the QC metrics Runs the QC on the session and stores a map of the metrics for each datapoint for each test, and a map of which datapoints passed for each test"},"document":{"kind":"string","value":"def compute(self, download_data=None):\n if self.extractor is None:\n # If download_data is None, decide based on whether eid or session path was provided\n ensure_data = self.download_data if download_data is None else download_data\n self.load_data(download_data=ensure_data)\n self.log.info(f\"Session {self.session_path}: Running QC on habituation data...\")\n\n # Initialize checks\n prefix = '_task_'\n data = self.extractor.data\n metrics = {}\n passed = {}\n\n # Check all reward volumes == 3.0ul\n check = prefix + 'reward_volumes'\n metrics[check] = data['rewardVolume']\n passed[check] = metrics[check] == 3.0\n\n # Check session durations are increasing in steps >= 12 minutes\n check = prefix + 'habituation_time'\n if not self.one or not self.session_path:\n self.log.warning('unable to determine session trials without ONE')\n metrics[check] = passed[check] = None\n else:\n subject, session_date = self.session_path.parts[-3:-1]\n # compute from the date specified\n date_minus_week = (\n datetime.strptime(session_date, '%Y-%m-%d') - timedelta(days=7)\n ).strftime('%Y-%m-%d')\n sessions = self.one.alyx.rest('sessions', 'list', subject=subject,\n date_range=[date_minus_week, session_date],\n task_protocol='habituation')\n # Remove the current session if already registered\n if sessions and sessions[0]['start_time'].startswith(session_date):\n sessions = sessions[1:]\n metric = ([0, data['intervals'][-1, 1] - data['intervals'][0, 0]] +\n [(datetime.fromisoformat(x['end_time']) -\n datetime.fromisoformat(x['start_time'])).total_seconds() / 60\n for x in [self.one.alyx.get(s['url']) for s in sessions]])\n\n # The duration from raw trial data\n # duration = map(float, self.extractor.raw_data[-1]['elapsed_time'].split(':'))\n # duration = timedelta(**dict(zip(('hours', 'minutes', 'seconds'),\n # duration))).total_seconds() / 60\n metrics[check] = np.array(metric)\n passed[check] = np.diff(metric) >= 12\n\n # Check event orders: trial_start < stim on < stim center < feedback < stim off\n check = prefix + 'trial_event_sequence'\n nans = (\n np.isnan(data[\"intervals\"][:, 0]) | # noqa\n np.isnan(data[\"stimOn_times\"]) | # noqa\n np.isnan(data[\"stimCenter_times\"]) |\n np.isnan(data[\"valveOpen_times\"]) | # noqa\n np.isnan(data[\"stimOff_times\"])\n )\n a = np.less(data[\"intervals\"][:, 0], data[\"stimOn_times\"], where=~nans)\n b = np.less(data[\"stimOn_times\"], data[\"stimCenter_times\"], where=~nans)\n c = np.less(data[\"stimCenter_times\"], data[\"valveOpen_times\"], where=~nans)\n d = np.less(data[\"valveOpen_times\"], data[\"stimOff_times\"], where=~nans)\n\n metrics[check] = a & b & c & d & ~nans\n passed[check] = metrics[check].astype(float)\n\n # Check that the time difference between the visual stimulus center-command being\n # triggered and the stimulus effectively appearing in the center is smaller than 150 ms.\n check = prefix + 'stimCenter_delays'\n metric = np.nan_to_num(data[\"stimCenter_times\"] - data[\"stimCenterTrigger_times\"],\n nan=np.inf)\n passed[check] = (metric <= 0.15) & (metric > 0)\n metrics[check] = metric\n\n # Phase check\n check = prefix + 'phase'\n metric = data['phase']\n passed[check] = (metric <= 2 * np.pi) & (metric >= 0)\n metrics[check] = metric\n\n check = prefix + 'phase_distribution'\n metric, _ = np.histogram(data['phase'])\n _, p = chisquare(metric)\n passed[check] = p < 0.05\n metrics[check] = metric\n\n # Checks common to training QC\n checks = [check_goCue_delays, check_stimOn_goCue_delays,\n check_stimOn_delays, check_stimOff_delays]\n for fcn in checks:\n check = prefix + fcn.__name__[6:]\n metrics[check], passed[check] = fcn(data)\n\n self.metrics, self.passed = (metrics, passed)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def compute(self, **kwargs):\n if self.extractor is None:\n kwargs['download_data'] = kwargs.pop('download_data', self.download_data)\n self.load_data(**kwargs)\n self.log.info(f\"Session {self.session_path}: Running QC on behavior data...\")\n self.metrics, self.passed = get_bpodqc_metrics_frame(\n self.extractor.data,\n wheel_gain=self.extractor.settings['STIM_GAIN'], # The wheel gain\n photodiode=self.extractor.frame_ttls,\n audio=self.extractor.audio_ttls,\n re_encoding=self.extractor.wheel_encoding or 'X1',\n min_qt=self.extractor.settings.get('QUIESCENT_PERIOD') or 0.2\n )\n return","def qc_metrics(self, files_in, qc_files):\n self.cmd(\"{samtools} index {bam_in}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in=files_in[0],\n ),\n shell=True)\n self.cmd(\"{samtools} idxstats {bam_in} | tee {qc_file}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in = files_in[0],\n qc_file = qc_files[0],\n ),\n shell=True,\n log_output=True)\n self.cmd(\"{samtools} flagstat {bam_in} | tee {qc_file}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in = files_in[0],\n qc_file = qc_files[1],\n ),\n shell=True,\n log_output=True)\n \n self.checkpoint(qc_files[0])\n self.checkpoint(qc_files[1])\n self.checkpoint(qc_files[2])","def compute_session_status(self):\n if self.passed is None:\n raise AttributeError('passed is None; compute QC first')\n # Get mean passed of each check, or None if passed is None or all NaN\n results = {k: None if v is None or np.isnan(v).all() else np.nanmean(v)\n for k, v in self.passed.items()}\n session_outcome, outcomes = self.compute_session_status_from_dict(results)\n return session_outcome, results, outcomes","def get_bpodqc_metrics_frame(data, **kwargs):\n def is_metric(x):\n return isfunction(x) and x.__name__.startswith('check_')\n # Find all methods that begin with 'check_'\n checks = getmembers(sys.modules[__name__], is_metric)\n prefix = '_task_' # Extended QC fields will start with this\n # Method 'check_foobar' stored with key '_task_foobar' in metrics map\n qc_metrics_map = {prefix + k[6:]: fn(data, **kwargs) for k, fn in checks}\n\n # Split metrics and passed frames\n metrics = {}\n passed = {}\n for k in qc_metrics_map:\n metrics[k], passed[k] = qc_metrics_map[k]\n\n # Add a check for trial level pass: did a given trial pass all checks?\n n_trials = data['intervals'].shape[0]\n # Trial-level checks return an array the length that equals the number of trials\n trial_level_passed = [m for m in passed.values()\n if isinstance(m, Sized) and len(m) == n_trials]\n name = prefix + 'passed_trial_checks'\n metrics[name] = reduce(np.logical_and, trial_level_passed or (None, None))\n passed[name] = metrics[name].astype(float) if trial_level_passed else None\n\n return metrics, passed","def metric_tests(self) -> Dict[str, FAIRResultEvaluationCriterium]:\n return self._metric_tests","def run_tests(self):\n\n self.test_report = []\n\n #dict of unsorted lists\n dict_of_un_lists = self.dict_un_lists_intersection_test(self.data_dict)\n self.test_report.append(dict_of_un_lists)\n\n #dict of sets\n dict_of_sets = self.build_dict_of_sets(self.data_dict)\n self.test_report.append(self.dict_sets_intersection_test(dict_of_sets))\n\n #pandas - experimental and probably not the way to use pandas\n # dict_of_pandas = self.build_dict_of_panda_series(self.data_dict)\n # self.test_report.append(self.dicts_any_intersection_node_test(dict_of_pandas))\n\n # print results\n\n if self.verbose:\n self.print_tests_results()","def test_evaluate(self):\n # test normalized by 'bbox_size'\n jhmdb_pck_metric = JhmdbPCKAccuracy(thr=0.5, norm_item='bbox')\n jhmdb_pck_metric.process(self.data_batch, self.data_samples)\n pck_results = jhmdb_pck_metric.evaluate(self.batch_size)\n target = {\n 'Head PCK': 1.0,\n 'Sho PCK': 1.0,\n 'Elb PCK': 1.0,\n 'Wri PCK': 1.0,\n 'Hip PCK': 1.0,\n 'Knee PCK': 1.0,\n 'Ank PCK': 1.0,\n 'PCK': 1.0,\n }\n self.assertDictEqual(pck_results, target)\n\n # test normalized by 'torso_size'\n jhmdb_tpck_metric = JhmdbPCKAccuracy(thr=0.2, norm_item='torso')\n jhmdb_tpck_metric.process(self.data_batch, self.data_samples)\n tpck_results = jhmdb_tpck_metric.evaluate(self.batch_size)\n target = {\n 'Head tPCK': 1.0,\n 'Sho tPCK': 1.0,\n 'Elb tPCK': 1.0,\n 'Wri tPCK': 1.0,\n 'Hip tPCK': 1.0,\n 'Knee tPCK': 1.0,\n 'Ank tPCK': 1.0,\n 'tPCK': 1.0,\n }\n self.assertDictEqual(tpck_results, target)","def qc_metrics(\n data: AnnData,\n mito_prefix: str = \"MT-\",\n min_genes: int = 500,\n max_genes: int = 6000,\n min_umis: int = 100,\n max_umis: int = 600000,\n percent_mito: float = 10.0,\n percent_cells: float = 0.05,\n) -> None:\n\n data.obs[\"passed_qc\"] = False\n\n data.obs[\"n_genes\"] = data.X.getnnz(axis=1)\n data.obs[\"n_counts\"] = data.X.sum(axis=1).A1\n\n mito_prefixes = mito_prefix.split(\",\")\n\n def startswith(name):\n for prefix in mito_prefixes:\n if name.startswith(prefix):\n return True\n return False\n\n mito_genes = data.var_names.map(startswith).values.nonzero()[0]\n data.obs[\"percent_mito\"] = (data.X[:, mito_genes].sum(axis=1).A1 / np.maximum(\n data.obs[\"n_counts\"].values, 1.0\n )) * 100\n\n # Assign passed_qc\n filters = [\n data.obs[\"n_genes\"] >= min_genes,\n data.obs[\"n_genes\"] < max_genes,\n data.obs[\"n_counts\"] >= min_umis,\n data.obs[\"n_counts\"] < max_umis,\n data.obs[\"percent_mito\"] < percent_mito,\n ]\n\n data.obs.loc[np.logical_and.reduce(filters), \"passed_qc\"] = True\n\n var = data.var\n data = data[\n data.obs[\"passed_qc\"]\n ] # compute gene stats in space of filtered cells only\n\n var[\"n_cells\"] = data.X.getnnz(axis=0)\n var[\"percent_cells\"] = (var[\"n_cells\"] / data.shape[0]) * 100\n var[\"robust\"] = var[\"percent_cells\"] >= percent_cells\n var[\"highly_variable_features\"] = var[\n \"robust\"\n ] # default all robust genes are \"highly\" variable","def calc_data(self):\n\n circ_counts = {}\n for trialidx in range(self._ntrials):\n for _, depth in enumerate(self._depths):\n circ_name = 'qv_depth_%d_trial_%d' % (depth, trialidx)\n\n # get the counts form ALL executed circuits\n count_list = []\n for result in self._result_list:\n try:\n count_list.append(result.get_counts(circ_name))\n except (QiskitError, KeyError):\n pass\n\n circ_counts[circ_name] = \\\n build_counts_dict_from_list(count_list)\n\n self._circ_shots[circ_name] = \\\n sum(circ_counts[circ_name].values())\n\n # calculate the heavy output probability\n self._heavy_output_counts[circ_name] = \\\n self._subset_probability(\n self._heavy_outputs[circ_name],\n circ_counts[circ_name])","def compute_metrics(self):\n pass","def collect_data(self):\n exp_conf: ec.ExperimentConfiguration\n # Disabled multiprocess run because of huge memory usage\n processes_number = 1 # self._campaign_configuration['General']['j']\n if processes_number == 1:\n self._logger.info(\"-->Evaluate experiments (sequentially)\")\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\n exp_conf.evaluate()\n if bool(self._campaign_configuration['General']['generate_plots']):\n exp_conf.generate_plots()\n self._logger.info(\"<--\")\n else:\n self._logger.info(\"-->Evaluate experiments (in parallel)\")\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\n if bool(self._campaign_configuration['General']['generate_plots']):\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\n self._logger.info(\"<--\")\n\n self.raw_results = {}\n for exp_conf in self._exp_confs:\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes","def get_test_cases_coverage(session_id):\n tc_stats={}\n tc_stats_list=[]\n total_executed=0\n sql='SELECT DISTINCT(test_id) FROM stats WHERE session_id=:sid AND test_id!=\"null\"'\n params={\"sid\":session_id}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n tests=c.fetchall()\n conn.close()\n if len(tests)>0:\n for t in tests:\n total_executed=0\n sql=\"SELECT DISTINCT(file_id) FROM stats WHERE session_id=:sid AND test_id=:tid\"\n params={\"sid\":session_id,\"tid\":t[0]}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n files=c.fetchall()\n conn.close()\n for f in files:\n line_count=get_executable_lines_count_for_file(f[0])\n # get executions\n sql=\"SELECT COUNT(DISTINCT line_guid) FROM stats WHERE session_id= :sid AND file_id= :fid AND test_id=:tid\"\n params={\"sid\":session_id,\"tid\":t[0],\"fid\":f[0]}\n conn=sqlite3.connect(CONNECTION_STRING)\n c=conn.cursor()\n c.execute(sql,params)\n executed=c.fetchone()\n conn.close()\n total_executed+=executed[0]\n # save test case and it's executions\n tc_stats={}\n tc_stats[\"test_id\"]=t[0]\n tc_stats[\"total_executed\"]=total_executed\n tc_stats[\"total_executed\"]\n \n tc_stats_list.append(tc_stats)\n return tc_stats_list","def mgcEval(self):\n import numpy as np\n def report_to_df(report):\n\n \"\"\"\n function to convert classification report to dataframe (for visualisation plot)\n \"\"\"\n\n report = re.sub(r\" +\", \" \", report).replace(\"avg / total\", \"avg/total\").replace(\"\\n \", \"\\n\")\n # update this due to sklearn classification report output change\n report = re.sub(r\" +\", \" \", report).replace(\"micro avg\", \"micro_avg\").replace(\"macro avg\", \"macro_avg\").replace(\"weighted avg\", \"weighted_avg\").replace(\"\\n \", \"\\n\")\n report_df = pd.read_csv(StringIO(\"Classes\" + report), sep=' ', index_col=0) \n return(report_df)\n \n #txt report to df\n class_rpttop1 = classification_report(self.y_true, self.y_pred)\n df_report = report_to_df(class_rpttop1)\n\n df_report = df_report.iloc[:self.nb_classes, :].copy()\n df_report.index = df_report.index.astype(int)\n \n\n # classifier prediction metrics\n def classMetrics(averagex):\n precision, recall, fscore, support = score(self.y_true, self.y_pred, average=averagex)\n \n return(\n print(''), \n print('-------------{0:}--------------------'.format(averagex)), \n print('precision: {0:.4f}'.format(precision)),\n print('recall: {0:.4f}'.format(recall)),\n print('fscore: {0:.4f}'.format(fscore)),\n print(''),\n print('kappa score: {0:.4f}'.format(cohen_kappa_score(self.y_true, self.y_pred))),\n print('accuracy score: {0:.4f}'.format(accuracy_score(self.y_true, self.y_pred))))\n \n def predSamp():\n\n correct = np.nonzero(self.y_pred==self.y_true)[0]\n incorrect = np.nonzero(self.y_pred!=self.y_true)[0]\n\n # quick check of the number of correct prediction from validation set\n print(\"\")\n print(\"correct/total = {0: .4f}\".format(len(correct)/(len(correct)+len(incorrect))))\n print(\"total correct sample = {0: .0f}\".format(len(correct)))\n print('------------------------------------------------------------------')\n \n def classReport():\n print('----------------------------- Classfication Report -------------------------------')\n print(classification_report(pd.Series(self.y_true).map(self.dict_label), pd.Series(self.y_pred).map(self.dict_label)))\n \n self.class_rpt = pd.concat([pd.DataFrame(pd.Series(df_report.index.tolist()).map(self.dict_label), columns = ['label']), df_report], axis = 1)\n \n self.classMetricsMac = classMetrics(\"macro\")\n self.classMetricsMic = classMetrics(\"micro\")\n self.predSample = predSamp()\n self.class_rptTop1 = classReport()\n \n return self","def calculate_dataset_metrics(self):\n pass","def run_tests():\n with open(FILENAME) as file:\n # Loads testing parameters from the yaml file.\n tests = yaml.safe_load(file)\n\n # create a dataframe to keep the results\n test_dict = tests['Tests']\n results = pd.DataFrame(test_dict)\n results['Last Average Score'] = \"\"\n results['No of Q-Learning episodes'] = \"\"\n\n # run experiments:\n for i, test in enumerate(test_dict):\n grid = Rooms(test[\"env_size\"], testing=True)\n learning = QLearning(grid, test[\"gamma\"], test[\"alpha\"], test[\"agent_start_pos\"])\n e_greedy = Policy(\"e-greedy\", test[\"epsilon\"], test[\"decay\"])\n greedy = Policy(policy_type=\"greedy\")\n experiment = Experiments(grid, learning, greedy, test[\"iters\"],\n test[\"agent_start_pos\"], test[\"test_no\"])\n\n for session in range(test[\"iters\"]):\n learning.run_multiple_episodes(test[\"batch_episodes\"], e_greedy)\n mean_reward = experiment.run_experiments(test[\"exp_per_batch\"])\n\n results.loc[i,'Last Average Score'] = mean_reward\n results.loc[i,'No of Q-Learning episodes'] = (session + 1) * test[\"batch_episodes\"]\n\n # save results to csv file\n filename = 'results/' + 'test_table.csv'\n results.to_csv(filename)\n\n # plot & save graphs\n experiment.generate_results(test[\"test_no\"], test)\n\n return results","def test_evaluate(self):\n # test normalized by 'bbox'\n pck_metric = PCKAccuracy(thr=0.5, norm_item='bbox')\n pck_metric.process(self.data_batch, self.data_samples)\n pck = pck_metric.evaluate(self.batch_size)\n target = {'PCK': 1.0}\n self.assertDictEqual(pck, target)\n\n # test normalized by 'head_size'\n pckh_metric = PCKAccuracy(thr=0.3, norm_item='head')\n pckh_metric.process(self.data_batch, self.data_samples)\n pckh = pckh_metric.evaluate(self.batch_size)\n target = {'PCKh': 1.0}\n self.assertDictEqual(pckh, target)\n\n # test normalized by 'torso_size'\n tpck_metric = PCKAccuracy(thr=0.05, norm_item=['bbox', 'torso'])\n tpck_metric.process(self.data_batch, self.data_samples)\n tpck = tpck_metric.evaluate(self.batch_size)\n self.assertIsInstance(tpck, dict)\n target = {\n 'PCK': 1.0,\n 'tPCK': 1.0,\n }\n self.assertDictEqual(tpck, target)","def initialize_metrics():\n metrics = {\n 'cd_losses': [],\n 'cd_corrects': [],\n 'cd_precisions': [],\n 'cd_recalls': [],\n 'cd_f1scores': [],\n }\n\n return metrics","def run_tests(self, validate=False):\n fitness = 0\n\n for test_set in [self.debugger.PASS, self.debugger.FAIL]:\n passed = self.run_test_set(test_set, validate=validate)\n ratio = passed / len(self.debugger.collectors[test_set])\n fitness += self.weight(test_set) * ratio\n\n return fitness","def compute_metrics(self, results: list) -> dict:","def run_test(self):\n self.output_analytics = self.run_inference()\n self.output_df = pd.DataFrame(self.output_analytics)","def evaluate_benchmarks(self):\n\n # iterate over replicates\n results = {}\n for replicate_id, replicate in self.replicates:\n\n # evaluate benchmark for current replicate\n bmark = SimulationBenchmark(replicate.copy(),\n graph=self.graphs[replicate_id],\n **self.params)\n\n # store results\n results[replicate_id] = dict(\n\n labels_MAE=bmark.scores['labels'].MAE,\n level_only_MAE=bmark.scores['level_only'].MAE,\n spatial_only_MAE=bmark.scores['spatial_only'].MAE,\n community_MAE=bmark.scores['labels_comm'].MAE,\n\n labels_PCT=bmark.scores['labels'].percent_correct,\n level_only_PCT=bmark.scores['level_only'].percent_correct,\n spatial_only_PCT=bmark.scores['spatial_only'].percent_correct,\n community_PCT=bmark.scores['labels_comm'].percent_correct)\n\n # compile dataframe\n results = pd.DataFrame.from_dict(results, orient='index')\n results.index.set_names(self.multiindex, inplace=True)\n\n return results","def _calculate_metrics(self):\n metrics = {}\n precision, recall = self.calc_precision_recall()\n metrics[\"precision\"] = precision\n metrics[\"recall\"] = recall\n metrics[\"entropy\"] = self.calc_entropy()\n metrics[\"component_entropy\"] = self.calc_component_entropy()\n metrics[\"num_comps\"] = len(self.get_components())\n metrics[\"num_diagnoses\"] = len(self.diagnoses)\n metrics[\"distinct_diagnoses_scores\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\n metrics[\"num_tests\"] = len(self.get_tests())\n metrics[\"num_distinct_traces\"] = len(self.get_distinct_traces())\n metrics[\"num_failed_tests\"] = len(self._get_tests_by_error(1))\n metrics[\"num_passed_tests\"] = len(self._get_tests_by_error(0))\n passed_comps = set(self._get_components_by_error(0))\n failed_comps = set(self.get_components_in_failed_tests())\n metrics[\"num_failed_comps\"] = len(failed_comps)\n metrics[\"only_failed_comps\"] = len(failed_comps - passed_comps)\n metrics[\"only_passed_comps\"] = len(passed_comps - failed_comps)\n metrics[\"num_bugs\"] = len(self.get_bugs())\n metrics[\"wasted\"] = self.calc_wasted_components()\n metrics[\"top_k\"] = self.calc_top_k()\n metrics[\"num_comps_in_diagnoses\"] = len(self._get_comps_in_diagnoses())\n metrics[\"bugs_cover_ratio\"] = self._get_bugs_cover_ratio()\n metrics[\"average_trace_size\"] = self._get_average_trace_size()\n metrics[\"average_component_activity\"] = self._get_average_component_activity()\n metrics[\"average_diagnosis_size\"] = self._get_average_diagnosis_size()\n metrics[\"bugs_scores_average\"], metrics[\"bugs_scores_std\"], metrics[\"bugs_scores_entropy\"] = self._get_bugs_scores()\n metrics[\"non_bugs_scores_average\"], metrics[\"non_bugs_scores_std\"], metrics[\"non_bugs_scores_entropy\"] = self._get_non_bugs_scores()\n metrics.update(self.cardinality())\n # metrics[\"ochiai\"] = self.calc_ochiai_values()\n return metrics","def run_tests():\n with open(FILENAME) as file:\n\n # Loads the test hyper-parameters as dictionaries.\n tests = yaml.safe_load(file)\n \n # create a dataframe to keep the results\n test_dict = tests['Tests']\n results = pd.DataFrame(test_dict)\n results[\"Episode\"] = \"\"\n results['Max average score'] = \"\"\n\n for i, test in enumerate(tests['Tests']):\n\n env = gym.make(test['env'])\n env.reset()\n\n actor_critic = ActorCritic(env, test['episodes'], test['max_score'], \n test['hidden_size'], test['gamma'], test['save'])\n\n ## run training \n best_score, episode, rew_hist = actor_critic.train()\n\n results.loc[i,'Episode'] = episode\n results.loc[i,'Max average score'] = best_score\n\n plot_graphs(test, rew_hist)\n\n # save results to csv file\n filename = 'results/' + 'test_table.csv'\n results.to_csv(filename)\n\n return results","def evaluate(self):\n results = dict()\n for metric in self.metrics:\n print('Evaluating clustering with metric %s' % metric)\n if metric in LABEL_METRICS.keys():\n results[metric] = LABEL_METRICS[metric](self.X, self.model.labels_)\n results['adjusted_rand_score'] = SCORE_METRICS['adjusted_rand_score'](self.Y[:, 0], self.model.labels_)\n self.results = results\n return results","def evaluate(self, test):\r\n self.logger.info(\"Testing model over test set\")\r\n metrics = self.run_evaluate(test)\r\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\r\n for k, v in metrics.items()])\r\n self.logger.info(msg)\r\n return metrics","def run_faqc(self, **kwargs):\n if self.qc is True:\n build([FaQC.SummarizeQC(fastq_dic=self.fastq_dic,\n num_cpus=self.num_cpus,\n workdir=self.workdir)],\n local_scheduler=self.local_scheduler,\n workers=1)\n qc_dic = {}\n for samp, path in self.fastq_dic.items():\n trim_dir = os.path.join(self.workdir, \"processes\", \"qc\", samp)\n qc_dic[samp] = trim_dir + \"/\" + samp + \".1.trimmed.fastq\" + \":\" + \\\n trim_dir + \"/\" + samp + \".2.trimmed.fastq\" \n return qc_dic\n\n else:\n return self.fastq_dic","def make_metrics(self):\n num_batches = self.data_loader.number_of_batches()\n dose_score_vec = np.zeros(num_batches)\n\n # Only make calculations if data_loader is not empty\n if not self.data_loader.file_paths_list:\n print('No patient information was given to calculate metrics')\n else:\n # Change batch size to 1\n self.data_loader.batch_size = 1 # Loads data related to ground truth patient information\n if self.dose_loader is not None:\n self.dose_loader.batch_size = 1 # Loads data related to ground truth patient information\n\n for idx in tqdm.tqdm(range(num_batches)):\n # Get roi masks for patient\n self.get_constant_patient_features(idx)\n # Get dose tensors for reference dose and evaluate criteria\n reference_dose = self.get_patient_dose_tensor(self.data_loader)\n if reference_dose is not None:\n self.reference_dose_metric_df = self.calculate_metrics(self.reference_dose_metric_df, reference_dose)\n # If a dose loader was provided, calculate the score\n if self.dose_loader is not None:\n new_dose = self.get_patient_dose_tensor(self.dose_loader)\n # Make metric data frames\n self.new_dose_metric_df = self.calculate_metrics(self.new_dose_metric_df, new_dose)\n # Evaluate mean absolute error of 3D dose\n dose_score_vec[idx] = np.sum(np.abs(reference_dose - new_dose)) / np.sum(self.possible_dose_mask)\n # Save metrics at the patient level (this is a template for how DVH stream participants could save\n # their files\n # self.dose_metric_df.loc[self.patient_list[0]].to_csv('{}.csv'.format(self.patient_list[0]))\n\n if self.dose_loader is not None:\n dvh_score = np.nanmean(np.abs(self.reference_dose_metric_df - self.new_dose_metric_df).values)\n dose_score = dose_score_vec.mean()\n return dvh_score, dose_score\n else:\n print('No new dose provided. Metrics were only calculated for the provided dose.')","def calculate_metrics(self):\n self.data_stats = self.sqlContext.read.format(\"org.apache.spark.sql.cassandra\").options(table=self.cassandra_trip_table, keyspace=self.cassandra_keyspace).load()\n self.data_stats = self.data_stats.groupBy(['time_block','day','month','borough_name']).agg(func.avg('num_trips').alias('mean'))","def evaluate_data():\n try:\n # General system related info\n ram = psutil.virtual_memory()\n total_ram = round((ram.total / 1024 / 1024),2)\n free_ram = round((ram.available / 1024 / 1024),2)\n used_ram = round((ram.used / 1024 / 1024),2)\n cpu_total = psutil.cpu_count(logical=True)\n cpu_loadavg = round([x / cpu_total * 100 for x in psutil.getloadavg()][0],2)\n acs_8080 = sp.getoutput(\"netstat -an|grep -c 8080\")\n acs_8181 = sp.getoutput(\"netstat -an|grep -c 8181\")\n acs_8443 = sp.getoutput(\"netstat -an|grep -c 8443\")\n mysql = sp.getoutput(\"netstat -an|grep -c 3306\")\n oracle = sp.getoutput(\"netstat -an|grep -c 1521\")\n logging.info('General system info obtained')\n except Exception as e:\n logging.exception(f\"EXCEPTION: {e} \\n Full stack trace: \\n\", exc_info=1)\n # Process specific details\n try:\n iis_pid = SystemInformation.get_pid(\"w3wp.exe\")\n iis_ram = SystemInformation.get_ram_usage(iis_pid)\n iis_cpu = SystemInformation.get_cpu_usage(iis_pid)\n java_pid = SystemInformation.get_pid(\"java.exe\")\n java_ram = SystemInformation.get_ram_usage(java_pid)\n java_cpu = SystemInformation.get_cpu_usage(java_pid)\n mysqld_pid = SystemInformation.get_pid(\"mysqld.exe\")\n mysqld_ram = SystemInformation.get_ram_usage(mysqld_pid) \n mysqld_cpu = SystemInformation.get_cpu_usage(mysqld_pid)\n except Exception as e:\n logging.exception(f\"EXCEPTION: {e} \\n Full stack trace: \\n\", exc_info=1)\n\n try:\n dictionary = {}\n now = datetime.datetime.now()\n timestampt = now.strftime(\"%Y-%m-%d-%H:%M:%S\")\n fieldnames = ['timestampt','total_ram','free_ram','used_ram','cpu_total','cpu_loadavg','acs_8080','acs_8181','acs_8443','mysql','oracle','iis_ram','iis_cpu','java_ram','java_cpu','mysqld_ram','mysqld_cpu']\n for var in fieldnames:\n dictionary[var] = eval(var)\n \n logging.info('Data for report generated')\n return dictionary\n except Exception as e:\n logging.exception(f\"EXCEPTION: {e} \\n Full stack trace: \\n\", exc_info=1)","def _cv_results(self, metrics):\n\n param_keys = self.param_combs[0].keys()\n param_dict = {k: [comb[k] for comb in self.param_combs]\n for k in param_keys}\n df_metric_result = {k: pd.DataFrame({'Metric mean': self.mean[k],\n 'Std. dev.': self.std[k],\n **param_dict})\n for k in metrics.keys()}\n self.cv_results_ = df_metric_result","def execute_testsets(testsets):\n group_results = dict() #results, by group\n group_failure_counts = dict()\n total_failures = 0\n myinteractive = False\n\n for testset in testsets:\n mytests = testset.tests\n myconfig = testset.config\n mybenchmarks = testset.benchmarks\n\n #Make sure we actually have tests to execute\n if not mytests and not mybenchmarks:\n # no tests in this test set, probably just imports.. skip to next test set\n break\n\n myinteractive = True if myinteractive or myconfig.interactive else False\n\n #Run tests, collecting statistics as needed\n for test in mytests:\n #Initialize the dictionaries to store test fail counts and results\n if test.group not in group_results:\n group_results[test.group] = list()\n group_failure_counts[test.group] = 0\n\n result = run_test(test, test_config = myconfig)\n result.body = None # Remove the body, save some memory!\n\n if not result.passed: #Print failure, increase failure counts for that test group\n logging.error('Test Failed: '+test.name+\" URL=\"+test.url+\" Group=\"+test.group+\" HTTP Status Code: \"+str(result.response_code))\n\n if test.validators is not None:\n for validator in test.validators:\n if validator.passed == False:\n logging.warning(\" Validation Failed: \" + str(validator))\n\n #Increment test failure counts for that group (adding an entry if not present)\n failures = group_failure_counts[test.group]\n failures = failures + 1\n group_failure_counts[test.group] = failures\n\n else: #Test passed, print results\n logging.info('Test Succeeded: '+test.name+\" URL=\"+test.url+\" Group=\"+test.group)\n\n #Add results for this test group to the resultset\n group_results[test.group].append(result)\n\n # handle stop_on_failure flag\n if not result.passed and test.stop_on_failure is not None and test.stop_on_failure:\n print 'STOP ON FAILURE! stopping test set execution, continuing with other test sets'\n break\n\n for benchmark in mybenchmarks: # Run benchmarks, analyze, write\n if not benchmark.metrics:\n logging.debug('Skipping benchmark, no metrics to collect')\n continue\n\n logging.info(\"Benchmark Starting: \"+benchmark.name+\" Group: \"+benchmark.group)\n curl = configure_curl(benchmark, myconfig)\n benchmark_result = run_benchmark(curl, benchmark, myconfig)\n print benchmark_result\n logging.info(\"Benchmark Done: \"+benchmark.name+\" Group: \"+benchmark.group)\n\n if benchmark.output_file: # Write file\n write_method = OUTPUT_METHODS[benchmark.output_format]\n my_file = open(benchmark.output_file, 'w') # Overwrites file\n logging.debug(\"Benchmark writing to file: \" + benchmark.output_file)\n write_method(my_file, benchmark_result, benchmark, test_config = myconfig)\n my_file.close()\n\n if myinteractive:\n # a break for when interactive bits are complete, before summary data\n print \"===================================\"\n\n #Print summary results\n for group in sorted(group_results.keys()):\n test_count = len(group_results[group])\n failures = group_failure_counts[group]\n total_failures = total_failures + failures\n if (failures > 0):\n print u'Test Group '+group+u' FAILED: '+ str((test_count-failures))+'/'+str(test_count) + u' Tests Passed!'\n else:\n print u'Test Group '+group+u' SUCCEEDED: '+ str((test_count-failures))+'/'+str(test_count) + u' Tests Passed!'\n\n return total_failures","def execute(self, context):\n redshift_hook = PostgresHook(postgres_conn_id=self.redshift_conn_id)\n\n for data_check in self.data_checks:\n records = redshift_hook.get_records(data_check[\"sql\"])\n num_records = records[0][0]\n\n assert (num_records != data_check[\"expected_result\"]) , \\\n f\"Data quality test returned unexpected result.\"\n\n self.log.info('DataQualityOperator not implemented yet')","def metrics(self):\n raise NotImplementedError(\"metrics\")","def do_system_evaluation(dataset, result_path, dataset_evaluation_mode='folds'):\n\n # Set warnings off, sklearn metrics will trigger warning for classes without\n # predicted samples in F1-scoring. This is just to keep printing clean.\n warnings.simplefilter(\"ignore\")\n\n overall_metrics_per_scene = {}\n\n for scene_id, scene_label in enumerate(dataset.scene_labels):\n if scene_label not in overall_metrics_per_scene:\n overall_metrics_per_scene[scene_label] = {}\n\n dcase2016_segment_based_metric = DCASE2016_EventDetection_SegmentBasedMetrics(class_list=dataset.event_labels(scene_label=scene_label))\n dcase2016_event_based_metric = DCASE2016_EventDetection_EventBasedMetrics(class_list=dataset.event_labels(scene_label=scene_label))\n\n for fold in dataset.folds(mode=dataset_evaluation_mode):\n results = []\n result_filename = get_result_filename(fold=fold, scene_label=scene_label, path=result_path)\n\n if os.path.isfile(result_filename):\n with open(result_filename, 'rt') as f:\n for row in csv.reader(f, delimiter='\\t'):\n results.append(row)\n else:\n raise IOError(\"Result file not found [%s]\" % result_filename)\n\n for file_id, item in enumerate(dataset.test(fold, scene_label=scene_label)):\n current_file_results = []\n for result_line in results:\n if len(result_line) != 0 and result_line[0] == dataset.absolute_to_relative(item['file']):\n current_file_results.append(\n {'file': result_line[0],\n 'event_onset': float(result_line[1]),\n 'event_offset': float(result_line[2]),\n 'event_label': result_line[3].rstrip()\n }\n )\n meta = dataset.file_meta(dataset.absolute_to_relative(item['file']))\n\n dcase2016_segment_based_metric.evaluate(system_output=current_file_results, annotated_ground_truth=meta)\n dcase2016_event_based_metric.evaluate(system_output=current_file_results, annotated_ground_truth=meta)\n\n overall_metrics_per_scene[scene_label]['segment_based_metrics'] = dcase2016_segment_based_metric.results()\n overall_metrics_per_scene[scene_label]['event_based_metrics'] = dcase2016_event_based_metric.results()\n\n print \" Evaluation over %d folds\" % dataset.fold_count\n print \" \"\n print \" Results per scene \"\n print \" {:18s} | {:5s} | | {:39s} \".format('', 'Main', 'Secondary metrics')\n print \" {:18s} | {:5s} | | {:38s} | {:14s} | {:14s} | {:14s} \".format('', '', 'Seg/Overall','Seg/Class', 'Event/Overall','Event/Class')\n print \" {:18s} | {:5s} | | {:6s} : {:5s} : {:5s} : {:5s} : {:5s} | {:6s} : {:5s} | {:6s} : {:5s} | {:6s} : {:5s} |\".format('Scene', 'ER', 'F1', 'ER', 'ER/S', 'ER/D', 'ER/I', 'F1', 'ER', 'F1', 'ER', 'F1', 'ER')\n print \" -------------------+-------+ +--------+-------+-------+-------+-------+--------+-------+--------+-------+--------+-------+\"\n averages = {\n 'segment_based_metrics': {\n 'overall': {\n 'ER': [],\n 'F': [],\n },\n 'class_wise_average': {\n 'ER': [],\n 'F': [],\n }\n },\n 'event_based_metrics': {\n 'overall': {\n 'ER': [],\n 'F': [],\n },\n 'class_wise_average': {\n 'ER': [],\n 'F': [],\n }\n },\n }\n for scene_id, scene_label in enumerate(dataset.scene_labels):\n print \" {:18s} | {:5.2f} | | {:4.1f} % : {:5.2f} : {:5.2f} : {:5.2f} : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} |\".format(scene_label,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['F'] * 100,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['S'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['D'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['I'],\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F']*100,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'],\n overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['F']*100,\n overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['ER'],\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F']*100,\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'],\n )\n averages['segment_based_metrics']['overall']['ER'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'])\n averages['segment_based_metrics']['overall']['F'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['F'])\n averages['segment_based_metrics']['class_wise_average']['ER'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'])\n averages['segment_based_metrics']['class_wise_average']['F'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F'])\n averages['event_based_metrics']['overall']['ER'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['ER'])\n averages['event_based_metrics']['overall']['F'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['F'])\n averages['event_based_metrics']['class_wise_average']['ER'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'])\n averages['event_based_metrics']['class_wise_average']['F'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F'])\n\n print \" -------------------+-------+ +--------+-------+-------+-------+-------+--------+-------+--------+-------+--------+-------+\"\n print \" {:18s} | {:5.2f} | | {:4.1f} % : {:5.2f} : {:21s} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} |\".format('Average',\n numpy.mean(averages['segment_based_metrics']['overall']['ER']),\n numpy.mean(averages['segment_based_metrics']['overall']['F'])*100,\n numpy.mean(averages['segment_based_metrics']['overall']['ER']),\n ' ',\n numpy.mean(averages['segment_based_metrics']['class_wise_average']['F'])*100,\n numpy.mean(averages['segment_based_metrics']['class_wise_average']['ER']),\n numpy.mean(averages['event_based_metrics']['overall']['F'])*100,\n numpy.mean(averages['event_based_metrics']['overall']['ER']),\n numpy.mean(averages['event_based_metrics']['class_wise_average']['F'])*100,\n numpy.mean(averages['event_based_metrics']['class_wise_average']['ER']),\n )\n\n print \" \"\n # Restore warnings to default settings\n warnings.simplefilter(\"default\")\n print \" Results per events \"\n\n for scene_id, scene_label in enumerate(dataset.scene_labels):\n print \" \"\n print \" \"+scene_label.upper()\n print \" {:20s} | {:30s} | | {:15s} \".format('', 'Segment-based', 'Event-based')\n print \" {:20s} | {:5s} : {:5s} : {:6s} : {:5s} | | {:5s} : {:5s} : {:6s} : {:5s} |\".format('Event', 'Nref', 'Nsys', 'F1', 'ER', 'Nref', 'Nsys', 'F1', 'ER')\n print \" ---------------------+-------+-------+--------+-------+ +-------+-------+--------+-------+\"\n seg_Nref = 0\n seg_Nsys = 0\n\n event_Nref = 0\n event_Nsys = 0\n for event_label in sorted(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise']):\n print \" {:20s} | {:5d} : {:5d} : {:4.1f} % : {:5.2f} | | {:5d} : {:5d} : {:4.1f} % : {:5.2f} |\".format(event_label,\n int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nref']),\n int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nsys']),\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['F']*100,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['ER'],\n int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nref']),\n int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nsys']),\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['F']*100,\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['ER'])\n seg_Nref += int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nref'])\n seg_Nsys += int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nsys'])\n\n event_Nref += int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nref'])\n event_Nsys += int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nsys'])\n print \" ---------------------+-------+-------+--------+-------+ +-------+-------+--------+-------+\"\n print \" {:20s} | {:5d} : {:5d} : {:14s} | | {:5d} : {:5d} : {:14s} |\".format('Sum',\n seg_Nref,\n seg_Nsys,\n '',\n event_Nref,\n event_Nsys,\n '')\n print \" {:20s} | {:5s} {:5s} : {:4.1f} % : {:5.2f} | | {:5s} {:5s} : {:4.1f} % : {:5.2f} |\".format('Average',\n '', '',\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F']*100,\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'],\n '', '',\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F']*100,\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'])\n print \" \"","def compute_statistics(self):","def evaluate(self, test):\n self.logger.info(\"Testing model over test set\")\n metrics = self.run_evaluate(test)\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\n for k, v in metrics.items()])\n self.logger.info(msg)\n return metrics","def evaluate(self, dataset):\n logging.info('Start evaluation')\n\n loss, predictions, labels = self.run_one_epoch(dataset, RunnerPhase.VALIDATE)\n\n metrics_dict = self.metric_class.get_metrics_dict(predictions, labels)\n\n eval_info = self.metric_class.metrics_dict_to_str(metrics_dict)\n\n logging.info(eval_info)\n\n logging.info('Evaluation finished')\n\n return metrics_dict","def compute_metrics(self, train_data, test_data, criterion):\n m = self.metrics\n warnings.filterwarnings('ignore','Mean of empty slice')\n\n ## load data\n trn, trn_labs = train_data\n tst, tst_labs = test_data\n\n # trn = trn.transpose(1,0)\n tst = tst.transpose(1,0)\n\n t_final = -(np.flipud(trn!=self.padding).argmax(0)+1)\n test_tfinal = -(np.flipud(tst!=self.padding).argmax(0)+1)\n\n ntest = tst.size(1)\n P = self.decoder.out_features\n\n ## training data ###########################################################\n # hidden = self.init_hidden(trn.size(1))\n # out, hidden = self.transparent_forward(trn, hidden)\n # # output = out[t_final, np.arange(trn.size(1)), :]\n # output = out.squeeze()\n # # compute orthogonality\n # mem_act = np.array([np.cumsum(trn==p,axis=0).int().detach().numpy() % 2 \\\n # for p in range(self.q_)]).transpose((1,2,0))\n\n # ps_clf = LinearDecoder(self, 2**(self.q_-1), MeanClassifier)\n # ps = []\n # for d in Dichotomies(mem_act, 'simple'):\n # np.warnings.filterwarnings('ignore',message='invalid value encountered in')\n # ps_clf.fit(hidden.detach().numpy(), d)\n # new_ps = ps_clf.orthogonality()\n # ps.append(new_ps)\n # # if new_ps > ps:\n # # ps = new_ps\n # m['train_parallelism'] = np.append(m['train_parallelism'], np.array(ps).T, axis=0)\n\n # # print(mem_act.shape)\n # # print(hidden.shape)\n # # self.orth_clf.fit(hidden.detach().numpy(), mem_act)\n # # orth_score = self.orth_clf.orthogonality()\n # # m['train_orthogonality'] = np.append(m['train_orthogonality'], orth_score)\n\n ## test data ##############################################################\n hidden = self.init_hidden(tst.size(1))\n out, hidden = self.transparent_forward(tst, hidden)\n # output = out.squeeze()\n # print(hidden.shape)\n # print(out.shape)\n # print(test_tfinal)\n output = out[test_tfinal, np.arange(tst.size(1)), :]\n # raise Exception\n\n # compute loss\n test_loss = criterion(output.squeeze(0),tst_labs.squeeze())\n\n m['test_loss'] = np.append(m['test_loss'], test_loss.item())\n\n # compute orthogonality\n # mem_act = np.array([np.cumsum(tst==p,axis=0).int().detach().numpy() % 2 \\\n # for p in range(self.q_)]).transpose((1,2,0))\n\n # # self.orth_clf.fit(hidden.detach().numpy(), mem_act)\n # # orth_score = self.orth_clf.orthogonality()\n # # m['test_orthogonality'] = np.append(m['test_orthogonality'], orth_score)\n\n # # compute parallelism\n # ps_clf = LinearDecoder(self, 2**(self.q_-1), MeanClassifier)\n # ps = []\n # for d in Dichotomies(mem_act, 'simple'):\n # np.warnings.filterwarnings('ignore',message='invalid value encountered in')\n # ps_clf.fit(hidden.detach().numpy(), d)\n # new_ps = ps_clf.orthogonality()\n # ps.append(new_ps)\n # # if new_ps > ps:\n # # ps = new_ps\n # m['test_parallelism'] = np.append(m['test_parallelism'], np.array(ps).T, axis=0)\n\n ## package #################################################################\n self.metrics = m\n warnings.filterwarnings('default')","def test_get_qc_metrics(integrated_ff):\n\n key, ff_env = integrated_ff['ff_key'], integrated_ff['ff_env']\n uuid = '331106bc-8535-3338-903e-854af460b544'\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, key=key, ff_env=ff_env)\n assert len(qc_metrics.keys()) == 1\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\n target_qc = qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']\n assert 'QualityMetric' in target_qc['values']['@type']\n assert target_qc['organism'] == 'human'\n assert target_qc['experiment_type'] == 'Dilution Hi-C'\n assert target_qc['experiment_subclass'] == 'Hi-C'\n assert target_qc['source_file_association'] == 'processed_files'\n assert target_qc['source_experiment'] == '4DNEXO67APV1'\n assert target_qc['source_experimentSet'] == '4DNESOPFAAA1'\n assert target_qc['biosource_summary'] == \"GM12878\"\n\n kwargs = { # do same as above w/ kwargs, specify to include raw files this time\n 'key': key,\n 'ff_env': ff_env,\n 'include_raw_files': True\n }\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, **kwargs)\n assert len(qc_metrics.keys()) == 2\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\n assert '4c9dabc6-61d6-4054-a951-c4fdd0023800' in qc_metrics\n assert 'QualityMetric' in qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']['values']['@type']\n assert 'QualityMetric' in qc_metrics['4c9dabc6-61d6-4054-a951-c4fdd0023800']['values']['@type']","def compute_statistics(self):\n for i in range(len(self.wine_matrix[0, :])):\n feature = self.wine_matrix[:, i]\n self.wine_stats['feature ' + str(i)] = {}\n if i == 11: # results column\n self.wine_stats['feature ' + str(i)]['positive_class_ratio'] = (feature == 1).sum() / len(feature)\n null, self.wine_stats['feature ' + str(i)]['pvalue'] = stats.normaltest(feature)\n\n # plot\n # pyplot.hist(feature, bins=50)\n # pyplot.show()\n\n for i in range(len(self.cancer_matrix[0, :])):\n feature = self.cancer_matrix[:, i]\n self.cancer_stats['feature ' + str(i)] = {}\n if i == 10: # results column\n self.cancer_stats['feature ' + str(i)]['positive_class_ratio'] = (feature == 1).sum() / len(feature)\n null, self.cancer_stats['feature ' + str(i)]['pvalue'] = stats.normaltest(feature)\n\n # plot\n # pyplot.hist(feature, bins=50)\n # pyplot.show()","def _run():\n subprocess.check_call(\n [\n \"tools/bazel\",\n \"build\",\n \"-c\",\n \"opt\",\n \"test/core/memory_usage/memory_usage_test\",\n ]\n )\n ret = {}\n for name, benchmark_args in _BENCHMARKS.items():\n for scenario, extra_args in _SCENARIOS.items():\n # TODO(chenancy) Remove when minstack is implemented for channel\n if name == \"channel\" and scenario == \"minstack\":\n continue\n try:\n output = subprocess.check_output(\n [\n \"bazel-bin/test/core/memory_usage/memory_usage_test\",\n ]\n + benchmark_args\n + extra_args\n )\n except subprocess.CalledProcessError as e:\n print(\"Error running benchmark:\", e)\n continue\n for line in output.splitlines():\n for key, (pattern, conversion) in _INTERESTING.items():\n m = re.match(pattern, line)\n if m:\n ret[scenario + \": \" + key] = conversion(m.group(1))\n return ret","def session_counting (self, target_dict, IEI_timeRange = (0, 900, 1), cal_IEI = True, cal_duration = True, cal_latency = True, cal_inputDistribution = True, num_bins = 10, **kwards):\r\n if len(self.df) == 0:\r\n #if empty then pass without analysis\r\n pass\r\n else:\r\n get_kwards = lambda x: (\"\",\"\") if x == None else x\r\n input1OnOff = get_kwards(kwards.get('Input1OnOff'))\r\n input2OnOff = get_kwards(kwards.get('Input2OnOff'))\r\n input3OnOff = get_kwards(kwards.get('Input3OnOff'))\r\n input4OnOff = get_kwards(kwards.get('Input4OnOff'))\r\n \r\n #get a start and end time point\r\n if 'Start' in self.df['States'].values:\r\n start = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Start')]['Time']\r\n else:\r\n start = pd.Series({'Start': self.df['Time'].values[0]-1})\r\n \r\n if 'Finish' in self.df['States'].values:\r\n end = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Finish')]['Time']\r\n else:\r\n end = pd.Series({'Finish': self.df['Time'].values[-1]+1}) #plus 1 second\r\n \r\n #get data from each event window\r\n event = self.df[(self.df['Time']>= start.iloc[0])&(self.df['Time']<= end.iloc[0])]\r\n \r\n result_dict = {}\r\n for k, v in target_dict.items():\r\n \r\n if k == 'Input1':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input1OnOff)\r\n elif k == 'Input2':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input2OnOff)\r\n elif k == 'Input3':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input3OnOff)\r\n elif k == 'Input4':\r\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input4OnOff)\r\n else:\r\n result_dict [v[1]] = self.__counting (event, v, self.subject)\r\n \r\n return result_dict","def metric_tests(self, metric_tests: Dict[str, FAIRResultEvaluationCriterium]):\n\n self._metric_tests = metric_tests","def evaluate(self, benchmark_data, metrics={}, options={}):\n dir_name = list(benchmark_data.keys())[0]\n relations = list(benchmark_data.values())[0]\n \n if \"relation\" in options :\n relations = [options[\"relation\"]]\n \n precision_total = 0\n for relation in relations :\n if relation.endswith(\"_inv\") :\n continue\n relation = relation.replace(\":\", \"_\")\n evaluate.setup(relation, dir_name)\n precision_total += evaluate.evaluate_logic()\n \n result = {}\n result[\"MAP\"] = precision_total/len(relations)\n\n return result","def makedata():\n # train\n print('Clean Train Dataset and separate questions')\n df = pd.read_csv(TRAIN_DATASET).replace(np.nan, ' ')\n t = df.shape[0] * 2\n print t\n df['question1'] = cleanText(df['question1'])\n df['question2'] = cleanText(df['question2'])\n\n df.to_csv(os.path.join(rootpathdata_cleaned, 'train.csx'), index=False)\n overallquestions = df['question1'].tolist() + df['question2'].tolist()\n tpm = pd.DataFrame()\n tpm['question'] = overallquestions\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'train_allquestions.csx'), index=False)\n # test\n\n print('Clean Test Dataset and separate questions')\n df = pd.read_csv(TEST_DATASET).fillna(' ')\n t1 = df.shape[0] * 2\n df['question1'] = cleanText(df['question1'])\n df['question2'] = cleanText(df['question2'])\n df.to_csv(os.path.join(rootpathdata_cleaned, 'test.csx'), index=False)\n\n overallquestions += df['question1'].tolist() + df['question2'].tolist()\n tpm = pd.DataFrame()\n tpm['question'] = overallquestions\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'test_allquestions.csx'), index=False)\n print len(overallquestions), t1 + t","def get_chartdata():\n callback = bottle.request.query.get('callback')\n y_axis = bottle.request.query.get('y_axis').strip()\n w_acts = [\"action='%s'\" % act for act in bottle.request.query.get('actions').strip().split(',')]\n w_acts = 'AND (%s)' % ' OR '.join(w_acts) if w_acts else ''\n f_value = 'AVG(latency)' if y_axis.startswith('avg') else 'COUNT(timestamp)'\n atomic = 1 if y_axis in ['aops', 'avgl'] else 0\n\n db_conn = tools.get_db_conn('%s.db' % bottle.request.query.test_run_id)\n sql = 'SELECT test_run_status, timestamp_started, timestamp_completed FROM info LIMIT 1'\n status, started, finished = tools.db_query(db_conn, sql)[1][0]\n progress = int(float(finished) - float(started)) if finished \\\n else int(tools.get_timestamp() - float(started))\n\n sql = 'SELECT substr(timestamp, 0, 11), code, %s FROM recs ' % f_value + \\\n 'WHERE atomic=%s %s GROUP BY code, substr(timestamp, 0, 11) ' % (atomic, w_acts) + \\\n 'ORDER BY id DESC LIMIT 3600' # last 1 hour activity\n\n result = tools.db_query(db_conn, sql)[1] if finished else tools.db_query(db_conn, sql)[1][:-1]\n result = list(reversed(result))\n results = {str(abs(int(item[0]) - int(float(started)))):\n {'failed': 0, 'passed': 0, 'incomplete': 0} for item in result}\n for item in result: # item[0] - timestamp, item[1] - code (None if incomplete), item[2] - value\n timestamp = str(int(item[0]) - int(float(started)))\n value = item[2] or 0\n results[timestamp]['failed'] += value if item[1] and item[1] != 200 else 0\n results[timestamp]['passed'] += value if item[1] == 200 else 0\n results[timestamp]['incomplete'] += value if item[1] == None else 0\n results = [{'timestamp': key, 'failed': value['failed'], 'passed': value['passed'],\n 'incomplete': value['incomplete']} for key, value in results.items()]\n result = {bottle.request.query.slave: results, 'status': status,\n 'started': started, 'finished': finished or '(not finished)', 'progress': progress}\n return '{0}({1})'.format(callback, result)","def test_scores(self) -> np.ndarray:\n return np.asarray(self.test_metric_dict[self.metric_name])","def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\n hist = {k: {} for k in {\"mks0\", \"mks1\", \"mks2\", \"l\"}} # pylint: disable=C0208\n wei = {k: {} for k in hist}\n res[\"hist\"] = hist\n res[\"histnow\"] = wei\n\n for el, _ in self.enumerate_test_metric(qset):\n le = len(el.value)\n w = el.weight\n res[\"mks0\"] += w * el.mks0\n res[\"mks1\"] += w * el.mks1\n res[\"mks2\"] += w * el.mks2\n res[\"sum_weights\"] += w\n res[\"sum_wlen\"] += w * le\n res[\"n\"] += 1\n\n if el.mks0 not in hist[\"mks0\"]:\n hist[\"mks0\"][el.mks0] = w\n wei[\"mks0\"][el.mks0] = 1\n else:\n hist[\"mks0\"][el.mks0] += w\n wei[\"mks0\"][el.mks0] += 1\n if el.mks1 not in hist[\"mks1\"]:\n hist[\"mks1\"][el.mks1] = w\n wei[\"mks1\"][el.mks1] = 1\n else:\n hist[\"mks1\"][el.mks1] += w\n wei[\"mks1\"][el.mks1] += 1\n if el.mks2 not in hist[\"mks2\"]:\n hist[\"mks2\"][el.mks2] = w\n wei[\"mks2\"][el.mks2] = 1\n else:\n hist[\"mks2\"][el.mks2] += w\n wei[\"mks2\"][el.mks2] += 1\n if le not in hist[\"l\"]:\n hist[\"l\"][le] = w\n wei[\"l\"][le] = 1\n else:\n hist[\"l\"][le] += w\n wei[\"l\"][le] += 1\n return res","def metrics_evaluation(y_true, y_prob, threshold, df_type='train'):\n\n y_pred = (y_prob>=threshold).astype(int)\n \n tn = metrics.confusion_matrix(y_true, y_pred)[0][0]\n fp = metrics.confusion_matrix(y_true, y_pred)[0][1]\n fn = metrics.confusion_matrix(y_true, y_pred)[1][0]\n tp = metrics.confusion_matrix(y_true, y_pred)[1][1]\n\n accuracy_scr = metrics.accuracy_score(y_true, y_pred)\n precision_scr = metrics.precision_score(y_true, y_pred)\n recall_scr = metrics.recall_score(y_true, y_pred)\n f1_scr = metrics.f1_score(y_true, y_pred)\n roc_auc_scr = metrics.roc_auc_score(y_true, y_pred)\n\n result = {'Dataset': df_type, 'No obs': len(y_true), 'Threshold': threshold,\n 'TP':tp, 'FP': fp, 'TN': tn, 'FN':fn , \n 'Accuracy Score':accuracy_scr, 'Precision Score':precision_scr, \n 'Recall Score':recall_scr, 'F1 Score':f1_scr, 'ROC AUC Score':roc_auc_scr}\n\n return result","def set_metrics(self):","def prepareAccumulatedMetrics(self):\n displayDF = analyzeMetricsDF(self.resultList)\n displayDF.to_csv(\"data/results.csv\")","def test_get_qc_metrics_logic_unit():\n with mock.patch(\"dcicutils.ff_utils.get_metadata\") as mock_get_metadata:\n mock_get_metadata.side_effect = mocked_get_metadata_from_data_files\n print() # start output on a fresh line\n input_uuid = \"431106bc-8535-4448-903e-854af460b260\"\n result = ff_utils.get_associated_qc_metrics(input_uuid)\n assert \"131106bc-8535-4448-903e-854abbbbbbbb\" in result # quick pre-test\n assert result == get_mocked_result(kind='QC metrics',\n dirname='test_qc_metrics',\n uuid=input_uuid)","def calc_metrics(data, sampled_data_list, dataset_type):\n result={}\n for sampled_data in sampled_data_list:\n c2st_roc_auc_metric = c2st_roc_auc(data, sampled_data)\n if \"c2st_roc_auc\" in result:\n result[\"c2st_roc_auc\"].append(c2st_roc_auc_metric)\n else:\n result[\"c2st_roc_auc\"] = [c2st_roc_auc_metric]\n mmd_p_val, mmd_stat = rbf_mmd_test(data.values, sampled_data.values)\n if \"mmd_p_val\" in result:\n result[\"mmd_p_val\"].append(mmd_p_val)\n result[\"mmd_stat\"].append(mmd_stat)\n else:\n result[\"mmd_p_val\"] = [mmd_p_val]\n result[\"mmd_stat\"] = [mmd_stat]\n ks_p_val, ks_stat, ks_n, ks_p_val_list, ks_stat_list = ks_test(data, sampled_data)\n if dataset_type != \"norm_dataset\":\n ks_p_val = ks_permutation(ks_stat_list, data, sampled_data)\n if \"ks_p_val\" in result:\n result[\"ks_p_val\"].append(ks_p_val)\n result[\"ks_stat\"].append(ks_stat)\n else:\n result[\"ks_p_val\"] = [ks_p_val]\n result[\"ks_stat\"] = [ks_stat]\n acc_r, acc_g = c2st_accuracy(data, sampled_data)\n if \"c2st_acc_r\" in result:\n result[\"c2st_acc_r\"].append(acc_r)\n result[\"c2st_acc_g\"].append(acc_g)\n else:\n result[\"c2st_acc_r\"] = [acc_r]\n result[\"c2st_acc_g\"] = [acc_g]\n return result","def test_evaluate(self):\n # test normalized by 'head_size'\n mpii_pck_metric = MpiiPCKAccuracy(thr=0.3, norm_item='head')\n mpii_pck_metric.process(self.data_batch, self.data_samples)\n pck_results = mpii_pck_metric.evaluate(self.batch_size)\n target = {\n 'Head PCK': 100.0,\n 'Shoulder PCK': 100.0,\n 'Elbow PCK': 100.0,\n 'Wrist PCK': 100.0,\n 'Hip PCK': 100.0,\n 'Knee PCK': 100.0,\n 'Ankle PCK': 100.0,\n 'PCK': 100.0,\n 'PCK@0.1': 100.0,\n }\n self.assertDictEqual(pck_results, target)","def _compute_experiment_statistics(self):\n pass","def _evaluate(self) -> dict:\n self.load()\n self.evaluate_all()\n self.finalize_results()\n log.debug(\"Clearing global instrumentation variables\")\n del_globals()","def measure(self,qc,qb,cb):\n if isinstance(qb,list) and isinstance(cb,list):\n assert len(qb) == len(cb)\n for q,c in zip(qb,cb):\n qc.measure(q,c)\n else:\n qc.measure(qb,cb)\n if self.ibmq:\n job = qk.execute(qc, \n backend = self.backend, \n shots=self.shots,\n optimization_level=self.optimization_level,\n initial_layout=self.layout)\n self.monitor(job)\n else:\n job = qk.execute(qc, \n backend = self.backend, \n shots=self.shots,\n optimization_level=self.optimization_level,\n noise_model=self.noise_model,\n coupling_map=self.coupling_map,\n basis_gates=self.basis_gates,\n initial_layout=self.layout,\n seed_transpiler=self.seed,\n seed_simulator=self.seed)\n return job.result().get_counts(qc)","def test_run(id_, args, kwargs, expected):\n # Remove results for test.\n results_path = expected['results_path']\n shutil.rmtree(results_path, ignore_errors=True)\n # Start code.\n # [future] attempts to run classification with n_jobs>1\n # global cnfg_default\n # sys.modules['cnfg_default'] = get_params(args[0], 'cnfg_default')\n # import cnfg_default\n # #from cnfg_default import custom_score_metric\n objects = pycnfg.run(oid='default', *args, **kwargs)\n tmp = {k: type(v).__name__ for k, v in objects.items()}\n print('OBJECTS:')\n print(tmp)\n # Compare results:\n # * Compare objects (keys and str of values).\n objects_ = expected['objects']\n objects = {k: type(v).__name__ for k, v in objects.items()}\n if objects != objects_:\n print(set(objects.items()) ^ set(objects_.items()))\n assert objects == objects_\n # for k, v in objects.items():\n # assert k in objects_\n # assert type(v).__name__ == objects_[k]\n # * Compare predictions csv(all available).\n pred_path = glob.glob(f\"{results_path}/models/*_pred.csv\")\n pred_path_ = glob.glob(expected['pred_path'])\n assert len(pred_path) == len(pred_path_)\n for act, exp in zip(sorted(pred_path), sorted(pred_path_)):\n file_diff(act, exp)\n assert filecmp.cmp(act, exp)\n # * Compare test logs.\n logs_path = glob.glob(f\"{results_path}/logs*/*_test.log\")[0]\n logs_path_ = expected['logs_path']\n file_diff(logs_path, logs_path_)\n assert filecmp.cmp(logs_path, logs_path_)\n # * Compare runs dataframe, non-universe columns.\n runs_path = f\"{results_path}/runs\"\n runs_path_ = expected['runs_path']\n df = runs_loader(runs_path)\n df_ = runs_loader(runs_path_)\n # First False/True for each element, then check all by columns.\n # col1 True\n # col2 False\n # dtype: bool\n df_diff = df.eq(df_).all()\n # Column names that are not equal.\n columns = sorted(list(df_diff[df_diff==False].dropna().index))\n # columns_eq = sorted(list(df_diff[df_diff==True].dropna().index))\n columns_ = expected['columns_diff']\n print('DIFF:\\n', columns)\n time.sleep(1)\n # assert columns == columns_\n # * Compare model.\n model_path = glob.glob(f\"{results_path}/models/*.model\")\n model_path_ = glob.glob(expected['model_path'])\n assert len(model_path) == len(model_path_)\n for act, exp in zip(sorted(model_path), sorted(model_path_)):\n assert filecmp.cmp(act, exp)\n return","def run(self):\n question_stats = self.MultipleChoiceQuestionAggregator(self._course)\n mapper = models_utils.QueryMapper(\n EventEntity.all(), batch_size=500, report_every=1000)\n mapper.run(question_stats.visit)\n return (question_stats.id_to_questions_dict,\n question_stats.id_to_assessments_dict)","def __dataset_statistics(self) -> None:\n # Print the expressions\n print(f'Available expressions: {self.idx_to_expression.values()}')\n \n # Print dataset cardinalities\n stats_table = PrettyTable()\n stats_table.field_names = ['Train samples', 'PublicTest samples', 'PrivateTest samples', 'Number of expressions']\n stats_table.add_row([len(self.db[self.db['Usage'] == 'Training']), len(self.db[self.db['Usage'] == 'PublicTest']), len(self.db[self.db['Usage'] == 'PrivateTest']), len(self.db.expression.unique().tolist())])\n print(stats_table)\n \n def eval_class_cardinality(expressions: list, train: str) -> [list, list]:\n cardinality = [len(self.db[(self.db['expression']==expr) & (self.db['Usage']==train)]) for expr in expressions]\n frac = [len(self.db[(self.db['expression']==expr) & (self.db['Usage']==train)])/len(self.db[self.db['Usage']==train]) for expr in expressions]\n return cardinality, frac\n\n expressions = self.db.expression.unique()\n expressions.sort()\n \n # Print expressions statistics --> Training \n stats_table = PrettyTable()\n stats_table.title = 'Training Samples'\n stats_table.field_names = [self.idx_to_expression[label] for label in expressions]\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='Training')\n stats_table.add_row(cardinality)\n stats_table.add_row(frac)\n\n # Print expressions statistics --> Validation \n stats_table2 = PrettyTable()\n stats_table2.title = 'Validation Samples'\n stats_table2.field_names = [self.idx_to_expression[label] for label in expressions]\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='PublicTest')\n stats_table2.add_row(cardinality)\n stats_table2.add_row(frac)\n\n # Print expressions statistics --> Test \n stats_table3 = PrettyTable()\n stats_table3.title = 'Test Samples'\n stats_table3.field_names = [self.idx_to_expression[label] for label in expressions]\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='PrivateTest')\n stats_table3.add_row(cardinality)\n stats_table3.add_row(frac)\n \n print(stats_table)\n print(stats_table2)\n print(stats_table3)","def test_metrics(self):\n # Check the route\n self.check_metrics(self.test_metrics_submission_id, False, \"award\")\n self.check_metrics(self.test_metrics_submission_id, True, \"award_financial\")\n self.check_metrics(self.test_metrics_submission_id, True, \"appropriations\")","def _perform_measurement(self, qubits: Sequence['cirq.Qid']) -> List[int]:\n return [self.state._measure(self.qubit_map[q], self.prng) for q in qubits]","def _eval_classifier(self):\n\n y_pred_baseline = self.df_baseline[self.score_column]\n y_pred_sample = self.df_sample[self.score_column]\n\n y_label_baseline = self.df_baseline[self.label_column]\n y_label_sample = self.df_sample[self.label_column]\n\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\n try:\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\n except ValueError:\n auc_baseline = \"NA\"\n\n precision_sample = precision_score(y_label_sample, y_pred_sample)\n recall_sample = recall_score(y_label_sample, y_pred_sample)\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\n f1_sample = f1_score(y_label_sample, y_pred_sample)\n try:\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\n except ValueError:\n auc_sample = \"NA\"\n\n metrics_df = pd.DataFrame(\n {\n \"Accuracy\": [acc_baseline, acc_sample],\n \"Precision\": [precision_baseline, precision_sample],\n \"Recall\": [recall_baseline, recall_sample],\n \"F1\": [f1_baseline, f1_sample],\n \"AUC\": [auc_baseline, auc_sample],\n },\n index=[\"baseline\", \"sample\"],\n )\n\n self.performance_comparison = metrics_df","def log_evaluation(tester, name, description):\r\n\tfor dataset, output in tester.preds.items():\r\n\t\tresults = pandas.DataFrame.from_dict(output)\r\n\t\tpath = os.path.join(\r\n\t\t\tEXPERIMENT_PATH, tester.config[\"name\"] + '-' + dataset)\r\n\t\twith open(path + \".csv\", \"w\") as f:\r\n\t\t\tresults.to_csv(f, sep=\"\\t\", encoding='utf-8',\r\n\t\t\t\tfloat_format='%.3f', index=False)","def qa_test():\r\n # Reads Code and Runs Code Metrics\r\n with open(\"BrainDataVisualiser.py\",\"r\") as file:\r\n code = file.read()\r\n with open(\"QA_LOGS.txt\",\"a\") as file:\r\n # Timestamp and append metric results to log\r\n file.write(datetime.date.today().strftime(\"%b-%d-%Y\")+\"\\n\\t\")\r\n file.write(\"General Analysis\\n\\t\\t\")\r\n file.write(str(analyze(code))+\"\\n\\t\")\r\n file.write(\"Cyclomatic Complexity\\n\")\r\n for i in cc_visit(code):\r\n file.write(\"\\t\\t\"+cc_rank(i.complexity)+\" \"+str(i)+\"\\n\")","def metrics(self):\n \n if self.mse.shape[0]>1:\n raise ValueError('Metrics can only handle single observations.')\n \n if self.N==1:\n pred = float('nan')\n err = float('nan')\n y_true = float('nan')\n else:\n pred = int(self._predictions[-1])\n err = self._mse[-1]\n y_true = int(self.label[0])\n \n is_outlier = {\"type\":\"GAUGE\",\"key\":\"is_outlier\",\"value\":pred}\n mse = {\"type\":\"GAUGE\",\"key\":\"mse\",\"value\":err}\n obs = {\"type\":\"GAUGE\",\"key\":\"observation\",\"value\":self.N - 1}\n threshold = {\"type\":\"GAUGE\",\"key\":\"threshold\",\"value\":self.threshold}\n \n label = {\"type\":\"GAUGE\",\"key\":\"label\",\"value\":y_true}\n \n accuracy_tot = {\"type\":\"GAUGE\",\"key\":\"accuracy_tot\",\"value\":self.metric[4]}\n precision_tot = {\"type\":\"GAUGE\",\"key\":\"precision_tot\",\"value\":self.metric[5]}\n recall_tot = {\"type\":\"GAUGE\",\"key\":\"recall_tot\",\"value\":self.metric[6]}\n f1_score_tot = {\"type\":\"GAUGE\",\"key\":\"f1_tot\",\"value\":self.metric[7]}\n f2_score_tot = {\"type\":\"GAUGE\",\"key\":\"f2_tot\",\"value\":self.metric[8]}\n \n accuracy_roll = {\"type\":\"GAUGE\",\"key\":\"accuracy_roll\",\"value\":self.metric[9]}\n precision_roll = {\"type\":\"GAUGE\",\"key\":\"precision_roll\",\"value\":self.metric[10]}\n recall_roll = {\"type\":\"GAUGE\",\"key\":\"recall_roll\",\"value\":self.metric[11]}\n f1_score_roll = {\"type\":\"GAUGE\",\"key\":\"f1_roll\",\"value\":self.metric[12]}\n f2_score_roll = {\"type\":\"GAUGE\",\"key\":\"f2_roll\",\"value\":self.metric[13]}\n \n true_negative = {\"type\":\"GAUGE\",\"key\":\"true_negative\",\"value\":self.metric[0]}\n false_positive = {\"type\":\"GAUGE\",\"key\":\"false_positive\",\"value\":self.metric[1]}\n false_negative = {\"type\":\"GAUGE\",\"key\":\"false_negative\",\"value\":self.metric[2]}\n true_positive = {\"type\":\"GAUGE\",\"key\":\"true_positive\",\"value\":self.metric[3]}\n \n nb_outliers_roll = {\"type\":\"GAUGE\",\"key\":\"nb_outliers_roll\",\"value\":self.metric[14]}\n nb_labels_roll = {\"type\":\"GAUGE\",\"key\":\"nb_labels_roll\",\"value\":self.metric[15]}\n nb_outliers_tot = {\"type\":\"GAUGE\",\"key\":\"nb_outliers_tot\",\"value\":self.metric[16]}\n nb_labels_tot = {\"type\":\"GAUGE\",\"key\":\"nb_labels_tot\",\"value\":self.metric[17]}\n \n return [is_outlier,mse,obs,threshold,label,\n accuracy_tot,precision_tot,recall_tot,f1_score_tot,f2_score_tot,\n accuracy_roll,precision_roll,recall_roll,f1_score_roll,f2_score_roll,\n true_negative,false_positive,false_negative,true_positive,\n nb_outliers_roll,nb_labels_roll,nb_outliers_tot,nb_labels_tot]","def generate_stats(results, ads, vmid, session_date, export_folder, process_ex_time):\n try:\n os.makedirs(export_folder)\n except OSError:\n pass\n\n # to be read and inserted into db\n totalads = 0 # total number of ads seen during this session\n totaluniqads = len(ads) # does not support multicategories at this point\n\n # for each category, for each test site, count total number of ads seen\n totalad_category = {} \n # for each category, for each test site, count total number of uniq ads seen\n uniqad_category = {}\n \n with open(os.path.join(export_folder, 'session_bugs.csv'), 'w') as bugs_wtr:\n bugs_wtr.write('#Ad-UID, Website-URL, Refresh-Num, Training-Topic,\\\n Site-Context, BugCount, BugSrc\\n')\n for train_category, cat_dict in results.items():\n totalad_category[train_category] = {}\n uniqad_category[train_category] = {}\n for test_site, bug_dict_list in cat_dict.items():\n total_ads = 0 # for each site\n uniq_ads = [] # for each site\n for refresh_num in range(len(bug_dict_list)):\n bug_dict = bug_dict_list[refresh_num]\n for bug, bugcount in bug_dict.items():\n if bug.is_ad():\n uuid = bug.get_uuid()\n bugs_wtr.write('{0}, {1}, {2}, {3}, {4}, {5}, {6}\\n'.format(uuid, test_site,\n refresh_num, train_category, 'N/A', bugcount, bug.get_src()))\n total_ads += bugcount\n if bug not in uniq_ads:\n uniq_ads.append(bug)\n totalad_category[train_category][test_site] = total_ads\n uniqad_category[train_category][test_site] = len(uniq_ads)\n totalads += total_ads # global count for total ads\n\n with open(os.path.join(export_folder, 'session_stats.csv'), 'w') as ses_wtr:\n # write some metadata information about this session\n ses_wtr.write('#VMID: %s\\n' % vmid)\n ses_wtr.write('#Session-Date: %s\\n' % session_date)\n ses_wtr.write('#Time to complete: %s\\n' % process_ex_time)\n ses_wtr.write('#Training Categories: %s\\n' % str(results.keys()))\n ses_wtr.write('#Total Number of ads: %d\\n' % totalads)\n ses_wtr.write('#Total Uniq ads: %d\\n\\n' % totaluniqads)\n ses_wtr.write('#TrainingTopic, Test-Site, NumberOfVisit, TotalAds, UniqAds\\n')\n\n for train_category, cat_dict in results.items(): \n for test_site, bug_dict_list in cat_dict.items():\n num_of_visit = len(bug_dict_list)\n ses_wtr.write('{0}, {1}, {2}, {3}, {4}\\n'.format(train_category,\n test_site, num_of_visit, totalad_category[train_category][test_site],\n uniqad_category[train_category][test_site]))","def evaluate(self, test_data, test_labels):\n raise NotImplementedError","def main():\n test_folders = argv[1]\n benchmark_file = argv[2]\n output_path = argv[3]\n\n method = ['n', 'a', 'a']\n bigram = ['False', 'False', 'True']\n output_file = output_path + '/' + 'method_comparison_cosine_values.csv'\n\n with open(test_folders, 'r') as f:\n test_folders = f.read()\n\n test_folders = test_folders.splitlines()\n\n with open(benchmark_file, 'r') as f:\n benchmark_file = f.read()\n\n benchmark_file = benchmark_file.splitlines()\n\n # initialize big data frame\n frames = []\n\n for k in xrange(len(benchmark_file)):\n\n test = str(test_folders[k]).replace('\"', '')\n print \"Reading test files from folder:\"\n print test\n\n benchmark = str(benchmark_file[k]).replace('\"', '')\n print \"Reading benchmark form file:\"\n print benchmark\n\n # read file paths from test documents folder\n query = sorted([os.path.join(test, f) for f in os.listdir(test) if f.endswith('.txt')])\n\n # load benchmark text file\n with open(benchmark, \"r\", encoding=\"utf-8\", errors='ignore') as doc:\n raw = doc.read()\n\n # initialize dict of dicts for data frame\n method_csv = {}\n\n for j in xrange(len(method)):\n # extract features from benchmark\n dtm = ExtractFeatures(method[j], bigram[j])\n benchmark_name = benchmark_file[k].split('\\\\')[-1]\n benchmark_features = dtm.extract_features_from_text(raw, benchmark_name)\n\n # extract terms from each text document to create a vocabulary (keeping unique terms only)\n vocabulary = sorted(set(w[1] for w in benchmark_features))\n print \"{0} features produced.\".format(str(len(vocabulary)))\n\n benchmark_dtv = DTM(vocabulary, benchmark_name, benchmark_features)\n benchmark_dtv = benchmark_dtv.compute_dtv()\n\n # load test document features\n test_features = []\n for q in query:\n dtm1 = ExtractFeatures(method[j], bigram[j])\n test_features = test_features + dtm1.extract_features_from_file(q)\n\n documents = sorted(set([d for d, w in test_features]))\n print \"{0} test documents read.\".format(str(len(documents)))\n\n print \"Computing DTM...\"\n test_dtm = DTM(vocabulary, documents, test_features)\n test_dtm = test_dtm.compute_dtm()\n\n print \"Computing cosine values...\"\n dv = {}\n for i in xrange(len(documents)):\n d = 1 - spatial.distance.cosine(benchmark_dtv[benchmark_name], test_dtm[documents[i]])\n if isnan(d):\n d = 0\n dv[documents[i]] = d\n\n this_method = \"method=\" + method[j] + '_' + \"bigram=\" + bigram[j]\n method_csv[this_method] = pd.Series(dv)\n\n print \"Saving to data frame...\"\n df = pd.DataFrame(method_csv)\n test = test.split('\\\\')[-1]\n test = test.split('.')[0]\n df['test_group'] = test\n\n frames.append(df)\n\n result = pd.concat(frames)\n\n print \"Saving results to file: \", output_file\n result.to_csv(output_file)\n\n print 'Finished computing {0} data frames'.format(str(len(test_folders)))","def compute_accuracy_measures(self, gt):\n data = quantification.compute_accuracy_measures(self.image, gt.image)\n return data","def test_step(self, x_test, y_test):\n\n print(\"Evaluation:\")\n\n input_x_op = self.session.graph.get_operation_by_name(\"input_x\").outputs[0]\n input_y_op = self.session.graph.get_operation_by_name(\"input_y\").outputs[0]\n global_step_op = self.session.graph.get_operation_by_name(\"global_step\").outputs[0]\n\n loss_op = self.session.graph.get_operation_by_name(\"loss/loss\").outputs[0]\n\n predictions_op = self.session.graph.get_operation_by_name(\"output/predictions\").outputs[0] \n\n accuracy_op = self.session.graph.get_operation_by_name(\"accuracy/accuracy\").outputs[0]\n confusion_update_op = self.session.graph.get_operation_by_name(\"accuracy/confusion_update\").outputs[0]\n\n d_ = {\n input_x_op: x_test,\n input_y_op: y_test\n }\n\n self.init_dataset(d_)\n\n valid_batches_per_epoch = (len(x_test) - 1) // self.FLAGS.batch_size + 1\n\n sum_accuracy = 0\n \n confusion_variable = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=\"accuracy/confusion\")[0]\n self.session.run([confusion_variable.initializer])\n\n for current_step in range(valid_batches_per_epoch):\n\n if self.FLAGS.summary:\n step, summaries, loss, accuracy, cnf_matrix, predictions = self.session.run(\n [global_step_op, self.dev_summary_op, loss_op, accuracy_op, confusion_update_op, predictions_op])\n\n self.writer.add_summary(summaries, step)\n else:\n step, loss, accuracy, cnf_matrix, predictions = self.session.run(\n [global_step_op, loss_op, accuracy_op, confusion_update_op, predictions_op]) \n\n sum_accuracy += accuracy\n\n try:\n all_predictions = np.concatenate((all_predictions, predictions), axis=0)\n except NameError:\n all_predictions = predictions\n\n\n valid_accuracy = sum_accuracy / valid_batches_per_epoch\n\n time_str = datetime.datetime.now().isoformat()\n print(\"{}: valid_accuracy {:g}\".format(time_str, valid_accuracy))\n print(\"Confusion matrix:\")\n print(cnf_matrix)\n\n return valid_accuracy, all_predictions","def test_fetch_qc_metrics_logic_integrated(mocked_replicate_experiment):\n result = ff_utils.fetch_files_qc_metrics(\n ff_utils.get_metadata(\"331106bc-8535-3338-903e-854af460b544\", ff_env='fourfront-mastertest'),\n ff_env='fourfront-mastertest',\n associated_files=['other_processed_files'],\n ignore_typical_fields=False)\n assert '131106bc-8535-4448-903e-854af460b000' in result\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in result","def run(self, inputIn):\n measureList = self.inputToInternal(inputIn)\n outputDict = {}\n assert(len(self.features) == len(measureList))\n for metricInstance in self.metricsDict.values():\n metricEngine = MetricDistributor.factory.returnInstance('MetricDistributor', metricInstance)\n for cnt in range(len(self.targets)):\n nodeName = (str(self.targets[cnt]) + '_' + str(self.features[cnt])).replace(\"|\",\"_\")\n varName = metricInstance.name + '|' + nodeName\n output = metricEngine.evaluate(measureList[cnt], weights=self.weight, multiOutput=self.multiOutput)\n outputDict[varName] = np.atleast_1d(output)\n return outputDict","def run_evaluate(self, test):\n accs = []\n correct_preds, total_correct, total_preds = 0., 0., 0.\n for words, labels in minibatches(test, self.config.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words)\n\n for lab, lab_pred, length in zip(labels, labels_pred,\n sequence_lengths):\n lab = lab[:length]\n lab_pred = lab_pred[:length]\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\n\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\n lab_pred_chunks = set(get_chunks(lab_pred,\n self.config.vocab_tags))\n\n correct_preds += len(lab_chunks & lab_pred_chunks)\n total_preds += len(lab_pred_chunks)\n total_correct += len(lab_chunks)\n\n p = correct_preds / total_preds if correct_preds > 0 else 0\n r = correct_preds / total_correct if correct_preds > 0 else 0\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\n acc = np.mean(accs)\n print('*'*20, '\\n')\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\n')\n print('*'*20)\n\n return {\"acc\": 100*acc, \"f1\": 100*f1}","def run_evaluate(self, test):\n accs = []\n correct_preds, total_correct, total_preds = 0., 0., 0.\n for words, labels in minibatches(test, self.config.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words)\n\n for lab, lab_pred, length in zip(labels, labels_pred,\n sequence_lengths):\n lab = lab[:length]\n lab_pred = lab_pred[:length]\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\n\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\n lab_pred_chunks = set(get_chunks(lab_pred,\n self.config.vocab_tags))\n\n correct_preds += len(lab_chunks & lab_pred_chunks)\n total_preds += len(lab_pred_chunks)\n total_correct += len(lab_chunks)\n\n p = correct_preds / total_preds if correct_preds > 0 else 0\n r = correct_preds / total_correct if correct_preds > 0 else 0\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\n acc = np.mean(accs)\n\n return {\"acc\": 100*acc, \"f1\": 100*f1}","def gather_sample(self):\n\n for _pid in self._select_processes():\n if not self.__trackers.get(_pid):\n self.__trackers[_pid] = ProcessTracker(_pid, self._logger, self.__id)\n\n self._reset_absolute_metrics()\n\n for _tracker in self.__trackers.values():\n _metrics = _tracker.collect()\n self.record_metrics(_tracker.pid, _metrics)\n\n self._calculate_aggregated_metrics()\n self._remove_dead_processes()\n\n self.print_metrics()","def load_results(self):\n self.find_benchmark_directories()\n for (benchmark, producer), result in self.results.items():\n print('Reading results for ' + benchmark + ' ' + producer)\n if not result.directory:\n print('No results found for ' + benchmark + ' ' + producer)\n else:\n print('Generating report for: ' + result.directory)\n report = Report(result.directory)\n result.reports = report.generate()","def getMeasures():","def execute(self):\r\n factors = self.factors\r\n variables = list(self.variables)\r\n variables.remove(self.query)\r\n\r\n for fac in factors:\r\n self.set_observations(fac)\r\n\r\n for var in variables:\r\n if var not in self.obs:\r\n factors = self.eliminate_variable(var, factors)\r\n\r\n result = factor_module.multiply_batch(self.query, factors)\r\n denominator = sum(result.get_cpt())\r\n print(denominator)\r\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def save_metrics(self):\n self.data_stats.write.format(\"org.apache.spark.sql.cassandra\").mode(\"append\").options(table=self.cassandra_stats_table, keyspace=self.cassandra_keyspace).save()\n print (\"Saved data successfully\")","def __init__(self, metrics, gt, pred):\n self.dict_metrics = self.compute_metrics(metrics, gt, pred)","def evaluate(cfg: DictConfig):\n\n experiments = cfg.get('experiment_type', f'{cfg.model.name}_only')\n fixed_t0 = cfg.get('fixed_t0', False)\n ext = '_fixedT0' if fixed_t0 else ''\n\n base_dir = cfg.device.root\n datasource = cfg.datasource.name\n\n if experiments == 'ablations':\n models = {\n 'FluxRGNN': ['final',\n 'final_without_encoder',\n 'final_without_boundary'],\n 'LocalLSTM': ['final']\n }\n elif experiments == 'final':\n models = {\n 'FluxRGNN': ['final'],\n 'GAM': ['final'],\n 'HA': ['final'],\n 'GBT': ['final']\n }\n else:\n m = cfg.model.name\n year = cfg.datasource.test_year\n\n # find all experiments available for this model, datasource and test year\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{year}')\n models = {\n m : [ f.name for f in os.scandir(result_dir) if f.is_dir() ]\n }\n\n\n # thresholds for binary classification metrics\n if cfg.datasource.name == 'abm':\n thresholds = [0.0019, 0.0207]\n else:\n thresholds = [0, 10, 20]\n\n rmse_per_hour = []\n mae_per_hour = []\n pcc_per_hour = []\n bin_per_hour = []\n\n rmse_per_night = []\n mae_per_night = []\n\n output_dir = osp.join(base_dir, 'results', datasource, f'performance_evaluation{ext}', experiments)\n os.makedirs(output_dir, exist_ok=True)\n\n counter = 0\n\n for m, dirs in models.items():\n print(f'evaluate {m}')\n\n for d in dirs:\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{cfg.datasource.test_year}', d)\n\n # check if directory exists\n if os.path.isdir(result_dir):\n results, model_cfg = load_cv_results(result_dir, trials=cfg.task.repeats, ext=ext)\n\n df_prep = pd.read_csv(osp.join(base_dir, 'data', 'preprocessed',\n f'{model_cfg[\"t_unit\"]}_{model_cfg[\"model\"][\"edge_type\"]}_ndummy={model_cfg[\"datasource\"][\"n_dummy_radars\"]}',\n datasource, cfg.season, str(cfg.datasource.test_year), 'dynamic_features.csv'))\n tidx2night = dict(zip(df_prep.tidx, df_prep.nightID))\n\n rmse_per_hour.append(compute_rmse(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n mae_per_hour.append(compute_mae(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n pcc_per_hour.append(compute_pcc(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n\n if fixed_t0:\n rmse_per_night.append(compute_rmse_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\n mae_per_night.append(compute_mae_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\n\n # compute binary classification measures\n for thr in thresholds:\n bin_per_hour.append(compute_bin(m, d, results, groupby=['horizon', 'trial'], threshold=thr, km2=True))\n\n counter += 1\n\n else:\n print(f'Experiment \"{d}\" for model \"{m}\" and datasource \"{datasource}\" is not available. '\n f'Use \"run_experiments.py model={m} datasource={datasource} +experiment={d}\" to run this experiment.')\n\n if counter > 0:\n rmse_per_hour = pd.concat(rmse_per_hour)\n rmse_per_hour.to_csv(osp.join(output_dir, f'rmse_per_hour.csv'))\n\n mae_per_hour = pd.concat(mae_per_hour)\n mae_per_hour.to_csv(osp.join(output_dir, f'mae_per_hour.csv'))\n\n pcc_per_hour = pd.concat(pcc_per_hour)\n pcc_per_hour.to_csv(osp.join(output_dir, f'pcc_per_hour.csv'))\n\n bin_per_hour = pd.concat(bin_per_hour)\n bin_per_hour.to_csv(osp.join(output_dir, f'bin_per_hour.csv'))\n\n if fixed_t0:\n rmse_per_night = pd.concat(rmse_per_night)\n rmse_per_night.to_csv(osp.join(output_dir, f'rmse_per_night.csv'))\n\n mae_per_night = pd.concat(mae_per_night)\n mae_per_night.to_csv(osp.join(output_dir, f'mae_per_night.csv'))","def compute_metrics(self, results: list) -> dict:\n dump(results, self.out_file_path)\n print_log(\n f'Results has been saved to {self.out_file_path}.',\n logger='current')\n return {}","def test(self):\n for data_tier in self.data_tiers:\n tot = len(self.preprocessed_data[data_tier]['features'])\n p = int(math.floor(tot*0.2))\n test_features = np.array(self.preprocessed_data[data_tier]['features'][p:])\n trend_test_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][p:])\n avg_test_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][p:])\n accuracy_trend = self.clf_trend[data_tier].score(test_features, trend_test_classifications)\n accuracy_avg = self.clf_avg[data_tier].score(test_features, avg_test_classifications)\n self.logger.info('The accuracy of %s trend classifier for data tier %s is %.3f', self.name, data_tier, accuracy_trend)\n self.logger.info('The accuracy of %s avg regressor for data tier %s is %.3f', self.name, data_tier, accuracy_avg)","def run(self):\n if self.verbose:\n print(f'Running {self.name} tests...')\n\n # try running setup if there is one\n if self.setup:\n self.__process_setup()\n\n final_report = [None] * len(self.tests)\n\n for test_in, test_out in sorted(self.tests.items()):\n # increment total num of tests\n self.total += 1\n\n if self.verbose:\n print(f'#{self.total}')\n\n # evaluate test input w/ setup vars, if any\n try:\n inp = eval(test_in, self.vars)\n except Exception as err:\n print(f'Issue during evaluation of test input: {err}')\n final_report[self.total - 1] = 'input eval error'\n if self.verbose:\n print(f'Test input was: {test_in}')\n print('Vars from execution: {}'.format({k : v for k, v in self.vars.items() if k != '__builtins__'}))\n continue\n\n \n # checking if function input has more than one arg\n if type(inp) in (list, tuple):\n try:\n student_out = self.student_function(*inp)\n except Exception as err:\n print(f'Issue while running student code: {err}')\n final_report[self.total - 1] = f'student code error: {err}; input: {inp}; func_name: {self.name}'\n if self.verbose:\n print(f'Function being run was: {self.name}')\n print(f'Inputs were: {inp}')\n continue\n else:\n try:\n student_out = self.student_function(inp)\n except Exception as err:\n print(f'Issue while running student code: {err}')\n final_report[self.total - 1] = f'student code error: {err}; input: {inp}; func_name: {self.name}'\n if self.verbose:\n print(f'Function being run was: {self.name}')\n print(f'Input was: {inp}')\n continue\n\n # ans alias for ease of answer checking\n self.vars['ans'] = student_out\n\n if self.schema:\n format_vals = eval(test_out, self.vars)\n results, maybe_failed_schema = self.__process_schema(format_vals)\n if all(results):\n self.correct += 1\n final_report[self.total - 1] = 'PASSED'\n else:\n # failed at least one of the tests\n failed_str = \" and \".join([\", \".join(maybe_failed_schema[:-1]),maybe_failed_schema[-1]] if len(maybe_failed_schema) > 2 else maybe_failed_schema)\n final_report[self.total - 1] = f'FAILED; failed following assertion(s): {failed_str}'\n else:\n expected_ans = eval(test_out, self.vars)\n if student_out == expected_ans:\n self.correct += 1\n final_report[self.total - 1] = 'PASSED'\n else:\n # failed the only test\n final_report[self.total - 1] = f'FAILED; got {repr(student_out)} but expected {repr(expected_ans)}'\n\n # run callback function, if there is one\n if self.callback:\n if self.verbose:\n print('Running callback...')\n print('call back is:', self.callback)\n\n # once done, put the final report on the queue\n self.queue.put((self.student_username, self.name, f'{self.correct}/{self.total}', final_report))","def execute(self, context):\n if len(self.data_quality_checks) == 0:\n self.log.info('DataQualityOperator not implemented yet')\n return\n \n redshift_hook = PostgresHook(postgres_conn_id=self.redshift_conn_id) \n \n errors = 0\n failure_tests = []\n\n # process each sql stmt for data quality relevant to each dimension table:\n # Dimension tables : a. songplays, b. songs, c. artists, d. users, e. time\n \n for (curr_table, check_stmt) in zip(self.list_of_tables, self.data_quality_checks):\n curr_sql = check_stmt.get('check_sql')\n result1 = check_stmt.get('expected_result')\n \n self.log.info('Current Table Processed : ' + curr_table)\n\n try:\n records = redshift_hook.get_records(curr_sql)[0]\n except Exception as e:\n self.loginfo(f\"Error : {curr_table} : Query failed : {e}\")\n\n # record error when actual result is not the same as expected result\n if result1 != records[0]:\n errors += 1\n failure_tests.append(curr_table + ' : ' + curr_sql)\n \n # display Failure or Success Message \n if errors > 0:\n self.log.info(failure_tests)\n self.log.info('Failure Msg : Tests Failed')\n raise ValueError('Error : Failed : Data Quality check')\n else:\n self.log.info('Success : All Data Quality Tests passed')","def dataStats(self):\n print (\"Performing statistical analysis of the data\")\n # stuff to do","def _test_evaluate(self, format_only, outfile_predix=None):\n metric = MOTChallengeMetric(\n metric=['HOTA', 'CLEAR', 'Identity'],\n format_only=format_only,\n outfile_prefix=outfile_predix)\n metric.dataset_meta = {'classes': ('pedestrian', )}\n data_batch = dict(input=None, data_samples=None)\n predictions = self._get_predictions_demo()\n metric.process(data_batch, predictions)\n eval_results = metric.evaluate()\n return eval_results","def save_performances(self):\r\n nb_datasets = len(self.results)\r\n resu = [[] for k in range(nb_datasets)]\r\n\r\n # fetch results\r\n for k in range(nb_datasets):\r\n best = np.argmax(self.results[k]['mean_test_score'])\r\n resu[k].append(('score', self.results[k]['mean_test_score'][best]))\r\n resu[k] = resu[k] + list(self.results[k]['params'][best].items())\r\n\r\n # write results in csv\r\n for k, resu in enumerate(resu):\r\n with open('results/final_results_{}.csv'.format(k), 'a') as file:\r\n writer = csv.writer(file)\r\n writer.writerow(resu)","def run_and_evaluate():\n tsp_problems = read_all_problems()\n # Empty list of metrics\n results = []\n for problem in tqdm.tqdm(tsp_problems):\n # As random factors are involved repeat experiments a couple of times\n best_routes_base = []\n best_routes_af = []\n best_routes_ms = []\n base_times = []\n af_times = []\n ms_times = []\n for i in range(10):\n # Base solution\n start_time = timeit.default_timer()\n best_route_base = solve_tsp_basic(problem)\n base_time = timeit.default_timer() - start_time\n best_routes_base.append(Fitness(route=best_route_base).route_distance())\n base_times.append(base_time)\n\n # AF clustering solution\n start_time = timeit.default_timer()\n best_route_af = solve_tsp_affinity_propagation(problem)\n af_time = timeit.default_timer() - start_time\n best_routes_af.append(Fitness(route=best_route_af).route_distance())\n af_times.append(af_time)\n\n # MS solution\n start_time = timeit.default_timer()\n best_route_ms = solve_mean_shift(problem)\n ms_time = timeit.default_timer() - start_time\n best_routes_ms.append(Fitness(route=best_route_ms).route_distance())\n ms_times.append(ms_time)\n\n results.append(\n {\n \"problem name\": problem.name,\n \"optimal solution\": find_route_optimal_route_length(problem),\n \"baseline tour length\": mean(best_routes_base),\n \"af clustering tour length\": mean(best_routes_af),\n \"ms clustering tour length\": mean(best_routes_ms),\n \"baseline algorithm time\": mean(base_times),\n \"af clustering algorithm time\": mean(af_times),\n \"ms clustering algorithm time\": mean(ms_times),\n }\n )\n # Create dataframe and safe results\n df = pd.DataFrame(results)\n df.to_csv(\"results.csv\", index=False)\n return df","def init_metrics(self):\n\n self.metrics = {}\n\n self.metrics['train_loss'] = np.zeros(0)\n self.metrics['test_loss'] = np.zeros(0)\n\n # self.orth_clf = LinearDecoder(self, self.q_, MeanClassifier)\n # self.metrics['train_orthogonality'] = np.zeros(0)\n # self.metrics['test_orthogonality'] = np.zeros(0)\n\n self.metrics['train_parallelism'] = np.zeros((0,self.q_)) \n self.metrics['test_parallelism'] = np.zeros((0,self.q_))","def test_cw_metrics(self):\n\n instances = set()\n result = self.cw_client.list_metrics(Namespace=\"CWAgent\", MetricName=\"cpu_usage_system\")\n for i in result[\"Metrics\"]:\n instances.add(i[\"Dimensions\"][0][\"Value\"])\n\n for key, value in self.cdk_output_map.items():\n if \"Instance\" in key:\n self.assertTrue(value in instances)","def metrics_env(cmd_ctx, cpc, **options):\n cmd_ctx.execute_cmd(lambda: cmd_metrics_env(cmd_ctx, cpc, options))","def evaluate(self) -> Dict[str, float]:\n eval_dataloader = self.get_eval_dataloader()\n\n output = self._prediction_loop(eval_dataloader, description=\"Evaluation\")\n return output.metrics","def _build_eval_metrics(self, results, features, labels):\n metrics = {}\n for metric in self.metrics:\n metrics[metric.IDENTIFIER] = getters.get_metric(\n metric.IDENTIFIER, results, labels, **metric.to_dict())\n return metrics","def evaluate(self, epoch, exploration_paths):\n logger.log(\"Collecting samples for evaluation\")\n paths = self._sample_eval_paths(epoch)\n statistics = OrderedDict()\n\n statistics.update(self._statistics_from_paths(paths, \"Test\"))\n statistics.update(self._get_other_statistics())\n statistics.update(self._statistics_from_paths(exploration_paths,\n \"Exploration\"))\n\n statistics['AverageReturn'] = get_average_returns(paths)\n statistics['Epoch'] = epoch\n\n for key, value in statistics.items():\n logger.record_tabular(key, value)\n\n self.log_diagnostics(paths)","def evaluation(self):\n rows_list = []\n for name in self.single_classifier_best.keys():\n row = {}\n row['algorithm'] = name \n row[self.scoring_metric] = self.single_classifier_best[name].best_score_\n rows_list.append(row)\n \n scoring_df = pd.DataFrame(rows_list)\n scoring_sorted = scoring_df.sort_values(self.scoring_metric, ascending=False)\n print()\n print('*'*shutil.get_terminal_size().columns)\n print(scoring_sorted)\n print('*'*shutil.get_terminal_size().columns)\n self.evaluation_scores = scoring_sorted","def getIndependentTestSetPerf(ml_df,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,group_col,model_type,ml_model,n_splits=10,n_repeats=10,n_jobs=1): \n X = ml_df[roi_cols].values\n X_col_names = roi_cols.copy()\n grp1_idx = np.array(ml_df[group_col]=='internal')\n grp2_idx = np.array(ml_df[group_col]=='external')\n\n # Check input var types and create dummy vars if needed\n if len(covar_continuous_cols) > 0:\n X_continuous_covar = ml_df[covar_continuous_cols].values\n print('Using {} continuous covar'.format(len(covar_continuous_cols)))\n X = np.hstack((X, X_continuous_covar))\n X_col_names += list(covar_continuous_cols)\n if len(covar_cat_cols) > 0:\n X_cat_covar_df = pd.get_dummies(ml_df[covar_cat_cols])\n X_cat_covar = X_cat_covar_df.values\n print('Using {} categorical cols as {} cat covar (dummies)'.format(covar_cat_cols,X_cat_covar.shape[1]))\n X = np.hstack((X, X_cat_covar))\n X_col_names += list(X_cat_covar_df.columns)\n\n print('n of input columns: {}'.format(len(X_col_names)))\n if model_type.lower() == 'classification':\n y = pd.get_dummies(ml_df[outcome_col]).values[:,0]\n print('Data shapes X {}, y {} ({})'.format(X.shape, len(y), list(ml_df[outcome_col].value_counts()))) \n perf_metric = 'roc_auc'\n cv = RepeatedStratifiedKFold(n_splits=n_splits,n_repeats=n_repeats,random_state=0)\n elif model_type.lower() == 'regression':\n y = ml_df[outcome_col].values\n print('Data shapes X {}, y {} ({:3.2f}m, {:3.2f}sd)'.format(X.shape, len(y), np.mean(y),np.std(y))) \n perf_metric = 'neg_mean_squared_error'\n cv = ShuffleSplit(n_splits=n_splits*n_repeats, random_state=0)\n else:\n print('unknown model type {} (needs to be classification or regression)'.format(model_type))\n\n\n print('Using {} model with perf metric {}'.format(model_type, perf_metric))\n\n X1 = X[grp1_idx]\n y1 = y[grp1_idx]\n X2 = X[grp2_idx]\n y2 = y[grp2_idx]\n\n scores_df_CV = pd.DataFrame()\n for train_index, test_index in cv.split(X1):\n X1_tr = X1[train_index]\n y1_tr = y1[train_index]\n X1_te = X1[test_index]\n y1_te = y1[test_index]\n \n ml_model.fit(X1_tr,y1_tr)\n y1_pred = ml_model.predict(X1_te)\n y2_pred = ml_model.predict(X2)\n \n if perf_metric == 'neg_mean_squared_error':\n perf1 = mean_squared_error(y1_te, y1_pred)\n perf2 = mean_squared_error(y2, y2_pred)\n else:\n print('Unknown scoring function {}'.format(perf_metric))\n perf1 = 0\n perf2 = 0\n \n scores_df = pd.DataFrame() \n scores_df[perf_metric] = [perf1,perf2]\n scores_df['test_subset'] = ['internal','external']\n scores_df_CV = scores_df_CV.append(scores_df)\n\n return scores_df_CV","def run(self):\n self.tf_idf_scores = self.tf_idf()\n self.word_scores = self.create_word_score()\n self.keyword_scores = self.create_keyword_score()\n self.text_ranks = self.create_text_rank()\n self.pos_scores = {}\n self.z_area_scores = {}\n self.create_pos_and_area_score()\n self.all_scores = self.weight_distribution()\n self.all_scores_dict = self.get_all_scores_dict()\n return self.get_keywords()"],"string":"[\n \"def compute(self, **kwargs):\\n if self.extractor is None:\\n kwargs['download_data'] = kwargs.pop('download_data', self.download_data)\\n self.load_data(**kwargs)\\n self.log.info(f\\\"Session {self.session_path}: Running QC on behavior data...\\\")\\n self.metrics, self.passed = get_bpodqc_metrics_frame(\\n self.extractor.data,\\n wheel_gain=self.extractor.settings['STIM_GAIN'], # The wheel gain\\n photodiode=self.extractor.frame_ttls,\\n audio=self.extractor.audio_ttls,\\n re_encoding=self.extractor.wheel_encoding or 'X1',\\n min_qt=self.extractor.settings.get('QUIESCENT_PERIOD') or 0.2\\n )\\n return\",\n \"def qc_metrics(self, files_in, qc_files):\\n self.cmd(\\\"{samtools} index {bam_in}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in=files_in[0],\\n ),\\n shell=True)\\n self.cmd(\\\"{samtools} idxstats {bam_in} | tee {qc_file}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in = files_in[0],\\n qc_file = qc_files[0],\\n ),\\n shell=True,\\n log_output=True)\\n self.cmd(\\\"{samtools} flagstat {bam_in} | tee {qc_file}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in = files_in[0],\\n qc_file = qc_files[1],\\n ),\\n shell=True,\\n log_output=True)\\n \\n self.checkpoint(qc_files[0])\\n self.checkpoint(qc_files[1])\\n self.checkpoint(qc_files[2])\",\n \"def compute_session_status(self):\\n if self.passed is None:\\n raise AttributeError('passed is None; compute QC first')\\n # Get mean passed of each check, or None if passed is None or all NaN\\n results = {k: None if v is None or np.isnan(v).all() else np.nanmean(v)\\n for k, v in self.passed.items()}\\n session_outcome, outcomes = self.compute_session_status_from_dict(results)\\n return session_outcome, results, outcomes\",\n \"def get_bpodqc_metrics_frame(data, **kwargs):\\n def is_metric(x):\\n return isfunction(x) and x.__name__.startswith('check_')\\n # Find all methods that begin with 'check_'\\n checks = getmembers(sys.modules[__name__], is_metric)\\n prefix = '_task_' # Extended QC fields will start with this\\n # Method 'check_foobar' stored with key '_task_foobar' in metrics map\\n qc_metrics_map = {prefix + k[6:]: fn(data, **kwargs) for k, fn in checks}\\n\\n # Split metrics and passed frames\\n metrics = {}\\n passed = {}\\n for k in qc_metrics_map:\\n metrics[k], passed[k] = qc_metrics_map[k]\\n\\n # Add a check for trial level pass: did a given trial pass all checks?\\n n_trials = data['intervals'].shape[0]\\n # Trial-level checks return an array the length that equals the number of trials\\n trial_level_passed = [m for m in passed.values()\\n if isinstance(m, Sized) and len(m) == n_trials]\\n name = prefix + 'passed_trial_checks'\\n metrics[name] = reduce(np.logical_and, trial_level_passed or (None, None))\\n passed[name] = metrics[name].astype(float) if trial_level_passed else None\\n\\n return metrics, passed\",\n \"def metric_tests(self) -> Dict[str, FAIRResultEvaluationCriterium]:\\n return self._metric_tests\",\n \"def run_tests(self):\\n\\n self.test_report = []\\n\\n #dict of unsorted lists\\n dict_of_un_lists = self.dict_un_lists_intersection_test(self.data_dict)\\n self.test_report.append(dict_of_un_lists)\\n\\n #dict of sets\\n dict_of_sets = self.build_dict_of_sets(self.data_dict)\\n self.test_report.append(self.dict_sets_intersection_test(dict_of_sets))\\n\\n #pandas - experimental and probably not the way to use pandas\\n # dict_of_pandas = self.build_dict_of_panda_series(self.data_dict)\\n # self.test_report.append(self.dicts_any_intersection_node_test(dict_of_pandas))\\n\\n # print results\\n\\n if self.verbose:\\n self.print_tests_results()\",\n \"def test_evaluate(self):\\n # test normalized by 'bbox_size'\\n jhmdb_pck_metric = JhmdbPCKAccuracy(thr=0.5, norm_item='bbox')\\n jhmdb_pck_metric.process(self.data_batch, self.data_samples)\\n pck_results = jhmdb_pck_metric.evaluate(self.batch_size)\\n target = {\\n 'Head PCK': 1.0,\\n 'Sho PCK': 1.0,\\n 'Elb PCK': 1.0,\\n 'Wri PCK': 1.0,\\n 'Hip PCK': 1.0,\\n 'Knee PCK': 1.0,\\n 'Ank PCK': 1.0,\\n 'PCK': 1.0,\\n }\\n self.assertDictEqual(pck_results, target)\\n\\n # test normalized by 'torso_size'\\n jhmdb_tpck_metric = JhmdbPCKAccuracy(thr=0.2, norm_item='torso')\\n jhmdb_tpck_metric.process(self.data_batch, self.data_samples)\\n tpck_results = jhmdb_tpck_metric.evaluate(self.batch_size)\\n target = {\\n 'Head tPCK': 1.0,\\n 'Sho tPCK': 1.0,\\n 'Elb tPCK': 1.0,\\n 'Wri tPCK': 1.0,\\n 'Hip tPCK': 1.0,\\n 'Knee tPCK': 1.0,\\n 'Ank tPCK': 1.0,\\n 'tPCK': 1.0,\\n }\\n self.assertDictEqual(tpck_results, target)\",\n \"def qc_metrics(\\n data: AnnData,\\n mito_prefix: str = \\\"MT-\\\",\\n min_genes: int = 500,\\n max_genes: int = 6000,\\n min_umis: int = 100,\\n max_umis: int = 600000,\\n percent_mito: float = 10.0,\\n percent_cells: float = 0.05,\\n) -> None:\\n\\n data.obs[\\\"passed_qc\\\"] = False\\n\\n data.obs[\\\"n_genes\\\"] = data.X.getnnz(axis=1)\\n data.obs[\\\"n_counts\\\"] = data.X.sum(axis=1).A1\\n\\n mito_prefixes = mito_prefix.split(\\\",\\\")\\n\\n def startswith(name):\\n for prefix in mito_prefixes:\\n if name.startswith(prefix):\\n return True\\n return False\\n\\n mito_genes = data.var_names.map(startswith).values.nonzero()[0]\\n data.obs[\\\"percent_mito\\\"] = (data.X[:, mito_genes].sum(axis=1).A1 / np.maximum(\\n data.obs[\\\"n_counts\\\"].values, 1.0\\n )) * 100\\n\\n # Assign passed_qc\\n filters = [\\n data.obs[\\\"n_genes\\\"] >= min_genes,\\n data.obs[\\\"n_genes\\\"] < max_genes,\\n data.obs[\\\"n_counts\\\"] >= min_umis,\\n data.obs[\\\"n_counts\\\"] < max_umis,\\n data.obs[\\\"percent_mito\\\"] < percent_mito,\\n ]\\n\\n data.obs.loc[np.logical_and.reduce(filters), \\\"passed_qc\\\"] = True\\n\\n var = data.var\\n data = data[\\n data.obs[\\\"passed_qc\\\"]\\n ] # compute gene stats in space of filtered cells only\\n\\n var[\\\"n_cells\\\"] = data.X.getnnz(axis=0)\\n var[\\\"percent_cells\\\"] = (var[\\\"n_cells\\\"] / data.shape[0]) * 100\\n var[\\\"robust\\\"] = var[\\\"percent_cells\\\"] >= percent_cells\\n var[\\\"highly_variable_features\\\"] = var[\\n \\\"robust\\\"\\n ] # default all robust genes are \\\"highly\\\" variable\",\n \"def calc_data(self):\\n\\n circ_counts = {}\\n for trialidx in range(self._ntrials):\\n for _, depth in enumerate(self._depths):\\n circ_name = 'qv_depth_%d_trial_%d' % (depth, trialidx)\\n\\n # get the counts form ALL executed circuits\\n count_list = []\\n for result in self._result_list:\\n try:\\n count_list.append(result.get_counts(circ_name))\\n except (QiskitError, KeyError):\\n pass\\n\\n circ_counts[circ_name] = \\\\\\n build_counts_dict_from_list(count_list)\\n\\n self._circ_shots[circ_name] = \\\\\\n sum(circ_counts[circ_name].values())\\n\\n # calculate the heavy output probability\\n self._heavy_output_counts[circ_name] = \\\\\\n self._subset_probability(\\n self._heavy_outputs[circ_name],\\n circ_counts[circ_name])\",\n \"def compute_metrics(self):\\n pass\",\n \"def collect_data(self):\\n exp_conf: ec.ExperimentConfiguration\\n # Disabled multiprocess run because of huge memory usage\\n processes_number = 1 # self._campaign_configuration['General']['j']\\n if processes_number == 1:\\n self._logger.info(\\\"-->Evaluate experiments (sequentially)\\\")\\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\\n exp_conf.evaluate()\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n exp_conf.generate_plots()\\n self._logger.info(\\\"<--\\\")\\n else:\\n self._logger.info(\\\"-->Evaluate experiments (in parallel)\\\")\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n self._logger.info(\\\"<--\\\")\\n\\n self.raw_results = {}\\n for exp_conf in self._exp_confs:\\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes\",\n \"def get_test_cases_coverage(session_id):\\n tc_stats={}\\n tc_stats_list=[]\\n total_executed=0\\n sql='SELECT DISTINCT(test_id) FROM stats WHERE session_id=:sid AND test_id!=\\\"null\\\"'\\n params={\\\"sid\\\":session_id}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n tests=c.fetchall()\\n conn.close()\\n if len(tests)>0:\\n for t in tests:\\n total_executed=0\\n sql=\\\"SELECT DISTINCT(file_id) FROM stats WHERE session_id=:sid AND test_id=:tid\\\"\\n params={\\\"sid\\\":session_id,\\\"tid\\\":t[0]}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n files=c.fetchall()\\n conn.close()\\n for f in files:\\n line_count=get_executable_lines_count_for_file(f[0])\\n # get executions\\n sql=\\\"SELECT COUNT(DISTINCT line_guid) FROM stats WHERE session_id= :sid AND file_id= :fid AND test_id=:tid\\\"\\n params={\\\"sid\\\":session_id,\\\"tid\\\":t[0],\\\"fid\\\":f[0]}\\n conn=sqlite3.connect(CONNECTION_STRING)\\n c=conn.cursor()\\n c.execute(sql,params)\\n executed=c.fetchone()\\n conn.close()\\n total_executed+=executed[0]\\n # save test case and it's executions\\n tc_stats={}\\n tc_stats[\\\"test_id\\\"]=t[0]\\n tc_stats[\\\"total_executed\\\"]=total_executed\\n tc_stats[\\\"total_executed\\\"]\\n \\n tc_stats_list.append(tc_stats)\\n return tc_stats_list\",\n \"def mgcEval(self):\\n import numpy as np\\n def report_to_df(report):\\n\\n \\\"\\\"\\\"\\n function to convert classification report to dataframe (for visualisation plot)\\n \\\"\\\"\\\"\\n\\n report = re.sub(r\\\" +\\\", \\\" \\\", report).replace(\\\"avg / total\\\", \\\"avg/total\\\").replace(\\\"\\\\n \\\", \\\"\\\\n\\\")\\n # update this due to sklearn classification report output change\\n report = re.sub(r\\\" +\\\", \\\" \\\", report).replace(\\\"micro avg\\\", \\\"micro_avg\\\").replace(\\\"macro avg\\\", \\\"macro_avg\\\").replace(\\\"weighted avg\\\", \\\"weighted_avg\\\").replace(\\\"\\\\n \\\", \\\"\\\\n\\\")\\n report_df = pd.read_csv(StringIO(\\\"Classes\\\" + report), sep=' ', index_col=0) \\n return(report_df)\\n \\n #txt report to df\\n class_rpttop1 = classification_report(self.y_true, self.y_pred)\\n df_report = report_to_df(class_rpttop1)\\n\\n df_report = df_report.iloc[:self.nb_classes, :].copy()\\n df_report.index = df_report.index.astype(int)\\n \\n\\n # classifier prediction metrics\\n def classMetrics(averagex):\\n precision, recall, fscore, support = score(self.y_true, self.y_pred, average=averagex)\\n \\n return(\\n print(''), \\n print('-------------{0:}--------------------'.format(averagex)), \\n print('precision: {0:.4f}'.format(precision)),\\n print('recall: {0:.4f}'.format(recall)),\\n print('fscore: {0:.4f}'.format(fscore)),\\n print(''),\\n print('kappa score: {0:.4f}'.format(cohen_kappa_score(self.y_true, self.y_pred))),\\n print('accuracy score: {0:.4f}'.format(accuracy_score(self.y_true, self.y_pred))))\\n \\n def predSamp():\\n\\n correct = np.nonzero(self.y_pred==self.y_true)[0]\\n incorrect = np.nonzero(self.y_pred!=self.y_true)[0]\\n\\n # quick check of the number of correct prediction from validation set\\n print(\\\"\\\")\\n print(\\\"correct/total = {0: .4f}\\\".format(len(correct)/(len(correct)+len(incorrect))))\\n print(\\\"total correct sample = {0: .0f}\\\".format(len(correct)))\\n print('------------------------------------------------------------------')\\n \\n def classReport():\\n print('----------------------------- Classfication Report -------------------------------')\\n print(classification_report(pd.Series(self.y_true).map(self.dict_label), pd.Series(self.y_pred).map(self.dict_label)))\\n \\n self.class_rpt = pd.concat([pd.DataFrame(pd.Series(df_report.index.tolist()).map(self.dict_label), columns = ['label']), df_report], axis = 1)\\n \\n self.classMetricsMac = classMetrics(\\\"macro\\\")\\n self.classMetricsMic = classMetrics(\\\"micro\\\")\\n self.predSample = predSamp()\\n self.class_rptTop1 = classReport()\\n \\n return self\",\n \"def calculate_dataset_metrics(self):\\n pass\",\n \"def run_tests():\\n with open(FILENAME) as file:\\n # Loads testing parameters from the yaml file.\\n tests = yaml.safe_load(file)\\n\\n # create a dataframe to keep the results\\n test_dict = tests['Tests']\\n results = pd.DataFrame(test_dict)\\n results['Last Average Score'] = \\\"\\\"\\n results['No of Q-Learning episodes'] = \\\"\\\"\\n\\n # run experiments:\\n for i, test in enumerate(test_dict):\\n grid = Rooms(test[\\\"env_size\\\"], testing=True)\\n learning = QLearning(grid, test[\\\"gamma\\\"], test[\\\"alpha\\\"], test[\\\"agent_start_pos\\\"])\\n e_greedy = Policy(\\\"e-greedy\\\", test[\\\"epsilon\\\"], test[\\\"decay\\\"])\\n greedy = Policy(policy_type=\\\"greedy\\\")\\n experiment = Experiments(grid, learning, greedy, test[\\\"iters\\\"],\\n test[\\\"agent_start_pos\\\"], test[\\\"test_no\\\"])\\n\\n for session in range(test[\\\"iters\\\"]):\\n learning.run_multiple_episodes(test[\\\"batch_episodes\\\"], e_greedy)\\n mean_reward = experiment.run_experiments(test[\\\"exp_per_batch\\\"])\\n\\n results.loc[i,'Last Average Score'] = mean_reward\\n results.loc[i,'No of Q-Learning episodes'] = (session + 1) * test[\\\"batch_episodes\\\"]\\n\\n # save results to csv file\\n filename = 'results/' + 'test_table.csv'\\n results.to_csv(filename)\\n\\n # plot & save graphs\\n experiment.generate_results(test[\\\"test_no\\\"], test)\\n\\n return results\",\n \"def test_evaluate(self):\\n # test normalized by 'bbox'\\n pck_metric = PCKAccuracy(thr=0.5, norm_item='bbox')\\n pck_metric.process(self.data_batch, self.data_samples)\\n pck = pck_metric.evaluate(self.batch_size)\\n target = {'PCK': 1.0}\\n self.assertDictEqual(pck, target)\\n\\n # test normalized by 'head_size'\\n pckh_metric = PCKAccuracy(thr=0.3, norm_item='head')\\n pckh_metric.process(self.data_batch, self.data_samples)\\n pckh = pckh_metric.evaluate(self.batch_size)\\n target = {'PCKh': 1.0}\\n self.assertDictEqual(pckh, target)\\n\\n # test normalized by 'torso_size'\\n tpck_metric = PCKAccuracy(thr=0.05, norm_item=['bbox', 'torso'])\\n tpck_metric.process(self.data_batch, self.data_samples)\\n tpck = tpck_metric.evaluate(self.batch_size)\\n self.assertIsInstance(tpck, dict)\\n target = {\\n 'PCK': 1.0,\\n 'tPCK': 1.0,\\n }\\n self.assertDictEqual(tpck, target)\",\n \"def initialize_metrics():\\n metrics = {\\n 'cd_losses': [],\\n 'cd_corrects': [],\\n 'cd_precisions': [],\\n 'cd_recalls': [],\\n 'cd_f1scores': [],\\n }\\n\\n return metrics\",\n \"def run_tests(self, validate=False):\\n fitness = 0\\n\\n for test_set in [self.debugger.PASS, self.debugger.FAIL]:\\n passed = self.run_test_set(test_set, validate=validate)\\n ratio = passed / len(self.debugger.collectors[test_set])\\n fitness += self.weight(test_set) * ratio\\n\\n return fitness\",\n \"def compute_metrics(self, results: list) -> dict:\",\n \"def run_test(self):\\n self.output_analytics = self.run_inference()\\n self.output_df = pd.DataFrame(self.output_analytics)\",\n \"def evaluate_benchmarks(self):\\n\\n # iterate over replicates\\n results = {}\\n for replicate_id, replicate in self.replicates:\\n\\n # evaluate benchmark for current replicate\\n bmark = SimulationBenchmark(replicate.copy(),\\n graph=self.graphs[replicate_id],\\n **self.params)\\n\\n # store results\\n results[replicate_id] = dict(\\n\\n labels_MAE=bmark.scores['labels'].MAE,\\n level_only_MAE=bmark.scores['level_only'].MAE,\\n spatial_only_MAE=bmark.scores['spatial_only'].MAE,\\n community_MAE=bmark.scores['labels_comm'].MAE,\\n\\n labels_PCT=bmark.scores['labels'].percent_correct,\\n level_only_PCT=bmark.scores['level_only'].percent_correct,\\n spatial_only_PCT=bmark.scores['spatial_only'].percent_correct,\\n community_PCT=bmark.scores['labels_comm'].percent_correct)\\n\\n # compile dataframe\\n results = pd.DataFrame.from_dict(results, orient='index')\\n results.index.set_names(self.multiindex, inplace=True)\\n\\n return results\",\n \"def _calculate_metrics(self):\\n metrics = {}\\n precision, recall = self.calc_precision_recall()\\n metrics[\\\"precision\\\"] = precision\\n metrics[\\\"recall\\\"] = recall\\n metrics[\\\"entropy\\\"] = self.calc_entropy()\\n metrics[\\\"component_entropy\\\"] = self.calc_component_entropy()\\n metrics[\\\"num_comps\\\"] = len(self.get_components())\\n metrics[\\\"num_diagnoses\\\"] = len(self.diagnoses)\\n metrics[\\\"distinct_diagnoses_scores\\\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\\n metrics[\\\"num_tests\\\"] = len(self.get_tests())\\n metrics[\\\"num_distinct_traces\\\"] = len(self.get_distinct_traces())\\n metrics[\\\"num_failed_tests\\\"] = len(self._get_tests_by_error(1))\\n metrics[\\\"num_passed_tests\\\"] = len(self._get_tests_by_error(0))\\n passed_comps = set(self._get_components_by_error(0))\\n failed_comps = set(self.get_components_in_failed_tests())\\n metrics[\\\"num_failed_comps\\\"] = len(failed_comps)\\n metrics[\\\"only_failed_comps\\\"] = len(failed_comps - passed_comps)\\n metrics[\\\"only_passed_comps\\\"] = len(passed_comps - failed_comps)\\n metrics[\\\"num_bugs\\\"] = len(self.get_bugs())\\n metrics[\\\"wasted\\\"] = self.calc_wasted_components()\\n metrics[\\\"top_k\\\"] = self.calc_top_k()\\n metrics[\\\"num_comps_in_diagnoses\\\"] = len(self._get_comps_in_diagnoses())\\n metrics[\\\"bugs_cover_ratio\\\"] = self._get_bugs_cover_ratio()\\n metrics[\\\"average_trace_size\\\"] = self._get_average_trace_size()\\n metrics[\\\"average_component_activity\\\"] = self._get_average_component_activity()\\n metrics[\\\"average_diagnosis_size\\\"] = self._get_average_diagnosis_size()\\n metrics[\\\"bugs_scores_average\\\"], metrics[\\\"bugs_scores_std\\\"], metrics[\\\"bugs_scores_entropy\\\"] = self._get_bugs_scores()\\n metrics[\\\"non_bugs_scores_average\\\"], metrics[\\\"non_bugs_scores_std\\\"], metrics[\\\"non_bugs_scores_entropy\\\"] = self._get_non_bugs_scores()\\n metrics.update(self.cardinality())\\n # metrics[\\\"ochiai\\\"] = self.calc_ochiai_values()\\n return metrics\",\n \"def run_tests():\\n with open(FILENAME) as file:\\n\\n # Loads the test hyper-parameters as dictionaries.\\n tests = yaml.safe_load(file)\\n \\n # create a dataframe to keep the results\\n test_dict = tests['Tests']\\n results = pd.DataFrame(test_dict)\\n results[\\\"Episode\\\"] = \\\"\\\"\\n results['Max average score'] = \\\"\\\"\\n\\n for i, test in enumerate(tests['Tests']):\\n\\n env = gym.make(test['env'])\\n env.reset()\\n\\n actor_critic = ActorCritic(env, test['episodes'], test['max_score'], \\n test['hidden_size'], test['gamma'], test['save'])\\n\\n ## run training \\n best_score, episode, rew_hist = actor_critic.train()\\n\\n results.loc[i,'Episode'] = episode\\n results.loc[i,'Max average score'] = best_score\\n\\n plot_graphs(test, rew_hist)\\n\\n # save results to csv file\\n filename = 'results/' + 'test_table.csv'\\n results.to_csv(filename)\\n\\n return results\",\n \"def evaluate(self):\\n results = dict()\\n for metric in self.metrics:\\n print('Evaluating clustering with metric %s' % metric)\\n if metric in LABEL_METRICS.keys():\\n results[metric] = LABEL_METRICS[metric](self.X, self.model.labels_)\\n results['adjusted_rand_score'] = SCORE_METRICS['adjusted_rand_score'](self.Y[:, 0], self.model.labels_)\\n self.results = results\\n return results\",\n \"def evaluate(self, test):\\r\\n self.logger.info(\\\"Testing model over test set\\\")\\r\\n metrics = self.run_evaluate(test)\\r\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\r\\n for k, v in metrics.items()])\\r\\n self.logger.info(msg)\\r\\n return metrics\",\n \"def run_faqc(self, **kwargs):\\n if self.qc is True:\\n build([FaQC.SummarizeQC(fastq_dic=self.fastq_dic,\\n num_cpus=self.num_cpus,\\n workdir=self.workdir)],\\n local_scheduler=self.local_scheduler,\\n workers=1)\\n qc_dic = {}\\n for samp, path in self.fastq_dic.items():\\n trim_dir = os.path.join(self.workdir, \\\"processes\\\", \\\"qc\\\", samp)\\n qc_dic[samp] = trim_dir + \\\"/\\\" + samp + \\\".1.trimmed.fastq\\\" + \\\":\\\" + \\\\\\n trim_dir + \\\"/\\\" + samp + \\\".2.trimmed.fastq\\\" \\n return qc_dic\\n\\n else:\\n return self.fastq_dic\",\n \"def make_metrics(self):\\n num_batches = self.data_loader.number_of_batches()\\n dose_score_vec = np.zeros(num_batches)\\n\\n # Only make calculations if data_loader is not empty\\n if not self.data_loader.file_paths_list:\\n print('No patient information was given to calculate metrics')\\n else:\\n # Change batch size to 1\\n self.data_loader.batch_size = 1 # Loads data related to ground truth patient information\\n if self.dose_loader is not None:\\n self.dose_loader.batch_size = 1 # Loads data related to ground truth patient information\\n\\n for idx in tqdm.tqdm(range(num_batches)):\\n # Get roi masks for patient\\n self.get_constant_patient_features(idx)\\n # Get dose tensors for reference dose and evaluate criteria\\n reference_dose = self.get_patient_dose_tensor(self.data_loader)\\n if reference_dose is not None:\\n self.reference_dose_metric_df = self.calculate_metrics(self.reference_dose_metric_df, reference_dose)\\n # If a dose loader was provided, calculate the score\\n if self.dose_loader is not None:\\n new_dose = self.get_patient_dose_tensor(self.dose_loader)\\n # Make metric data frames\\n self.new_dose_metric_df = self.calculate_metrics(self.new_dose_metric_df, new_dose)\\n # Evaluate mean absolute error of 3D dose\\n dose_score_vec[idx] = np.sum(np.abs(reference_dose - new_dose)) / np.sum(self.possible_dose_mask)\\n # Save metrics at the patient level (this is a template for how DVH stream participants could save\\n # their files\\n # self.dose_metric_df.loc[self.patient_list[0]].to_csv('{}.csv'.format(self.patient_list[0]))\\n\\n if self.dose_loader is not None:\\n dvh_score = np.nanmean(np.abs(self.reference_dose_metric_df - self.new_dose_metric_df).values)\\n dose_score = dose_score_vec.mean()\\n return dvh_score, dose_score\\n else:\\n print('No new dose provided. Metrics were only calculated for the provided dose.')\",\n \"def calculate_metrics(self):\\n self.data_stats = self.sqlContext.read.format(\\\"org.apache.spark.sql.cassandra\\\").options(table=self.cassandra_trip_table, keyspace=self.cassandra_keyspace).load()\\n self.data_stats = self.data_stats.groupBy(['time_block','day','month','borough_name']).agg(func.avg('num_trips').alias('mean'))\",\n \"def evaluate_data():\\n try:\\n # General system related info\\n ram = psutil.virtual_memory()\\n total_ram = round((ram.total / 1024 / 1024),2)\\n free_ram = round((ram.available / 1024 / 1024),2)\\n used_ram = round((ram.used / 1024 / 1024),2)\\n cpu_total = psutil.cpu_count(logical=True)\\n cpu_loadavg = round([x / cpu_total * 100 for x in psutil.getloadavg()][0],2)\\n acs_8080 = sp.getoutput(\\\"netstat -an|grep -c 8080\\\")\\n acs_8181 = sp.getoutput(\\\"netstat -an|grep -c 8181\\\")\\n acs_8443 = sp.getoutput(\\\"netstat -an|grep -c 8443\\\")\\n mysql = sp.getoutput(\\\"netstat -an|grep -c 3306\\\")\\n oracle = sp.getoutput(\\\"netstat -an|grep -c 1521\\\")\\n logging.info('General system info obtained')\\n except Exception as e:\\n logging.exception(f\\\"EXCEPTION: {e} \\\\n Full stack trace: \\\\n\\\", exc_info=1)\\n # Process specific details\\n try:\\n iis_pid = SystemInformation.get_pid(\\\"w3wp.exe\\\")\\n iis_ram = SystemInformation.get_ram_usage(iis_pid)\\n iis_cpu = SystemInformation.get_cpu_usage(iis_pid)\\n java_pid = SystemInformation.get_pid(\\\"java.exe\\\")\\n java_ram = SystemInformation.get_ram_usage(java_pid)\\n java_cpu = SystemInformation.get_cpu_usage(java_pid)\\n mysqld_pid = SystemInformation.get_pid(\\\"mysqld.exe\\\")\\n mysqld_ram = SystemInformation.get_ram_usage(mysqld_pid) \\n mysqld_cpu = SystemInformation.get_cpu_usage(mysqld_pid)\\n except Exception as e:\\n logging.exception(f\\\"EXCEPTION: {e} \\\\n Full stack trace: \\\\n\\\", exc_info=1)\\n\\n try:\\n dictionary = {}\\n now = datetime.datetime.now()\\n timestampt = now.strftime(\\\"%Y-%m-%d-%H:%M:%S\\\")\\n fieldnames = ['timestampt','total_ram','free_ram','used_ram','cpu_total','cpu_loadavg','acs_8080','acs_8181','acs_8443','mysql','oracle','iis_ram','iis_cpu','java_ram','java_cpu','mysqld_ram','mysqld_cpu']\\n for var in fieldnames:\\n dictionary[var] = eval(var)\\n \\n logging.info('Data for report generated')\\n return dictionary\\n except Exception as e:\\n logging.exception(f\\\"EXCEPTION: {e} \\\\n Full stack trace: \\\\n\\\", exc_info=1)\",\n \"def _cv_results(self, metrics):\\n\\n param_keys = self.param_combs[0].keys()\\n param_dict = {k: [comb[k] for comb in self.param_combs]\\n for k in param_keys}\\n df_metric_result = {k: pd.DataFrame({'Metric mean': self.mean[k],\\n 'Std. dev.': self.std[k],\\n **param_dict})\\n for k in metrics.keys()}\\n self.cv_results_ = df_metric_result\",\n \"def execute_testsets(testsets):\\n group_results = dict() #results, by group\\n group_failure_counts = dict()\\n total_failures = 0\\n myinteractive = False\\n\\n for testset in testsets:\\n mytests = testset.tests\\n myconfig = testset.config\\n mybenchmarks = testset.benchmarks\\n\\n #Make sure we actually have tests to execute\\n if not mytests and not mybenchmarks:\\n # no tests in this test set, probably just imports.. skip to next test set\\n break\\n\\n myinteractive = True if myinteractive or myconfig.interactive else False\\n\\n #Run tests, collecting statistics as needed\\n for test in mytests:\\n #Initialize the dictionaries to store test fail counts and results\\n if test.group not in group_results:\\n group_results[test.group] = list()\\n group_failure_counts[test.group] = 0\\n\\n result = run_test(test, test_config = myconfig)\\n result.body = None # Remove the body, save some memory!\\n\\n if not result.passed: #Print failure, increase failure counts for that test group\\n logging.error('Test Failed: '+test.name+\\\" URL=\\\"+test.url+\\\" Group=\\\"+test.group+\\\" HTTP Status Code: \\\"+str(result.response_code))\\n\\n if test.validators is not None:\\n for validator in test.validators:\\n if validator.passed == False:\\n logging.warning(\\\" Validation Failed: \\\" + str(validator))\\n\\n #Increment test failure counts for that group (adding an entry if not present)\\n failures = group_failure_counts[test.group]\\n failures = failures + 1\\n group_failure_counts[test.group] = failures\\n\\n else: #Test passed, print results\\n logging.info('Test Succeeded: '+test.name+\\\" URL=\\\"+test.url+\\\" Group=\\\"+test.group)\\n\\n #Add results for this test group to the resultset\\n group_results[test.group].append(result)\\n\\n # handle stop_on_failure flag\\n if not result.passed and test.stop_on_failure is not None and test.stop_on_failure:\\n print 'STOP ON FAILURE! stopping test set execution, continuing with other test sets'\\n break\\n\\n for benchmark in mybenchmarks: # Run benchmarks, analyze, write\\n if not benchmark.metrics:\\n logging.debug('Skipping benchmark, no metrics to collect')\\n continue\\n\\n logging.info(\\\"Benchmark Starting: \\\"+benchmark.name+\\\" Group: \\\"+benchmark.group)\\n curl = configure_curl(benchmark, myconfig)\\n benchmark_result = run_benchmark(curl, benchmark, myconfig)\\n print benchmark_result\\n logging.info(\\\"Benchmark Done: \\\"+benchmark.name+\\\" Group: \\\"+benchmark.group)\\n\\n if benchmark.output_file: # Write file\\n write_method = OUTPUT_METHODS[benchmark.output_format]\\n my_file = open(benchmark.output_file, 'w') # Overwrites file\\n logging.debug(\\\"Benchmark writing to file: \\\" + benchmark.output_file)\\n write_method(my_file, benchmark_result, benchmark, test_config = myconfig)\\n my_file.close()\\n\\n if myinteractive:\\n # a break for when interactive bits are complete, before summary data\\n print \\\"===================================\\\"\\n\\n #Print summary results\\n for group in sorted(group_results.keys()):\\n test_count = len(group_results[group])\\n failures = group_failure_counts[group]\\n total_failures = total_failures + failures\\n if (failures > 0):\\n print u'Test Group '+group+u' FAILED: '+ str((test_count-failures))+'/'+str(test_count) + u' Tests Passed!'\\n else:\\n print u'Test Group '+group+u' SUCCEEDED: '+ str((test_count-failures))+'/'+str(test_count) + u' Tests Passed!'\\n\\n return total_failures\",\n \"def execute(self, context):\\n redshift_hook = PostgresHook(postgres_conn_id=self.redshift_conn_id)\\n\\n for data_check in self.data_checks:\\n records = redshift_hook.get_records(data_check[\\\"sql\\\"])\\n num_records = records[0][0]\\n\\n assert (num_records != data_check[\\\"expected_result\\\"]) , \\\\\\n f\\\"Data quality test returned unexpected result.\\\"\\n\\n self.log.info('DataQualityOperator not implemented yet')\",\n \"def metrics(self):\\n raise NotImplementedError(\\\"metrics\\\")\",\n \"def do_system_evaluation(dataset, result_path, dataset_evaluation_mode='folds'):\\n\\n # Set warnings off, sklearn metrics will trigger warning for classes without\\n # predicted samples in F1-scoring. This is just to keep printing clean.\\n warnings.simplefilter(\\\"ignore\\\")\\n\\n overall_metrics_per_scene = {}\\n\\n for scene_id, scene_label in enumerate(dataset.scene_labels):\\n if scene_label not in overall_metrics_per_scene:\\n overall_metrics_per_scene[scene_label] = {}\\n\\n dcase2016_segment_based_metric = DCASE2016_EventDetection_SegmentBasedMetrics(class_list=dataset.event_labels(scene_label=scene_label))\\n dcase2016_event_based_metric = DCASE2016_EventDetection_EventBasedMetrics(class_list=dataset.event_labels(scene_label=scene_label))\\n\\n for fold in dataset.folds(mode=dataset_evaluation_mode):\\n results = []\\n result_filename = get_result_filename(fold=fold, scene_label=scene_label, path=result_path)\\n\\n if os.path.isfile(result_filename):\\n with open(result_filename, 'rt') as f:\\n for row in csv.reader(f, delimiter='\\\\t'):\\n results.append(row)\\n else:\\n raise IOError(\\\"Result file not found [%s]\\\" % result_filename)\\n\\n for file_id, item in enumerate(dataset.test(fold, scene_label=scene_label)):\\n current_file_results = []\\n for result_line in results:\\n if len(result_line) != 0 and result_line[0] == dataset.absolute_to_relative(item['file']):\\n current_file_results.append(\\n {'file': result_line[0],\\n 'event_onset': float(result_line[1]),\\n 'event_offset': float(result_line[2]),\\n 'event_label': result_line[3].rstrip()\\n }\\n )\\n meta = dataset.file_meta(dataset.absolute_to_relative(item['file']))\\n\\n dcase2016_segment_based_metric.evaluate(system_output=current_file_results, annotated_ground_truth=meta)\\n dcase2016_event_based_metric.evaluate(system_output=current_file_results, annotated_ground_truth=meta)\\n\\n overall_metrics_per_scene[scene_label]['segment_based_metrics'] = dcase2016_segment_based_metric.results()\\n overall_metrics_per_scene[scene_label]['event_based_metrics'] = dcase2016_event_based_metric.results()\\n\\n print \\\" Evaluation over %d folds\\\" % dataset.fold_count\\n print \\\" \\\"\\n print \\\" Results per scene \\\"\\n print \\\" {:18s} | {:5s} | | {:39s} \\\".format('', 'Main', 'Secondary metrics')\\n print \\\" {:18s} | {:5s} | | {:38s} | {:14s} | {:14s} | {:14s} \\\".format('', '', 'Seg/Overall','Seg/Class', 'Event/Overall','Event/Class')\\n print \\\" {:18s} | {:5s} | | {:6s} : {:5s} : {:5s} : {:5s} : {:5s} | {:6s} : {:5s} | {:6s} : {:5s} | {:6s} : {:5s} |\\\".format('Scene', 'ER', 'F1', 'ER', 'ER/S', 'ER/D', 'ER/I', 'F1', 'ER', 'F1', 'ER', 'F1', 'ER')\\n print \\\" -------------------+-------+ +--------+-------+-------+-------+-------+--------+-------+--------+-------+--------+-------+\\\"\\n averages = {\\n 'segment_based_metrics': {\\n 'overall': {\\n 'ER': [],\\n 'F': [],\\n },\\n 'class_wise_average': {\\n 'ER': [],\\n 'F': [],\\n }\\n },\\n 'event_based_metrics': {\\n 'overall': {\\n 'ER': [],\\n 'F': [],\\n },\\n 'class_wise_average': {\\n 'ER': [],\\n 'F': [],\\n }\\n },\\n }\\n for scene_id, scene_label in enumerate(dataset.scene_labels):\\n print \\\" {:18s} | {:5.2f} | | {:4.1f} % : {:5.2f} : {:5.2f} : {:5.2f} : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} |\\\".format(scene_label,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['F'] * 100,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['S'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['D'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['I'],\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F']*100,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'],\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['F']*100,\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['ER'],\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F']*100,\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'],\\n )\\n averages['segment_based_metrics']['overall']['ER'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['ER'])\\n averages['segment_based_metrics']['overall']['F'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['overall']['F'])\\n averages['segment_based_metrics']['class_wise_average']['ER'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'])\\n averages['segment_based_metrics']['class_wise_average']['F'].append(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F'])\\n averages['event_based_metrics']['overall']['ER'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['ER'])\\n averages['event_based_metrics']['overall']['F'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['overall']['F'])\\n averages['event_based_metrics']['class_wise_average']['ER'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'])\\n averages['event_based_metrics']['class_wise_average']['F'].append(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F'])\\n\\n print \\\" -------------------+-------+ +--------+-------+-------+-------+-------+--------+-------+--------+-------+--------+-------+\\\"\\n print \\\" {:18s} | {:5.2f} | | {:4.1f} % : {:5.2f} : {:21s} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} | {:4.1f} % : {:5.2f} |\\\".format('Average',\\n numpy.mean(averages['segment_based_metrics']['overall']['ER']),\\n numpy.mean(averages['segment_based_metrics']['overall']['F'])*100,\\n numpy.mean(averages['segment_based_metrics']['overall']['ER']),\\n ' ',\\n numpy.mean(averages['segment_based_metrics']['class_wise_average']['F'])*100,\\n numpy.mean(averages['segment_based_metrics']['class_wise_average']['ER']),\\n numpy.mean(averages['event_based_metrics']['overall']['F'])*100,\\n numpy.mean(averages['event_based_metrics']['overall']['ER']),\\n numpy.mean(averages['event_based_metrics']['class_wise_average']['F'])*100,\\n numpy.mean(averages['event_based_metrics']['class_wise_average']['ER']),\\n )\\n\\n print \\\" \\\"\\n # Restore warnings to default settings\\n warnings.simplefilter(\\\"default\\\")\\n print \\\" Results per events \\\"\\n\\n for scene_id, scene_label in enumerate(dataset.scene_labels):\\n print \\\" \\\"\\n print \\\" \\\"+scene_label.upper()\\n print \\\" {:20s} | {:30s} | | {:15s} \\\".format('', 'Segment-based', 'Event-based')\\n print \\\" {:20s} | {:5s} : {:5s} : {:6s} : {:5s} | | {:5s} : {:5s} : {:6s} : {:5s} |\\\".format('Event', 'Nref', 'Nsys', 'F1', 'ER', 'Nref', 'Nsys', 'F1', 'ER')\\n print \\\" ---------------------+-------+-------+--------+-------+ +-------+-------+--------+-------+\\\"\\n seg_Nref = 0\\n seg_Nsys = 0\\n\\n event_Nref = 0\\n event_Nsys = 0\\n for event_label in sorted(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise']):\\n print \\\" {:20s} | {:5d} : {:5d} : {:4.1f} % : {:5.2f} | | {:5d} : {:5d} : {:4.1f} % : {:5.2f} |\\\".format(event_label,\\n int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nref']),\\n int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nsys']),\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['F']*100,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['ER'],\\n int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nref']),\\n int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nsys']),\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['F']*100,\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['ER'])\\n seg_Nref += int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nref'])\\n seg_Nsys += int(overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise'][event_label]['Nsys'])\\n\\n event_Nref += int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nref'])\\n event_Nsys += int(overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise'][event_label]['Nsys'])\\n print \\\" ---------------------+-------+-------+--------+-------+ +-------+-------+--------+-------+\\\"\\n print \\\" {:20s} | {:5d} : {:5d} : {:14s} | | {:5d} : {:5d} : {:14s} |\\\".format('Sum',\\n seg_Nref,\\n seg_Nsys,\\n '',\\n event_Nref,\\n event_Nsys,\\n '')\\n print \\\" {:20s} | {:5s} {:5s} : {:4.1f} % : {:5.2f} | | {:5s} {:5s} : {:4.1f} % : {:5.2f} |\\\".format('Average',\\n '', '',\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['F']*100,\\n overall_metrics_per_scene[scene_label]['segment_based_metrics']['class_wise_average']['ER'],\\n '', '',\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['F']*100,\\n overall_metrics_per_scene[scene_label]['event_based_metrics']['class_wise_average']['ER'])\\n print \\\" \\\"\",\n \"def compute_statistics(self):\",\n \"def evaluate(self, test):\\n self.logger.info(\\\"Testing model over test set\\\")\\n metrics = self.run_evaluate(test)\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\n for k, v in metrics.items()])\\n self.logger.info(msg)\\n return metrics\",\n \"def evaluate(self, dataset):\\n logging.info('Start evaluation')\\n\\n loss, predictions, labels = self.run_one_epoch(dataset, RunnerPhase.VALIDATE)\\n\\n metrics_dict = self.metric_class.get_metrics_dict(predictions, labels)\\n\\n eval_info = self.metric_class.metrics_dict_to_str(metrics_dict)\\n\\n logging.info(eval_info)\\n\\n logging.info('Evaluation finished')\\n\\n return metrics_dict\",\n \"def compute_metrics(self, train_data, test_data, criterion):\\n m = self.metrics\\n warnings.filterwarnings('ignore','Mean of empty slice')\\n\\n ## load data\\n trn, trn_labs = train_data\\n tst, tst_labs = test_data\\n\\n # trn = trn.transpose(1,0)\\n tst = tst.transpose(1,0)\\n\\n t_final = -(np.flipud(trn!=self.padding).argmax(0)+1)\\n test_tfinal = -(np.flipud(tst!=self.padding).argmax(0)+1)\\n\\n ntest = tst.size(1)\\n P = self.decoder.out_features\\n\\n ## training data ###########################################################\\n # hidden = self.init_hidden(trn.size(1))\\n # out, hidden = self.transparent_forward(trn, hidden)\\n # # output = out[t_final, np.arange(trn.size(1)), :]\\n # output = out.squeeze()\\n # # compute orthogonality\\n # mem_act = np.array([np.cumsum(trn==p,axis=0).int().detach().numpy() % 2 \\\\\\n # for p in range(self.q_)]).transpose((1,2,0))\\n\\n # ps_clf = LinearDecoder(self, 2**(self.q_-1), MeanClassifier)\\n # ps = []\\n # for d in Dichotomies(mem_act, 'simple'):\\n # np.warnings.filterwarnings('ignore',message='invalid value encountered in')\\n # ps_clf.fit(hidden.detach().numpy(), d)\\n # new_ps = ps_clf.orthogonality()\\n # ps.append(new_ps)\\n # # if new_ps > ps:\\n # # ps = new_ps\\n # m['train_parallelism'] = np.append(m['train_parallelism'], np.array(ps).T, axis=0)\\n\\n # # print(mem_act.shape)\\n # # print(hidden.shape)\\n # # self.orth_clf.fit(hidden.detach().numpy(), mem_act)\\n # # orth_score = self.orth_clf.orthogonality()\\n # # m['train_orthogonality'] = np.append(m['train_orthogonality'], orth_score)\\n\\n ## test data ##############################################################\\n hidden = self.init_hidden(tst.size(1))\\n out, hidden = self.transparent_forward(tst, hidden)\\n # output = out.squeeze()\\n # print(hidden.shape)\\n # print(out.shape)\\n # print(test_tfinal)\\n output = out[test_tfinal, np.arange(tst.size(1)), :]\\n # raise Exception\\n\\n # compute loss\\n test_loss = criterion(output.squeeze(0),tst_labs.squeeze())\\n\\n m['test_loss'] = np.append(m['test_loss'], test_loss.item())\\n\\n # compute orthogonality\\n # mem_act = np.array([np.cumsum(tst==p,axis=0).int().detach().numpy() % 2 \\\\\\n # for p in range(self.q_)]).transpose((1,2,0))\\n\\n # # self.orth_clf.fit(hidden.detach().numpy(), mem_act)\\n # # orth_score = self.orth_clf.orthogonality()\\n # # m['test_orthogonality'] = np.append(m['test_orthogonality'], orth_score)\\n\\n # # compute parallelism\\n # ps_clf = LinearDecoder(self, 2**(self.q_-1), MeanClassifier)\\n # ps = []\\n # for d in Dichotomies(mem_act, 'simple'):\\n # np.warnings.filterwarnings('ignore',message='invalid value encountered in')\\n # ps_clf.fit(hidden.detach().numpy(), d)\\n # new_ps = ps_clf.orthogonality()\\n # ps.append(new_ps)\\n # # if new_ps > ps:\\n # # ps = new_ps\\n # m['test_parallelism'] = np.append(m['test_parallelism'], np.array(ps).T, axis=0)\\n\\n ## package #################################################################\\n self.metrics = m\\n warnings.filterwarnings('default')\",\n \"def test_get_qc_metrics(integrated_ff):\\n\\n key, ff_env = integrated_ff['ff_key'], integrated_ff['ff_env']\\n uuid = '331106bc-8535-3338-903e-854af460b544'\\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, key=key, ff_env=ff_env)\\n assert len(qc_metrics.keys()) == 1\\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\\n target_qc = qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']\\n assert 'QualityMetric' in target_qc['values']['@type']\\n assert target_qc['organism'] == 'human'\\n assert target_qc['experiment_type'] == 'Dilution Hi-C'\\n assert target_qc['experiment_subclass'] == 'Hi-C'\\n assert target_qc['source_file_association'] == 'processed_files'\\n assert target_qc['source_experiment'] == '4DNEXO67APV1'\\n assert target_qc['source_experimentSet'] == '4DNESOPFAAA1'\\n assert target_qc['biosource_summary'] == \\\"GM12878\\\"\\n\\n kwargs = { # do same as above w/ kwargs, specify to include raw files this time\\n 'key': key,\\n 'ff_env': ff_env,\\n 'include_raw_files': True\\n }\\n qc_metrics = ff_utils.get_associated_qc_metrics(uuid, **kwargs)\\n assert len(qc_metrics.keys()) == 2\\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in qc_metrics\\n assert '4c9dabc6-61d6-4054-a951-c4fdd0023800' in qc_metrics\\n assert 'QualityMetric' in qc_metrics['131106bc-8535-4448-903e-854abbbbbbbb']['values']['@type']\\n assert 'QualityMetric' in qc_metrics['4c9dabc6-61d6-4054-a951-c4fdd0023800']['values']['@type']\",\n \"def compute_statistics(self):\\n for i in range(len(self.wine_matrix[0, :])):\\n feature = self.wine_matrix[:, i]\\n self.wine_stats['feature ' + str(i)] = {}\\n if i == 11: # results column\\n self.wine_stats['feature ' + str(i)]['positive_class_ratio'] = (feature == 1).sum() / len(feature)\\n null, self.wine_stats['feature ' + str(i)]['pvalue'] = stats.normaltest(feature)\\n\\n # plot\\n # pyplot.hist(feature, bins=50)\\n # pyplot.show()\\n\\n for i in range(len(self.cancer_matrix[0, :])):\\n feature = self.cancer_matrix[:, i]\\n self.cancer_stats['feature ' + str(i)] = {}\\n if i == 10: # results column\\n self.cancer_stats['feature ' + str(i)]['positive_class_ratio'] = (feature == 1).sum() / len(feature)\\n null, self.cancer_stats['feature ' + str(i)]['pvalue'] = stats.normaltest(feature)\\n\\n # plot\\n # pyplot.hist(feature, bins=50)\\n # pyplot.show()\",\n \"def _run():\\n subprocess.check_call(\\n [\\n \\\"tools/bazel\\\",\\n \\\"build\\\",\\n \\\"-c\\\",\\n \\\"opt\\\",\\n \\\"test/core/memory_usage/memory_usage_test\\\",\\n ]\\n )\\n ret = {}\\n for name, benchmark_args in _BENCHMARKS.items():\\n for scenario, extra_args in _SCENARIOS.items():\\n # TODO(chenancy) Remove when minstack is implemented for channel\\n if name == \\\"channel\\\" and scenario == \\\"minstack\\\":\\n continue\\n try:\\n output = subprocess.check_output(\\n [\\n \\\"bazel-bin/test/core/memory_usage/memory_usage_test\\\",\\n ]\\n + benchmark_args\\n + extra_args\\n )\\n except subprocess.CalledProcessError as e:\\n print(\\\"Error running benchmark:\\\", e)\\n continue\\n for line in output.splitlines():\\n for key, (pattern, conversion) in _INTERESTING.items():\\n m = re.match(pattern, line)\\n if m:\\n ret[scenario + \\\": \\\" + key] = conversion(m.group(1))\\n return ret\",\n \"def session_counting (self, target_dict, IEI_timeRange = (0, 900, 1), cal_IEI = True, cal_duration = True, cal_latency = True, cal_inputDistribution = True, num_bins = 10, **kwards):\\r\\n if len(self.df) == 0:\\r\\n #if empty then pass without analysis\\r\\n pass\\r\\n else:\\r\\n get_kwards = lambda x: (\\\"\\\",\\\"\\\") if x == None else x\\r\\n input1OnOff = get_kwards(kwards.get('Input1OnOff'))\\r\\n input2OnOff = get_kwards(kwards.get('Input2OnOff'))\\r\\n input3OnOff = get_kwards(kwards.get('Input3OnOff'))\\r\\n input4OnOff = get_kwards(kwards.get('Input4OnOff'))\\r\\n \\r\\n #get a start and end time point\\r\\n if 'Start' in self.df['States'].values:\\r\\n start = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Start')]['Time']\\r\\n else:\\r\\n start = pd.Series({'Start': self.df['Time'].values[0]-1})\\r\\n \\r\\n if 'Finish' in self.df['States'].values:\\r\\n end = self.df[(self.df['Events'] == '') & (self.df['States'] == 'Finish')]['Time']\\r\\n else:\\r\\n end = pd.Series({'Finish': self.df['Time'].values[-1]+1}) #plus 1 second\\r\\n \\r\\n #get data from each event window\\r\\n event = self.df[(self.df['Time']>= start.iloc[0])&(self.df['Time']<= end.iloc[0])]\\r\\n \\r\\n result_dict = {}\\r\\n for k, v in target_dict.items():\\r\\n \\r\\n if k == 'Input1':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input1OnOff)\\r\\n elif k == 'Input2':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input2OnOff)\\r\\n elif k == 'Input3':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input3OnOff)\\r\\n elif k == 'Input4':\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject, IEI_timeRange, cal_IEI, cal_duration, cal_latency, cal_inputDistribution, num_bins, InputOnOff = input4OnOff)\\r\\n else:\\r\\n result_dict [v[1]] = self.__counting (event, v, self.subject)\\r\\n \\r\\n return result_dict\",\n \"def metric_tests(self, metric_tests: Dict[str, FAIRResultEvaluationCriterium]):\\n\\n self._metric_tests = metric_tests\",\n \"def evaluate(self, benchmark_data, metrics={}, options={}):\\n dir_name = list(benchmark_data.keys())[0]\\n relations = list(benchmark_data.values())[0]\\n \\n if \\\"relation\\\" in options :\\n relations = [options[\\\"relation\\\"]]\\n \\n precision_total = 0\\n for relation in relations :\\n if relation.endswith(\\\"_inv\\\") :\\n continue\\n relation = relation.replace(\\\":\\\", \\\"_\\\")\\n evaluate.setup(relation, dir_name)\\n precision_total += evaluate.evaluate_logic()\\n \\n result = {}\\n result[\\\"MAP\\\"] = precision_total/len(relations)\\n\\n return result\",\n \"def makedata():\\n # train\\n print('Clean Train Dataset and separate questions')\\n df = pd.read_csv(TRAIN_DATASET).replace(np.nan, ' ')\\n t = df.shape[0] * 2\\n print t\\n df['question1'] = cleanText(df['question1'])\\n df['question2'] = cleanText(df['question2'])\\n\\n df.to_csv(os.path.join(rootpathdata_cleaned, 'train.csx'), index=False)\\n overallquestions = df['question1'].tolist() + df['question2'].tolist()\\n tpm = pd.DataFrame()\\n tpm['question'] = overallquestions\\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'train_allquestions.csx'), index=False)\\n # test\\n\\n print('Clean Test Dataset and separate questions')\\n df = pd.read_csv(TEST_DATASET).fillna(' ')\\n t1 = df.shape[0] * 2\\n df['question1'] = cleanText(df['question1'])\\n df['question2'] = cleanText(df['question2'])\\n df.to_csv(os.path.join(rootpathdata_cleaned, 'test.csx'), index=False)\\n\\n overallquestions += df['question1'].tolist() + df['question2'].tolist()\\n tpm = pd.DataFrame()\\n tpm['question'] = overallquestions\\n tpm.to_csv(os.path.join(rootpathdata_cleaned, 'test_allquestions.csx'), index=False)\\n print len(overallquestions), t1 + t\",\n \"def get_chartdata():\\n callback = bottle.request.query.get('callback')\\n y_axis = bottle.request.query.get('y_axis').strip()\\n w_acts = [\\\"action='%s'\\\" % act for act in bottle.request.query.get('actions').strip().split(',')]\\n w_acts = 'AND (%s)' % ' OR '.join(w_acts) if w_acts else ''\\n f_value = 'AVG(latency)' if y_axis.startswith('avg') else 'COUNT(timestamp)'\\n atomic = 1 if y_axis in ['aops', 'avgl'] else 0\\n\\n db_conn = tools.get_db_conn('%s.db' % bottle.request.query.test_run_id)\\n sql = 'SELECT test_run_status, timestamp_started, timestamp_completed FROM info LIMIT 1'\\n status, started, finished = tools.db_query(db_conn, sql)[1][0]\\n progress = int(float(finished) - float(started)) if finished \\\\\\n else int(tools.get_timestamp() - float(started))\\n\\n sql = 'SELECT substr(timestamp, 0, 11), code, %s FROM recs ' % f_value + \\\\\\n 'WHERE atomic=%s %s GROUP BY code, substr(timestamp, 0, 11) ' % (atomic, w_acts) + \\\\\\n 'ORDER BY id DESC LIMIT 3600' # last 1 hour activity\\n\\n result = tools.db_query(db_conn, sql)[1] if finished else tools.db_query(db_conn, sql)[1][:-1]\\n result = list(reversed(result))\\n results = {str(abs(int(item[0]) - int(float(started)))):\\n {'failed': 0, 'passed': 0, 'incomplete': 0} for item in result}\\n for item in result: # item[0] - timestamp, item[1] - code (None if incomplete), item[2] - value\\n timestamp = str(int(item[0]) - int(float(started)))\\n value = item[2] or 0\\n results[timestamp]['failed'] += value if item[1] and item[1] != 200 else 0\\n results[timestamp]['passed'] += value if item[1] == 200 else 0\\n results[timestamp]['incomplete'] += value if item[1] == None else 0\\n results = [{'timestamp': key, 'failed': value['failed'], 'passed': value['passed'],\\n 'incomplete': value['incomplete']} for key, value in results.items()]\\n result = {bottle.request.query.slave: results, 'status': status,\\n 'started': started, 'finished': finished or '(not finished)', 'progress': progress}\\n return '{0}({1})'.format(callback, result)\",\n \"def test_scores(self) -> np.ndarray:\\n return np.asarray(self.test_metric_dict[self.metric_name])\",\n \"def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\\n hist = {k: {} for k in {\\\"mks0\\\", \\\"mks1\\\", \\\"mks2\\\", \\\"l\\\"}} # pylint: disable=C0208\\n wei = {k: {} for k in hist}\\n res[\\\"hist\\\"] = hist\\n res[\\\"histnow\\\"] = wei\\n\\n for el, _ in self.enumerate_test_metric(qset):\\n le = len(el.value)\\n w = el.weight\\n res[\\\"mks0\\\"] += w * el.mks0\\n res[\\\"mks1\\\"] += w * el.mks1\\n res[\\\"mks2\\\"] += w * el.mks2\\n res[\\\"sum_weights\\\"] += w\\n res[\\\"sum_wlen\\\"] += w * le\\n res[\\\"n\\\"] += 1\\n\\n if el.mks0 not in hist[\\\"mks0\\\"]:\\n hist[\\\"mks0\\\"][el.mks0] = w\\n wei[\\\"mks0\\\"][el.mks0] = 1\\n else:\\n hist[\\\"mks0\\\"][el.mks0] += w\\n wei[\\\"mks0\\\"][el.mks0] += 1\\n if el.mks1 not in hist[\\\"mks1\\\"]:\\n hist[\\\"mks1\\\"][el.mks1] = w\\n wei[\\\"mks1\\\"][el.mks1] = 1\\n else:\\n hist[\\\"mks1\\\"][el.mks1] += w\\n wei[\\\"mks1\\\"][el.mks1] += 1\\n if el.mks2 not in hist[\\\"mks2\\\"]:\\n hist[\\\"mks2\\\"][el.mks2] = w\\n wei[\\\"mks2\\\"][el.mks2] = 1\\n else:\\n hist[\\\"mks2\\\"][el.mks2] += w\\n wei[\\\"mks2\\\"][el.mks2] += 1\\n if le not in hist[\\\"l\\\"]:\\n hist[\\\"l\\\"][le] = w\\n wei[\\\"l\\\"][le] = 1\\n else:\\n hist[\\\"l\\\"][le] += w\\n wei[\\\"l\\\"][le] += 1\\n return res\",\n \"def metrics_evaluation(y_true, y_prob, threshold, df_type='train'):\\n\\n y_pred = (y_prob>=threshold).astype(int)\\n \\n tn = metrics.confusion_matrix(y_true, y_pred)[0][0]\\n fp = metrics.confusion_matrix(y_true, y_pred)[0][1]\\n fn = metrics.confusion_matrix(y_true, y_pred)[1][0]\\n tp = metrics.confusion_matrix(y_true, y_pred)[1][1]\\n\\n accuracy_scr = metrics.accuracy_score(y_true, y_pred)\\n precision_scr = metrics.precision_score(y_true, y_pred)\\n recall_scr = metrics.recall_score(y_true, y_pred)\\n f1_scr = metrics.f1_score(y_true, y_pred)\\n roc_auc_scr = metrics.roc_auc_score(y_true, y_pred)\\n\\n result = {'Dataset': df_type, 'No obs': len(y_true), 'Threshold': threshold,\\n 'TP':tp, 'FP': fp, 'TN': tn, 'FN':fn , \\n 'Accuracy Score':accuracy_scr, 'Precision Score':precision_scr, \\n 'Recall Score':recall_scr, 'F1 Score':f1_scr, 'ROC AUC Score':roc_auc_scr}\\n\\n return result\",\n \"def set_metrics(self):\",\n \"def prepareAccumulatedMetrics(self):\\n displayDF = analyzeMetricsDF(self.resultList)\\n displayDF.to_csv(\\\"data/results.csv\\\")\",\n \"def test_get_qc_metrics_logic_unit():\\n with mock.patch(\\\"dcicutils.ff_utils.get_metadata\\\") as mock_get_metadata:\\n mock_get_metadata.side_effect = mocked_get_metadata_from_data_files\\n print() # start output on a fresh line\\n input_uuid = \\\"431106bc-8535-4448-903e-854af460b260\\\"\\n result = ff_utils.get_associated_qc_metrics(input_uuid)\\n assert \\\"131106bc-8535-4448-903e-854abbbbbbbb\\\" in result # quick pre-test\\n assert result == get_mocked_result(kind='QC metrics',\\n dirname='test_qc_metrics',\\n uuid=input_uuid)\",\n \"def calc_metrics(data, sampled_data_list, dataset_type):\\n result={}\\n for sampled_data in sampled_data_list:\\n c2st_roc_auc_metric = c2st_roc_auc(data, sampled_data)\\n if \\\"c2st_roc_auc\\\" in result:\\n result[\\\"c2st_roc_auc\\\"].append(c2st_roc_auc_metric)\\n else:\\n result[\\\"c2st_roc_auc\\\"] = [c2st_roc_auc_metric]\\n mmd_p_val, mmd_stat = rbf_mmd_test(data.values, sampled_data.values)\\n if \\\"mmd_p_val\\\" in result:\\n result[\\\"mmd_p_val\\\"].append(mmd_p_val)\\n result[\\\"mmd_stat\\\"].append(mmd_stat)\\n else:\\n result[\\\"mmd_p_val\\\"] = [mmd_p_val]\\n result[\\\"mmd_stat\\\"] = [mmd_stat]\\n ks_p_val, ks_stat, ks_n, ks_p_val_list, ks_stat_list = ks_test(data, sampled_data)\\n if dataset_type != \\\"norm_dataset\\\":\\n ks_p_val = ks_permutation(ks_stat_list, data, sampled_data)\\n if \\\"ks_p_val\\\" in result:\\n result[\\\"ks_p_val\\\"].append(ks_p_val)\\n result[\\\"ks_stat\\\"].append(ks_stat)\\n else:\\n result[\\\"ks_p_val\\\"] = [ks_p_val]\\n result[\\\"ks_stat\\\"] = [ks_stat]\\n acc_r, acc_g = c2st_accuracy(data, sampled_data)\\n if \\\"c2st_acc_r\\\" in result:\\n result[\\\"c2st_acc_r\\\"].append(acc_r)\\n result[\\\"c2st_acc_g\\\"].append(acc_g)\\n else:\\n result[\\\"c2st_acc_r\\\"] = [acc_r]\\n result[\\\"c2st_acc_g\\\"] = [acc_g]\\n return result\",\n \"def test_evaluate(self):\\n # test normalized by 'head_size'\\n mpii_pck_metric = MpiiPCKAccuracy(thr=0.3, norm_item='head')\\n mpii_pck_metric.process(self.data_batch, self.data_samples)\\n pck_results = mpii_pck_metric.evaluate(self.batch_size)\\n target = {\\n 'Head PCK': 100.0,\\n 'Shoulder PCK': 100.0,\\n 'Elbow PCK': 100.0,\\n 'Wrist PCK': 100.0,\\n 'Hip PCK': 100.0,\\n 'Knee PCK': 100.0,\\n 'Ankle PCK': 100.0,\\n 'PCK': 100.0,\\n 'PCK@0.1': 100.0,\\n }\\n self.assertDictEqual(pck_results, target)\",\n \"def _compute_experiment_statistics(self):\\n pass\",\n \"def _evaluate(self) -> dict:\\n self.load()\\n self.evaluate_all()\\n self.finalize_results()\\n log.debug(\\\"Clearing global instrumentation variables\\\")\\n del_globals()\",\n \"def measure(self,qc,qb,cb):\\n if isinstance(qb,list) and isinstance(cb,list):\\n assert len(qb) == len(cb)\\n for q,c in zip(qb,cb):\\n qc.measure(q,c)\\n else:\\n qc.measure(qb,cb)\\n if self.ibmq:\\n job = qk.execute(qc, \\n backend = self.backend, \\n shots=self.shots,\\n optimization_level=self.optimization_level,\\n initial_layout=self.layout)\\n self.monitor(job)\\n else:\\n job = qk.execute(qc, \\n backend = self.backend, \\n shots=self.shots,\\n optimization_level=self.optimization_level,\\n noise_model=self.noise_model,\\n coupling_map=self.coupling_map,\\n basis_gates=self.basis_gates,\\n initial_layout=self.layout,\\n seed_transpiler=self.seed,\\n seed_simulator=self.seed)\\n return job.result().get_counts(qc)\",\n \"def test_run(id_, args, kwargs, expected):\\n # Remove results for test.\\n results_path = expected['results_path']\\n shutil.rmtree(results_path, ignore_errors=True)\\n # Start code.\\n # [future] attempts to run classification with n_jobs>1\\n # global cnfg_default\\n # sys.modules['cnfg_default'] = get_params(args[0], 'cnfg_default')\\n # import cnfg_default\\n # #from cnfg_default import custom_score_metric\\n objects = pycnfg.run(oid='default', *args, **kwargs)\\n tmp = {k: type(v).__name__ for k, v in objects.items()}\\n print('OBJECTS:')\\n print(tmp)\\n # Compare results:\\n # * Compare objects (keys and str of values).\\n objects_ = expected['objects']\\n objects = {k: type(v).__name__ for k, v in objects.items()}\\n if objects != objects_:\\n print(set(objects.items()) ^ set(objects_.items()))\\n assert objects == objects_\\n # for k, v in objects.items():\\n # assert k in objects_\\n # assert type(v).__name__ == objects_[k]\\n # * Compare predictions csv(all available).\\n pred_path = glob.glob(f\\\"{results_path}/models/*_pred.csv\\\")\\n pred_path_ = glob.glob(expected['pred_path'])\\n assert len(pred_path) == len(pred_path_)\\n for act, exp in zip(sorted(pred_path), sorted(pred_path_)):\\n file_diff(act, exp)\\n assert filecmp.cmp(act, exp)\\n # * Compare test logs.\\n logs_path = glob.glob(f\\\"{results_path}/logs*/*_test.log\\\")[0]\\n logs_path_ = expected['logs_path']\\n file_diff(logs_path, logs_path_)\\n assert filecmp.cmp(logs_path, logs_path_)\\n # * Compare runs dataframe, non-universe columns.\\n runs_path = f\\\"{results_path}/runs\\\"\\n runs_path_ = expected['runs_path']\\n df = runs_loader(runs_path)\\n df_ = runs_loader(runs_path_)\\n # First False/True for each element, then check all by columns.\\n # col1 True\\n # col2 False\\n # dtype: bool\\n df_diff = df.eq(df_).all()\\n # Column names that are not equal.\\n columns = sorted(list(df_diff[df_diff==False].dropna().index))\\n # columns_eq = sorted(list(df_diff[df_diff==True].dropna().index))\\n columns_ = expected['columns_diff']\\n print('DIFF:\\\\n', columns)\\n time.sleep(1)\\n # assert columns == columns_\\n # * Compare model.\\n model_path = glob.glob(f\\\"{results_path}/models/*.model\\\")\\n model_path_ = glob.glob(expected['model_path'])\\n assert len(model_path) == len(model_path_)\\n for act, exp in zip(sorted(model_path), sorted(model_path_)):\\n assert filecmp.cmp(act, exp)\\n return\",\n \"def run(self):\\n question_stats = self.MultipleChoiceQuestionAggregator(self._course)\\n mapper = models_utils.QueryMapper(\\n EventEntity.all(), batch_size=500, report_every=1000)\\n mapper.run(question_stats.visit)\\n return (question_stats.id_to_questions_dict,\\n question_stats.id_to_assessments_dict)\",\n \"def __dataset_statistics(self) -> None:\\n # Print the expressions\\n print(f'Available expressions: {self.idx_to_expression.values()}')\\n \\n # Print dataset cardinalities\\n stats_table = PrettyTable()\\n stats_table.field_names = ['Train samples', 'PublicTest samples', 'PrivateTest samples', 'Number of expressions']\\n stats_table.add_row([len(self.db[self.db['Usage'] == 'Training']), len(self.db[self.db['Usage'] == 'PublicTest']), len(self.db[self.db['Usage'] == 'PrivateTest']), len(self.db.expression.unique().tolist())])\\n print(stats_table)\\n \\n def eval_class_cardinality(expressions: list, train: str) -> [list, list]:\\n cardinality = [len(self.db[(self.db['expression']==expr) & (self.db['Usage']==train)]) for expr in expressions]\\n frac = [len(self.db[(self.db['expression']==expr) & (self.db['Usage']==train)])/len(self.db[self.db['Usage']==train]) for expr in expressions]\\n return cardinality, frac\\n\\n expressions = self.db.expression.unique()\\n expressions.sort()\\n \\n # Print expressions statistics --> Training \\n stats_table = PrettyTable()\\n stats_table.title = 'Training Samples'\\n stats_table.field_names = [self.idx_to_expression[label] for label in expressions]\\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='Training')\\n stats_table.add_row(cardinality)\\n stats_table.add_row(frac)\\n\\n # Print expressions statistics --> Validation \\n stats_table2 = PrettyTable()\\n stats_table2.title = 'Validation Samples'\\n stats_table2.field_names = [self.idx_to_expression[label] for label in expressions]\\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='PublicTest')\\n stats_table2.add_row(cardinality)\\n stats_table2.add_row(frac)\\n\\n # Print expressions statistics --> Test \\n stats_table3 = PrettyTable()\\n stats_table3.title = 'Test Samples'\\n stats_table3.field_names = [self.idx_to_expression[label] for label in expressions]\\n cardinality, frac = eval_class_cardinality(expressions=expressions, train='PrivateTest')\\n stats_table3.add_row(cardinality)\\n stats_table3.add_row(frac)\\n \\n print(stats_table)\\n print(stats_table2)\\n print(stats_table3)\",\n \"def test_metrics(self):\\n # Check the route\\n self.check_metrics(self.test_metrics_submission_id, False, \\\"award\\\")\\n self.check_metrics(self.test_metrics_submission_id, True, \\\"award_financial\\\")\\n self.check_metrics(self.test_metrics_submission_id, True, \\\"appropriations\\\")\",\n \"def _perform_measurement(self, qubits: Sequence['cirq.Qid']) -> List[int]:\\n return [self.state._measure(self.qubit_map[q], self.prng) for q in qubits]\",\n \"def _eval_classifier(self):\\n\\n y_pred_baseline = self.df_baseline[self.score_column]\\n y_pred_sample = self.df_sample[self.score_column]\\n\\n y_label_baseline = self.df_baseline[self.label_column]\\n y_label_sample = self.df_sample[self.label_column]\\n\\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\\n try:\\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\\n except ValueError:\\n auc_baseline = \\\"NA\\\"\\n\\n precision_sample = precision_score(y_label_sample, y_pred_sample)\\n recall_sample = recall_score(y_label_sample, y_pred_sample)\\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\\n f1_sample = f1_score(y_label_sample, y_pred_sample)\\n try:\\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\\n except ValueError:\\n auc_sample = \\\"NA\\\"\\n\\n metrics_df = pd.DataFrame(\\n {\\n \\\"Accuracy\\\": [acc_baseline, acc_sample],\\n \\\"Precision\\\": [precision_baseline, precision_sample],\\n \\\"Recall\\\": [recall_baseline, recall_sample],\\n \\\"F1\\\": [f1_baseline, f1_sample],\\n \\\"AUC\\\": [auc_baseline, auc_sample],\\n },\\n index=[\\\"baseline\\\", \\\"sample\\\"],\\n )\\n\\n self.performance_comparison = metrics_df\",\n \"def log_evaluation(tester, name, description):\\r\\n\\tfor dataset, output in tester.preds.items():\\r\\n\\t\\tresults = pandas.DataFrame.from_dict(output)\\r\\n\\t\\tpath = os.path.join(\\r\\n\\t\\t\\tEXPERIMENT_PATH, tester.config[\\\"name\\\"] + '-' + dataset)\\r\\n\\t\\twith open(path + \\\".csv\\\", \\\"w\\\") as f:\\r\\n\\t\\t\\tresults.to_csv(f, sep=\\\"\\\\t\\\", encoding='utf-8',\\r\\n\\t\\t\\t\\tfloat_format='%.3f', index=False)\",\n \"def qa_test():\\r\\n # Reads Code and Runs Code Metrics\\r\\n with open(\\\"BrainDataVisualiser.py\\\",\\\"r\\\") as file:\\r\\n code = file.read()\\r\\n with open(\\\"QA_LOGS.txt\\\",\\\"a\\\") as file:\\r\\n # Timestamp and append metric results to log\\r\\n file.write(datetime.date.today().strftime(\\\"%b-%d-%Y\\\")+\\\"\\\\n\\\\t\\\")\\r\\n file.write(\\\"General Analysis\\\\n\\\\t\\\\t\\\")\\r\\n file.write(str(analyze(code))+\\\"\\\\n\\\\t\\\")\\r\\n file.write(\\\"Cyclomatic Complexity\\\\n\\\")\\r\\n for i in cc_visit(code):\\r\\n file.write(\\\"\\\\t\\\\t\\\"+cc_rank(i.complexity)+\\\" \\\"+str(i)+\\\"\\\\n\\\")\",\n \"def metrics(self):\\n \\n if self.mse.shape[0]>1:\\n raise ValueError('Metrics can only handle single observations.')\\n \\n if self.N==1:\\n pred = float('nan')\\n err = float('nan')\\n y_true = float('nan')\\n else:\\n pred = int(self._predictions[-1])\\n err = self._mse[-1]\\n y_true = int(self.label[0])\\n \\n is_outlier = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"is_outlier\\\",\\\"value\\\":pred}\\n mse = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"mse\\\",\\\"value\\\":err}\\n obs = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"observation\\\",\\\"value\\\":self.N - 1}\\n threshold = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"threshold\\\",\\\"value\\\":self.threshold}\\n \\n label = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"label\\\",\\\"value\\\":y_true}\\n \\n accuracy_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"accuracy_tot\\\",\\\"value\\\":self.metric[4]}\\n precision_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"precision_tot\\\",\\\"value\\\":self.metric[5]}\\n recall_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"recall_tot\\\",\\\"value\\\":self.metric[6]}\\n f1_score_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f1_tot\\\",\\\"value\\\":self.metric[7]}\\n f2_score_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f2_tot\\\",\\\"value\\\":self.metric[8]}\\n \\n accuracy_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"accuracy_roll\\\",\\\"value\\\":self.metric[9]}\\n precision_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"precision_roll\\\",\\\"value\\\":self.metric[10]}\\n recall_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"recall_roll\\\",\\\"value\\\":self.metric[11]}\\n f1_score_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f1_roll\\\",\\\"value\\\":self.metric[12]}\\n f2_score_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f2_roll\\\",\\\"value\\\":self.metric[13]}\\n \\n true_negative = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"true_negative\\\",\\\"value\\\":self.metric[0]}\\n false_positive = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"false_positive\\\",\\\"value\\\":self.metric[1]}\\n false_negative = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"false_negative\\\",\\\"value\\\":self.metric[2]}\\n true_positive = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"true_positive\\\",\\\"value\\\":self.metric[3]}\\n \\n nb_outliers_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_outliers_roll\\\",\\\"value\\\":self.metric[14]}\\n nb_labels_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_labels_roll\\\",\\\"value\\\":self.metric[15]}\\n nb_outliers_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_outliers_tot\\\",\\\"value\\\":self.metric[16]}\\n nb_labels_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_labels_tot\\\",\\\"value\\\":self.metric[17]}\\n \\n return [is_outlier,mse,obs,threshold,label,\\n accuracy_tot,precision_tot,recall_tot,f1_score_tot,f2_score_tot,\\n accuracy_roll,precision_roll,recall_roll,f1_score_roll,f2_score_roll,\\n true_negative,false_positive,false_negative,true_positive,\\n nb_outliers_roll,nb_labels_roll,nb_outliers_tot,nb_labels_tot]\",\n \"def generate_stats(results, ads, vmid, session_date, export_folder, process_ex_time):\\n try:\\n os.makedirs(export_folder)\\n except OSError:\\n pass\\n\\n # to be read and inserted into db\\n totalads = 0 # total number of ads seen during this session\\n totaluniqads = len(ads) # does not support multicategories at this point\\n\\n # for each category, for each test site, count total number of ads seen\\n totalad_category = {} \\n # for each category, for each test site, count total number of uniq ads seen\\n uniqad_category = {}\\n \\n with open(os.path.join(export_folder, 'session_bugs.csv'), 'w') as bugs_wtr:\\n bugs_wtr.write('#Ad-UID, Website-URL, Refresh-Num, Training-Topic,\\\\\\n Site-Context, BugCount, BugSrc\\\\n')\\n for train_category, cat_dict in results.items():\\n totalad_category[train_category] = {}\\n uniqad_category[train_category] = {}\\n for test_site, bug_dict_list in cat_dict.items():\\n total_ads = 0 # for each site\\n uniq_ads = [] # for each site\\n for refresh_num in range(len(bug_dict_list)):\\n bug_dict = bug_dict_list[refresh_num]\\n for bug, bugcount in bug_dict.items():\\n if bug.is_ad():\\n uuid = bug.get_uuid()\\n bugs_wtr.write('{0}, {1}, {2}, {3}, {4}, {5}, {6}\\\\n'.format(uuid, test_site,\\n refresh_num, train_category, 'N/A', bugcount, bug.get_src()))\\n total_ads += bugcount\\n if bug not in uniq_ads:\\n uniq_ads.append(bug)\\n totalad_category[train_category][test_site] = total_ads\\n uniqad_category[train_category][test_site] = len(uniq_ads)\\n totalads += total_ads # global count for total ads\\n\\n with open(os.path.join(export_folder, 'session_stats.csv'), 'w') as ses_wtr:\\n # write some metadata information about this session\\n ses_wtr.write('#VMID: %s\\\\n' % vmid)\\n ses_wtr.write('#Session-Date: %s\\\\n' % session_date)\\n ses_wtr.write('#Time to complete: %s\\\\n' % process_ex_time)\\n ses_wtr.write('#Training Categories: %s\\\\n' % str(results.keys()))\\n ses_wtr.write('#Total Number of ads: %d\\\\n' % totalads)\\n ses_wtr.write('#Total Uniq ads: %d\\\\n\\\\n' % totaluniqads)\\n ses_wtr.write('#TrainingTopic, Test-Site, NumberOfVisit, TotalAds, UniqAds\\\\n')\\n\\n for train_category, cat_dict in results.items(): \\n for test_site, bug_dict_list in cat_dict.items():\\n num_of_visit = len(bug_dict_list)\\n ses_wtr.write('{0}, {1}, {2}, {3}, {4}\\\\n'.format(train_category,\\n test_site, num_of_visit, totalad_category[train_category][test_site],\\n uniqad_category[train_category][test_site]))\",\n \"def evaluate(self, test_data, test_labels):\\n raise NotImplementedError\",\n \"def main():\\n test_folders = argv[1]\\n benchmark_file = argv[2]\\n output_path = argv[3]\\n\\n method = ['n', 'a', 'a']\\n bigram = ['False', 'False', 'True']\\n output_file = output_path + '/' + 'method_comparison_cosine_values.csv'\\n\\n with open(test_folders, 'r') as f:\\n test_folders = f.read()\\n\\n test_folders = test_folders.splitlines()\\n\\n with open(benchmark_file, 'r') as f:\\n benchmark_file = f.read()\\n\\n benchmark_file = benchmark_file.splitlines()\\n\\n # initialize big data frame\\n frames = []\\n\\n for k in xrange(len(benchmark_file)):\\n\\n test = str(test_folders[k]).replace('\\\"', '')\\n print \\\"Reading test files from folder:\\\"\\n print test\\n\\n benchmark = str(benchmark_file[k]).replace('\\\"', '')\\n print \\\"Reading benchmark form file:\\\"\\n print benchmark\\n\\n # read file paths from test documents folder\\n query = sorted([os.path.join(test, f) for f in os.listdir(test) if f.endswith('.txt')])\\n\\n # load benchmark text file\\n with open(benchmark, \\\"r\\\", encoding=\\\"utf-8\\\", errors='ignore') as doc:\\n raw = doc.read()\\n\\n # initialize dict of dicts for data frame\\n method_csv = {}\\n\\n for j in xrange(len(method)):\\n # extract features from benchmark\\n dtm = ExtractFeatures(method[j], bigram[j])\\n benchmark_name = benchmark_file[k].split('\\\\\\\\')[-1]\\n benchmark_features = dtm.extract_features_from_text(raw, benchmark_name)\\n\\n # extract terms from each text document to create a vocabulary (keeping unique terms only)\\n vocabulary = sorted(set(w[1] for w in benchmark_features))\\n print \\\"{0} features produced.\\\".format(str(len(vocabulary)))\\n\\n benchmark_dtv = DTM(vocabulary, benchmark_name, benchmark_features)\\n benchmark_dtv = benchmark_dtv.compute_dtv()\\n\\n # load test document features\\n test_features = []\\n for q in query:\\n dtm1 = ExtractFeatures(method[j], bigram[j])\\n test_features = test_features + dtm1.extract_features_from_file(q)\\n\\n documents = sorted(set([d for d, w in test_features]))\\n print \\\"{0} test documents read.\\\".format(str(len(documents)))\\n\\n print \\\"Computing DTM...\\\"\\n test_dtm = DTM(vocabulary, documents, test_features)\\n test_dtm = test_dtm.compute_dtm()\\n\\n print \\\"Computing cosine values...\\\"\\n dv = {}\\n for i in xrange(len(documents)):\\n d = 1 - spatial.distance.cosine(benchmark_dtv[benchmark_name], test_dtm[documents[i]])\\n if isnan(d):\\n d = 0\\n dv[documents[i]] = d\\n\\n this_method = \\\"method=\\\" + method[j] + '_' + \\\"bigram=\\\" + bigram[j]\\n method_csv[this_method] = pd.Series(dv)\\n\\n print \\\"Saving to data frame...\\\"\\n df = pd.DataFrame(method_csv)\\n test = test.split('\\\\\\\\')[-1]\\n test = test.split('.')[0]\\n df['test_group'] = test\\n\\n frames.append(df)\\n\\n result = pd.concat(frames)\\n\\n print \\\"Saving results to file: \\\", output_file\\n result.to_csv(output_file)\\n\\n print 'Finished computing {0} data frames'.format(str(len(test_folders)))\",\n \"def compute_accuracy_measures(self, gt):\\n data = quantification.compute_accuracy_measures(self.image, gt.image)\\n return data\",\n \"def test_step(self, x_test, y_test):\\n\\n print(\\\"Evaluation:\\\")\\n\\n input_x_op = self.session.graph.get_operation_by_name(\\\"input_x\\\").outputs[0]\\n input_y_op = self.session.graph.get_operation_by_name(\\\"input_y\\\").outputs[0]\\n global_step_op = self.session.graph.get_operation_by_name(\\\"global_step\\\").outputs[0]\\n\\n loss_op = self.session.graph.get_operation_by_name(\\\"loss/loss\\\").outputs[0]\\n\\n predictions_op = self.session.graph.get_operation_by_name(\\\"output/predictions\\\").outputs[0] \\n\\n accuracy_op = self.session.graph.get_operation_by_name(\\\"accuracy/accuracy\\\").outputs[0]\\n confusion_update_op = self.session.graph.get_operation_by_name(\\\"accuracy/confusion_update\\\").outputs[0]\\n\\n d_ = {\\n input_x_op: x_test,\\n input_y_op: y_test\\n }\\n\\n self.init_dataset(d_)\\n\\n valid_batches_per_epoch = (len(x_test) - 1) // self.FLAGS.batch_size + 1\\n\\n sum_accuracy = 0\\n \\n confusion_variable = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=\\\"accuracy/confusion\\\")[0]\\n self.session.run([confusion_variable.initializer])\\n\\n for current_step in range(valid_batches_per_epoch):\\n\\n if self.FLAGS.summary:\\n step, summaries, loss, accuracy, cnf_matrix, predictions = self.session.run(\\n [global_step_op, self.dev_summary_op, loss_op, accuracy_op, confusion_update_op, predictions_op])\\n\\n self.writer.add_summary(summaries, step)\\n else:\\n step, loss, accuracy, cnf_matrix, predictions = self.session.run(\\n [global_step_op, loss_op, accuracy_op, confusion_update_op, predictions_op]) \\n\\n sum_accuracy += accuracy\\n\\n try:\\n all_predictions = np.concatenate((all_predictions, predictions), axis=0)\\n except NameError:\\n all_predictions = predictions\\n\\n\\n valid_accuracy = sum_accuracy / valid_batches_per_epoch\\n\\n time_str = datetime.datetime.now().isoformat()\\n print(\\\"{}: valid_accuracy {:g}\\\".format(time_str, valid_accuracy))\\n print(\\\"Confusion matrix:\\\")\\n print(cnf_matrix)\\n\\n return valid_accuracy, all_predictions\",\n \"def test_fetch_qc_metrics_logic_integrated(mocked_replicate_experiment):\\n result = ff_utils.fetch_files_qc_metrics(\\n ff_utils.get_metadata(\\\"331106bc-8535-3338-903e-854af460b544\\\", ff_env='fourfront-mastertest'),\\n ff_env='fourfront-mastertest',\\n associated_files=['other_processed_files'],\\n ignore_typical_fields=False)\\n assert '131106bc-8535-4448-903e-854af460b000' in result\\n assert '131106bc-8535-4448-903e-854abbbbbbbb' in result\",\n \"def run(self, inputIn):\\n measureList = self.inputToInternal(inputIn)\\n outputDict = {}\\n assert(len(self.features) == len(measureList))\\n for metricInstance in self.metricsDict.values():\\n metricEngine = MetricDistributor.factory.returnInstance('MetricDistributor', metricInstance)\\n for cnt in range(len(self.targets)):\\n nodeName = (str(self.targets[cnt]) + '_' + str(self.features[cnt])).replace(\\\"|\\\",\\\"_\\\")\\n varName = metricInstance.name + '|' + nodeName\\n output = metricEngine.evaluate(measureList[cnt], weights=self.weight, multiOutput=self.multiOutput)\\n outputDict[varName] = np.atleast_1d(output)\\n return outputDict\",\n \"def run_evaluate(self, test):\\n accs = []\\n correct_preds, total_correct, total_preds = 0., 0., 0.\\n for words, labels in minibatches(test, self.config.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words)\\n\\n for lab, lab_pred, length in zip(labels, labels_pred,\\n sequence_lengths):\\n lab = lab[:length]\\n lab_pred = lab_pred[:length]\\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\\n\\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\\n lab_pred_chunks = set(get_chunks(lab_pred,\\n self.config.vocab_tags))\\n\\n correct_preds += len(lab_chunks & lab_pred_chunks)\\n total_preds += len(lab_pred_chunks)\\n total_correct += len(lab_chunks)\\n\\n p = correct_preds / total_preds if correct_preds > 0 else 0\\n r = correct_preds / total_correct if correct_preds > 0 else 0\\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\\n acc = np.mean(accs)\\n print('*'*20, '\\\\n')\\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\\\n')\\n print('*'*20)\\n\\n return {\\\"acc\\\": 100*acc, \\\"f1\\\": 100*f1}\",\n \"def run_evaluate(self, test):\\n accs = []\\n correct_preds, total_correct, total_preds = 0., 0., 0.\\n for words, labels in minibatches(test, self.config.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words)\\n\\n for lab, lab_pred, length in zip(labels, labels_pred,\\n sequence_lengths):\\n lab = lab[:length]\\n lab_pred = lab_pred[:length]\\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\\n\\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\\n lab_pred_chunks = set(get_chunks(lab_pred,\\n self.config.vocab_tags))\\n\\n correct_preds += len(lab_chunks & lab_pred_chunks)\\n total_preds += len(lab_pred_chunks)\\n total_correct += len(lab_chunks)\\n\\n p = correct_preds / total_preds if correct_preds > 0 else 0\\n r = correct_preds / total_correct if correct_preds > 0 else 0\\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\\n acc = np.mean(accs)\\n\\n return {\\\"acc\\\": 100*acc, \\\"f1\\\": 100*f1}\",\n \"def gather_sample(self):\\n\\n for _pid in self._select_processes():\\n if not self.__trackers.get(_pid):\\n self.__trackers[_pid] = ProcessTracker(_pid, self._logger, self.__id)\\n\\n self._reset_absolute_metrics()\\n\\n for _tracker in self.__trackers.values():\\n _metrics = _tracker.collect()\\n self.record_metrics(_tracker.pid, _metrics)\\n\\n self._calculate_aggregated_metrics()\\n self._remove_dead_processes()\\n\\n self.print_metrics()\",\n \"def load_results(self):\\n self.find_benchmark_directories()\\n for (benchmark, producer), result in self.results.items():\\n print('Reading results for ' + benchmark + ' ' + producer)\\n if not result.directory:\\n print('No results found for ' + benchmark + ' ' + producer)\\n else:\\n print('Generating report for: ' + result.directory)\\n report = Report(result.directory)\\n result.reports = report.generate()\",\n \"def getMeasures():\",\n \"def execute(self):\\r\\n factors = self.factors\\r\\n variables = list(self.variables)\\r\\n variables.remove(self.query)\\r\\n\\r\\n for fac in factors:\\r\\n self.set_observations(fac)\\r\\n\\r\\n for var in variables:\\r\\n if var not in self.obs:\\r\\n factors = self.eliminate_variable(var, factors)\\r\\n\\r\\n result = factor_module.multiply_batch(self.query, factors)\\r\\n denominator = sum(result.get_cpt())\\r\\n print(denominator)\\r\\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def save_metrics(self):\\n self.data_stats.write.format(\\\"org.apache.spark.sql.cassandra\\\").mode(\\\"append\\\").options(table=self.cassandra_stats_table, keyspace=self.cassandra_keyspace).save()\\n print (\\\"Saved data successfully\\\")\",\n \"def __init__(self, metrics, gt, pred):\\n self.dict_metrics = self.compute_metrics(metrics, gt, pred)\",\n \"def evaluate(cfg: DictConfig):\\n\\n experiments = cfg.get('experiment_type', f'{cfg.model.name}_only')\\n fixed_t0 = cfg.get('fixed_t0', False)\\n ext = '_fixedT0' if fixed_t0 else ''\\n\\n base_dir = cfg.device.root\\n datasource = cfg.datasource.name\\n\\n if experiments == 'ablations':\\n models = {\\n 'FluxRGNN': ['final',\\n 'final_without_encoder',\\n 'final_without_boundary'],\\n 'LocalLSTM': ['final']\\n }\\n elif experiments == 'final':\\n models = {\\n 'FluxRGNN': ['final'],\\n 'GAM': ['final'],\\n 'HA': ['final'],\\n 'GBT': ['final']\\n }\\n else:\\n m = cfg.model.name\\n year = cfg.datasource.test_year\\n\\n # find all experiments available for this model, datasource and test year\\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{year}')\\n models = {\\n m : [ f.name for f in os.scandir(result_dir) if f.is_dir() ]\\n }\\n\\n\\n # thresholds for binary classification metrics\\n if cfg.datasource.name == 'abm':\\n thresholds = [0.0019, 0.0207]\\n else:\\n thresholds = [0, 10, 20]\\n\\n rmse_per_hour = []\\n mae_per_hour = []\\n pcc_per_hour = []\\n bin_per_hour = []\\n\\n rmse_per_night = []\\n mae_per_night = []\\n\\n output_dir = osp.join(base_dir, 'results', datasource, f'performance_evaluation{ext}', experiments)\\n os.makedirs(output_dir, exist_ok=True)\\n\\n counter = 0\\n\\n for m, dirs in models.items():\\n print(f'evaluate {m}')\\n\\n for d in dirs:\\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{cfg.datasource.test_year}', d)\\n\\n # check if directory exists\\n if os.path.isdir(result_dir):\\n results, model_cfg = load_cv_results(result_dir, trials=cfg.task.repeats, ext=ext)\\n\\n df_prep = pd.read_csv(osp.join(base_dir, 'data', 'preprocessed',\\n f'{model_cfg[\\\"t_unit\\\"]}_{model_cfg[\\\"model\\\"][\\\"edge_type\\\"]}_ndummy={model_cfg[\\\"datasource\\\"][\\\"n_dummy_radars\\\"]}',\\n datasource, cfg.season, str(cfg.datasource.test_year), 'dynamic_features.csv'))\\n tidx2night = dict(zip(df_prep.tidx, df_prep.nightID))\\n\\n rmse_per_hour.append(compute_rmse(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n mae_per_hour.append(compute_mae(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n pcc_per_hour.append(compute_pcc(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n\\n if fixed_t0:\\n rmse_per_night.append(compute_rmse_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\\n mae_per_night.append(compute_mae_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\\n\\n # compute binary classification measures\\n for thr in thresholds:\\n bin_per_hour.append(compute_bin(m, d, results, groupby=['horizon', 'trial'], threshold=thr, km2=True))\\n\\n counter += 1\\n\\n else:\\n print(f'Experiment \\\"{d}\\\" for model \\\"{m}\\\" and datasource \\\"{datasource}\\\" is not available. '\\n f'Use \\\"run_experiments.py model={m} datasource={datasource} +experiment={d}\\\" to run this experiment.')\\n\\n if counter > 0:\\n rmse_per_hour = pd.concat(rmse_per_hour)\\n rmse_per_hour.to_csv(osp.join(output_dir, f'rmse_per_hour.csv'))\\n\\n mae_per_hour = pd.concat(mae_per_hour)\\n mae_per_hour.to_csv(osp.join(output_dir, f'mae_per_hour.csv'))\\n\\n pcc_per_hour = pd.concat(pcc_per_hour)\\n pcc_per_hour.to_csv(osp.join(output_dir, f'pcc_per_hour.csv'))\\n\\n bin_per_hour = pd.concat(bin_per_hour)\\n bin_per_hour.to_csv(osp.join(output_dir, f'bin_per_hour.csv'))\\n\\n if fixed_t0:\\n rmse_per_night = pd.concat(rmse_per_night)\\n rmse_per_night.to_csv(osp.join(output_dir, f'rmse_per_night.csv'))\\n\\n mae_per_night = pd.concat(mae_per_night)\\n mae_per_night.to_csv(osp.join(output_dir, f'mae_per_night.csv'))\",\n \"def compute_metrics(self, results: list) -> dict:\\n dump(results, self.out_file_path)\\n print_log(\\n f'Results has been saved to {self.out_file_path}.',\\n logger='current')\\n return {}\",\n \"def test(self):\\n for data_tier in self.data_tiers:\\n tot = len(self.preprocessed_data[data_tier]['features'])\\n p = int(math.floor(tot*0.2))\\n test_features = np.array(self.preprocessed_data[data_tier]['features'][p:])\\n trend_test_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][p:])\\n avg_test_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][p:])\\n accuracy_trend = self.clf_trend[data_tier].score(test_features, trend_test_classifications)\\n accuracy_avg = self.clf_avg[data_tier].score(test_features, avg_test_classifications)\\n self.logger.info('The accuracy of %s trend classifier for data tier %s is %.3f', self.name, data_tier, accuracy_trend)\\n self.logger.info('The accuracy of %s avg regressor for data tier %s is %.3f', self.name, data_tier, accuracy_avg)\",\n \"def run(self):\\n if self.verbose:\\n print(f'Running {self.name} tests...')\\n\\n # try running setup if there is one\\n if self.setup:\\n self.__process_setup()\\n\\n final_report = [None] * len(self.tests)\\n\\n for test_in, test_out in sorted(self.tests.items()):\\n # increment total num of tests\\n self.total += 1\\n\\n if self.verbose:\\n print(f'#{self.total}')\\n\\n # evaluate test input w/ setup vars, if any\\n try:\\n inp = eval(test_in, self.vars)\\n except Exception as err:\\n print(f'Issue during evaluation of test input: {err}')\\n final_report[self.total - 1] = 'input eval error'\\n if self.verbose:\\n print(f'Test input was: {test_in}')\\n print('Vars from execution: {}'.format({k : v for k, v in self.vars.items() if k != '__builtins__'}))\\n continue\\n\\n \\n # checking if function input has more than one arg\\n if type(inp) in (list, tuple):\\n try:\\n student_out = self.student_function(*inp)\\n except Exception as err:\\n print(f'Issue while running student code: {err}')\\n final_report[self.total - 1] = f'student code error: {err}; input: {inp}; func_name: {self.name}'\\n if self.verbose:\\n print(f'Function being run was: {self.name}')\\n print(f'Inputs were: {inp}')\\n continue\\n else:\\n try:\\n student_out = self.student_function(inp)\\n except Exception as err:\\n print(f'Issue while running student code: {err}')\\n final_report[self.total - 1] = f'student code error: {err}; input: {inp}; func_name: {self.name}'\\n if self.verbose:\\n print(f'Function being run was: {self.name}')\\n print(f'Input was: {inp}')\\n continue\\n\\n # ans alias for ease of answer checking\\n self.vars['ans'] = student_out\\n\\n if self.schema:\\n format_vals = eval(test_out, self.vars)\\n results, maybe_failed_schema = self.__process_schema(format_vals)\\n if all(results):\\n self.correct += 1\\n final_report[self.total - 1] = 'PASSED'\\n else:\\n # failed at least one of the tests\\n failed_str = \\\" and \\\".join([\\\", \\\".join(maybe_failed_schema[:-1]),maybe_failed_schema[-1]] if len(maybe_failed_schema) > 2 else maybe_failed_schema)\\n final_report[self.total - 1] = f'FAILED; failed following assertion(s): {failed_str}'\\n else:\\n expected_ans = eval(test_out, self.vars)\\n if student_out == expected_ans:\\n self.correct += 1\\n final_report[self.total - 1] = 'PASSED'\\n else:\\n # failed the only test\\n final_report[self.total - 1] = f'FAILED; got {repr(student_out)} but expected {repr(expected_ans)}'\\n\\n # run callback function, if there is one\\n if self.callback:\\n if self.verbose:\\n print('Running callback...')\\n print('call back is:', self.callback)\\n\\n # once done, put the final report on the queue\\n self.queue.put((self.student_username, self.name, f'{self.correct}/{self.total}', final_report))\",\n \"def execute(self, context):\\n if len(self.data_quality_checks) == 0:\\n self.log.info('DataQualityOperator not implemented yet')\\n return\\n \\n redshift_hook = PostgresHook(postgres_conn_id=self.redshift_conn_id) \\n \\n errors = 0\\n failure_tests = []\\n\\n # process each sql stmt for data quality relevant to each dimension table:\\n # Dimension tables : a. songplays, b. songs, c. artists, d. users, e. time\\n \\n for (curr_table, check_stmt) in zip(self.list_of_tables, self.data_quality_checks):\\n curr_sql = check_stmt.get('check_sql')\\n result1 = check_stmt.get('expected_result')\\n \\n self.log.info('Current Table Processed : ' + curr_table)\\n\\n try:\\n records = redshift_hook.get_records(curr_sql)[0]\\n except Exception as e:\\n self.loginfo(f\\\"Error : {curr_table} : Query failed : {e}\\\")\\n\\n # record error when actual result is not the same as expected result\\n if result1 != records[0]:\\n errors += 1\\n failure_tests.append(curr_table + ' : ' + curr_sql)\\n \\n # display Failure or Success Message \\n if errors > 0:\\n self.log.info(failure_tests)\\n self.log.info('Failure Msg : Tests Failed')\\n raise ValueError('Error : Failed : Data Quality check')\\n else:\\n self.log.info('Success : All Data Quality Tests passed')\",\n \"def dataStats(self):\\n print (\\\"Performing statistical analysis of the data\\\")\\n # stuff to do\",\n \"def _test_evaluate(self, format_only, outfile_predix=None):\\n metric = MOTChallengeMetric(\\n metric=['HOTA', 'CLEAR', 'Identity'],\\n format_only=format_only,\\n outfile_prefix=outfile_predix)\\n metric.dataset_meta = {'classes': ('pedestrian', )}\\n data_batch = dict(input=None, data_samples=None)\\n predictions = self._get_predictions_demo()\\n metric.process(data_batch, predictions)\\n eval_results = metric.evaluate()\\n return eval_results\",\n \"def save_performances(self):\\r\\n nb_datasets = len(self.results)\\r\\n resu = [[] for k in range(nb_datasets)]\\r\\n\\r\\n # fetch results\\r\\n for k in range(nb_datasets):\\r\\n best = np.argmax(self.results[k]['mean_test_score'])\\r\\n resu[k].append(('score', self.results[k]['mean_test_score'][best]))\\r\\n resu[k] = resu[k] + list(self.results[k]['params'][best].items())\\r\\n\\r\\n # write results in csv\\r\\n for k, resu in enumerate(resu):\\r\\n with open('results/final_results_{}.csv'.format(k), 'a') as file:\\r\\n writer = csv.writer(file)\\r\\n writer.writerow(resu)\",\n \"def run_and_evaluate():\\n tsp_problems = read_all_problems()\\n # Empty list of metrics\\n results = []\\n for problem in tqdm.tqdm(tsp_problems):\\n # As random factors are involved repeat experiments a couple of times\\n best_routes_base = []\\n best_routes_af = []\\n best_routes_ms = []\\n base_times = []\\n af_times = []\\n ms_times = []\\n for i in range(10):\\n # Base solution\\n start_time = timeit.default_timer()\\n best_route_base = solve_tsp_basic(problem)\\n base_time = timeit.default_timer() - start_time\\n best_routes_base.append(Fitness(route=best_route_base).route_distance())\\n base_times.append(base_time)\\n\\n # AF clustering solution\\n start_time = timeit.default_timer()\\n best_route_af = solve_tsp_affinity_propagation(problem)\\n af_time = timeit.default_timer() - start_time\\n best_routes_af.append(Fitness(route=best_route_af).route_distance())\\n af_times.append(af_time)\\n\\n # MS solution\\n start_time = timeit.default_timer()\\n best_route_ms = solve_mean_shift(problem)\\n ms_time = timeit.default_timer() - start_time\\n best_routes_ms.append(Fitness(route=best_route_ms).route_distance())\\n ms_times.append(ms_time)\\n\\n results.append(\\n {\\n \\\"problem name\\\": problem.name,\\n \\\"optimal solution\\\": find_route_optimal_route_length(problem),\\n \\\"baseline tour length\\\": mean(best_routes_base),\\n \\\"af clustering tour length\\\": mean(best_routes_af),\\n \\\"ms clustering tour length\\\": mean(best_routes_ms),\\n \\\"baseline algorithm time\\\": mean(base_times),\\n \\\"af clustering algorithm time\\\": mean(af_times),\\n \\\"ms clustering algorithm time\\\": mean(ms_times),\\n }\\n )\\n # Create dataframe and safe results\\n df = pd.DataFrame(results)\\n df.to_csv(\\\"results.csv\\\", index=False)\\n return df\",\n \"def init_metrics(self):\\n\\n self.metrics = {}\\n\\n self.metrics['train_loss'] = np.zeros(0)\\n self.metrics['test_loss'] = np.zeros(0)\\n\\n # self.orth_clf = LinearDecoder(self, self.q_, MeanClassifier)\\n # self.metrics['train_orthogonality'] = np.zeros(0)\\n # self.metrics['test_orthogonality'] = np.zeros(0)\\n\\n self.metrics['train_parallelism'] = np.zeros((0,self.q_)) \\n self.metrics['test_parallelism'] = np.zeros((0,self.q_))\",\n \"def test_cw_metrics(self):\\n\\n instances = set()\\n result = self.cw_client.list_metrics(Namespace=\\\"CWAgent\\\", MetricName=\\\"cpu_usage_system\\\")\\n for i in result[\\\"Metrics\\\"]:\\n instances.add(i[\\\"Dimensions\\\"][0][\\\"Value\\\"])\\n\\n for key, value in self.cdk_output_map.items():\\n if \\\"Instance\\\" in key:\\n self.assertTrue(value in instances)\",\n \"def metrics_env(cmd_ctx, cpc, **options):\\n cmd_ctx.execute_cmd(lambda: cmd_metrics_env(cmd_ctx, cpc, options))\",\n \"def evaluate(self) -> Dict[str, float]:\\n eval_dataloader = self.get_eval_dataloader()\\n\\n output = self._prediction_loop(eval_dataloader, description=\\\"Evaluation\\\")\\n return output.metrics\",\n \"def _build_eval_metrics(self, results, features, labels):\\n metrics = {}\\n for metric in self.metrics:\\n metrics[metric.IDENTIFIER] = getters.get_metric(\\n metric.IDENTIFIER, results, labels, **metric.to_dict())\\n return metrics\",\n \"def evaluate(self, epoch, exploration_paths):\\n logger.log(\\\"Collecting samples for evaluation\\\")\\n paths = self._sample_eval_paths(epoch)\\n statistics = OrderedDict()\\n\\n statistics.update(self._statistics_from_paths(paths, \\\"Test\\\"))\\n statistics.update(self._get_other_statistics())\\n statistics.update(self._statistics_from_paths(exploration_paths,\\n \\\"Exploration\\\"))\\n\\n statistics['AverageReturn'] = get_average_returns(paths)\\n statistics['Epoch'] = epoch\\n\\n for key, value in statistics.items():\\n logger.record_tabular(key, value)\\n\\n self.log_diagnostics(paths)\",\n \"def evaluation(self):\\n rows_list = []\\n for name in self.single_classifier_best.keys():\\n row = {}\\n row['algorithm'] = name \\n row[self.scoring_metric] = self.single_classifier_best[name].best_score_\\n rows_list.append(row)\\n \\n scoring_df = pd.DataFrame(rows_list)\\n scoring_sorted = scoring_df.sort_values(self.scoring_metric, ascending=False)\\n print()\\n print('*'*shutil.get_terminal_size().columns)\\n print(scoring_sorted)\\n print('*'*shutil.get_terminal_size().columns)\\n self.evaluation_scores = scoring_sorted\",\n \"def getIndependentTestSetPerf(ml_df,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,group_col,model_type,ml_model,n_splits=10,n_repeats=10,n_jobs=1): \\n X = ml_df[roi_cols].values\\n X_col_names = roi_cols.copy()\\n grp1_idx = np.array(ml_df[group_col]=='internal')\\n grp2_idx = np.array(ml_df[group_col]=='external')\\n\\n # Check input var types and create dummy vars if needed\\n if len(covar_continuous_cols) > 0:\\n X_continuous_covar = ml_df[covar_continuous_cols].values\\n print('Using {} continuous covar'.format(len(covar_continuous_cols)))\\n X = np.hstack((X, X_continuous_covar))\\n X_col_names += list(covar_continuous_cols)\\n if len(covar_cat_cols) > 0:\\n X_cat_covar_df = pd.get_dummies(ml_df[covar_cat_cols])\\n X_cat_covar = X_cat_covar_df.values\\n print('Using {} categorical cols as {} cat covar (dummies)'.format(covar_cat_cols,X_cat_covar.shape[1]))\\n X = np.hstack((X, X_cat_covar))\\n X_col_names += list(X_cat_covar_df.columns)\\n\\n print('n of input columns: {}'.format(len(X_col_names)))\\n if model_type.lower() == 'classification':\\n y = pd.get_dummies(ml_df[outcome_col]).values[:,0]\\n print('Data shapes X {}, y {} ({})'.format(X.shape, len(y), list(ml_df[outcome_col].value_counts()))) \\n perf_metric = 'roc_auc'\\n cv = RepeatedStratifiedKFold(n_splits=n_splits,n_repeats=n_repeats,random_state=0)\\n elif model_type.lower() == 'regression':\\n y = ml_df[outcome_col].values\\n print('Data shapes X {}, y {} ({:3.2f}m, {:3.2f}sd)'.format(X.shape, len(y), np.mean(y),np.std(y))) \\n perf_metric = 'neg_mean_squared_error'\\n cv = ShuffleSplit(n_splits=n_splits*n_repeats, random_state=0)\\n else:\\n print('unknown model type {} (needs to be classification or regression)'.format(model_type))\\n\\n\\n print('Using {} model with perf metric {}'.format(model_type, perf_metric))\\n\\n X1 = X[grp1_idx]\\n y1 = y[grp1_idx]\\n X2 = X[grp2_idx]\\n y2 = y[grp2_idx]\\n\\n scores_df_CV = pd.DataFrame()\\n for train_index, test_index in cv.split(X1):\\n X1_tr = X1[train_index]\\n y1_tr = y1[train_index]\\n X1_te = X1[test_index]\\n y1_te = y1[test_index]\\n \\n ml_model.fit(X1_tr,y1_tr)\\n y1_pred = ml_model.predict(X1_te)\\n y2_pred = ml_model.predict(X2)\\n \\n if perf_metric == 'neg_mean_squared_error':\\n perf1 = mean_squared_error(y1_te, y1_pred)\\n perf2 = mean_squared_error(y2, y2_pred)\\n else:\\n print('Unknown scoring function {}'.format(perf_metric))\\n perf1 = 0\\n perf2 = 0\\n \\n scores_df = pd.DataFrame() \\n scores_df[perf_metric] = [perf1,perf2]\\n scores_df['test_subset'] = ['internal','external']\\n scores_df_CV = scores_df_CV.append(scores_df)\\n\\n return scores_df_CV\",\n \"def run(self):\\n self.tf_idf_scores = self.tf_idf()\\n self.word_scores = self.create_word_score()\\n self.keyword_scores = self.create_keyword_score()\\n self.text_ranks = self.create_text_rank()\\n self.pos_scores = {}\\n self.z_area_scores = {}\\n self.create_pos_and_area_score()\\n self.all_scores = self.weight_distribution()\\n self.all_scores_dict = self.get_all_scores_dict()\\n return self.get_keywords()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61865723","0.61484236","0.6111889","0.6068964","0.59302425","0.5927652","0.5902292","0.5878314","0.5785274","0.5735238","0.57067233","0.56961745","0.56763333","0.5656826","0.5624611","0.5584238","0.55624455","0.55575174","0.5555539","0.5554058","0.55537844","0.554788","0.5516049","0.5514577","0.54895395","0.5478405","0.5478227","0.54697764","0.5443361","0.5443084","0.5438497","0.54299843","0.5426859","0.54031557","0.5397921","0.5397196","0.5382928","0.53812057","0.537277","0.53689325","0.5362363","0.53595793","0.5346941","0.5343817","0.53434306","0.5335857","0.5332038","0.532539","0.5321456","0.5315792","0.5310982","0.53093886","0.5301637","0.5287999","0.5285853","0.52824634","0.52800417","0.5279901","0.52779675","0.5276553","0.5265042","0.5256322","0.5255094","0.5254885","0.5235576","0.52351624","0.52283823","0.52280146","0.5224105","0.5216522","0.5216309","0.5212902","0.5206638","0.5201787","0.5197425","0.5196407","0.5195393","0.51895154","0.5187135","0.51860136","0.5185676","0.51782244","0.5171174","0.51700836","0.51693195","0.51670223","0.5164521","0.51588035","0.51548743","0.5149526","0.5147534","0.5146205","0.5143033","0.51427495","0.5139956","0.5126883","0.51132345","0.5112745","0.5112213","0.5108503"],"string":"[\n \"0.61865723\",\n \"0.61484236\",\n \"0.6111889\",\n \"0.6068964\",\n \"0.59302425\",\n \"0.5927652\",\n \"0.5902292\",\n \"0.5878314\",\n \"0.5785274\",\n \"0.5735238\",\n \"0.57067233\",\n \"0.56961745\",\n \"0.56763333\",\n \"0.5656826\",\n \"0.5624611\",\n \"0.5584238\",\n \"0.55624455\",\n \"0.55575174\",\n \"0.5555539\",\n \"0.5554058\",\n \"0.55537844\",\n \"0.554788\",\n \"0.5516049\",\n \"0.5514577\",\n \"0.54895395\",\n \"0.5478405\",\n \"0.5478227\",\n \"0.54697764\",\n \"0.5443361\",\n \"0.5443084\",\n \"0.5438497\",\n \"0.54299843\",\n \"0.5426859\",\n \"0.54031557\",\n \"0.5397921\",\n \"0.5397196\",\n \"0.5382928\",\n \"0.53812057\",\n \"0.537277\",\n \"0.53689325\",\n \"0.5362363\",\n \"0.53595793\",\n \"0.5346941\",\n \"0.5343817\",\n \"0.53434306\",\n \"0.5335857\",\n \"0.5332038\",\n \"0.532539\",\n \"0.5321456\",\n \"0.5315792\",\n \"0.5310982\",\n \"0.53093886\",\n \"0.5301637\",\n \"0.5287999\",\n \"0.5285853\",\n \"0.52824634\",\n \"0.52800417\",\n \"0.5279901\",\n \"0.52779675\",\n \"0.5276553\",\n \"0.5265042\",\n \"0.5256322\",\n \"0.5255094\",\n \"0.5254885\",\n \"0.5235576\",\n \"0.52351624\",\n \"0.52283823\",\n \"0.52280146\",\n \"0.5224105\",\n \"0.5216522\",\n \"0.5216309\",\n \"0.5212902\",\n \"0.5206638\",\n \"0.5201787\",\n \"0.5197425\",\n \"0.5196407\",\n \"0.5195393\",\n \"0.51895154\",\n \"0.5187135\",\n \"0.51860136\",\n \"0.5185676\",\n \"0.51782244\",\n \"0.5171174\",\n \"0.51700836\",\n \"0.51693195\",\n \"0.51670223\",\n \"0.5164521\",\n \"0.51588035\",\n \"0.51548743\",\n \"0.5149526\",\n \"0.5147534\",\n \"0.5146205\",\n \"0.5143033\",\n \"0.51427495\",\n \"0.5139956\",\n \"0.5126883\",\n \"0.51132345\",\n \"0.5112745\",\n \"0.5112213\",\n \"0.5108503\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6186402"},"document_rank":{"kind":"string","value":"1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":214,"numItemsPerPage":100,"numTotalItems":95772,"offset":21400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjQ2NDAzMSwianRpIjoiNDJhNDQwOGMtYWNhMi00MWQxLWIxMDktZGYwMmE4YzE2NjJlIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY0Njc2MzEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.Hu3eKzf-2In5LbZYRQZOPtSqeYYo7t-Y5PNy1DQ6pFShQIEY4kmrLpmg4cERmleMvnrRQB8qg_fof1PfTgiHDA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Compute the KL divergence KL[q || p] between q(x) = N(q_mu, q_sqrt^2) and p(x) = N(0, K) We assume N multiple independent distributions, given by the columns of q_mu and the last dimension of q_sqrt. Returns the sum of the divergences. q_mu is a matrix (M x N), each column contains a mean. q_sqrt can be a 3D tensor (M ... | def gauss_kl(q_mu, q_sqrt, K=None):
#print(q_sqrt._tf_array)
#q_sqrt = q_sqrt._tf_array
#q_mu = q_mu._tf_array
if K is None:
white = True
alpha = q_mu
else:
white = False
Lp = tf.cholesky(K)
alpha = tf.matrix_triangular_solve(Lp, q_mu, lower=True)
if q_s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kl_divergence(self, params_q, params_p):\n means_q = params_q[:, :, 0]\n log_std_q = params_q[:, :, 1]\n\n means_p = params_p[:, :, 0]\n log_std_p = params_p[:, :, 1]\n\n std_q = torch.exp(log_std_q)\n std_p = torch.exp(log_std_p)\n\n kl_div = log_std_p - log_st... | [
"0.71765184",
"0.7019512",
"0.6987265",
"0.69375336",
"0.69356835",
"0.6904298",
"0.689787",
"0.6729169",
"0.6645247",
"0.65512383",
"0.6495925",
"0.64693046",
"0.6374325",
"0.63563484",
"0.6350259",
"0.6266845",
"0.6263321",
"0.6241391",
"0.62203217",
"0.6207716",
"0.6193783... | 0.67699784 | 7 |
Testing if paths are constructed correctly | def test_paths(self):
# minify and combine
js_source = javascript_link('/deep/a.js', '/b.js', combined=True, minified=True)
css_source = stylesheet_link('/deep/a.css', '/b.css', combined=True, minified=True)
self.assert_('"/a.b.COMBINED.min.css"' in css_source)
self.assert_('"/a.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_verify_path_7(self):\n result = basic.verify_path(str(self.test_directory1), \"invalid\")\n self.assertFalse(result)",
"def test__build_paths():\n files1 = [\"file1\", \"file2\"]\n userdefined_path = classifier_module.DATA_PATH + classifier_module.USER_DIR\n\n expected_out_files1 ... | [
"0.7151249",
"0.71028125",
"0.704526",
"0.70197225",
"0.69946885",
"0.6940732",
"0.68837845",
"0.6856557",
"0.68369985",
"0.68248403",
"0.6765043",
"0.6747541",
"0.67444754",
"0.6742994",
"0.6723944",
"0.6718389",
"0.67026347",
"0.66905177",
"0.6668439",
"0.66664594",
"0.6648... | 0.0 | -1 |
Testing for proper beaker kwargs usage | def test_beaker_kwargs(self):
css_source = stylesheet_link('/deep/a.css', '/b.css', combined=True, minified=True)
from fixtures import beaker_container
self.assertEqual(beaker_container, beaker_kwargs)
css_source = stylesheet_link('/deep/a.css', '/b.css', combined=True, minified=True, b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_020_kwargs(self):\n caller = self.get_caller([KwargsTaskOverride])\n self.assertEqual([\"A\", \"B\"], caller(\"A\", \"B\"))",
"def test_kwargs(self):\n kwargs = forge.kwargs\n assert isinstance(kwargs, forge._signature.VarKeyword)\n assert kwargs.name == 'kwargs'\n ... | [
"0.7301403",
"0.72157216",
"0.69301623",
"0.6644783",
"0.65698075",
"0.65681475",
"0.65209633",
"0.6470704",
"0.6410706",
"0.6393279",
"0.6379091",
"0.6320997",
"0.6313386",
"0.6237101",
"0.6231931",
"0.621528",
"0.62060726",
"0.6202357",
"0.6099443",
"0.6098508",
"0.6097881"... | 0.7554935 | 0 |
test that timestamp is really remembered | def test_timestamp(self):
# apply real memoize to do proper testing
minwebhelpers.beaker_cache = memoize
css_source_1 = stylesheet_link('/deep/a.css', '/b.css', combined=True, minified=True, timestamp=True)
time.sleep(1)
css_source_2 = stylesheet_link('/deep/a.css', '/b.css', co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isFresh(self, timestamp):\n pass;",
"def __expired_timestamp(self, timestamp):\n return int(time.time()) > timestamp + self.__ttl",
"def test_last_used(self, monkeypatch):\n monkeypatch.setenv('ENABLE_AUTO_EXPIRE', 'true')\n monkeypatch.setenv('INACTIVITY_AGE', '10')\n cr... | [
"0.7103609",
"0.7088542",
"0.6672816",
"0.65801454",
"0.64244413",
"0.641137",
"0.64082605",
"0.63636667",
"0.63623965",
"0.6352042",
"0.6347807",
"0.6344862",
"0.6342813",
"0.6341419",
"0.6334243",
"0.6309578",
"0.62998533",
"0.62858075",
"0.62832284",
"0.6267803",
"0.624547... | 0.59452564 | 49 |
Call first_move() after good key was pressed. Good key will be saved in self.first_key | def wait_first_move(self):
self.env.keyboard.listen_once(self.catch_key_first, key_down) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first_move(self):\n self.play_sound(self.first_key)\n self.make_blink()\n self.wait_second_move()",
"def key_handler(self, event):\n if event.type == pygame.KEYUP: \n self.done = True",
"def wait_second_move(self):\n self.qr_unregister()\n self.env.ke... | [
"0.7691176",
"0.69349104",
"0.68719256",
"0.68288636",
"0.6766883",
"0.6606569",
"0.6452956",
"0.63939595",
"0.63457495",
"0.6345322",
"0.6335956",
"0.63320196",
"0.6313395",
"0.6303774",
"0.6273421",
"0.6273016",
"0.62193775",
"0.6212796",
"0.61779016",
"0.616101",
"0.615977... | 0.7749387 | 0 |
Responses for first_key press. | def first_move(self):
self.play_sound(self.first_key)
self.make_blink()
self.wait_second_move() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait_first_move(self):\n self.env.keyboard.listen_once(self.catch_key_first, key_down)",
"def keypress_callback():\n data = request.get_json()\n buttonid = data['buttonid']\n assert buttonid in pyautogui.KEYBOARD_KEYS, \"Unknown buttonid received\"\n pyautogui.press(buttonid)\n return j... | [
"0.65326923",
"0.6267843",
"0.62426716",
"0.6083045",
"0.6003534",
"0.5993124",
"0.59164053",
"0.5813882",
"0.5776835",
"0.5767592",
"0.57570904",
"0.5756149",
"0.5752199",
"0.5737215",
"0.5722572",
"0.57125866",
"0.5695015",
"0.5670828",
"0.56411684",
"0.5629136",
"0.5627699... | 0.6002405 | 5 |
Call second_move() after good key was pressed. Good key will be saved in self.second_key | def wait_second_move(self):
self.qr_unregister()
self.env.keyboard.listen_once(self.catch_key_second, key_down) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def second_move(self):\n self.play_sound(self.second_key)\n self.end_move()",
"def first_move(self):\n self.play_sound(self.first_key)\n self.make_blink()\n self.wait_second_move()",
"def wait_first_move(self):\n self.env.keyboard.listen_once(self.catch_key_first, key_... | [
"0.7825597",
"0.7296097",
"0.7028338",
"0.67003924",
"0.66919225",
"0.6691698",
"0.65923977",
"0.6526897",
"0.6478581",
"0.64533395",
"0.6391608",
"0.63787925",
"0.63162094",
"0.63137877",
"0.62750816",
"0.6266099",
"0.62504405",
"0.62090117",
"0.6191794",
"0.61795557",
"0.61... | 0.7450435 | 1 |
Responses for second_key press. | def second_move(self):
self.play_sound(self.second_key)
self.end_move() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait_second_move(self):\n self.qr_unregister()\n self.env.keyboard.listen_once(self.catch_key_second, key_down)",
"def goto_second():\n\tglobal c2\n\tglobal a2\n\tglobal BUF_SIZE\n\tglobal state\n\n\tmsg = c2.recv(BUF_SIZE) # wait for the taken off message\n\tprint a2, ' >> ', msg\n\tif msg != ... | [
"0.6041951",
"0.58219993",
"0.57078713",
"0.567378",
"0.55835176",
"0.55665016",
"0.55074126",
"0.55048704",
"0.5473432",
"0.5445047",
"0.5436347",
"0.54057235",
"0.5393213",
"0.5380113",
"0.53439146",
"0.5318712",
"0.5311537",
"0.52885514",
"0.5287942",
"0.5277704",
"0.52646... | 0.63019663 | 0 |
Plot a histogram of the pnorms of the solutions | def plot_p_norm(p=2, bins=500):
plt.title(f"{p}-norms of solutions for lattice point quaternion polynomials")
plt.hist([sum(abs(x)**p for x in abcd)**(1/p) for abcd in solutions], bins=bins) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_imag_p_norm(p=2, bins=500):\n plt.title(f\"{p}-norms of imaginary parts of solutions to polynomials with quaternion coefficients\")\n plt.hist([sum(abs(x) ** p for x in abcd[1:]) ** (1 / p) for abcd in solutions], bins=bins)",
"def test_normal(self):\r\n s = np.random.normal(-0.42, 0.55, 50... | [
"0.765192",
"0.68404233",
"0.66037804",
"0.65835",
"0.6533649",
"0.64928544",
"0.6461779",
"0.645999",
"0.6441155",
"0.6404364",
"0.6345734",
"0.6342641",
"0.6324178",
"0.63204044",
"0.62690324",
"0.62213695",
"0.61868656",
"0.6182514",
"0.6176014",
"0.61743295",
"0.6171994",... | 0.8222845 | 0 |
Plot a histogram of the pnorms of the imaginary parts of the solutions | def plot_imag_p_norm(p=2, bins=500):
plt.title(f"{p}-norms of imaginary parts of solutions to polynomials with quaternion coefficients")
plt.hist([sum(abs(x) ** p for x in abcd[1:]) ** (1 / p) for abcd in solutions], bins=bins) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_p_norm(p=2, bins=500):\n plt.title(f\"{p}-norms of solutions for lattice point quaternion polynomials\")\n plt.hist([sum(abs(x)**p for x in abcd)**(1/p) for abcd in solutions], bins=bins)",
"def show_histogram(im):\n\n if im.ndim == 2:\n # Input image is single channel\n ... | [
"0.777749",
"0.6434252",
"0.6400417",
"0.62809926",
"0.6274087",
"0.62183875",
"0.6199149",
"0.61816305",
"0.6179878",
"0.6179878",
"0.6179878",
"0.61471015",
"0.6140279",
"0.6139242",
"0.6112178",
"0.6104909",
"0.60622525",
"0.60274523",
"0.5973794",
"0.59647155",
"0.5960954... | 0.83347857 | 0 |
First Python implementation method of the Levenshtein distance between strings | def levenshtein(s1, s2):
if len(s1) < len(s2):
return levenshtein(s2, s1)
# len(s1) >= len(s2)
if len(s2) == 0:
return len(s1)
previous_row = range(len(s2) + 1)
for i, c1 in enumerate(s1):
current_row = [i + 1]
for j, c2 in enumerate(s2):
insertions = pr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def levenshtein_distance(s1,s2):\n\n\t\tif len(s1) < len(s2):\n\t\t\treturn Searcher.levenshtein_distance(s2, s1)\n\n\t\t# len(s1) >= len(s2)\n\t\tif len(s2) == 0:\n\t\t\treturn len(s1)\n\n\t\tprevious_row = range(len(s2) + 1)\n\t\tfor i, c1 in enumerate(s1):\n\t\t\tcurrent_row = [i + 1]\n\t\t\tfor j, c2 in enumer... | [
"0.81522393",
"0.79750335",
"0.7954744",
"0.7949555",
"0.78139377",
"0.7758564",
"0.7698071",
"0.7673589",
"0.7605972",
"0.7590628",
"0.7568366",
"0.7530191",
"0.74639803",
"0.7419249",
"0.739178",
"0.7367446",
"0.7348473",
"0.7338631",
"0.73206055",
"0.7319021",
"0.7293537",... | 0.80752313 | 1 |
Use Gensim package to find relation triplet similarities between Ntriplets based on wordmover distance. | def wmd_matrix(
triplet_list: Iterable[dict],
model: gensim.models.keyedvectors.Word2VecKeyedVectors) -> dict and Iterable[Iterable[float]]:
# Concatenate subj-pred-obj into single sentence document, indexed
triplets_idx = {idx: trip for idx, trip in enumerate(triplet_list)}
triplets = {id... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wordNet_similarity(sentence1, sentence2):\r\n # Tokenize and tag\r\n \r\n # sentence1 = pos_tag(word_tokenize(sentence1))\r\n sentence1=st_tagger.tag(word_tokenize(sentence1))\r\n \r\n # sentence2 = pos_tag(word_tokenize(sentence2))\r\n sentence2=st_tagger.tag(word_tokenize(sentence2))\r\n... | [
"0.6340076",
"0.60962826",
"0.5978031",
"0.589854",
"0.57848215",
"0.575694",
"0.5731846",
"0.5714283",
"0.56484836",
"0.56170404",
"0.5613912",
"0.5593854",
"0.5553895",
"0.55014926",
"0.54705215",
"0.53969795",
"0.5396031",
"0.53880775",
"0.5378547",
"0.5377828",
"0.5369617... | 0.0 | -1 |
Leverage Pythonwrapper to Stanford CoreNLP Java engine for purpose of relationtriplet extractions. | def __init__(self):
# Initialise class attributes (visibility ease)
self.__corpus__ = None
self.__pron_det_pos_words__ = None
self.__triples_corpus__ = None
self.__entities_in_doc__ = None
self.__wvmodel__ = None
# For purpose of parsing relation triplets... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parseSentences(jobidsentences):\n\n jobid, docs, Config = jobidsentences\n\n #start stanford server, we need to find an open port through guessing\n maxtries = 12\n tries=0\n err=[]\n while tries <maxtries:\n try:\n np.random.seed()\n jobid = np.random.randint(0, ... | [
"0.5475957",
"0.543991",
"0.5417777",
"0.537119",
"0.53507733",
"0.5336107",
"0.52587",
"0.52349573",
"0.5205756",
"0.51611793",
"0.51351035",
"0.51071185",
"0.5032567",
"0.50286174",
"0.50137883",
"0.499988",
"0.49943662",
"0.49602225",
"0.4914728",
"0.49007335",
"0.4897188"... | 0.50233644 | 14 |
It is reccommended that preprocessing has taken place before loading directly into object class in iterable format level to avoid inconsistencies due to document delimitation from the puctuations. Upon calling method `.fit()` on corpus, collection sets on entities and PoS will be identified to harmonise the extracted r... | def fit(self,
corpus: Union[str, Iterable[str]],
sent_delim: str='\.\s+|\r|\n',
preferred_spacy_core: str='en_core_web_sm'
) -> None:
# Initialise corpus
if type(corpus) == str:
self.__corpus__ = [sent+'.' if ('\.' in sent_delim and sent[-1] != '.') else sent... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _preprocess(self):\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\n # self._get_frequent_features()\n # self._compactness_pruning()\n # self._redundancy_pruning()\n # self._ge... | [
"0.6566442",
"0.64008427",
"0.6272306",
"0.6270147",
"0.6244757",
"0.62283623",
"0.61422414",
"0.6133686",
"0.6117981",
"0.6093613",
"0.60885054",
"0.60684276",
"0.6040109",
"0.60277957",
"0.6005362",
"0.59342384",
"0.59225696",
"0.59128237",
"0.5904542",
"0.58896387",
"0.588... | 0.64138544 | 1 |
Starts a java server powering CoreNLP backend to obtain triplets. Sentences (documents) will be joined with a `\s` to form a continuous string for purpose of triplettext annotation. | def extract_triplets(self) -> Iterable[dict]:
stg_corpus = [txt.strip()+"." if txt.strip()[-1]!="." else txt.strip() for txt in self.__corpus__]
stg_corpus = ' '.join(self.__corpus__)
with StanfordOpenIE() as client:
triples_corpus = client.annotate(stg_corpus)
self.__tripl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, corenlp_path=CORENLP_PATH, memory=\"3g\", serving=False,\n annotators=[\"tokenize\", \"ssplit\", \"pos\", \"lemma\", \"ner\", \"parse\", \"dcoref\"], **kwargs):\n\n # spawn the server\n self.serving = serving\n self.corenlp_path = corenlp_path\n self.m... | [
"0.6039067",
"0.58356154",
"0.5720516",
"0.5653867",
"0.5537428",
"0.5528703",
"0.54213464",
"0.54019606",
"0.5283025",
"0.5274211",
"0.5274211",
"0.5243562",
"0.52289236",
"0.5215304",
"0.51969665",
"0.5168834",
"0.51489794",
"0.51383555",
"0.50998783",
"0.5063674",
"0.50617... | 0.45885175 | 100 |
Parse relation triplets over the following conditions 1. Remove triplets with pronouns and determinants in subj/obj; i.e. "we", "she" "I", "their", etc. 2. Harmonise duplicated triplets, return only the superset triplet Semantic comparison option using word mover distance & agglomerative clustering FastText via Gensim ... | def parse_triplets(self,
levenshtein_thold: float=20.,
coph_scr: float=2.) -> Iterable[dict]:
# Remove pronoun and determiners
parse_triples = [triple for triple in self.__triples_corpus__
if (triple['subject'] not in self.__pron_det_pos_words__ and
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_data_from_input_file(triplet):\n\n sentence = triplet.subject + ' ' + triplet.predicate + ' ' + triplet.object\n doc = nlp(unicode(sentence))\n root = doc[0]\n for t in doc:\n if t.pos_ == 'VERB' and t.head == t:\n root = t\n # elif t.pos_ == 'NOUN'\n\n # also, i... | [
"0.61057407",
"0.56719995",
"0.55161005",
"0.5455312",
"0.5447199",
"0.5435746",
"0.5421998",
"0.5421532",
"0.53770727",
"0.5327237",
"0.53150713",
"0.5306053",
"0.52893126",
"0.52765054",
"0.52570033",
"0.5234349",
"0.5214712",
"0.5208659",
"0.5204619",
"0.5195088",
"0.51826... | 0.61369044 | 0 |
iterate through all the columns of a dataframe and modify the data type to reduce memory usage. | def reduce_mem_usage(df):
start_mem = df.memory_usage().sum() / 1024**2
print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
for col in df.columns:
col_type = df[col].dtype
if col_type != object:
c_min = df[col].min()
c_max = df[col].max()
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce_memory_footprint(df):\n for col in df.columns:\n if df[col].dtypes == 'float64':\n df[col] = df[col].astype('float32')\n elif df[col].dtypes == 'int64':\n df[col] = df[col].astype('int32')\n \n return df",
"def assign_column_types(self):\n type_list ... | [
"0.7273015",
"0.7129629",
"0.6986671",
"0.6947576",
"0.6945362",
"0.6894538",
"0.68647027",
"0.684416",
"0.6794204",
"0.66469336",
"0.6535974",
"0.65137196",
"0.6412989",
"0.6380717",
"0.6350639",
"0.6318383",
"0.62952274",
"0.62595475",
"0.6252028",
"0.6232626",
"0.6206035",... | 0.5701764 | 55 |
Set defaul config to app | def configure_app(self, defaults: t.Optional[DefaultConfig]) -> None:
self.config = Config(defaults) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_config(app):\n # set config from config.py\n app.config.from_object('config')\n\n # override config from secret conf files\n pi_home = os.path.dirname(app.config['ENVPATH']) # /home/pi\n secret_conf_dir = os.path.join(pi_home, 'CONFIG_CHAUDIERE') # /home/pi/CONFIG_... | [
"0.7135407",
"0.6767803",
"0.67038256",
"0.6664277",
"0.65583634",
"0.6471732",
"0.6440063",
"0.64349705",
"0.64288706",
"0.63906646",
"0.6379789",
"0.63641423",
"0.63625246",
"0.6274701",
"0.627201",
"0.6265376",
"0.6263423",
"0.6263423",
"0.62554973",
"0.6252563",
"0.624745... | 0.7263818 | 0 |
A temporary method that puts the current class object into context | def init_context(self, obj: object) -> None:
self.context = Context.init_curent_app_context(obj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, context):\n self.__context = context",
"def __init__(self, context):\n self.__context = context",
"def __init__(self):\n self._context = {}",
"def context(self) -> Any:\n ...",
"def context(self) -> CONTEXT:",
"def context(self, context):\n self._context ... | [
"0.7450737",
"0.70434624",
"0.7007259",
"0.6924677",
"0.691949",
"0.6833353",
"0.6827452",
"0.67908674",
"0.6757111",
"0.67294806",
"0.67294806",
"0.6697211",
"0.66805935",
"0.6665369",
"0.6659875",
"0.66362715",
"0.66362715",
"0.66362715",
"0.66362715",
"0.66362715",
"0.6636... | 0.62170887 | 37 |
Special decorator. Apends route to all routes list. | def route(self, path: str, **args: t.Any) -> t.Callable:
def decorator(f: t.Callable) -> None:
RouteMap.add_route(Route(path, f, args.get('methods', ['GET'])))
return decorator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_routes(self):\n pass",
"def decorator(self, decorator: Route.Decorator):\n pass",
"def routes(self, body):\n pass",
"def add_route(app, *args):\n for route in args:\n app.router.add_route(route[0], route[1], route[2])",
"def add_routes(self, mapper):\n pass",
... | [
"0.71331024",
"0.6906696",
"0.68637866",
"0.6778305",
"0.6636988",
"0.661092",
"0.65922093",
"0.65910494",
"0.6576909",
"0.65327954",
"0.6525126",
"0.6481399",
"0.64676505",
"0.64033693",
"0.63921976",
"0.6354994",
"0.6352109",
"0.6248349",
"0.6196869",
"0.61872745",
"0.61815... | 0.68121827 | 3 |
Posts the product data into the ProductData Model. | def setUpClass(self):
self.content_type = "application/json"
self.product_payload = {"name": "Olive Oil"} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self):\n data = request.json\n new_product = ProductModel(**data)\n new_product.save()\n response_object = {\n 'status': 'success',\n 'message': 'Product successfully created.',\n 'product_id': new_product.id\n }\n return response_... | [
"0.6956942",
"0.6889219",
"0.67746776",
"0.6755537",
"0.6738365",
"0.65107906",
"0.63893867",
"0.6386395",
"0.6373849",
"0.61861396",
"0.6185986",
"0.61542445",
"0.61542445",
"0.6140429",
"0.61243504",
"0.6106736",
"0.61011493",
"0.6093553",
"0.60679495",
"0.6036408",
"0.5984... | 0.0 | -1 |
SetUp method will be called before executing each test case. Validating with Post request by providing valid data | def setUp(self):
# Request the Product Id by posting it
response = self.client.post('/api/productsdata/',
data=json.dumps(self.product_payload),
content_type=self.content_type)
# Checking the response
self.assertEqu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n self.app = app\n self.client = self.app.test_client(self)\n self.app.testing = True\n self.order = mock_data['order']\n data = json.dumps(mock_data['admin'])\n response = self.client.post(\n 'api/v1/login', content_type=\"application/json\", d... | [
"0.7155883",
"0.714143",
"0.70978665",
"0.705759",
"0.7048931",
"0.7033783",
"0.70278466",
"0.7015345",
"0.6962825",
"0.69618106",
"0.6950066",
"0.6931418",
"0.6914347",
"0.6913533",
"0.68996364",
"0.68958426",
"0.68958426",
"0.68958426",
"0.68882835",
"0.6876467",
"0.6873621... | 0.6510264 | 64 |
Resets the default values | def tearDownClass(self):
self.product_id = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _reset(self):\n self._value = self._default",
"def reset(self):\n self.data = self._defaults",
"def reset(self):\r\n # TODO: have reset flag such that it forces all the bottom changes\r\n self.pwm_freq = self._default[\"pwm_freq\"]\r\n self.gate_logic = self._default[... | [
"0.8205602",
"0.8185284",
"0.8134978",
"0.7798123",
"0.77967864",
"0.76986134",
"0.7528179",
"0.7445453",
"0.73893666",
"0.7374498",
"0.7374498",
"0.7374498",
"0.7374498",
"0.7344047",
"0.7329444",
"0.73153704",
"0.73153704",
"0.73153704",
"0.7301515",
"0.72893625",
"0.728936... | 0.0 | -1 |
Validating ProductsDataViewSet by giving Invalid data | def test_ProductsDataViewSet_with_post_Invalid_data(self):
payload = {
"name": "1234"
}
# Request the data by API call.
response = self.client.post('/api/productsdata/',
data=json.dumps(payload),
content... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_dataset(self):\n pass",
"def is_valid(self, dataset):\n pass",
"def test_ProductsDataViewSet_with_get_request_Invalid_id(self):\n # Request the data by API call.\n response = self.client.get('/api/productsdata/{}/'.format(-1))\n\n # Checking the response\n ... | [
"0.6795187",
"0.6527712",
"0.62331474",
"0.62078047",
"0.6093575",
"0.6072888",
"0.5991253",
"0.5977534",
"0.59747654",
"0.5947358",
"0.5937604",
"0.5932143",
"0.59246784",
"0.5910832",
"0.58964",
"0.5830329",
"0.5815245",
"0.5773554",
"0.5771487",
"0.57573295",
"0.57554066",... | 0.73469806 | 0 |
Validating ProductsDataViewSet using get request method | def test_ProductsDataViewSet_with_get_request(self):
# Request the data by API call.
response = self.client.get('/api/productsdata/')
# Checking the response
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['count'], 1)
self.assertEqual(respon... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ProductsDataViewSet_with_get_request_id(self):\n # Request the data by API call.\n response = self.client.get('/api/productsdata/{}/'.format(\n self.product_id))\n\n # Checking the response\n self.assertEqual(response.status_code, 200)\n self.assertIsNotNone(r... | [
"0.7251704",
"0.6607075",
"0.6369387",
"0.5741582",
"0.5719708",
"0.5598621",
"0.55916286",
"0.55769634",
"0.5567388",
"0.5546251",
"0.55135393",
"0.5474931",
"0.5474357",
"0.5402799",
"0.5396396",
"0.5390451",
"0.5390293",
"0.5374702",
"0.5366535",
"0.53604525",
"0.5345702",... | 0.7067096 | 1 |
Validating ProductsDataViewSet using get request method with Id | def test_ProductsDataViewSet_with_get_request_id(self):
# Request the data by API call.
response = self.client.get('/api/productsdata/{}/'.format(
self.product_id))
# Checking the response
self.assertEqual(response.status_code, 200)
self.assertIsNotNone(response.json... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ProductsDataViewSet_with_get_request_Invalid_id(self):\n # Request the data by API call.\n response = self.client.get('/api/productsdata/{}/'.format(-1))\n\n # Checking the response\n self.assertEqual(response.status_code, 404)\n self.assertEqual(response.json()['detail'... | [
"0.7191686",
"0.673298",
"0.59211195",
"0.585185",
"0.58161724",
"0.5667275",
"0.5570321",
"0.5554077",
"0.5522598",
"0.5515945",
"0.5448646",
"0.5404771",
"0.53977585",
"0.53932184",
"0.5391353",
"0.53493273",
"0.53440976",
"0.5339966",
"0.533051",
"0.53057694",
"0.5302475",... | 0.7739606 | 0 |
Validating ProductsDataViewSet using get request method with Invalid Id | def test_ProductsDataViewSet_with_get_request_Invalid_id(self):
# Request the data by API call.
response = self.client.get('/api/productsdata/{}/'.format(-1))
# Checking the response
self.assertEqual(response.status_code, 404)
self.assertEqual(response.json()['detail'], 'Not fou... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ProductsDataViewSet_with_get_request_id(self):\n # Request the data by API call.\n response = self.client.get('/api/productsdata/{}/'.format(\n self.product_id))\n\n # Checking the response\n self.assertEqual(response.status_code, 200)\n self.assertIsNotNone(r... | [
"0.73838174",
"0.650162",
"0.6430197",
"0.6365987",
"0.59624434",
"0.5900515",
"0.5785338",
"0.5644582",
"0.5601564",
"0.55595815",
"0.5494436",
"0.5453852",
"0.5401711",
"0.5401711",
"0.5401711",
"0.53924847",
"0.5382707",
"0.537352",
"0.5360401",
"0.5338085",
"0.53339374",
... | 0.77829665 | 0 |
Map towers to 412 integer Examples >>> state([[1], [3], [5, 4], [2]]) 668 = 0 40 + 2 41 + 1 42 + 2 43 + 2 44 | def state(towers):
ret = 0
for i, row in enumerate(towers):
for val in row:
ret += i * 4**(val-1)
return ret | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def state_to_locations(state: list) -> list:\n\n locations = []\n for i in range(0, 16):\n locations.append((0, 0))\n # Each tuple represents a location on the board as (row, column)\n\n \"\"\" \"locations\" keeps track of all fifteen numbers in the given state and the goal \n state. The ... | [
"0.5918972",
"0.58628327",
"0.5638546",
"0.56378",
"0.55551183",
"0.55406606",
"0.5532196",
"0.5530488",
"0.55285954",
"0.5523649",
"0.5497859",
"0.54556745",
"0.5416261",
"0.5404722",
"0.53601176",
"0.53601176",
"0.53426325",
"0.53384787",
"0.53346574",
"0.53269804",
"0.5321... | 0.70966303 | 0 |
Compile a Keras model for training. | def compile_model(arch='unet', input_shape=(512, 512, 3), base_depth=64,
lr=0.0001, optimizer='Adam', loss_func='binary_crossentropy',
additional_metrics=[], verbose=False, **model_args):
if arch == 'unet':
model = vanilla_unet(input_shape=input_shape, base_depth=base_de... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_model(self):\n self.model = Sequential()\n # print self.layers[0].identifier\n # print self.layers[0].parameters\n for layer in self.layers:\n # print layer.identifier\n # print layer.parameters\n self.model.add(layer.toKerasFn())\n\n\n ... | [
"0.75971025",
"0.73542714",
"0.7245603",
"0.72389716",
"0.7190872",
"0.7189013",
"0.7189013",
"0.7041905",
"0.70105064",
"0.7008368",
"0.6986616",
"0.69407946",
"0.69306886",
"0.6893068",
"0.6885908",
"0.6857928",
"0.6855142",
"0.68523884",
"0.68522537",
"0.68383485",
"0.6812... | 0.6354171 | 71 |
Keras implementation of untrained TernausNet model architecture. | def ternausnetv1(input_shape=(512, 512, 3), base_depth=64):
inputs = Input(input_shape)
conv1 = Conv2D(base_depth, 3, activation='relu', padding='same')(inputs)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2_1 = Conv2D(base_depth*2, 3, activation='relu',
padding='same')(pool1)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_model(self, inputs, is_training):\n with tf.variable_scope('ResNet50'):\n x = conv2d(inputs, 64, [7, 7], strides=[1, 2, 2, 1], name='conv1') # size 1/2\n x = bn(x, is_training)\n x = relu(x)\n x = max_pool(x, ksize=[1, 3, 3, 1], name='pool1') ... | [
"0.68659437",
"0.6799533",
"0.67096835",
"0.65879214",
"0.6583436",
"0.6571797",
"0.65467453",
"0.6540808",
"0.6535172",
"0.6508968",
"0.64964247",
"0.64894855",
"0.6482305",
"0.6459471",
"0.6444903",
"0.6442067",
"0.6426774",
"0.64207906",
"0.6405138",
"0.6398822",
"0.639816... | 0.65226 | 9 |
Keras vanilla unet architecture implementation. | def vanilla_unet(input_shape=(512, 512, 3), base_depth=32, drop_rate=0,
seed=1337):
input = Input(input_shape)
conv1 = Conv2D(base_depth, 3, activation='relu', padding='same')(input)
bn1 = BatchNormalization()(conv1)
drop1 = Dropout(drop_rate, seed=seed)(bn1)
conv2 = Conv2D(base_de... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mobile_unet(\n inputs, \n depth=3,\n filters=64,\n out_channels=None,\n out_activation=None,\n kernel_initializer=None,\n dtype=None,\n name=None,\n seed=None,\n):\n\n name_scope = name\n if name_scope:\n name = lambda n: '{}/{}'.format(name_scope, n)\n else:\n name = lambda n: n\n kernel_in... | [
"0.7285625",
"0.6758433",
"0.66565907",
"0.6478514",
"0.6467221",
"0.64668006",
"0.6460222",
"0.64068955",
"0.63583106",
"0.6349955",
"0.62737465",
"0.62671775",
"0.62398577",
"0.62321264",
"0.62173873",
"0.61882025",
"0.6175658",
"0.6164245",
"0.6078906",
"0.6075447",
"0.606... | 0.6500072 | 3 |
Builds a CoverMultiWaySearchTree of n nodes with all the currency codes in the standard | def build_tree(n=None) -> CoverMultiWaySearchTree:
tree = CoverMultiWaySearchTree()
codes = [currency.code for currency in cur]
shuffle(codes)
currencies = [Currency(code) for code in codes]
if n is None:
n = len(currencies)
for currency in currencies[:n]:
tree[currency._code] = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_tree(n, d, name=defaultname):\n return build_tree_helper(1, n, 1, d, name)",
"def build(n):\n if n not in memo:\n res = []\n if n % 2 != 0:\n for i in range(1, n - 1):\n left = i\n right = n - 1... | [
"0.5964563",
"0.5795323",
"0.5791167",
"0.5771873",
"0.55232745",
"0.5508132",
"0.5490907",
"0.5467991",
"0.5449655",
"0.53897923",
"0.53540474",
"0.5349767",
"0.53464985",
"0.53308815",
"0.5326568",
"0.5323885",
"0.5319227",
"0.5293522",
"0.5292058",
"0.5261324",
"0.52417105... | 0.8640555 | 0 |
Find the number of items in nodes in range [a, b] | def get_number_of_useful_items(nodes, a: str, b: str) -> int:
return sum(int(a <= item.key <= b) for node in nodes for item in node.elements) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def f02_03_countElemBetween(l, a, b):\n return sum([a < x < b for x in l])",
"def numberOfNodes(i):\n \n if (i == 1 or i == 2):\n i = RANGE\n else:\n i = i + RANGE\n return i",
"def countNodes(epr):\n result = 1\n argLst = epr.args\n for arg in argLst:\n ... | [
"0.69374925",
"0.6823391",
"0.65383244",
"0.6350672",
"0.6334986",
"0.6127555",
"0.6124622",
"0.6086067",
"0.6057941",
"0.6051697",
"0.6039297",
"0.5993141",
"0.59556144",
"0.59417903",
"0.59389144",
"0.5936251",
"0.59148836",
"0.5914569",
"0.5904718",
"0.5901973",
"0.5877726... | 0.8006855 | 0 |
Tries to compute the (k, c1, c2)cover of tree with the minimum number of nodes. It follows a greedylike approach. | def compute_cover(tree: CoverMultiWaySearchTree,
k: int, c1: str, c2: str) -> Optional[Set[CoverMultiWaySearchTree.Position.Node]]:
# Step 1: Find nodes useful for the (k, c1, c2)-cover
nodes = tree.find_nodes_in_range(c1, c2)
# Step 2: Count number of items in range [c1, c2]
n = get_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Trees__LCA_LowestCommonDenominator():\n # Python2 ported to Python3 via 2to3-3.7\n # URL:# URL:https://www.hackerrank.com/challenges/binary-search-tree-lowest-common-ancestor/problem\n '''\n class Node:\n def __init__(self,info): \n self.info = info \n self.left ... | [
"0.58355105",
"0.5734315",
"0.5723906",
"0.56961703",
"0.55900025",
"0.55862707",
"0.5409351",
"0.53967494",
"0.53904384",
"0.53811276",
"0.5372247",
"0.53711116",
"0.536589",
"0.5354127",
"0.53164554",
"0.52926135",
"0.529009",
"0.5275919",
"0.5232045",
"0.52311265",
"0.5228... | 0.7809844 | 0 |
given 2d image, lidar and camera as well as the current scan message, localizes the pixel against the lidar data | def localize_pixel(img_pos,camera : Camera,lidar : Lidar, scan : LaserScan) -> tuple:
# ---OBJ--
# x r1 /\ r2 x
# / \
#cam_ray / \ average_ray
# / \
# / \
# CAM ----> LID
#
# has to be 2d
assert (img_pos.size == 2)
cam_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def localize(image):\n\n # Call the vision function in order to have the grid with the obstacle and the goal coordinate\n object_grid, occupancy_grid, world = vision(image)\n\n # Correction of the goal coordinate in order to fit the A* coordinate\n goal_x = object_grid[0][1]\n goal_y = WIDTH_G - o... | [
"0.5971704",
"0.59564734",
"0.5860076",
"0.57806957",
"0.57335377",
"0.56992394",
"0.5685931",
"0.56329805",
"0.5621531",
"0.5617687",
"0.5521019",
"0.5454433",
"0.54460114",
"0.5421576",
"0.5418019",
"0.53956425",
"0.5381104",
"0.53777224",
"0.53671235",
"0.53640884",
"0.534... | 0.80712897 | 0 |
dataset should be an numpy array | def create_dataset(dataset,time_step=1):
dataX,dataY=[],[]
for i in range(len(dataset)-time_step):
a=dataset[i:i+time_step]
dataX.append(a)
dataY.append(dataset[i+time_step])
return np.asarray(dataX),np.asarray(dataY) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def import_data(path_dataset):\n\n X=np.array(pd.read_hdf(path_dataset))\n\n print('Data set shape:',np.shape(X))\n print('#####################################')\n \n return X",
"def __init__(self, dataset: Dataset):\n self.dataset = dataset",
"def normalize_dataset(self):",
"def test_... | [
"0.67377925",
"0.66809493",
"0.66608226",
"0.66065985",
"0.6585924",
"0.6566672",
"0.64988893",
"0.6468879",
"0.6449775",
"0.63172317",
"0.6311449",
"0.6303254",
"0.62615097",
"0.6236997",
"0.621917",
"0.62086684",
"0.6187008",
"0.61858666",
"0.6175827",
"0.6150293",
"0.61375... | 0.6350002 | 9 |
Check that the response is cached. | def test_cache_page(self):
content = self.unique()
calls = []
def get(self, request, *args, **kwargs):
calls.append(None)
return http.HttpResponse(content)
self.assertViewBehavior(
{"get": get},
repeat=2,
status_code=200,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _may_cache(self, request, response=None):\n # any successful request may be cached\n return ((HTTPStatus.OK <= response.status_code < HTTPStatus.BAD_REQUEST)\n if response else True)",
"def _check_cache(self):\n return os.path.exists(self._cache_key)",
"def is_cacheable(... | [
"0.8405517",
"0.7709429",
"0.7438877",
"0.74282634",
"0.72732776",
"0.7268804",
"0.724536",
"0.7205072",
"0.7148417",
"0.71081144",
"0.70911866",
"0.6916305",
"0.686247",
"0.686158",
"0.6831019",
"0.6830744",
"0.675096",
"0.67503",
"0.6729999",
"0.67271733",
"0.6707089",
"0... | 0.6797344 | 16 |
Check that the response is not cached when the behavior is disabled. | def test_cache_page_disabled(self):
content = self.unique()
calls = []
def get(self, request, *args, **kwargs):
calls.append(None)
return http.HttpResponse(content)
self.assertViewBehavior(
{"cache_page": False, "get": get},
repeat=2,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _may_cache(self, request, response=None):\n # any successful request may be cached\n return ((HTTPStatus.OK <= response.status_code < HTTPStatus.BAD_REQUEST)\n if response else True)",
"def test_disabled(self):\n content = self.unique()\n self.assertViewBehavior(\n ... | [
"0.81057525",
"0.76422733",
"0.75728554",
"0.7479882",
"0.7288173",
"0.7107524",
"0.7067377",
"0.7039522",
"0.68838865",
"0.6812274",
"0.676797",
"0.6756619",
"0.6708938",
"0.6700436",
"0.6537605",
"0.65188557",
"0.65129423",
"0.65013593",
"0.64976686",
"0.6464215",
"0.645495... | 0.7505479 | 3 |
Check that the default HTTP method name protection takes precedence. | def test_cache_page_precedence(self):
self.assertViewBehavior(
status_code=405) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _method_check(self, request, allowed=None):\n if allowed is None:\n allowed = []\n\n request_method = request.method.lower()\n allows = ','.join(map(str.upper, allowed))\n\n if request_method == \"options\":\n response = HttpResponse(allows)\n respon... | [
"0.7103364",
"0.70686543",
"0.70461714",
"0.69518584",
"0.68466485",
"0.6784883",
"0.6704716",
"0.67026776",
"0.66991746",
"0.6694735",
"0.66651976",
"0.65623546",
"0.65139705",
"0.64794755",
"0.64261013",
"0.64012486",
"0.63546383",
"0.6338937",
"0.6317658",
"0.63083893",
"0... | 0.0 | -1 |
Check that the defaults do not set any cache control headers on the response. | def test_defaults(self):
content = self.unique()
self.assertViewBehavior(
{"get": content},
status_code=200,
content=content,
headers_exclude="Cache-Control") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _may_cache(self, request, response=None):\n # any successful request may be cached\n return ((HTTPStatus.OK <= response.status_code < HTTPStatus.BAD_REQUEST)\n if response else True)",
"def never_cache_preview(response):\n response.cache_control.max_age = 0\n response.cache... | [
"0.7360473",
"0.7291879",
"0.72360945",
"0.7173469",
"0.704552",
"0.70238",
"0.69512165",
"0.68105143",
"0.67153543",
"0.6714631",
"0.6711166",
"0.6690023",
"0.66247284",
"0.6617076",
"0.6613454",
"0.6605222",
"0.6562822",
"0.6557137",
"0.6548916",
"0.6548916",
"0.6537977",
... | 0.6132521 | 68 |
Check that the public cache control header is set on the resopnse. | def test_public(self):
content = self.unique()
self.assertViewBehavior(
{"cache_control_public": True, "get": content},
status_code=200,
content=content,
headers_exact={"Cache-Control": "public"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def surrogate_control(self):\n def on_update(surrogate_control):\n if not surrogate_control and \"surrogate-control\" in self.headers:\n del self.headers[\"surrogate-control\"]\n elif surrogate_control: # pragma: no cover\n self.headers[\"Surrogate-Contro... | [
"0.6707758",
"0.6568386",
"0.64592665",
"0.6406012",
"0.63427687",
"0.6286725",
"0.6247568",
"0.6247568",
"0.6219212",
"0.61471593",
"0.6057611",
"0.59990674",
"0.5977669",
"0.5969899",
"0.5969899",
"0.5955601",
"0.59221154",
"0.5918134",
"0.59029275",
"0.589787",
"0.5883854"... | 0.6245776 | 8 |
Check that the private cache control header is set on the resopnse. | def test_private(self):
content = self.unique()
self.assertViewBehavior(
{"cache_control_public": False, "get": content},
status_code=200,
content=content,
headers_exact={"Cache-Control": "private"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _may_cache(self, request, response=None):\n # any successful request may be cached\n return ((HTTPStatus.OK <= response.status_code < HTTPStatus.BAD_REQUEST)\n if response else True)",
"def surrogate_control(self):\n def on_update(surrogate_control):\n if not su... | [
"0.66482395",
"0.65089506",
"0.63601464",
"0.6351916",
"0.6276832",
"0.62689084",
"0.6260363",
"0.6110769",
"0.6093864",
"0.6089491",
"0.6072236",
"0.6028623",
"0.59268093",
"0.5891261",
"0.5891261",
"0.5782495",
"0.5728541",
"0.5728541",
"0.57169425",
"0.57111984",
"0.570364... | 0.63673204 | 2 |
Check that the no_cache cache control header is set on the resopnse. | def test_no_cache(self):
content = self.unique()
self.assertViewBehavior(
{"cache_control_no_cache": True, "get": content},
status_code=200,
content=content,
headers_exact={"Cache-Control": "no-cache"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _may_cache(self, request, response=None):\n # any successful request may be cached\n return ((HTTPStatus.OK <= response.status_code < HTTPStatus.BAD_REQUEST)\n if response else True)",
"def nocache(response):\n response.headers['Cache-Control'] = 'no-store, no-cache, m... | [
"0.7414972",
"0.6805398",
"0.67788416",
"0.67497075",
"0.6657216",
"0.6639991",
"0.6516709",
"0.6489518",
"0.6489176",
"0.64887327",
"0.644979",
"0.6448329",
"0.6426001",
"0.63928515",
"0.63785326",
"0.6366645",
"0.63470674",
"0.63470674",
"0.63428575",
"0.6316757",
"0.628442... | 0.7025476 | 1 |
Check that the no_transform cache control header is set on the resopnse. | def test_no_transform(self):
content = self.unique()
self.assertViewBehavior(
{"cache_control_no_transform": True, "get": content},
status_code=200,
content=content,
headers_exact={"Cache-Control": "no-transform"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _may_cache(self, request, response=None):\n # any successful request may be cached\n return ((HTTPStatus.OK <= response.status_code < HTTPStatus.BAD_REQUEST)\n if response else True)",
"def test_not_modified_headers(self):\n\n def get_response(req):\n resp = sel... | [
"0.6575073",
"0.62584645",
"0.6253825",
"0.61756957",
"0.6135134",
"0.61045665",
"0.6085116",
"0.6053426",
"0.6017882",
"0.58883804",
"0.5885764",
"0.5883365",
"0.58609915",
"0.58609915",
"0.577764",
"0.5760166",
"0.57544553",
"0.5737813",
"0.5737813",
"0.5734081",
"0.5727316... | 0.72058463 | 0 |
Check that the must_revalidate cache control header is set on the resopnse. | def test_must_revalidate(self):
content = self.unique()
self.assertViewBehavior(
{"cache_control_must_revalidate": True, "get": content},
status_code=200,
content=content,
headers_exact={"Cache-Control": "must-revalidate"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _may_cache(self, request, response=None):\n # any successful request may be cached\n return ((HTTPStatus.OK <= response.status_code < HTTPStatus.BAD_REQUEST)\n if response else True)",
"def has_cached(self,ourmod,etag=None):\n if \"If-Modified-Since\" in self.request.heade... | [
"0.70986366",
"0.67210567",
"0.6683338",
"0.6584366",
"0.6584366",
"0.6293861",
"0.62422216",
"0.62041104",
"0.6199004",
"0.6124973",
"0.6101025",
"0.608115",
"0.6053864",
"0.60428745",
"0.60428745",
"0.6038889",
"0.6029584",
"0.6014237",
"0.600515",
"0.5989785",
"0.59765875"... | 0.7850928 | 0 |
Check that the proxy_revalidate cache control header is set on the response. | def test_proxy_revalidate(self):
content = self.unique()
self.assertViewBehavior(
{"cache_control_proxy_revalidate": True, "get": content},
status_code=200,
content=content,
headers_exact={"Cache-Control": "proxy-revalidate"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_must_revalidate(self):\n content = self.unique()\n self.assertViewBehavior(\n {\"cache_control_must_revalidate\": True, \"get\": content},\n status_code=200,\n content=content,\n headers_exact={\"Cache-Control\": \"must-revalidate\"})",
"def _may... | [
"0.72086537",
"0.7039436",
"0.6617241",
"0.65517527",
"0.6426039",
"0.6425563",
"0.6400477",
"0.63885456",
"0.63592887",
"0.6339059",
"0.6339059",
"0.6319922",
"0.6256228",
"0.6244743",
"0.62436944",
"0.6205305",
"0.6193491",
"0.6190335",
"0.6190335",
"0.612926",
"0.6054342",... | 0.7780337 | 0 |
Check that the max_age cache control header is set on the resopnse. | def test_max_age(self):
content = self.unique()
self.assertViewBehavior(
{"cache_control_max_age": 1, "get": content},
status_code=200,
content=content,
headers_exact={"Cache-Control": "max-age=1"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_client_max_age_3600(self, sess):\r\n r = sess.get(self.url)\r\n assert self.cache.get(self.url) == r.raw\r\n\r\n # request that we don't want a new one unless\r\n r = sess.get(self.url, headers={'Cache-Control': 'max-age=3600'})\r\n assert r.from_cache is True\r\n\r\n ... | [
"0.72107726",
"0.6873612",
"0.68624157",
"0.66889685",
"0.6536094",
"0.6532378",
"0.6311946",
"0.62280434",
"0.6197227",
"0.61068356",
"0.61068356",
"0.6103469",
"0.60647094",
"0.6050893",
"0.5995915",
"0.5928432",
"0.58629507",
"0.58624345",
"0.5841793",
"0.5827531",
"0.5821... | 0.7228714 | 0 |
Check that the s_maxage cache control header is set on the response. | def test_s_maxage(self):
content = self.unique()
self.assertViewBehavior(
{"cache_control_s_maxage": 1, "get": content},
status_code=200,
content=content,
headers_exact={"Cache-Control": "s-maxage=1"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_max_age(self):\n content = self.unique()\n self.assertViewBehavior(\n {\"cache_control_max_age\": 1, \"get\": content},\n status_code=200,\n content=content,\n headers_exact={\"Cache-Control\": \"max-age=1\"})",
"def test_client_max_age_3600(self... | [
"0.7056533",
"0.69589156",
"0.6764175",
"0.6662597",
"0.6601882",
"0.6553718",
"0.6453501",
"0.640816",
"0.6405672",
"0.63611406",
"0.63209236",
"0.63209236",
"0.63096035",
"0.6251666",
"0.6251313",
"0.6150831",
"0.6150831",
"0.6129807",
"0.6030514",
"0.6019444",
"0.60143363"... | 0.71437556 | 0 |
Check that the behavior is disabled when cache_control is falsy. | def test_disabled(self):
content = self.unique()
self.assertViewBehavior({
"cache_control": False,
"cache_control_public": True,
"get": content},
status_code=200,
content=content,
headers_exclude="Cache-Control") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_disabled(self):\n content = self.unique()\n self.assertViewBehavior(\n {\"never_cache\": False, \"get\": content},\n status_code=200,\n content=content,\n headers_exclude=\"Cache-Control\")",
"def test_no_cache(self):\n content = self.uniq... | [
"0.6935497",
"0.6439297",
"0.6283687",
"0.62281615",
"0.62020856",
"0.6143714",
"0.61050105",
"0.6087825",
"0.59735376",
"0.58653027",
"0.57895696",
"0.5783289",
"0.5764132",
"0.57436347",
"0.57417667",
"0.5730427",
"0.5700605",
"0.5676634",
"0.5612492",
"0.5606958",
"0.55914... | 0.70288587 | 0 |
Check that the default HTTP method name protection takes precedence and that no cache control headers are set on the response. | def test_precedence(self):
self.assertViewBehavior(
{"cache_control_public": True},
status_code=405,
headers_exclude="Cache-Control") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_precedence(self):\n self.assertViewBehavior(\n status_code=405,\n headers_exclude=\"Cache-Control\")",
"def test_cache_page_precedence(self):\n self.assertViewBehavior(\n status_code=405)",
"def filter_request():\n if request.method not in ALLOWED_... | [
"0.7021219",
"0.6748958",
"0.65596247",
"0.64970404",
"0.6401734",
"0.6361947",
"0.6359896",
"0.6333692",
"0.6294945",
"0.62907964",
"0.626692",
"0.6196885",
"0.6187532",
"0.6166396",
"0.61391157",
"0.6137009",
"0.6135213",
"0.6134873",
"0.6127822",
"0.6123319",
"0.6056474",
... | 0.7186979 | 0 |
Check that the defaults set the never cache control headers on the response. | def test_defaults(self):
content = self.unique()
self.assertViewBehavior(
{"get": content},
status_code=200,
content=content,
headers_exact={"Cache-Control": "max-age=0"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_not_modified_headers(self):\n\n def get_response(req):\n resp = self.client.get(req.path_info)\n resp[\"Date\"] = \"Sat, 12 Feb 2011 17:35:44 GMT\"\n resp[\"Last-Modified\"] = \"Sat, 12 Feb 2011 17:35:44 GMT\"\n resp[\"Expires\"] = \"Sun, 13 Feb 2011 17:3... | [
"0.74749523",
"0.730792",
"0.72691476",
"0.7204676",
"0.7196334",
"0.71114993",
"0.70886433",
"0.7050699",
"0.70001507",
"0.69911003",
"0.69644284",
"0.69644284",
"0.68751776",
"0.68522364",
"0.6808271",
"0.6753384",
"0.67490506",
"0.672789",
"0.67168194",
"0.66634655",
"0.66... | 0.64401513 | 65 |
Check that the behavior is disabled when never_cache is falsy. | def test_disabled(self):
content = self.unique()
self.assertViewBehavior(
{"never_cache": False, "get": content},
status_code=200,
content=content,
headers_exclude="Cache-Control") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def can_be_disabled(self) -> bool:\n return True",
"def test_disabled(self):\n content = self.unique()\n self.assertViewBehavior({\n \"cache_control\": False,\n \"cache_control_public\": True,\n \"get\": content},\n status_code=200,\n ... | [
"0.6629997",
"0.6369304",
"0.6163698",
"0.6107162",
"0.60885584",
"0.60602385",
"0.6041304",
"0.60086805",
"0.59680194",
"0.5952674",
"0.5931698",
"0.5891131",
"0.5890093",
"0.5888327",
"0.58407855",
"0.58371407",
"0.5833242",
"0.58196545",
"0.57784563",
"0.57356924",
"0.5717... | 0.66546726 | 0 |
Check that the defualt HTTP method name protection takes precedence and that no cache control headers are set on the response. | def test_precedence(self):
self.assertViewBehavior(
status_code=405,
headers_exclude="Cache-Control") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_precedence(self):\n self.assertViewBehavior(\n {\"cache_control_public\": True},\n status_code=405,\n headers_exclude=\"Cache-Control\")",
"def test_cache_page_precedence(self):\n self.assertViewBehavior(\n status_code=405)",
"def filter_reques... | [
"0.7131305",
"0.6643577",
"0.6529459",
"0.6490842",
"0.63628715",
"0.6359141",
"0.6331613",
"0.62303495",
"0.6216774",
"0.62062776",
"0.6205969",
"0.619509",
"0.6160482",
"0.6113934",
"0.6082911",
"0.6071884",
"0.6065874",
"0.6062073",
"0.6059281",
"0.6055744",
"0.6038644",
... | 0.6926853 | 1 |
Gets the next expiration date for controller init | def get_expiration_date():
dt = datetime.now()
bdays_indx = pd.bdate_range(
dt.strftime("%Y-%m-%d"),
(dt + timedelta(days=20)).strftime("%Y-%m-%d"),
freq=pd.offsets.CustomBusinessDay(calendar=USFederalHolidayCalendar()),
).tolist()
expiration = [x.strftime("%Y-%m-%d") for x in bd... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_expiration_date(self):\n return self.expiration_date",
"def new_token_expiry_date():\n\treturn timezone.now() + datetime.timedelta(days=TOKEN_VALID_DATE)",
"def expireDate(self)->datetime:\n return self.firstAccessDate + timedelta(seconds=self.expirePeriodInSeconds)",
"def default_expir... | [
"0.7094592",
"0.7065402",
"0.69285613",
"0.69055295",
"0.689841",
"0.68810546",
"0.673245",
"0.6552515",
"0.6523685",
"0.6479755",
"0.64234036",
"0.63735986",
"0.6339951",
"0.63121927",
"0.63121927",
"0.62286556",
"0.6214449",
"0.62109494",
"0.6199436",
"0.6199257",
"0.619664... | 0.5652823 | 51 |
Gets the parameters of a controller's `__init__` signature. If required parameters are missing, we get the type and use a default value for it. | def get_parameters(
controller_cls: BaseController, name: str, df_loaded: pd.DataFrame, symbol: str
) -> Dict[str, Any]:
signature = inspect.signature(controller_cls) # type: ignore
kwargs: Dict[str, Any] = {}
for param in signature.parameters.values():
if param.name in ("ticker", "symbol", "c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_controller_parameters(self):\n pass",
"def get_init_arguments_and_types(cls) -> List[Tuple[str, Tuple, Any]]:\n trainer_default_params = inspect.signature(cls).parameters\n name_type_default = []\n for arg in trainer_default_params:\n arg_type = trainer_default_params[arg].annotat... | [
"0.68228567",
"0.6067612",
"0.60517603",
"0.5950492",
"0.5941824",
"0.59053797",
"0.5816272",
"0.57345223",
"0.5695107",
"0.5673528",
"0.565494",
"0.56521165",
"0.56392384",
"0.56297624",
"0.5618912",
"0.5572611",
"0.5571474",
"0.55582863",
"0.5550893",
"0.5530791",
"0.551558... | 0.58957845 | 6 |
Get parser information from source | def _get_parser(self, command: str) -> None:
self.image_exportable[command] = False
def mock_func(fparser: argparse.ArgumentParser, *args, **kwargs):
"""Mock function to get the parser"""
allowed = [EXPORT_BOTH_RAW_DATA_AND_FIGURES, EXPORT_ONLY_FIGURES_ALLOWED]
expor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def source_info(self,fname):\n\t\t# Has this source file already been parsed?\n\t\tif fname in self.src_info:\n\t\t\t# if yes return the previous parse-result\n\t\t\treturn self.src_info[fname]\n\t\t\n\t\t# Create a source file parse-info-container and ast-parse the sourcefile\n\t\tself.src_info[fname] = {}\n\t\ts... | [
"0.6904902",
"0.6440271",
"0.6395715",
"0.6365495",
"0.60317427",
"0.6026721",
"0.60110956",
"0.60086006",
"0.59582776",
"0.5948747",
"0.59301144",
"0.5928795",
"0.5908244",
"0.5893313",
"0.5880123",
"0.5827625",
"0.5825661",
"0.5821086",
"0.5819807",
"0.57932854",
"0.5792863... | 0.0 | -1 |
Mock function to get the parser | def mock_func(fparser: argparse.ArgumentParser, *args, **kwargs):
allowed = [EXPORT_BOTH_RAW_DATA_AND_FIGURES, EXPORT_ONLY_FIGURES_ALLOWED]
export = kwargs.get("export_allowed", NO_EXPORT)
if export in allowed:
self.image_exportable[command] = True
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mock_parser_fcn(s):",
"def mock_parser_fcn(s):\n return s",
"def get_parser_test():\n copy.get_parser()",
"def test_gen_parser(self):\n pass",
"def test_parser_patch_______(parser):\n pass",
"def test_basic_parsers():",
"def test_simple_parse(self):\n pass",
"def test_parse... | [
"0.84827256",
"0.8188624",
"0.7934197",
"0.7360252",
"0.7231253",
"0.69312716",
"0.68654865",
"0.68405986",
"0.6748091",
"0.6636669",
"0.66233593",
"0.65562665",
"0.65125597",
"0.64893055",
"0.6411233",
"0.63841695",
"0.6341068",
"0.6321437",
"0.63205254",
"0.6290101",
"0.627... | 0.0 | -1 |
Get all command parsers | def get_all_command_parsers(self) -> None:
for command in self.commands:
self.get_command_parser(command) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_parsers():\n return [OptimizerFactory.get_parser(optimizer) for optimizer in OptimizerFactory.optimizers]",
"def get_parsers(self):\n return tuple([getattr(self, '_{}'.format(i)) for i in self.parsers_available])",
"def list_parsers(self, *args):\n print('==== Available parsing... | [
"0.7812656",
"0.76759416",
"0.7401005",
"0.715044",
"0.68813735",
"0.6622853",
"0.65283746",
"0.6448501",
"0.63693243",
"0.6357003",
"0.63433",
"0.629923",
"0.62847006",
"0.6254544",
"0.6221769",
"0.62131053",
"0.61972797",
"0.617932",
"0.6152421",
"0.6145008",
"0.61301106",
... | 0.8496855 | 0 |
Checks if controller has commands | def has_commands(self) -> bool:
return len(self.commands) > 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_commands(self):\n pass",
"def check_commands(self):\n self.check_subsystem_commands()\n self._select_mode()",
"def check_subsystem_commands(self):\n self.communications.check_controls()\n self.__check_video()\n self.__check_picture()\n self.__check_pin... | [
"0.78209513",
"0.69910705",
"0.6867466",
"0.6849808",
"0.6793685",
"0.67325574",
"0.6730906",
"0.66486543",
"0.65833414",
"0.6539244",
"0.65337753",
"0.65301454",
"0.65070695",
"0.64574474",
"0.6441197",
"0.6439012",
"0.643634",
"0.6421861",
"0.6406352",
"0.6401896",
"0.63948... | 0.78347164 | 0 |
Gets all controllers modules | def _get_modules(self) -> Dict[str, ModuleType]:
modules = {}
terminal_path = Path(openbb_terminal.__file__).parent
for file in terminal_path.glob("**/*controller.py"):
spec = spec_from_file_location(file.stem, file)
if spec is not None and spec.loader is not None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_modules(self):\n return self._modules.values()",
"def get_controllers(self):\n s = self._NDL_API('getcontrollers', {})\n return s.split(\",\")",
"def modules(self):\n return self._modules.keys()",
"def modules(self):\n return self._modules",
"def init_controllers(self... | [
"0.6834421",
"0.6675395",
"0.6673012",
"0.6617",
"0.65380013",
"0.65167725",
"0.6488117",
"0.635962",
"0.62996364",
"0.62916434",
"0.6280447",
"0.6221304",
"0.62206507",
"0.6197537",
"0.61878586",
"0.6163962",
"0.61522275",
"0.61329126",
"0.6120377",
"0.6109719",
"0.610647",
... | 0.6716505 | 1 |
Get the ControllerDoc instance for a controller | def get_controller_doc(self, controller_name: str) -> ControllerDoc:
if controller_name not in self.controller_docs:
raise KeyError(f"Controller {controller_name} not found")
return self.controller_docs[controller_name] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_controller(self):\n return self.__controller",
"def getController(self):\n return self.__controller",
"def controller( self ):\n\t\ttry:\n\t\t\treturn self._controller\n\t\texcept Exception as e:\n\t\t\tself.logToConsole( \"controller: %s\" % str(e) )",
"def get_controller(cls):\n i... | [
"0.741653",
"0.7332534",
"0.7241322",
"0.7156778",
"0.69970584",
"0.67327803",
"0.66837436",
"0.6661715",
"0.6410457",
"0.6287942",
"0.6268927",
"0.62614125",
"0.6155133",
"0.59957176",
"0.5957962",
"0.59505653",
"0.5928965",
"0.58955836",
"0.5859399",
"0.58194286",
"0.570986... | 0.8244815 | 0 |
Create your Flask app here, with any configuration you need | def create_app(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_app(self):\r\n self.app = Flask(__name__, instance_relative_config=True)\r\n\r\n # Init the secret key of the app -it is a must for flask to run\r\n self.app.config.from_mapping(\r\n SECRET_KEY='!ZNeverSayNever116Z!',\r\n MONGODB_SETTINGS= {'host': 'mongodb://l... | [
"0.8607028",
"0.8580267",
"0.84813267",
"0.8429017",
"0.8415944",
"0.8400027",
"0.83875513",
"0.83820134",
"0.8361291",
"0.8326353",
"0.8321436",
"0.8311477",
"0.83113503",
"0.8264292",
"0.82542884",
"0.82488364",
"0.82475644",
"0.82314956",
"0.82283074",
"0.8227069",
"0.8216... | 0.0 | -1 |
Does the required setup, doing it here means you don't have to call super.setUp in subclasses. | def __call__(self, result=None):
self._pre_setup()
super(TestCase, self).__call__(result)
self._post_tearDown() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n\n BaseTest.setUp(self)",
"def setUp(self):\n\n self._set_up()",
"def setUp(self):\n MainTests.setUp(self)",
"def setUp(self):\r\n # nothing to do, all tests use different things\r\n pass",
"def setUp(self):\n super(BasicTestCase, self).setUp()",
... | [
"0.86375827",
"0.84891623",
"0.8426224",
"0.83878005",
"0.8345125",
"0.8325611",
"0.83032525",
"0.82992846",
"0.82351387",
"0.82132673",
"0.82132673",
"0.8207163",
"0.8206046",
"0.81811917",
"0.81789845",
"0.8178328",
"0.8178328",
"0.813938",
"0.813938",
"0.81383854",
"0.8138... | 0.0 | -1 |
Checks if a HTTP 404 returned e.g. resp = self.client.get("/") self.assert404(resp) | def assert404(self, response):
self.assertTrue(response.status_code == 404) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assertHttpNotFound(self, resp):\r\n return self.assertEqual(resp.status_code, 404)",
"def assert404(self, response):\n self.assertEqual(response.status_code, 404)",
"def test_404_not_found(self):\n response = self.client.get('/testPage404')\n self.assertEqual(response.status_cod... | [
"0.9120416",
"0.8772316",
"0.83236855",
"0.8294703",
"0.8184818",
"0.8164809",
"0.8145341",
"0.8111421",
"0.8110962",
"0.81032133",
"0.80804664",
"0.80263186",
"0.801481",
"0.8005329",
"0.79936945",
"0.79776466",
"0.7923277",
"0.79124707",
"0.77978474",
"0.7754215",
"0.772836... | 0.8698492 | 2 |
Return n random Gaussian mixtures, each of length m. | def layers(n, m):
def bump(a):
x = 1 / (.1 + np.random.random())
y = 2 * np.random.random() - .5
z = 10 / (.1 + np.random.random())
for i in range(m):
w = (i / float(m) - y) * z
a[i] += x * np.exp(-w * w)
a = np.zeros((m, n))
for i in range(n):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_samples(mu1,cov,number_of_samples):\n samples = np.random.multivariate_normal(mu1, cov,number_of_samples)\n return samples",
"def gen_mixture():\n npr.seed(0)\n num_exp = int(1e4)\n x_dim = 2\n z_dim = 2\n mu1 = [5, 5,]\n mu2 = [-5, -5]\n theta = np.array([[2,1],[-1,-2]])\... | [
"0.68880814",
"0.6878117",
"0.68643713",
"0.6842355",
"0.67705274",
"0.67523295",
"0.66760635",
"0.6578122",
"0.6500326",
"0.6500326",
"0.6487499",
"0.646933",
"0.6437274",
"0.64274",
"0.63682324",
"0.63277197",
"0.6299529",
"0.62947476",
"0.6261145",
"0.62566286",
"0.6222994... | 0.0 | -1 |
Delivers HTML for the index (search) page | def get(self):
return render_template("index.html") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search():\r\n return render_template(\"/home/search.html\")",
"def index(self) -> HTMLBody:\n\t\treturn render_template(\"index.jinja2\")",
"def index(self):\n\t\treturn render_template('index.html')",
"def search_page():\n return render_template('page_query.html', search_label=g_search_type)",
"... | [
"0.7677268",
"0.73201054",
"0.72925377",
"0.7237074",
"0.7205405",
"0.7118157",
"0.7075616",
"0.7043515",
"0.7043515",
"0.7014733",
"0.7010515",
"0.70035577",
"0.6989658",
"0.6979827",
"0.6978994",
"0.69691384",
"0.69691384",
"0.6959514",
"0.6951294",
"0.6951294",
"0.6951294"... | 0.66266 | 98 |
Return the mongodb session document or None | def _get_mongo_session(self, sid):
return self.coll.find_one({'sid': sid}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def find_session_by_id(id: int, mongo: MongoDB = mongodb) -> SessionOutModel:\n if session := await mongo.session_coll.find_one({\"id\": id}):\n return SessionOutModel(**session)\n else:\n return SessionOutModel()",
"def document(self):\n query = {\"_id\": ObjectId(self.document_... | [
"0.68857235",
"0.6614606",
"0.6558535",
"0.6487476",
"0.64846057",
"0.6472054",
"0.6447504",
"0.6445352",
"0.6444354",
"0.64425755",
"0.64312917",
"0.6427674",
"0.6427674",
"0.6384613",
"0.63736564",
"0.636652",
"0.636652",
"0.63567775",
"0.62485236",
"0.61746705",
"0.6169451... | 0.7997712 | 0 |
Find most similar restaurants to the given restaurant id. | def find_most_similar(topMatches, unique_ids, business_id_to_name, id1, destCity, contributing_words, k=15):
topMatchesRow = topMatches[id1][destCity]
# max_indices = np.argpartition(rel_row, -k)[-k:]
# most_similar_scores_and_ids = [(rel_row[x], business_id_to_name[unique_ids[x]]) for x in max_indices]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def knearest( self, restaurant_id, set_of_restaurants, k = 7, reg = 3.0 ):\t\t\n\t\tsimilar = []\t\t\n\t\tfor other_rest_id in set_of_restaurants:\n\t\t\tif other_rest_id != restaurant_id:\n\t\t\t\tsim, n_common = self.get( other_rest_id, restaurant_id )\n\t\t\t\tsim = self.shrunk_sim( sim = sim, n_common = n_comm... | [
"0.6971912",
"0.61779565",
"0.58842546",
"0.5853193",
"0.58256835",
"0.5704557",
"0.5649172",
"0.55321133",
"0.5525376",
"0.5499993",
"0.5454",
"0.5446497",
"0.543819",
"0.53923166",
"0.53886646",
"0.5385439",
"0.5318487",
"0.5313097",
"0.5302046",
"0.52968377",
"0.5293707",
... | 0.516834 | 28 |
Constructor takes a function implementing | def __init__(self, target, size=1, disable_result=False, max_backlog=None):
super(UnorderedStage, self).__init__(_Worker, size, disable_result,
input_tube=TubeQ(maxsize=max_backlog) if max_backlog else None,
task_fn=target... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self,\n function: Callable):\n\n self._function = function",
"def __init__(self, fn: callable):\n self.fn = fn",
"def __init__(self, function, **kwargs):\n self.function = function\n self.kwargs = kwargs",
"def __init__(self, function: Optional[Callabl... | [
"0.8293008",
"0.81340635",
"0.783096",
"0.77749276",
"0.77566177",
"0.7748299",
"0.7734389",
"0.770646",
"0.7631844",
"0.75551623",
"0.7547969",
"0.75283885",
"0.75283885",
"0.7436056",
"0.74256027",
"0.74251497",
"0.7334676",
"0.72538793",
"0.720251",
"0.71191573",
"0.711218... | 0.0 | -1 |
Used for users choice to abort execution | def user_exit(cls):
cls.exit_program(ErrorCodes.E_USER_EXIT) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def abort(self):\n print(\"abort\")",
"def aborting(self):\n \n pass",
"def abort() -> NoReturn:\n raise AbortSignal",
"def abort(self):\r\n LOG(\"Aborting execution\")\r\n self.controller.abort()",
"def abort(self):\n raise NotImplementedError",
"def Abort(self):... | [
"0.81656134",
"0.80324596",
"0.7812907",
"0.7759768",
"0.7715282",
"0.75887483",
"0.7499933",
"0.7460148",
"0.7410472",
"0.7264979",
"0.7194431",
"0.7194431",
"0.7194431",
"0.7179388",
"0.7179388",
"0.7112557",
"0.7080062",
"0.7078822",
"0.7020458",
"0.701344",
"0.701344",
... | 0.0 | -1 |
Useed when aborting in error | def error_exit(cls, error_code):
cls.exit_program(error_code) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def aborting(self):\n \n pass",
"def abort(self):\n print(\"abort\")",
"def abort(self):\n raise NotImplementedError",
"def finalize_error():\n print('')\n exit(-1)",
"def fatal(self, *args, **kwargs):",
"def ERR(self):",
"def failed(self):\n\t\tpass",
"def handle_err(se... | [
"0.7865947",
"0.72063535",
"0.7203983",
"0.71698415",
"0.7069497",
"0.6951282",
"0.6933891",
"0.69055516",
"0.6844137",
"0.681956",
"0.6798855",
"0.6763129",
"0.6727556",
"0.67188966",
"0.66756785",
"0.6650366",
"0.663791",
"0.65903723",
"0.65489334",
"0.6545612",
"0.65073806... | 0.0 | -1 |
Helper method for standardizing exit routines | def exit_program(cls, return_code):
print("Exiting due to: %s" % (ErrorMessages.verbose(return_code)))
sys.exit(return_code) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _exit(msg):\n __exit(msg)",
"def finalize_error():\n print('')\n exit(-1)",
"def __exit(self, *args):\n sys.exit(0)",
"def exit(status=None): # real signature unknown; restored from __doc__\n pass",
"def exit():\n sys.exit(1)",
"def dummy_exit():\r\n def dummy_exit(_exitcode=... | [
"0.75113183",
"0.73528576",
"0.73165536",
"0.72860515",
"0.7231626",
"0.707343",
"0.7060248",
"0.703285",
"0.69615054",
"0.693568",
"0.6898283",
"0.68836755",
"0.68731815",
"0.6870767",
"0.6852176",
"0.6847975",
"0.68277407",
"0.6815739",
"0.6809839",
"0.6800383",
"0.67857563... | 0.64677787 | 55 |
Returns array of all symbols that IEX Cloud supports for API calls | def get_symbols(**kwargs):
return Symbols(**kwargs).fetch() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_iex_symbols(**kwargs):\n return IEXSymbols(**kwargs).fetch()",
"async def get_symbols(self):\n uri = \"/v3/spot/symbols\"\n success, error = await self.request(\"GET\", uri)\n return success, error",
"def get_tickers_IEX():\n iex_token = os.getenv(\"IEX_TOKEN\")\n \n if... | [
"0.7311484",
"0.69377726",
"0.684967",
"0.68196577",
"0.6682733",
"0.66792375",
"0.6649474",
"0.663225",
"0.6602125",
"0.62015605",
"0.6174994",
"0.617182",
"0.6117978",
"0.61011267",
"0.6100854",
"0.6094222",
"0.6056894",
"0.6051363",
"0.60039604",
"0.59178466",
"0.59129816"... | 0.64378136 | 9 |
Returns array of all symbols the Investor's Exchange supports for trading | def get_iex_symbols(**kwargs):
return IEXSymbols(**kwargs).fetch() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_symbols(self):\n return self._call_txtrader_api('query_symbols', {'data': False})",
"def getSymbols(self):\n return self.alpha.getSymbols()",
"def query_all_symbols(self):\n return self._call_txtrader_api('query_symbols', {'data': True})",
"def get_instrument_symbols(self):\n\n... | [
"0.6964469",
"0.6938037",
"0.6910915",
"0.6800684",
"0.64778215",
"0.6415556",
"0.6412698",
"0.6327654",
"0.6232211",
"0.6206617",
"0.6046996",
"0.5954076",
"0.59358066",
"0.58985454",
"0.58625966",
"0.58343506",
"0.58019054",
"0.5789877",
"0.57768756",
"0.5752643",
"0.572558... | 0.608002 | 10 |
Returns IEX Corporate Actions from the refdata endpoints | def get_iex_corporate_actions(start=None, **kwargs):
return CorporateActions(start=start, **kwargs).fetch() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def actions(self) -> List[str]:\n return list(self.__endpoints.keys())",
"def _get_cloud_functions_actions(self, namespace_id):\n\n res = requests.get(\n f\"{self.cf_namespaces_url}/{namespace_id}/actions?limit=200\",\n headers=self.get_headers(),\n )\n return js... | [
"0.578277",
"0.5591671",
"0.55305415",
"0.546881",
"0.5408633",
"0.5356158",
"0.5350876",
"0.53415024",
"0.53084",
"0.5253717",
"0.5253717",
"0.5253717",
"0.5253487",
"0.524838",
"0.52430826",
"0.52192104",
"0.51942307",
"0.51654327",
"0.51577294",
"0.51444995",
"0.5118404",
... | 0.6782529 | 0 |
Returns IEX Dividends from the refdata endpoints | def get_iex_dividends(start=None, **kwargs):
return Dividends(start=start, **kwargs).fetch() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_path_endpoints(self):\n endpoints = []\n\n # Get the far end of the last path segment\n path, split_ends, position_stack = self.trace()\n endpoint = path[-1][2]\n if split_ends is not None:\n for termination in split_ends:\n endpoints.extend(term... | [
"0.57260317",
"0.570597",
"0.5704981",
"0.5656375",
"0.5609971",
"0.542474",
"0.5416715",
"0.54091465",
"0.5392832",
"0.53809077",
"0.5363819",
"0.53049743",
"0.52954215",
"0.5283466",
"0.5228727",
"0.52135223",
"0.51494527",
"0.5141439",
"0.51192796",
"0.5101566",
"0.5099677... | 0.60407233 | 0 |
Returns IEX Next Day Ex Date from the refdata endpoints | def get_iex_next_day_ex_date(start=None, **kwargs):
return NextDay(start=start, **kwargs).fetch() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_next_day(self):\n pass",
"def next_day(isotext):\n as_arrow = arrow.get(isotext)\n return as_arrow.replace(days=+1).isoformat()",
"def next_day(isotext):\n as_arrow = arrow.get(isotext)\n return as_arrow.replace(days=+1).isoformat()",
"def _get_date(self, relative_idx):\r\n ... | [
"0.6659892",
"0.6455671",
"0.6455671",
"0.5981699",
"0.57411253",
"0.56931394",
"0.5636958",
"0.5636958",
"0.562946",
"0.55402404",
"0.5531359",
"0.5511678",
"0.54665154",
"0.5407168",
"0.538642",
"0.5366092",
"0.5354358",
"0.5353504",
"0.5346452",
"0.53019017",
"0.5287904",
... | 0.71448374 | 0 |
Returns IEX Listed Symbol Directory from the refdata endpoints | def get_iex_listed_symbol_dir(start=None, **kwargs):
return ListedSymbolDir(start=start, **kwargs).fetch() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def path_entries(self):",
"async def Available_Endpoints() -> List[Dict[str, str]]:\n return [{\"path\": endpoint} for endpoint in busylightapi.endpoints]",
"def uri(self) -> list:\n raise NotImplementedError(\"ErddapArgoDataFetcher.uri not implemented\")",
"def build_filelist(basepath):\n log.i... | [
"0.52443194",
"0.52027243",
"0.51738554",
"0.50811166",
"0.507001",
"0.5039871",
"0.5038013",
"0.5036818",
"0.5025535",
"0.5022163",
"0.5022163",
"0.4984427",
"0.4979942",
"0.49156174",
"0.48973256",
"0.48810825",
"0.48625612",
"0.48537242",
"0.48472953",
"0.48335177",
"0.483... | 0.67579544 | 0 |
Stores the start or end time depending on which call. Prints the execution time. | def mark(self, message=''):
if message not in self.start:
self.start[message] = -1
self.end[message] = -1
if self.start[message] is -1:
self.start[message] = timer()
else:
if self.end[message] is -1:
self.end[message] = time... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_execution_time(self):\n self.execution_time = self.end_time - self.start_time\n\n print('\\n')\n self.message('**[OPERATION COMPLETE]**********************************************************************')\n if self.arg_data:\n self.message(' Execution Time: {} ms'.fo... | [
"0.7140009",
"0.69303364",
"0.68803954",
"0.6845913",
"0.6787339",
"0.67645544",
"0.67532915",
"0.67017174",
"0.6616614",
"0.6606172",
"0.6602709",
"0.6592854",
"0.6588501",
"0.65421814",
"0.6496357",
"0.64860296",
"0.6475452",
"0.64733225",
"0.64631885",
"0.6398203",
"0.6392... | 0.0 | -1 |
Converts a string into a returned boolean. | def string_to_bool(arg):
if arg.lower() == 'true':
arg = True
elif arg.lower() == 'false':
arg = False
else:
raise ValueError('ValueError: Argument must be either "true" or "false".')
return arg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toBool( string ):\r\n return string == 'true'",
"def __str_to_bool(self, s):\n if s == 'True':\n return True\n elif s == 'False':\n return False\n else:\n raise ValueError",
"def strToBool(s):\n\tassert type(s) == str or type(s) == unicode\n\treturn ... | [
"0.84717965",
"0.84081817",
"0.82726616",
"0.8180654",
"0.8157958",
"0.81277066",
"0.81115925",
"0.8042077",
"0.8028196",
"0.8024185",
"0.80018777",
"0.7945584",
"0.7944686",
"0.79419595",
"0.79260886",
"0.792579",
"0.7923662",
"0.7874771",
"0.78647715",
"0.7845575",
"0.78369... | 0.7726734 | 27 |
Configures CUDA environment variable and returns tensorflow GPU config. | def set_gpu(gpu):
os.environ['CUDA_VISIBLE_DEVICES'] = gpu
tf_config = tf.ConfigProto()
tf_config.gpu_options.allow_growth = True
return tf_config | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def configure_gpu_tf():\n\n try:\n # locate available devices & set required environment variables\n available_device_ids = GPUtil.getFirstAvailable(order='first', maxLoad=0.7, maxMemory=0.7, attempts=1, interval=10)\n available_device_id = available_device_ids[0]\n os.environ['CUDA_... | [
"0.7806248",
"0.71696466",
"0.7148312",
"0.7142579",
"0.69135433",
"0.686044",
"0.6859421",
"0.6798698",
"0.6659943",
"0.66523975",
"0.6578853",
"0.64233935",
"0.6382924",
"0.63151455",
"0.62676334",
"0.6249967",
"0.6245296",
"0.620838",
"0.6173646",
"0.6164236",
"0.61608374"... | 0.78912264 | 0 |
Initializes params dictionary to be used in most functions. | def set_parameters(api_name='',
targeted_flag='true',
tv_flag='false',
hinge_flag='true',
cos_flag='false',
interpolation='bilinear',
model_type='large',
loss_type='triplet',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_params(self, params):\n pass",
"def init_params(self):\n blah",
"def getInitParams(self):\n paramDict = super().getInitParams()\n paramDict['workingDir'] = self.workingDir\n paramDict['dataFilename'] = self.dataFilename\n paramDict['functionID'] = self.functionID\n param... | [
"0.84140587",
"0.8211438",
"0.767338",
"0.7606534",
"0.757486",
"0.75057864",
"0.7484527",
"0.7381143",
"0.7344505",
"0.7301356",
"0.72852105",
"0.7271599",
"0.7269397",
"0.72342885",
"0.7229577",
"0.71677095",
"0.7143791",
"0.7110839",
"0.70676434",
"0.70676434",
"0.70661026... | 0.0 | -1 |
gets the event_id to be used for updating the NR history | def _get_next_event_id(oracle_cursor, transaction_type): # -> (int)
oracle_cursor.execute("""select event_seq.NEXTVAL from dual""")
row = oracle_cursor.fetchone()
event_id = int(row[0])
oracle_cursor.execute("""
INSERT INTO event (event_id, event_type_cd, event_timestamp)
VALUES (:event_id... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def event_id(self):\n return self._event_id",
"def id(self) -> str:\n return self._event.get('id')",
"def _get_next_event_id():\n VenueCrawler._event_id += 1\n return VenueCrawler._event_id",
"def GetEventIdentifier(self):\n return self._event_identifier",
"def getUniqueID(ev... | [
"0.7380551",
"0.6994781",
"0.69346756",
"0.6788159",
"0.67672545",
"0.6624493",
"0.6550354",
"0.6521109",
"0.65177155",
"0.6485925",
"0.6348875",
"0.6325851",
"0.6303582",
"0.62975746",
"0.6296188",
"0.62841356",
"0.6223792",
"0.6218612",
"0.61961144",
"0.6065413",
"0.6057378... | 0.5865381 | 29 |
find the current name instance, set it's end_event_id to event_id if the name was deleted, nothing more needs to be done. otherwise, create a new name_instance and set its start_event_id to event_id | def _consume_nro_names(oracle_cursor, nr, event_id, corp_num):
for name in nr.names:
oracle_cursor.execute("""
SELECT ni.name_instance_id, ni.name_id
FROM name_instance ni
LEFT OUTER JOIN name nm ON nm.name_id = ni.name_id
WHERE nm.request_id = :request_id
AND ni.cho... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_instance_name(self, name):\n self.__instance_name = name",
"def __assign_name_id(self):\n if not self.name_id:\n self.name_id = str(BaseTicketing.objects.create())",
"def find_or_add_event(name, owner, **kwargs):\n res = Event.objects.filter(event_name=name)\n if res.exi... | [
"0.57359993",
"0.55851823",
"0.5272143",
"0.5252561",
"0.5185405",
"0.50811505",
"0.5004009",
"0.49299312",
"0.49113548",
"0.49069375",
"0.4889691",
"0.48329812",
"0.48328593",
"0.4809183",
"0.4782595",
"0.47754022",
"0.4768552",
"0.47577935",
"0.47520742",
"0.47374955",
"0.4... | 0.47233048 | 21 |
Create baseline convolutional recurrent model. Arguments | def create_baseline_model(filters, gru_units, dropout, bias, mels, nb_classes):
inp = Input(shape=(259, mels, 1))
x = Conv2D(filters, (3,3), padding='same', activation='relu', use_bias=bias)(inp)
x = MaxPooling2D(pool_size=(1,5))(x)
x = Conv2D(filters, (3,3), padding='same', activation='relu', use_bias=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_baseline(cls: Type['ResNet'], *, d_in: int, n_blocks: int, d_main: int, d_hidden: int, dropout_first: float, dropout_second: float, d_out: int) ->'ResNet':\n return cls(d_in=d_in, n_blocks=n_blocks, d_main=d_main, d_hidden=d_hidden, dropout_first=dropout_first, dropout_second=dropout_second, normal... | [
"0.647522",
"0.6304403",
"0.6284953",
"0.6194349",
"0.60414153",
"0.5895362",
"0.587735",
"0.58602476",
"0.58557093",
"0.5830293",
"0.5820108",
"0.5811813",
"0.5765692",
"0.576528",
"0.5761624",
"0.57612926",
"0.5757742",
"0.5744773",
"0.573896",
"0.57358533",
"0.573499",
"... | 0.64495075 | 1 |
Create save folder and return the path. Arguments | def save_folder(date_time, sfid, logs_folder, checkpoints_folder):
date_now = str(date_time.date())
time_now = str(date_time.time())
sf = "saved_models/" + date_now + "_" + time_now + "_" \
+ os.path.basename(__file__).split('.')[0] + '_' + sfid
if not os.path.isdir(sf):
os.makedirs(sf)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_save_folder(self):\n absolute_output = os.path.abspath(self.output).replace(\"\\\\\", \"/\")\n if self.paddle_length_factor is not None:\n self.save_folder = f\"{absolute_output}/{self.env_name}/PaddleLength_\" \\\n f\"{self.paddle_length_factor}/se... | [
"0.7928659",
"0.7695204",
"0.76085055",
"0.7281233",
"0.71740186",
"0.7165479",
"0.70561624",
"0.6956532",
"0.6895045",
"0.68900746",
"0.683801",
"0.68368167",
"0.6809364",
"0.6801099",
"0.6799192",
"0.67921394",
"0.6790769",
"0.6772145",
"0.67521167",
"0.67416507",
"0.672368... | 0.75882685 | 3 |
Saves model and history file. Arguments | def save_model(save_folder):
model.save(save_folder + '/savedmodel' + '.h5')
with open(save_folder +'/history.pickle', 'wb') as f_save:
pickle.dump(model_fit.history, f_save) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_model(self, filename):\r\n pass",
"def save_model(model, model_filepath):",
"def save(path_to_model):\n pass",
"def save_model(self, model_path: str):",
"def do_save(self, arg):\n try:\n args = self.saveparser.parseString(arg)\n except pyparsing.ParseException:\n... | [
"0.78629273",
"0.7653769",
"0.73715615",
"0.7215964",
"0.7110899",
"0.70959747",
"0.7047263",
"0.7046574",
"0.7008128",
"0.70005685",
"0.6987576",
"0.6981723",
"0.6968098",
"0.6932804",
"0.69116753",
"0.6904762",
"0.68979573",
"0.68828714",
"0.68811744",
"0.68712103",
"0.6836... | 0.6840933 | 20 |
Plot the accuracy during training for the train and val datasets. Arguments | def plot_accuracy(model_fit, save_folder):
train_acc = model_fit.history['binary_accuracy']
val_acc = model_fit.history['val_binary_accuracy']
epoch_axis = np.arange(1, len(train_acc) + 1)
plt.title('Train vs Validation Accuracy')
plt.plot(epoch_axis, train_acc, 'b', label='Train Acc')
plt.plot... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_accuracy(self):\n plot_title, img_title = self.prep_titles(\"\")\n test_legend = ['training data', 'test data']\n\n # Data for plotting x- and y-axis\n x = np.arange(1, CFG.EPOCHS + 1)\n y = [self.tr_accuracy, self.test_accuracy]\n\n # prints x and y-axis values\n... | [
"0.82207394",
"0.7538035",
"0.7494659",
"0.74623656",
"0.7418454",
"0.7315145",
"0.72615117",
"0.72388804",
"0.7238736",
"0.71817374",
"0.7173168",
"0.71567535",
"0.7148802",
"0.71439624",
"0.7055238",
"0.70549214",
"0.7051441",
"0.7018947",
"0.70176554",
"0.70033777",
"0.700... | 0.7705123 | 1 |
Plot the loss during training for the train and val datasets. Arguments | def plot_loss(model_fit, save_folder):
train_loss = model_fit.history['loss']
val_loss = model_fit.history['val_loss']
epoch_axis = np.arange(1, len(train_loss) + 1)
plt.title('Train vs Validation Loss')
plt.plot(epoch_axis, train_loss, 'b', label='Train Loss')
plt.plot(epoch_axis, val_loss,'r'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loss_plot(train_loss, val_loss, filename):\n\tplt.plot(train_loss)\n\tplt.plot(val_loss)\n\tplt.ylabel('Loss')\n\tplt.xlabel('Epochs')\n\tplt.legend(['Train', 'Val'], loc='upper right')\n\tplt.savefig(filename)\n\tplt.close()",
"def plot_loss():\n df = pd.read_csv('data/loss.csv', encoding='utf-8')\n l... | [
"0.81466526",
"0.80646133",
"0.80406374",
"0.79073626",
"0.7877066",
"0.78295696",
"0.77334934",
"0.7585977",
"0.7578295",
"0.7422468",
"0.735688",
"0.73400354",
"0.72983456",
"0.7278823",
"0.7261395",
"0.72606814",
"0.72324854",
"0.71921957",
"0.71786606",
"0.71336514",
"0.7... | 0.75181407 | 9 |
Plot and save the ROC with AUC value. Arguments | def plot_ROC(model, x_test, y_test, save_folder):
predicted = model.predict(x_test).ravel()
actual = y_test.ravel()
fpr, tpr, thresholds = roc_curve(actual, predicted, pos_label=None)
roc_auc = auc(fpr, tpr)
plt.title('Test ROC AUC')
plt.plot(fpr, tpr, 'b', label='AUC = %0.3f' % roc_auc)
pl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_roc(X,y,test_preds,fname=\"res/roc.png\"):\n\t#Retrieve multiple fpr and tpr values for different thresholds\n\tfpr, tpr, thresholds = roc_curve(y,test_preds)\n\tplt.plot(fpr, tpr)\n\tplt.title(auc(fpr, tpr))\n\tplt.savefig(fname, bbox_inches='tight')\n\tplt.close()",
"def plot_roc_acc(self,x_test,y_tes... | [
"0.7867306",
"0.7626776",
"0.732372",
"0.7319301",
"0.73173314",
"0.7298921",
"0.7294701",
"0.7286847",
"0.71924317",
"0.71809953",
"0.71744895",
"0.7162829",
"0.71388173",
"0.712525",
"0.70957816",
"0.7076601",
"0.70679814",
"0.70641404",
"0.706279",
"0.69863737",
"0.6980341... | 0.78781956 | 0 |
Calculate the TPR, TNR, FPR, FNR and F1 score. Arguments | def metrics(x, y, save_folder, threshold, ds_name):
predicted = model.predict(x)
predicted[predicted > threshold] = 1
predicted[predicted <= threshold] = 0
actual = y
TP = np.sum(np.logical_and(predicted == 1, actual == 1))
FN = np.sum(np.logical_and(predicted == 0, actual == 1))
TN = np.sum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def computeFScores(self, targetLabels, actualLabels):\r\n if self.prMeasures is None:\r\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\r\n if self.prMeasures[0] == 0:\r\n return 0\r\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[... | [
"0.6962998",
"0.6783924",
"0.6656604",
"0.6580796",
"0.6549494",
"0.6458977",
"0.64446396",
"0.6435898",
"0.64287984",
"0.64278877",
"0.6422356",
"0.64145064",
"0.6384937",
"0.6361993",
"0.6317291",
"0.6312312",
"0.6308689",
"0.62624353",
"0.6238393",
"0.6236581",
"0.62225837... | 0.0 | -1 |
Saves the network architecture as a .txt file. Arguments | def save_arch(model, save_folder):
with open(save_folder + '/architecture.txt','w') as a_save:
model.summary(print_fn=lambda x: a_save.write(x + '\n')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, path=\"\"):\n path = path + \"model_\" + str(self.name) + \".txt\"\n if os.path.isfile(path):\n os.remove(path)\n f = open(path, \"w+\")\n for ident in self.networks:\n f.write(ident + \"_\" + self.networks[ident].descriptor.codify_components() + \"_... | [
"0.7442755",
"0.6993565",
"0.69844145",
"0.69380265",
"0.69357723",
"0.6913174",
"0.6849668",
"0.6798643",
"0.66806936",
"0.65847754",
"0.6535876",
"0.6521386",
"0.64706856",
"0.6424189",
"0.6404124",
"0.6398808",
"0.63774717",
"0.6374491",
"0.6335782",
"0.6327243",
"0.629258... | 0.7138623 | 1 |
Reformat data into a suitable format. Arguments | def reformat(dataset):
x = dataset[:, 1]
x = np.stack(x) # reshape to (n, mel bands, timesteps)
x = np.expand_dims(np.moveaxis(x, 1, -1), axis=3) # reformat x to (n, timesteps, mel bands, 1)
y = dataset[:, 2]
y = np.moveaxis(np.stack(y), 1, -1) # reformat y to (n, timesteps, 8)
return x, y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_data(self, data):",
"def format(self, data):",
"def _normalize(self, data):\n norm_data = []\n\n for row in data:\n norm_row = []\n\n for column in row:\n # custom format strings for specific objects\n if isinstance(column, float):\n ... | [
"0.7618255",
"0.7096688",
"0.6632938",
"0.6506588",
"0.6437094",
"0.63554853",
"0.6353619",
"0.63322175",
"0.6280301",
"0.6274984",
"0.626859",
"0.626859",
"0.6263245",
"0.624401",
"0.62409395",
"0.61382896",
"0.61014044",
"0.6049214",
"0.60481143",
"0.6002033",
"0.5962946",
... | 0.56401306 | 40 |
Find scaling value. Arguments | def scale(original_train, new_train):
# find magnitude original training data
o_mag = np.linalg.norm(np.stack(original_train[:,1]))
# find magnitude new data
n_mag = np.linalg.norm(np.stack(new_train[:,1]))
# scale new data
scale = o_mag / n_mag
return scale | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetScale(self):\n ...",
"def get_scale():\r\n\r\n \r\n return 0.5",
"def scale(self):\n return self.distribution.scale",
"def FindScale(self):\n\n ## 6 and from the cv code the distance is 6 then we are good\n print(\"TODO: Very hard\")",
"def get_scaled_value(self, value)... | [
"0.7423413",
"0.73347855",
"0.73237866",
"0.73164004",
"0.7237661",
"0.71535647",
"0.71269476",
"0.70387477",
"0.7011061",
"0.7011061",
"0.6986615",
"0.6979968",
"0.6975686",
"0.695767",
"0.69401443",
"0.69075817",
"0.68978745",
"0.6861623",
"0.68483704",
"0.6829874",
"0.6802... | 0.0 | -1 |
Computes the outcome of a single key by applying thresholding. | def _thresholding(qc_value, thresholds=None):
MAX_BOUND, MIN_BOUND = (1, 0)
if not thresholds:
thresholds = TaskQC.criteria['default'].copy()
if qc_value is None or np.isnan(qc_value):
return int(-1)
elif (qc_value > MAX_BOUND) or (qc_value < MIN_BOUND):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_thresholding(x):\n return x > threshold_otsu(x)",
"def global_threshold(img, threshold_method):\n pass",
"def binary_predict(probs, threshold = 0.5):\n return (probs >= threshold) * np.ones(len(probs))",
"def get_predict(prediction, threshold):\n\n prediction[prediction < threshold] = 0\n... | [
"0.6783998",
"0.67353284",
"0.63087225",
"0.6274074",
"0.61894006",
"0.61030537",
"0.61008376",
"0.60762995",
"0.6047671",
"0.60170645",
"0.59696436",
"0.59311014",
"0.5793961",
"0.57806987",
"0.57802975",
"0.57697934",
"0.5745665",
"0.5731439",
"0.5718352",
"0.5692189",
"0.5... | 0.0 | -1 |
Extract the data from raw data files Extracts all the required task data from the raw data files. | def load_data(self, bpod_only=False, download_data=True):
self.extractor = TaskQCExtractor(
self.session_path, one=self.one, download_data=download_data, bpod_only=bpod_only) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _extract(self):\r\n self._data = []\r\n for fname in self.files:\r\n meta = dict(filename=fname)\r\n\r\n # Perform the actual metadata extraction\r\n fname = os.path.splitext(self.filter_filename(fname))[0]\r\n values = fname.split(self.sep)\r\n\r\n ... | [
"0.6336488",
"0.6332432",
"0.62876016",
"0.61459774",
"0.6088567",
"0.60835356",
"0.60774356",
"0.6022968",
"0.59951735",
"0.59720063",
"0.5907739",
"0.59039",
"0.5902059",
"0.5858731",
"0.5857515",
"0.5839464",
"0.58262634",
"0.5805191",
"0.58041966",
"0.57704633",
"0.576746... | 0.0 | -1 |
Compute and store the QC metrics Runs the QC on the session and stores a map of the metrics for each datapoint for each test, and a map of which datapoints passed for each test | def compute(self, **kwargs):
if self.extractor is None:
kwargs['download_data'] = kwargs.pop('download_data', self.download_data)
self.load_data(**kwargs)
self.log.info(f"Session {self.session_path}: Running QC on behavior data...")
self.metrics, self.passed = get_bpodqc_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute(self, download_data=None):\n if self.extractor is None:\n # If download_data is None, decide based on whether eid or session path was provided\n ensure_data = self.download_data if download_data is None else download_data\n self.load_data(download_data=ensure_dat... | [
"0.6188606",
"0.6146431",
"0.6113068",
"0.60673046",
"0.59287566",
"0.5926206",
"0.5902293",
"0.5877014",
"0.5784998",
"0.573546",
"0.5707369",
"0.5694776",
"0.56773263",
"0.5656921",
"0.5625058",
"0.5584204",
"0.55599093",
"0.5556537",
"0.55550545",
"0.55543596",
"0.5553796"... | 0.61870587 | 1 |
Given a dictionary of results, computes the overall session QC for each key and aggregates in a single value | def compute_session_status_from_dict(results):
indices = np.zeros(len(results), dtype=int)
for i, k in enumerate(results):
if k in TaskQC.criteria.keys():
indices[i] = TaskQC._thresholding(results[k], thresholds=TaskQC.criteria[k])
else:
indices[i]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def aggregate_results(results):\n\n for (config,con,dec),folds in results.iteritems():\n m = MODEL_PATTERN.match(config)\n if m:\n mode = m.groupdict()['mode'] # mle, rl, mrt, ...\n model = m.groupdict()['model'] # haem, hacm, hard, ...\n align = m.groupdict()['a... | [
"0.6222572",
"0.60406405",
"0.5990933",
"0.5945015",
"0.58555114",
"0.5849532",
"0.5788227",
"0.57747865",
"0.5715895",
"0.5701647",
"0.56428385",
"0.5619109",
"0.5589009",
"0.55545366",
"0.5523717",
"0.5481006",
"0.5478383",
"0.545642",
"0.54334474",
"0.53829503",
"0.5372924... | 0.6752876 | 0 |
Computes the overall session QC for each key and aggregates in a single value | def compute_session_status(self):
if self.passed is None:
raise AttributeError('passed is None; compute QC first')
# Get mean passed of each check, or None if passed is None or all NaN
results = {k: None if v is None or np.isnan(v).all() else np.nanmean(v)
for k, v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def aggregate(self):\n data_to_track = {}\n for possession in self.possessions_to_track_aggregate:\n data_to_track[possession] = self._haves[possession]\n\n for variable in self.variables_to_track_aggregate:\n try:\n data_to_track[variable] = self.__dict__[... | [
"0.5516195",
"0.5445356",
"0.5358602",
"0.5349585",
"0.5333742",
"0.5271777",
"0.52661145",
"0.5255679",
"0.5213781",
"0.5190634",
"0.51589733",
"0.51226103",
"0.51122093",
"0.50610095",
"0.5024973",
"0.501899",
"0.50044125",
"0.49149823",
"0.49074388",
"0.48728678",
"0.48719... | 0.5601444 | 0 |
Compute and store the QC metrics Runs the QC on the session and stores a map of the metrics for each datapoint for each test, and a map of which datapoints passed for each test | def compute(self, download_data=None):
if self.extractor is None:
# If download_data is None, decide based on whether eid or session path was provided
ensure_data = self.download_data if download_data is None else download_data
self.load_data(download_data=ensure_data)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute(self, **kwargs):\n if self.extractor is None:\n kwargs['download_data'] = kwargs.pop('download_data', self.download_data)\n self.load_data(**kwargs)\n self.log.info(f\"Session {self.session_path}: Running QC on behavior data...\")\n self.metrics, self.passed =... | [
"0.61865723",
"0.61484236",
"0.6111889",
"0.6068964",
"0.59302425",
"0.5927652",
"0.5902292",
"0.5878314",
"0.5785274",
"0.5735238",
"0.57067233",
"0.56961745",
"0.56763333",
"0.5656826",
"0.5624611",
"0.5584238",
"0.55624455",
"0.55575174",
"0.5555539",
"0.5554058",
"0.55537... | 0.6186402 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.