code stringlengths 42 43.2k | apis list | extract_api stringlengths 115 61.9k |
|---|---|---|
from pathlib import Path
import sys
sys.path.append(str(Path().absolute()))
import logging
log_level = "INFO"
logging.basicConfig(
filename=str(snakemake.log),
filemode="w",
level=log_level,
format="[%(asctime)s]:%(levelname)s: %(message)s",
datefmt="%d/%m/%Y %I:%M:%S %p",
)
from evaluate.calculator... | [
"evaluate.calculator.RecallCalculator",
"evaluate.report.RecallReport.from_files"
] | [((918, 981), 'pathlib.Path', 'Path', (['snakemake.output.recall_file_for_one_sample_vs_nb_samples'], {}), '(snakemake.output.recall_file_for_one_sample_vs_nb_samples)\n', (922, 981), False, 'from pathlib import Path\n'), ((996, 1027), 'logging.info', 'logging.info', (['f"""Loading report"""'], {}), "(f'Loading report'... |
import argparse
import os
import random
import shutil
import time
import warnings
import pickle
from collections import OrderedDict
from datetime import datetime
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import to... | [
"evaluate.Evaluator",
"evaluate.ClassifierGenerator"
] | [((901, 965), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""PyTorch ImageNet Training"""'}), "(description='PyTorch ImageNet Training')\n", (924, 965), False, 'import argparse\n'), ((7204, 7229), 'torch.cuda.device_count', 'torch.cuda.device_count', ([], {}), '()\n', (7227, 7229), False... |
# repo originally forked from https://github.com/Confusezius/Deep-Metric-Learning-Baselines
"""to do:
clean all of the files - particularly the main.py and also the losses and dataset files and the file for doing the dataloading
-- fast loading etc
need to change all of the copyrights at the top of all of the files... | [
"evaluate.DistanceMeasure",
"evaluate.evaluate",
"evaluate.GradientMeasure"
] | [((399, 432), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (422, 432), False, 'import warnings\n'), ((576, 597), 'matplotlib.use', 'matplotlib.use', (['"""agg"""'], {}), "('agg')\n", (590, 597), False, 'import os, numpy as np, argparse, random, matplotlib, datetime\n'), ... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 3 14:33:25 2018
@author: iswariya
"""
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.models as models
from dataloader import SoccerDataset, get_dataloader
from evaluate import predict
from met... | [
"evaluate.predict"
] | [((890, 1016), 'dataloader.SoccerDataset', 'SoccerDataset', (['PATH', 'image_folder', 'mask_folder', 'downsampled_resolution'], {'transform': "['Horizontal_Flip', 'Brightness_adjust']"}), "(PATH, image_folder, mask_folder, downsampled_resolution,\n transform=['Horizontal_Flip', 'Brightness_adjust'])\n", (903, 1016),... |
from argparse import ArgumentParser
from pathlib import Path
import time
import os
import gin
import numpy as np
import torch
import torch.nn as nn
import torch.optim.lr_scheduler as lr_scheduler
from torch.nn import CrossEntropyLoss
from datasets import get_dataset
from models.gan import get_architecture
from torch.... | [
"evaluate.classifier.test_classifier",
"evaluate.classifier.accuracy",
"evaluate.AverageMeter"
] | [((1217, 1244), 'gin.configurable', 'gin.configurable', (['"""options"""'], {}), "('options')\n", (1233, 1244), False, 'import gin\n'), ((699, 762), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""Testing script: Linear evaluation"""'}), "(description='Testing script: Linear evaluation')\n", (713,... |
import os
from generate_libfm_data import generate_libfm_data, tfidf2str
from evaluate import scoring
if not os.path.exists('news_tfidf.pkl') or not os.path.exists('user_tfidf.pkl'):
os.system('python generate_tf_idf_feature_file.py')
if not os.path.exists('train.libfm') or not os.path.exists('dev.libfm') or not ... | [
"evaluate.scoring"
] | [((189, 240), 'os.system', 'os.system', (['"""python generate_tf_idf_feature_file.py"""'], {}), "('python generate_tf_idf_feature_file.py')\n", (198, 240), False, 'import os\n'), ((354, 375), 'generate_libfm_data.generate_libfm_data', 'generate_libfm_data', ([], {}), '()\n', (373, 375), False, 'from generate_libfm_data... |
'''
Usage:
quote_detection.py <model-name> -t <corpus-type> -c <corpus-path> -e <embedding-path>
Options:
-t Corpus type (either parc, rwg, or stop)
-c Path to corpus
-e Path to embeddings file
'''
import random
from docopt import docopt
import torch
import torch.nn as nn
impo... | [
"evaluate.report",
"evaluate.evaluate"
] | [((15507, 15529), 'random.shuffle', 'random.shuffle', (['zipped'], {}), '(zipped)\n', (15521, 15529), False, 'import random\n'), ((20864, 20934), 'evaluate.evaluate', 'evaluate', (['predicted_processed', 'raw_labels'], {'roles': 'roles', 'mode': 'eval_mode'}), '(predicted_processed, raw_labels, roles=roles, mode=eval_m... |
import evaluate
evaluate.dump_aggregated_period()
| [
"evaluate.dump_aggregated_period"
] | [((17, 50), 'evaluate.dump_aggregated_period', 'evaluate.dump_aggregated_period', ([], {}), '()\n', (48, 50), False, 'import evaluate\n')] |
from data_processing import preprocess_28D
import autoencoders.autoencoder as ae
import autoencoders.variational_autoencoder as vae
import autoencoders.sparse_autoencoder as sae
from create_plots import plot_initial_data, plot_test_pred_data, correlation_plot
from evaluate import evaluate_model
import pandas as pd
impo... | [
"evaluate.evaluate_model"
] | [((444, 469), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (467, 469), False, 'import argparse\n'), ((1854, 1898), 'data_loader.load_cms_data', 'load_cms_data', ([], {'filename': '"""open_cms_data.root"""'}), "(filename='open_cms_data.root')\n", (1867, 1898), False, 'from data_loader import l... |
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__)))
import yaml
import logging
import torch
import torch.optim as optim
import torch.optim.lr_scheduler as lr_scheduler
from torch.cuda import amp
from tools.datasets import create_dataloader, preprocess
from tqdm import tqdm
import math
import ... | [
"evaluate.test"
] | [((674, 701), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (691, 701), False, 'import logging\n'), ((1182, 1214), 'os.makedirs', 'os.makedirs', (['wdir'], {'exist_ok': '(True)'}), '(wdir, exist_ok=True)\n', (1193, 1214), False, 'import os\n'), ((1689, 1709), 'tools.general.init_seeds', ... |
import json
from typing import List
from resource_mapping.result_analyzer import ResultAnalyzer
from execution_handler.execution_handler import ExecutionHandler
from aggregator.aggregator import Aggregator, AggregatorResults
from datetime import datetime, date
from quantum_execution_job import QuantumExecutionJob
from ... | [
"evaluate.circuit_gen.circ_gen",
"evaluate.util.sv_to_probability"
] | [((1883, 1897), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1895, 1897), False, 'from datetime import datetime, date\n'), ((2802, 2822), 'config.load_config.load_or_create', 'cfg.load_or_create', ([], {}), '()\n', (2820, 2822), True, 'import config.load_config as cfg\n'), ((2827, 2867), 'logger.set_log_... |
#!/usr/bin/env python3
import argparse
import os
import time
import numpy as np
import pandas as pd
import torch
from torch import optim
import callbacks as cb
import evaluate
import utils
import visual_plt
from continual_learner import ContinualLearner
from data import get_multitask_experiment
from encoder import Cl... | [
"evaluate.intial_accuracy",
"evaluate.show_reconstruction",
"evaluate.show_samples",
"evaluate.initiate_metrics_dict"
] | [((580, 682), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""./main.py"""'], {'description': '"""Run individual continual learning experiment."""'}), "('./main.py', description=\n 'Run individual continual learning experiment.')\n", (603, 682), False, 'import argparse\n'), ((11920, 11959), 'torch.device... |
import argparse
import os
import sys
import json
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
from datasets.ct_dataset import get_dataloaders
from evaluate import evaluate
from config import *
from metrics import VolumeLoss
from models import get_model
def test(train_data_root, mo... | [
"evaluate.evaluate"
] | [((1011, 1098), 'metrics.VolumeLoss', 'VolumeLoss', (['config.dice_loss_weight', 'config.wce_loss_weight', 'config.ce_loss_weight'], {}), '(config.dice_loss_weight, config.wce_loss_weight, config.\n ce_loss_weight)\n', (1021, 1098), False, 'from metrics import VolumeLoss\n'), ((1226, 1316), 'evaluate.evaluate', 'eva... |
# -*- coding: utf-8 -*-
import time
import numpy as np
from evaluate import get_idcg_list, evaluate, evaluate_ranking, evaluate_alpha
from clicks import *
import StartStatus as ss
class SingleSimulation(object):
def __init__(self, sim_args, output_queue, click_model, datafold):
self.train_only = sim_args.train... | [
"evaluate.evaluate_ranking",
"evaluate.get_idcg_list",
"evaluate.evaluate_alpha",
"evaluate.evaluate"
] | [((765, 869), 'evaluate.get_idcg_list', 'get_idcg_list', (['self.datafold.train_label_vector', 'self.datafold.train_doclist_ranges', 'self.n_results'], {}), '(self.datafold.train_label_vector, self.datafold.\n train_doclist_ranges, self.n_results)\n', (778, 869), False, 'from evaluate import get_idcg_list, evaluate,... |
import os
import time
import json
import logging
import argparse
import sys
sys.path.append("libs")
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras import backend as K
from data import CollaborativeVAEDataGenerator
from train_vae import get_collabo_vae
from eval... | [
"evaluate.EvaluateModel"
] | [((84, 107), 'sys.path.append', 'sys.path.append', (['"""libs"""'], {}), "('libs')\n", (99, 107), False, 'import sys\n'), ((476, 501), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (499, 501), False, 'import argparse\n'), ((1188, 1204), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([], {}), '()... |
import operator
import numpy as np
import tensorflow as tf
from data import get_best_span, get_phrase
from evaluate import evaluate
class Evaluation(object):
pass
class SquadEvaluation(Evaluation):
def __init__(self, data, inputs=None, outputs=None, loss=None, global_step=None):
self.inputs = inpu... | [
"evaluate.evaluate"
] | [((3054, 3096), 'evaluate.evaluate', 'evaluate', (["self.data.squad['data']", 'answers'], {}), "(self.data.squad['data'], answers)\n", (3062, 3096), False, 'from evaluate import evaluate\n'), ((2549, 2597), 'data.get_best_span', 'get_best_span', (['logits1', 'logits2'], {'op': 'operator.add'}), '(logits1, logits2, op=o... |
"""Train an encoder using Contrastive Learning."""
import argparse
import os
import subprocess
import torch
import torch.backends.cudnn as cudnn
import torch.nn as nn
import torch.optim as optim
from optimizers import LARS # from torchlars import LARS
from tqdm import tqdm
from dataset import get_datasets
from crit... | [
"evaluate.test",
"evaluate.encode_train_set",
"evaluate.train_clf"
] | [((655, 682), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (672, 682), False, 'import logging\n'), ((686, 738), 'hydra.main', 'hydra.main', ([], {'config_path': '"""conf"""', 'config_name': '"""config"""'}), "(config_path='conf', config_name='config')\n", (696, 738), False, 'import hydr... |
# from rdkit import Chem
# from torch_geometric.data import Data, Batch
from train import train
from data import ModalRetriever
# import torch
import os
# from train_utils import setup_common
# from utils import mkdir
# from model.load_model import get
# from transformers import BertTokenizer
# from transformers impor... | [
"evaluate.evaluate"
] | [((758, 769), 'options.read_args', 'read_args', ([], {}), '()\n', (767, 769), False, 'from options import read_args\n'), ((3010, 3084), 'data.ModalRetriever', 'ModalRetriever', (["(data_dir + 'mention2ent.json')", "(data_dir + 'cmpd_info.json')"], {}), "(data_dir + 'mention2ent.json', data_dir + 'cmpd_info.json')\n", (... |
# python train.py anchor-based --model-dir ../models/ab_mobilenet --splits ../splits/tvsum.yml ../splits/summe.yml --max-epoch 50 --cnn mobilenet --base-model attention --num-feature 1280 --num-head 10
# python train.py anchor-based --model-dir ../models/ab_mobilenet_lstm --splits ../splits/tvsum.yml ../splits/summe.y... | [
"evaluate.evaluate"
] | [((770, 789), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (787, 789), False, 'import logging\n'), ((1138, 1292), 'anchor_based.dsnet.DSNet', 'DSNet', ([], {'base_model': 'args.base_model', 'num_feature': 'args.num_feature', 'num_hidden': 'args.num_hidden', 'anchor_scales': 'args.anchor_scales', 'num_hea... |
from __future__ import print_function, division
import sys
sys.path.append('core')
import copy
from datetime import datetime
import argparse
import os
import time
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.optim as optim
i... | [
"evaluate.validate_chairs",
"evaluate.validate_kitti",
"evaluate.validate_viper",
"evaluate.validate_sintel",
"evaluate.validate_things"
] | [((59, 82), 'sys.path.append', 'sys.path.append', (['"""core"""'], {}), "('core')\n", (74, 82), False, 'import sys\n'), ((201, 222), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (215, 222), False, 'import matplotlib\n'), ((2289, 2467), 'torch.optim.lr_scheduler.OneCycleLR', 'optim.lr_scheduler.... |
# python train.py anchor-free --model-dir ../models/af_mobilenet --splits ../splits/tvsum.yml ../splits/summe.yml --max-epoch 50 --cnn mobilenet --base-model attention --num-feature 1280 --num-head 10 --nms-thresh 0.4
# python train.py anchor-free --model-dir ../models/af_default --splits ../splits/tvsum.yml ../spli... | [
"evaluate.evaluate"
] | [((1476, 1495), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (1493, 1495), False, 'import logging\n'), ((1545, 1666), 'anchor_free.dsnet_af.DSNetAF', 'DSNetAF', ([], {'base_model': 'args.base_model', 'num_feature': 'args.num_feature', 'num_hidden': 'args.num_hidden', 'num_head': 'args.num_head'}), '(base... |
import pickle
import os
import sys
import pathlib
import numpy as np
from torch import optim
from torch.utils.data import DataLoader
import torch
from torch.nn.utils import clip_grad_norm_
from tqdm import tqdm
from tensorboardX import SummaryWriter
abs_path = pathlib.Path(__file__).parent.absolute()
sys.path.append(... | [
"evaluate.evaluate"
] | [((320, 345), 'sys.path.append', 'sys.path.append', (['abs_path'], {}), '(abs_path)\n', (335, 345), False, 'import sys\n'), ((908, 957), 'torch.device', 'torch.device', (["('cuda' if config.is_cuda else 'cpu')"], {}), "('cuda' if config.is_cuda else 'cpu')\n", (920, 957), False, 'import torch\n'), ((971, 977), 'model.P... |
""" Evaluate the output files to get the numbers reported in ACL18"""
import argparse
from os.path import join, abspath, dirname, exists
from evaluate import eval_meteor, eval_rouge
_REF_DIR = join(abspath(dirname(__file__)), 'acl18_results')
def main(args):
dec_dir = args.decode_dir
ref_dir = join(_REF_DI... | [
"evaluate.eval_rouge",
"evaluate.eval_meteor"
] | [((308, 335), 'os.path.join', 'join', (['_REF_DIR', '"""reference"""'], {}), "(_REF_DIR, 'reference')\n", (312, 335), False, 'from os.path import join, abspath, dirname, exists\n'), ((706, 722), 'os.path.exists', 'exists', (['_REF_DIR'], {}), '(_REF_DIR)\n', (712, 722), False, 'from os.path import join, abspath, dirnam... |
from torch.utils.data.dataloader import default_collate
import visual_visdom
import evaluate
#########################################################
## Callback-functions for evaluating model-performance ##
#########################################################
def _sample_cb(log, config, visdom=None, test_data... | [
"evaluate.precision"
] | [((2402, 2672), 'evaluate.precision', 'evaluate.precision', (['classifier', 'test_datasets', 'task', 'iteration'], {'classes_per_task': 'classes_per_task', 'scenario': 'scenario', 'precision_dict': 'precision_dict', 'collate_fn': 'collate_fn', 'test_size': 'test_size', 'visdom': 'visdom', 'summary_graph': 'summary_grap... |
import torch
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import argparse
import numpy as np
import os
from data import build_train_dataset
from gmflow.gmflow import GMFlow
from loss import flow_loss_func
from evaluate import (validate_chairs, validate_things, v... | [
"evaluate.validate_chairs",
"evaluate.create_sintel_submission",
"evaluate.validate_kitti",
"evaluate.create_kitti_submission",
"evaluate.inference_on_dir",
"evaluate.validate_sintel",
"evaluate.validate_things"
] | [((623, 648), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (646, 648), False, 'import argparse\n'), ((6394, 6417), 'torch.manual_seed', 'torch.manual_seed', (['seed'], {}), '(seed)\n', (6411, 6417), False, 'import torch\n'), ((6423, 6443), 'numpy.random.seed', 'np.random.seed', (['seed'], {})... |
#!/usr/bin/env python2
from __future__ import print_function
import os
import sys
from joblib import Parallel, delayed
import numpy as np
from tqdm import tqdm
sys.path.insert(0, '../prog_data/')
import evaluate
sys.path.append('%s/../prog_common' % os.path.dirname(os.path.realpath(__file__)))
from cmd_args import... | [
"evaluate.tokenize",
"evaluate.parse",
"evaluate.get_parser",
"evaluate.eval_at"
] | [((164, 199), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""../prog_data/"""'], {}), "(0, '../prog_data/')\n", (179, 199), False, 'import pdb, traceback, sys, code\n'), ((606, 626), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (620, 626), True, 'import numpy as np\n'), ((699, 713), 'att_model... |
import itertools
import math
import os
import random
import time
import datetime
from statistics import mean
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
import torchvision.transforms as transforms
from torch.utils.tensorboard import SummaryWriter # tensorboard --logdir /home/isaeng/Exjobb/... | [
"evaluate.evaluate"
] | [((989, 1040), 'os.path.join', 'os.path.join', (['EXTR_PATH_SSD', '"""final_data_info.json"""'], {}), "(EXTR_PATH_SSD, 'final_data_info.json')\n", (1001, 1040), False, 'import os\n'), ((1056, 1093), 'os.path.join', 'os.path.join', (['EXTR_PATH_SSD', '"""final/"""'], {}), "(EXTR_PATH_SSD, 'final/')\n", (1068, 1093), Fal... |
# @yifan
# 2021.12.05
# Hierarchical VQ
# return label and depth
import numpy as np
import faiss
from myKMeans import myKMeans
from evaluate import MSE
class HKM():
def __init__(self, n_nodes_p_level):
self.n_nodes_p_level = n_nodes_p_level
self.depth = len(n_nodes_p_level)
self.init_clust... | [
"evaluate.MSE"
] | [((1879, 1911), 'faiss.IndexFlatL2', 'faiss.IndexFlatL2', (['cent.shape[1]'], {}), '(cent.shape[1])\n', (1896, 1911), False, 'import faiss\n'), ((674, 718), 'myKMeans.myKMeans', 'myKMeans', ([], {'n_clusters': 'self.n_nodes_p_level[i]'}), '(n_clusters=self.n_nodes_p_level[i])\n', (682, 718), False, 'from myKMeans impor... |
from flask import Flask
from flask import render_template
from flask import request
from time import process_time
from game import Game
import evaluate
app = Flask(__name__)
game = Game()
@app.route("/")
def main():
global game
game = Game()
game.depth = 4
game.timeout = 60
return render_template('index.... | [
"evaluate.evaluate"
] | [((160, 175), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (165, 175), False, 'from flask import Flask\n'), ((184, 190), 'game.Game', 'Game', ([], {}), '()\n', (188, 190), False, 'from game import Game\n'), ((243, 249), 'game.Game', 'Game', ([], {}), '()\n', (247, 249), False, 'from game import Game\n'),... |
import os
import sys
sys.path.insert(1, os.path.join(sys.path[0], '../utils'))
import numpy as np
import argparse
import h5py
import math
import time
import logging
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import pickle
from utilities... | [
"evaluate.StatisticsContainer",
"evaluate.Evaluator"
] | [((40, 77), 'os.path.join', 'os.path.join', (['sys.path[0]', '"""../utils"""'], {}), "(sys.path[0], '../utils')\n", (52, 77), False, 'import os\n'), ((3402, 3496), 'os.path.join', 'os.path.join', (['workspace', '"""cross_validation_metadata"""', '"""train_curated_cross_validation.csv"""'], {}), "(workspace, 'cross_vali... |
#!/usr/bin/env python
# coding: utf-8
from __future__ import division, print_function, unicode_literals
import argparse
import json
import os
import shutil
import time
from datetime import datetime
from io import open
from itertools import product
from pathlib import Path
import submitit
import torch
import wandb
fro... | [
"evaluate.MultiWozEvaluator"
] | [((9406, 9431), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (9429, 9431), False, 'import argparse\n'), ((1397, 1506), 'model.model.Model', 'Model', (['args', 'input_lang_index2word', 'output_lang_index2word', 'input_lang_word2index', 'output_lang_word2index'], {}), '(args, input_lang_index2w... |
from evaluate import evaluate_activity_detection
from app import main, init_activity_detection, init_classificator, init_feature_extraction, init_pre_processing
from models import Waveform
from utils import load_groundtruth, load_annotation, read_csv, plot_metrics_boxplot
import numpy as np
import os
import csv
'''
Ac... | [
"evaluate.evaluate_activity_detection"
] | [((1249, 1274), 'os.path.exists', 'os.path.exists', (['tests_dir'], {}), '(tests_dir)\n', (1263, 1274), False, 'import os\n'), ((1280, 1302), 'os.makedirs', 'os.makedirs', (['tests_dir'], {}), '(tests_dir)\n', (1291, 1302), False, 'import os\n'), ((1746, 1768), 'models.Waveform', 'Waveform', ([], {'path': 'wav_dir'}), ... |
import sys
import os
import keras
import random as rn
import numpy as np
import tensorflow as tf
from keras.optimizers import Adam
from keras.regularizers import l2
from keras import backend as K
from keras.models import Model
from evaluate import evaluate
config = tf.ConfigProto()
config.gpu_options.allow_growth = Tru... | [
"evaluate.evaluate"
] | [((266, 282), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([], {}), '()\n', (280, 282), True, 'import tensorflow as tf\n'), ((330, 355), 'tensorflow.Session', 'tf.Session', ([], {'config': 'config'}), '(config=config)\n', (340, 355), True, 'import tensorflow as tf\n'), ((358, 396), 'keras.backend.tensorflow_backend.set... |
import glob
import logging
import os
import pickle
import random
import re
import shutil
from typing import Dict, List, Tuple
import pandas as pd
import numpy as np
import torch
from sklearn.model_selection import train_test_split
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data impo... | [
"evaluate.evaluate"
] | [((974, 1001), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (991, 1001), False, 'import logging\n'), ((1033, 1066), 'transformers.MODEL_WITH_LM_HEAD_MAPPING.keys', 'MODEL_WITH_LM_HEAD_MAPPING.keys', ([], {}), '()\n', (1064, 1066), False, 'from transformers import MODEL_WITH_LM_HEAD_MAPP... |
import pandas as pd
from pandas.testing import assert_frame_equal
from evaluate.report import (
PrecisionReport,
RecallReport,
Report,
DelimNotFoundError,
ReturnTypeDoesNotMatchError
)
from evaluate.classification import AlignmentAssessment
import pytest
from io import StringIO
import math
from test... | [
"evaluate.report.RecallReport",
"evaluate.report.PrecisionReport",
"evaluate.report.PrecisionReport.from_files",
"evaluate.report.RecallReport.from_files",
"evaluate.report.Report.get_value_from_header_fast"
] | [((23973, 24045), 'unittest.mock.patch.object', 'patch.object', (['RecallReport', 'RecallReport._create_helper_columns.__name__'], {}), '(RecallReport, RecallReport._create_helper_columns.__name__)\n', (23985, 24045), False, 'from unittest.mock import patch\n'), ((24742, 24814), 'unittest.mock.patch.object', 'patch.obj... |
#!/usr/bin/env python
import math
import config
import configspark
import ml_parse
import evaluate
sc = configspark.SPARK_CONTEXT
def clean():
config.clean_path(config.ML_MODEL)
def main():
clean()
ratings_train_text = sc.textFile(config.ML_RATINGS_TRAIN)
ratings_train = (
ratings_train_t... | [
"evaluate.evaluate"
] | [((151, 185), 'config.clean_path', 'config.clean_path', (['config.ML_MODEL'], {}), '(config.ML_MODEL)\n', (168, 185), False, 'import config\n'), ((679, 755), 'evaluate.evaluate', 'evaluate.evaluate', (['ratings_train', 'ratings_validation', 'config.ML_RESULTS_FILE'], {}), '(ratings_train, ratings_validation, config.ML_... |
""" Evaluate trained models and print errors on test and dev datasets """
import logging
import os
from os.path import basename
from evaluate import evaluate
import config
def run_evaluate():
"""
Run evaluation on 2 models:
* baseline
* baseline + lexical
Save evaluation and error analy... | [
"evaluate.evaluate"
] | [((617, 666), 'logging.info', 'logging.info', (['f"""Reports directory: {reports_dir}"""'], {}), "(f'Reports directory: {reports_dir}')\n", (629, 666), False, 'import logging\n'), ((671, 710), 'os.makedirs', 'os.makedirs', (['reports_dir'], {'exist_ok': '(True)'}), '(reports_dir, exist_ok=True)\n', (682, 710), False, '... |
import argparse, torch, gc, os, random, json
from data import MyDataset, load_data, my_collate_fn, device, word2feature, label_multihot, mask_noFeature
from model import MCEncoder
from lcmodel import LCEncoder
from tqdm import tqdm
from evaluate import evaluate, evaluate_test
import numpy as np
import os
def main(freq... | [
"evaluate.evaluate_test",
"evaluate.evaluate"
] | [((486, 523), 'os.makedirs', 'os.makedirs', (['directory'], {'exist_ok': '(True)'}), '(directory, exist_ok=True)\n', (497, 523), False, 'import os\n'), ((627, 647), 'data.load_data', 'load_data', (['frequency'], {}), '(frequency)\n', (636, 647), False, 'from data import MyDataset, load_data, my_collate_fn, device, word... |
#!/usr/bin/env python3
from pathlib import Path
import argparse
import listing
# Version of the format where I save the models, cases, etc. If in the future
# I change the format I can just change the string, so a new folder will be made
# and old things will be left ignored in old folder
DATA_VERSION = "v5"
CASES_P... | [
"evaluate.evaluate"
] | [((326, 358), 'pathlib.Path', 'Path', (['f"""./cases/{DATA_VERSION}/"""'], {}), "(f'./cases/{DATA_VERSION}/')\n", (330, 358), False, 'from pathlib import Path\n'), ((401, 426), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (424, 426), False, 'import argparse\n'), ((636, 659), 'train.train', 't... |
# Entry point for a script to attempt vocal and music separation using Tensorflow
# Accompanying thesis: Vocal and Audio separation using deep learning for Riga Technical University.
# Author: <NAME> <<EMAIL>>, Student ID: 161RDB280
import logging
import argparse
import os
import sys
from dataset import Dataset
from m... | [
"evaluate.Evaluator"
] | [((488, 516), 'config.prepare_config', 'prepare_config', (['"""config.ini"""'], {}), "('config.ini')\n", (502, 516), False, 'from config import prepare_config\n'), ((1009, 1043), 'logging.addLevelName', 'logging.addLevelName', (['(55)', '"""Hello!"""'], {}), "(55, 'Hello!')\n", (1029, 1043), False, 'import logging\n'),... |
import os
import glob
import numpy as np
import caffe
import evaluate
import config
caffe.set_mode_gpu()
caffe.set_device(0)
model_weights = os.path.join(config.LRCN_MODELS_DIR, 'RGB_lstm_model_iter_30000.caffemodel')
h5Files = glob.glob(os.path.join(config.DATASET_DIR, 'extracted_features_lstm_RGB/*.h5'))
model_lst... | [
"evaluate.evaluate"
] | [((86, 106), 'caffe.set_mode_gpu', 'caffe.set_mode_gpu', ([], {}), '()\n', (104, 106), False, 'import caffe\n'), ((107, 126), 'caffe.set_device', 'caffe.set_device', (['(0)'], {}), '(0)\n', (123, 126), False, 'import caffe\n'), ((144, 220), 'os.path.join', 'os.path.join', (['config.LRCN_MODELS_DIR', '"""RGB_lstm_model_... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import absolute_import, division, print_function
import os
import sys
log_level_index = sys.argv.index('--log_level') + 1 if '--log_level' in sys.argv else 0
os.environ['TF_CPP_MIN_LOG_LEVEL'] = sys.argv[log_level_index] if log_level_index > 0 and log_leve... | [
"evaluate.evaluate"
] | [((3177, 3212), 'tensorflow.transpose', 'tf.transpose', (['batch_x', '[1, 0, 2, 3]'], {}), '(batch_x, [1, 0, 2, 3])\n', (3189, 3212), True, 'import tensorflow as tf\n'), ((3274, 3360), 'tensorflow.reshape', 'tf.reshape', (['batch_x', '[-1, Config.n_input + 2 * Config.n_input * Config.n_context]'], {}), '(batch_x, [-1, ... |
import misc, model, eval, evaluate
import numpy as np
import torch, time, random
from torch import nn
import TD_RvNN
device = 'cuda'
tree_file = 'resource/data.TD_RvNN.vol_5000.txt'
label_file = 'resource/Twitter15_label_All.txt'
train_file = 'nfold/RNNtrainSet_Twitter152_tree.txt'
test_file = 'nfold/RNNtestSet_Tw... | [
"evaluate.evaluation_4class"
] | [((756, 774), 'TD_RvNN.loadData', 'TD_RvNN.loadData', ([], {}), '()\n', (772, 774), False, 'import TD_RvNN\n'), ((1309, 1336), 'torch.nn.MSELoss', 'nn.MSELoss', ([], {'reduction': '"""sum"""'}), "(reduction='sum')\n", (1319, 1336), False, 'from torch import nn\n'), ((1575, 1586), 'time.time', 'time.time', ([], {}), '()... |
import os
import util
import time
import math
import torch
import logging
import evaluate
import coref_model
format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s'
logging.basicConfig(format=format)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
if __name__ == "__main__":
os.environ[... | [
"evaluate.evaluate"
] | [((174, 208), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': 'format'}), '(format=format)\n', (193, 208), False, 'import logging\n'), ((218, 245), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (235, 245), False, 'import logging\n'), ((357, 382), 'torch.cuda.is_available', ... |
import time
import numpy as np
import torch
import os
from evaluate import angle_acc
import argparse
from model import DenseNet_GCN
from loss import JSD_Loss
from dataset import Sphere_Dataset
from train import train
from torch.utils.data import DataLoader
def test(epoch, device, data_loader, model, criterion, vis, s... | [
"evaluate.angle_acc"
] | [((610, 621), 'time.time', 'time.time', ([], {}), '()\n', (619, 621), False, 'import time\n'), ((4085, 4110), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (4108, 4110), False, 'import argparse\n'), ((4717, 4771), 'dataset.Sphere_Dataset', 'Sphere_Dataset', ([], {'root': 'test_opts.data_path',... |
import os
import time
import numpy as np
import torch
from torch.autograd import Variable
import torchvision.utils as vutils
from options import TestOptions
from edges2shoes_data import DataLoader, load_edges2shoes, AlignedIterator, UnalignedIterator
from model import StochCycleGAN, AugmentedCycleGAN
import cPickle as ... | [
"evaluate.eval_mse_A",
"evaluate.eval_ubo_B"
] | [((748, 779), 'os.path.join', 'os.path.join', (['opt.res_dir', 'name'], {}), '(opt.res_dir, name)\n', (760, 779), False, 'import os\n'), ((1208, 1239), 'os.path.join', 'os.path.join', (['opt.res_dir', 'name'], {}), '(opt.res_dir, name)\n', (1220, 1239), False, 'import os\n'), ((2036, 2067), 'os.path.join', 'os.path.joi... |
from __future__ import print_function
# from network import VGGNet
from dirtorch.utils import common
import dirtorch.nets as nets
import pandas as pd
import faiss
import torch
import torchvision.transforms as transforms
import torch.nn as nn
from six.moves import cPickle
import numpy as np
import image... | [
"evaluate.evaluate_class"
] | [((487, 523), 'dirtorch.utils.common.load_checkpoint', 'common.load_checkpoint', (['path', 'iscuda'], {}), '(path, iscuda)\n', (509, 523), False, 'from dirtorch.utils import common\n'), ((535, 598), 'dirtorch.nets.create_model', 'nets.create_model', ([], {'pretrained': '""""""'}), "(pretrained='', **checkpoint['model_o... |
from config import Arguments as args
import os
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"]=args.train_visible_devices
import sys, random
import numpy as np
import torch
import torch.nn as nn
from torch.optim import Adam
from torch.utils.data import DataLoader
from torch.utils.t... | [
"evaluate.evaluate"
] | [((2638, 2793), 'utils.scheduler.WarmupScheduler', 'WarmupScheduler', (['optimizer'], {'warmup_epochs': 'args.warmup_steps', 'initial_lr': 'args.init_lr', 'max_lr': 'args.max_lr', 'milestones': 'args.milestones', 'gamma': 'args.gamma'}), '(optimizer, warmup_epochs=args.warmup_steps, initial_lr=args\n .init_lr, max_l... |
from evaluate import evaluate
from os_utils import OSUtils
from save_slot_checkpoint import save_slot
from torch import nn
from tqdm import tqdm
def train(model, train_dl, val_dl, args, optimizer, scheduler=None):
print(f"training on {len(train_dl.dataset)}, validating on {len(val_dl.dataset)} examples.")
c... | [
"evaluate.evaluate"
] | [((331, 352), 'torch.nn.CrossEntropyLoss', 'nn.CrossEntropyLoss', ([], {}), '()\n', (350, 352), False, 'from torch import nn\n'), ((1128, 1175), 'evaluate.evaluate', 'evaluate', (['model', 'val_dl', 'criterion', 'args.device'], {}), '(model, val_dl, criterion, args.device)\n', (1136, 1175), False, 'from evaluate import... |
import os
import json
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from evaluate import evaluate
if __name__ == '__main__':
training_commands, predict_commands = [], []
seq2vec_name_to_last_layer = {"dan": 4, "gru": 4}
probing_accuracies = {}
for seq2vec_name, layer in ... | [
"evaluate.evaluate"
] | [((40, 63), 'matplotlib.use', 'matplotlib.use', (['"""TkAgg"""'], {}), "('TkAgg')\n", (54, 63), False, 'import matplotlib\n'), ((4198, 4220), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Accuracy"""'], {}), "('Accuracy')\n", (4208, 4220), True, 'import matplotlib.pyplot as plt\n'), ((4225, 4288), 'matplotlib.pyplot.... |
"""
Baseline training script
"""
import os
import sys
import copy
import glob
import math
import json
import shutil
import argparse
import logging
from typing import Any, Dict, Optional
from types import SimpleNamespace
from itertools import cycle
from contextlib import ExitStack
from comet_ml import Experiment # mus... | [
"evaluate.Evaluator"
] | [((2586, 2607), 'metrics.MetricStore', 'metrics.MetricStore', ([], {}), '()\n', (2605, 2607), False, 'import metrics\n'), ((3138, 3230), 'experiment.initialize_experiment', 'initialize_experiment', (['self.args', "('data', 'model', 'optim')", 'self.args.experiment_name'], {}), "(self.args, ('data', 'model', 'optim'), s... |
import pickle
import numpy
import glob
import os
import sys
from keras.callbacks import ModelCheckpoint
from keras.layers import LSTM
from kutilities.callbacks import MetricsCallback, PlottingCallback
from kutilities.helpers.data_preparation import get_labels_to_categories_map, \
get_class_weights2, onehot_to_categ... | [
"evaluate.evaluate.performance_analysis"
] | [((742, 765), 'numpy.random.seed', 'numpy.random.seed', (['(1337)'], {}), '(1337)\n', (759, 765), False, 'import numpy\n'), ((2296, 2340), 'utilities_nn.data_loader.get_embeddings', 'get_embeddings', ([], {'corpus': 'WV_CORPUS', 'dim': 'WV_DIM'}), '(corpus=WV_CORPUS, dim=WV_DIM)\n', (2310, 2340), False, 'from utilities... |
import argparse
import functools
import itertools
import os.path
import time
from pprint import pprint
import torch
import numpy as np
from benepar import char_lstm
from benepar import decode_chart
from benepar import nkutil
from benepar import parse_chart
import evaluate
import learning_rates
import treebanks
def... | [
"evaluate.evalb"
] | [((732, 1457), 'benepar.nkutil.HParams', 'nkutil.HParams', ([], {'max_len_train': '(0)', 'max_len_dev': '(0)', 'batch_size': '(32)', 'learning_rate': '(5e-05)', 'learning_rate_warmup_steps': '(160)', 'clip_grad_norm': '(0.0)', 'checks_per_epoch': '(4)', 'step_decay_factor': '(0.5)', 'step_decay_patience': '(5)', 'max_c... |
import chess
import random
from evaluate import evaluate
#import copy
#import os
#import psutil
from multiprocessing import Pool
count = 0
# TODO Learn about castling properly!
# TODO Eliminate 3-fold repetition! See code of main.py
# TODO Implement time constraints to avoid "Black forfeits on time"
def search(board... | [
"evaluate.evaluate"
] | [((799, 820), 'evaluate.evaluate', 'evaluate', (['board', 'turn'], {}), '(board, turn)\n', (807, 820), False, 'from evaluate import evaluate\n')] |
""" WORKER OF HPBANDSTER OPTIMIZER """
import numpy
import time
import ConfigSpace as CS
from hpbandster.core.worker import Worker
import os
from evaluate import evaluate
from set_up_run_folder import set_up_run_folder
class MyWorker(Worker):
def __init__(self, *args, **kwargs):
super().__init__(*args,... | [
"evaluate.evaluate"
] | [((1576, 1595), 'set_up_run_folder.set_up_run_folder', 'set_up_run_folder', ([], {}), '()\n', (1593, 1595), False, 'from set_up_run_folder import set_up_run_folder\n'), ((2613, 2636), 'ConfigSpace.ConfigurationSpace', 'CS.ConfigurationSpace', ([], {}), '()\n', (2634, 2636), True, 'import ConfigSpace as CS\n'), ((1973, ... |
import sys
import time
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
from ray import tune
from ray.tune.schedulers import HyperBandScheduler
from datasets import dataset_factory
from datasets.augmentation import *
from datasets.graph impor... | [
"evaluate.evaluate"
] | [((612, 626), 'utils.AverageMeter', 'AverageMeter', ([], {}), '()\n', (624, 626), False, 'from utils import AverageMeter\n'), ((643, 657), 'utils.AverageMeter', 'AverageMeter', ([], {}), '()\n', (655, 657), False, 'from utils import AverageMeter\n'), ((671, 685), 'utils.AverageMeter', 'AverageMeter', ([], {}), '()\n', ... |
import datetime
import os
import json
import yaml
import visdom
import torch
import numpy as np
from gamified_squad import GamifiedSquad
from gamified_newsqa import GamifiedNewsQA
from agent import Agent, HistoryScoreCache
import generic
import evaluate
def train():
time_1 = datetime.datetime.now()
wit... | [
"evaluate.evaluate"
] | [((284, 307), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (305, 307), False, 'import datetime\n'), ((565, 572), 'agent.Agent', 'Agent', ([], {}), '()\n', (570, 572), False, 'from agent import Agent, HistoryScoreCache\n'), ((597, 612), 'visdom.Visdom', 'visdom.Visdom', ([], {}), '()\n', (610, 612... |
import os
import sys
import math
import argparse
import numpy as np
from tqdm import tqdm
import torch
from torch.multiprocessing import Queue, Process
sys.path.insert(0, '../lib')
sys.path.insert(0, '../model')
from data.WiderPerson import WiderPerson
from utils import misc_utils, nms_utils
from evaluate import comp... | [
"evaluate.compute_JI.evaluation_all",
"evaluate.compute_APMR.compute_APMR"
] | [((154, 182), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""../lib"""'], {}), "(0, '../lib')\n", (169, 182), False, 'import sys\n'), ((183, 213), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""../model"""'], {}), "(0, '../model')\n", (198, 213), False, 'import sys\n'), ((410, 468), 'os.path.join', 'os.path.joi... |
import os
import sys
import time
import random
import argparse
import shutil
import logging
import torch
import numpy as np
from allennlp.data.iterators import BasicIterator
from preprocess import build_tasks
from models import build_model
from trainer import build_trainer
from evaluate import evaluate
from util impor... | [
"evaluate.evaluate"
] | [((405, 444), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '""""""'}), "(description='')\n", (428, 444), False, 'import argparse\n'), ((5828, 5871), 'os.makedirs', 'os.makedirs', (['args.store_root'], {'exist_ok': '(True)'}), '(args.store_root, exist_ok=True)\n', (5839, 5871), False, 'impo... |
import config
from utils import squad_evaluate, load_and_cache_examples
import glob
import json
import logging
import os
import random
from evaluate import evaluate
import numpy as np
import torch
from torch.utils.data import DataLoader, RandomSampler
from torch.utils.data.distributed import DistributedSampler
from tqd... | [
"evaluate.evaluate"
] | [((429, 456), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (446, 456), False, 'import logging\n'), ((555, 577), 'random.seed', 'random.seed', (['args.seed'], {}), '(args.seed)\n', (566, 577), False, 'import random\n'), ((582, 607), 'numpy.random.seed', 'np.random.seed', (['args.seed'], ... |
"""Train the model"""
import argparse
import logging
import os
import random
import numpy as np
import torch
import torch.optim as optim
from torch.autograd import Variable
from tqdm import tqdm
import sys
sys.path.append('')
#os.chdir("..")
import utils
from data.data_utils import fetch_data, FERDataset, DataLoade... | [
"evaluate.evaluate"
] | [((209, 228), 'sys.path.append', 'sys.path.append', (['""""""'], {}), "('')\n", (224, 228), False, 'import sys\n'), ((1398, 1428), 'train_utils.ConfusionMatrix', 'ConfusionMatrix', ([], {'num_classes': '(8)'}), '(num_classes=8)\n', (1413, 1428), False, 'from train_utils import MarginCalibratedCELoss, ConfusionMatrix\n'... |
import numpy as np
import torch
import torch.nn as nn
import os
import matplotlib.pyplot as plt
import torchvision.transforms as transforms
from utils.opt import parse_option
from torch.utils.tensorboard import SummaryWriter
from torchvision.datasets import mnist
from torch.nn import CrossEntropyLoss
from torch.optim i... | [
"evaluate.validate"
] | [((520, 534), 'utils.opt.parse_option', 'parse_option', ([], {}), '()\n', (532, 534), False, 'from utils.opt import parse_option\n'), ((995, 1036), 'torch.utils.data.DataLoader', 'DataLoader', (['train_dataset', 'opt.batch_size'], {}), '(train_dataset, opt.batch_size)\n', (1005, 1036), False, 'from torch.utils.data imp... |
import argparse
from tools import ParsingCfg
import numpy as np
from tools import InitDataDir
# ###
# import os
# os.environ["CUDA_VISIBLE_DEVICES"] = "0"
# ###
if __name__ == '__main__':
parser=argparse.ArgumentParser()
parser.add_argument("cfg_path",help="config file path",type=str)
parse... | [
"evaluate.cocoeval.COCOEval",
"evaluate.Evaluation",
"evaluate.FramePerSecond"
] | [((214, 239), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (237, 239), False, 'import argparse\n'), ((1771, 1791), 'tools.ParsingCfg', 'ParsingCfg', (['cfg_path'], {}), '(cfg_path)\n', (1781, 1791), False, 'from tools import ParsingCfg\n'), ((2112, 2144), 'numpy.array', 'np.array', (["cfg_dic... |
from training import train
from testing import test
from evaluate import evaluate
def random_forest(path_train,
path_test,
name_identifiers,
name_targets,
features,
delimiter,
num_cores=1):
'''
this met... | [
"evaluate.evaluate"
] | [((1489, 1618), 'training.train', 'train', (['path_train', 'name_identifiers', 'name_targets', 'features'], {'output_path_model': 'None', 'cores': 'num_cores', 'the_delimiter': 'delimiter'}), '(path_train, name_identifiers, name_targets, features,\n output_path_model=None, cores=num_cores, the_delimiter=delimiter)\n... |
import numpy as np
from scipy import sparse
import torch
import time
from tqdm import tqdm
from evaluate import eval_func, euclidean_dist
def calculate_V(initial_rank, all_feature_len, dis_i_qg, i, k1):
# dis_i_qg = euclidean_dist(torch.tensor([all_feature[i].numpy()]), all_feature).numpy()
forward_k_nei... | [
"evaluate.euclidean_dist"
] | [((1426, 1465), 'numpy.unique', 'np.unique', (['k_reciprocal_expansion_index'], {}), '(k_reciprocal_expansion_index)\n', (1435, 1465), True, 'import numpy as np\n'), ((1521, 1568), 'numpy.exp', 'np.exp', (['(-dis_i_qg[k_reciprocal_expansion_index])'], {}), '(-dis_i_qg[k_reciprocal_expansion_index])\n', (1527, 1568), Tr... |
#%% -*- coding: utf-8 -*-
# Plotting
import matplotlib
matplotlib.use('agg')
import os
import time
import argparse
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
# Internal imports
from utils.data import load_dataset, get_external_sounds
from models.vae.ae import AE, RegressionAE, Di... | [
"evaluate.evaluate_latent_space",
"evaluate.evaluate_semantic_parameters",
"evaluate.evaluate_projection",
"evaluate.evaluate_synthesis",
"evaluate.evaluate_latent_neighborhood",
"evaluate.evaluate_reconstruction",
"evaluate.evaluate_params",
"evaluate.evaluate_meta_parameters"
] | [((56, 77), 'matplotlib.use', 'matplotlib.use', (['"""agg"""'], {}), "('agg')\n", (70, 77), False, 'import matplotlib\n'), ((695, 720), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (718, 720), False, 'import argparse\n'), ((6309, 6320), 'time.time', 'time.time', ([], {}), '()\n', (6318, 6320)... |
from pathlib import Path
import sys
sys.path.append(str(Path().absolute()))
import logging
log_level = "INFO"
logging.basicConfig(
filename=str(snakemake.log),
filemode="w",
level=log_level,
format="[%(asctime)s]:%(levelname)s: %(message)s",
datefmt="%d/%m/%Y %I:%M:%S %p",
)
from evaluate.calcula... | [
"evaluate.report.PrecisionReport.from_files",
"evaluate.calculator.PrecisionCalculator"
] | [((554, 606), 'pathlib.Path', 'Path', (['snakemake.output.precision_file_for_one_sample'], {}), '(snakemake.output.precision_file_for_one_sample)\n', (558, 606), False, 'from pathlib import Path\n'), ((932, 963), 'logging.info', 'logging.info', (['f"""Loading report"""'], {}), "(f'Loading report')\n", (944, 963), False... |
#!/usr/bin/env python
import sys
import os
import config
import evaluate
import ml_parse
from pyspark.mllib.recommendation import MatrixFactorizationModel, ALS
def main():
import configspark
sc = configspark.SPARK_CONTEXT
print("\nLoading MovieLens test dataset\n")
test_text = sc.textFile(config.ML... | [
"evaluate.evaluate_model"
] | [((437, 468), 'os.path.exists', 'os.path.exists', (['config.ML_MODEL'], {}), '(config.ML_MODEL)\n', (451, 468), False, 'import os\n'), ((748, 792), 'evaluate.evaluate_model', 'evaluate.evaluate_model', (['model', 'ratings_test'], {}), '(model, ratings_test)\n', (771, 792), False, 'import evaluate\n'), ((589, 639), 'pys... |
"""Train the model"""
import argparse
import logging
from tensorboardX import SummaryWriter
import os, shutil
import numpy as np
import pandas as pd
from sklearn.utils.class_weight import compute_class_weight
import torch
import torch.optim as optim
import torchvision.models as models
from torch.autograd import Varia... | [
"evaluate.evaluate"
] | [((533, 558), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (556, 558), False, 'import argparse\n'), ((3886, 3908), 'utils.RunningAverage', 'utils.RunningAverage', ([], {}), '()\n', (3906, 3908), False, 'import utils\n'), ((13597, 13616), 'torch.cat', 'torch.cat', (['Zhats', '(0)'], {}), '(Zha... |
#!/usr/bin/env python
import sys
import os
from shutil import copyfile
import time
import itertools
import torch
from torch.autograd import Variable
import torchvision.utils as vutils
from options import TrainOptions, create_sub_dirs
from edges2shoes_data import DataLoader, load_edges2shoes, AlignedIterator, Unaligne... | [
"evaluate.eval_mse_A",
"evaluate.eval_ubo_B"
] | [((596, 634), 'os.path.join', 'os.path.join', (['expr_dir', '"""results.json"""'], {}), "(expr_dir, 'results.json')\n", (608, 634), False, 'import os\n'), ((824, 855), 'glob.glob', 'glob.glob', (["('%s/*.py' % dir_path)"], {}), "('%s/*.py' % dir_path)\n", (833, 855), False, 'import glob\n'), ((1615, 1676), 'os.path.joi... |
### modified from https://github.com/qiuqiangkong/audioset_tagging_cnn
import os
import sys
sys.path.insert(1, os.path.join(sys.path[0], '../utils'))
import numpy as np
import argparse
import h5py
import math
import time
import logging
import matplotlib.pyplot as plt
from sklearn import metrics
import _pickle as cPickl... | [
"evaluate.Evaluator"
] | [((372, 392), 'torch.manual_seed', 'torch.manual_seed', (['(0)'], {}), '(0)\n', (389, 392), False, 'import torch\n'), ((111, 148), 'os.path.join', 'os.path.join', (['sys.path[0]', '"""../utils"""'], {}), "(sys.path[0], '../utils')\n", (123, 148), False, 'import os\n'), ((2465, 2489), 'losses.get_loss_func', 'get_loss_f... |
import argparse
import logging
import os
from types import SimpleNamespace
import falcon
import pandas
import torch
from falcon_cors import CORS
import json
import waitress
from data import Data
from torch.utils.data import DataLoader
from utils import load_torch_model
from model import BertForClassification, CharCNN
f... | [
"evaluate.evaluate"
] | [((441, 517), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '"""%(asctime)-18s %(message)s"""'}), "(level=logging.INFO, format='%(asctime)-18s %(message)s')\n", (460, 517), False, 'import logging\n'), ((527, 546), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (544,... |
'''
Created on Aug 9, 2016
Keras Implementation of Neural Matrix Factorization (NeuMF) recommender model in:
He Xiangnan et al. Neural Collaborative Filtering. In WWW 2017.
@author: <NAME> (<EMAIL>)
'''
import argparse
from time import time
import numpy as np
from keras.layers import Embedding, Input, Dens... | [
"evaluate.evaluate_model"
] | [((662, 710), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Run NNCF."""'}), "(description='Run NNCF.')\n", (685, 710), False, 'import argparse\n'), ((3347, 3398), 'keras.layers.Input', 'Input', ([], {'shape': '(1,)', 'dtype': '"""int32"""', 'name': '"""user_input"""'}), "(shape=(1,), d... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
# @Version : Python 3.6
import os
import json
import torch
import torch.optim as optim
import torch.nn as nn
import numpy as np
from tqdm import tqdm
from config import Config
from utils import EmbeddingLoader, RelationLoader, NYTDataLoader
from model import DS_Model
f... | [
"evaluate.Eval"
] | [((3172, 3180), 'config.Config', 'Config', ([], {}), '()\n', (3178, 3180), False, 'from config import Config\n'), ((3518, 3557), 'utils.NYTDataLoader', 'NYTDataLoader', (['rel2id', 'token2id', 'config'], {}), '(rel2id, token2id, config)\n', (3531, 3557), False, 'from utils import EmbeddingLoader, RelationLoader, NYTDat... |
import warnings
warnings.filterwarnings("ignore")
import os, numpy as np, argparse, random, matplotlib, datetime
os.chdir(os.path.dirname(os.path.realpath(__file__)))
from pathlib import Path
matplotlib.use('agg')
from tqdm import tqdm
import auxiliaries as aux
import datasets as data
import netlib as netlib
import los... | [
"evaluate.GradientMeasure",
"evaluate.DistanceMeasure",
"evaluate.evaluate"
] | [((16, 49), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (39, 49), False, 'import warnings\n'), ((192, 213), 'matplotlib.use', 'matplotlib.use', (['"""agg"""'], {}), "('agg')\n", (206, 213), False, 'import os, numpy as np, argparse, random, matplotlib, datetime\n'), ((53... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
###############################################################################
# Git-based CTF
###############################################################################
#
# Author: <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
#
# Copyright (... | [
"evaluate.evaluate"
] | [((3346, 3398), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'desc', 'prog': 'prog'}), '(description=desc, prog=prog)\n', (3369, 3398), False, 'import argparse\n'), ((3561, 3649), 'verify_service.verify_service', 'verify_service', (['args.team', 'args.branch', 'args.service_port', 'args.ho... |
from ignite.engine.engine import Engine, State, Events
from dataset import get_iterator
from model import get_model
from loss import get_loss
from optimizer import get_optimizer
from logger import get_logger, log_results
from utils import prepare_batch
from metric import get_metrics
from evaluate import get_evaluator... | [
"evaluate.evaluate_once",
"evaluate.get_evaluator"
] | [((853, 873), 'ignite.engine.engine.Engine', 'Engine', (['update_model'], {}), '(update_model)\n', (859, 873), False, 'from ignite.engine.engine import Engine, State, Events\n'), ((1315, 1333), 'dataset.get_iterator', 'get_iterator', (['args'], {}), '(args)\n', (1327, 1333), False, 'from dataset import get_iterator\n')... |
# coding:utf-8
"""
Filename: train.py
Author: @DvdNss
Created on 12/17/2021
"""
import argparse
import os
import torch
from sklearn.metrics import accuracy_score
from torch.utils.data import DataLoader
from tqdm import tqdm
from transformers import PerceiverForSequenceClassification, AdamW
from evaluate import evalu... | [
"evaluate.evaluate"
] | [((471, 496), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (494, 496), False, 'import argparse\n'), ((1556, 1705), 'transformers.PerceiverForSequenceClassification.from_pretrained', 'PerceiverForSequenceClassification.from_pretrained', (['"""deepmind/language-perceiver"""'], {'problem_type': ... |
import torch
import gym
from config import CartPole, Pong
from train import train
from evaluate import evaluate_policy
import os
os.environ['KMP_DUPLICATE_LIB_OK'] = 'True' # needed locally
ENV_CONFIGS = {
'CartPole-v0': CartPole,
'Pong-v0': Pong
}
def training(env):
"""
function that is used to ca... | [
"evaluate.evaluate_policy"
] | [((412, 422), 'train.train', 'train', (['env'], {}), '(env)\n', (417, 422), False, 'from train import train\n'), ((841, 854), 'gym.make', 'gym.make', (['env'], {}), '(env)\n', (849, 854), False, 'import gym\n'), ((1112, 1229), 'evaluate.evaluate_policy', 'evaluate_policy', (['dqn', 'env', 'env_config', 'env_name', 'n_e... |
""" Evaluate the baselines ont ROUGE/METEOR"""
import argparse
import json
import os
from os.path import join, exists
from evaluate import eval_meteor, eval_rouge
try:
_DATA_DIR = os.environ['DATA']
except KeyError:
print('please use environment variable to specify data directories')
def main(args):
de... | [
"evaluate.eval_meteor",
"evaluate.eval_rouge"
] | [((328, 359), 'os.path.join', 'join', (['args.decode_dir', '"""output"""'], {}), "(args.decode_dir, 'output')\n", (332, 359), False, 'from os.path import join, exists\n'), ((475, 505), 'os.path.join', 'join', (['_DATA_DIR', '"""refs"""', 'split'], {}), "(_DATA_DIR, 'refs', split)\n", (479, 505), False, 'from os.path im... |
import os
import time
import json
import logging
import argparse
import sys
sys.path.append("libs")
from utils import Init_logging
from utils import PiecewiseSchedule
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras import optimizers
from tensorflow.keras import call... | [
"evaluate.EvaluateCold",
"evaluate.EvaluateModel"
] | [((84, 107), 'sys.path.append', 'sys.path.append', (['"""libs"""'], {}), "('libs')\n", (99, 107), False, 'import sys\n'), ((888, 921), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (911, 921), False, 'import warnings\n'), ((952, 973), 'numpy.random.seed', 'np.random.seed'... |
import pandas as pd
import matplotlib.pyplot as plt
import keras
from keras import layers
from keras.utils import plot_model
from keras.constraints import non_neg
from keras.callbacks import ModelCheckpoint
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.... | [
"evaluate.mean_average_precision",
"evaluate.roc_auc",
"evaluate.normalized_dcg"
] | [((651, 675), 'load_ratings.load', 'load_ratings.load', (['"""../"""'], {}), "('../')\n", (668, 675), False, 'import load_ratings\n'), ((751, 807), 'sklearn.model_selection.train_test_split', 'train_test_split', (['dataset'], {'test_size': '(0.3)', 'random_state': '(0)'}), '(dataset, test_size=0.3, random_state=0)\n', ... |
#保存结果与建议至json文件
import time
import json
from evaluate import evaluate,getTimes
from getdata import get_alldata
def get_advice(proposal,times):
standard_proposal=[x/times for x in proposal]
if max(standard_proposal)<1.5:
#print("动作标准，请继续保持")
return "动作标准，请继续保持"
elif max(standard_proposal[... | [
"evaluate.getTimes"
] | [((1263, 1298), 'getdata.get_alldata', 'get_alldata', (['"""./jsonfile/standard/"""'], {}), "('./jsonfile/standard/')\n", (1274, 1298), False, 'from getdata import get_alldata\n'), ((1336, 1382), 'getdata.get_alldata', 'get_alldata', (['"""./jsonfile/now/"""'], {'isRunning': '(True)'}), "('./jsonfile/now/', isRunning=T... |
import matplotlib.pyplot as plt
import numpy as np
import matplotlib as mpl
import pandas as pd
import sys
sys.path.append("..")
mpl.use('tkagg') # issues with Big Sur
import matplotlib.pyplot as plt
from strategy.bollinger_bands import bollinger_bands
from backtest import Backtest
from evaluate import PortfolioRetu... | [
"evaluate.CAGR",
"evaluate.SharpeRatio",
"evaluate.MaxDrawdown"
] | [((107, 128), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (122, 128), False, 'import sys\n'), ((129, 145), 'matplotlib.use', 'mpl.use', (['"""tkagg"""'], {}), "('tkagg')\n", (136, 145), True, 'import matplotlib as mpl\n'), ((373, 481), 'pandas.read_csv', 'pd.read_csv', (['"""../../database/hke... |
import os
import re
import sys
sys.path.append('.')
import cv2
import csv
import math
import time
import string
import random
import scipy
import argparse
import matplotlib
import numpy as np
import pylab as plt
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
from ... | [
"evaluate.coco_eval.get_outputs"
] | [((31, 51), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (46, 51), False, 'import sys\n'), ((964, 989), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (987, 989), False, 'import argparse\n'), ((7240, 7264), 'lib.config.update_config', 'update_config', (['cfg', 'args'], {}... |
import os
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import torch
import torch.nn as nn
from torch.autograd import Variable
from torch import optim
import torch.nn.functional as F
import logging
from evaluate import test
class Solver(object):
default_adam_args = {"lr": 0.001,
... | [
"evaluate.test"
] | [((700, 719), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (717, 719), False, 'import logging\n'), ((1684, 1705), 'torch.nn.CrossEntropyLoss', 'nn.CrossEntropyLoss', ([], {}), '()\n', (1703, 1705), True, 'import torch.nn as nn\n'), ((1576, 1610), 'os.path.join', 'os.path.join', (['model_dir', '"""cnn.pkl... |
import pathlib
import itertools
import logging
import logging.config
from dataclasses import dataclass
import yaap
import torch
import torch.utils.tensorboard
import torchmodels
import utils
import train
import evaluate
import models
import models.dialog
import datasets
from datasets import Dialog
from loopers import... | [
"evaluate.evaluate"
] | [((827, 838), 'yaap.Yaap', 'yaap.Yaap', ([], {}), '()\n', (836, 838), False, 'import yaap\n'), ((5537, 5564), 'pathlib.Path', 'pathlib.Path', (['args.save_dir'], {}), '(args.save_dir)\n', (5549, 5564), False, 'import pathlib\n'), ((5762, 5780), 'utils.ShellUtils', 'utils.ShellUtils', ([], {}), '()\n', (5778, 5780), Fal... |
"""Train the model"""
import argparse
import logging
import os
from tqdm import tqdm
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.optim.lr_scheduler as lr_scheduler
from torch.autograd import Variable
import models.nets as nets
import models.vgg as vgg
import models.... | [
"evaluate.evaluate"
] | [((402, 427), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (425, 427), False, 'import argparse\n'), ((1889, 1911), 'utils.RunningAverage', 'utils.RunningAverage', ([], {}), '()\n', (1909, 1911), False, 'import utils\n'), ((3892, 3942), 'logging.info', 'logging.info', (["('- Train metrics: ' +... |
import train
import evaluate
if __name__ == "__main__":
#trainer = train.TumorDetectionNet()
#trainer.train(path_to_dataset="archive/", model_filename="Tumor_classifier_model.h5")
evaluator = evaluate.Evaluator()
evaluator.evaluate(model_path="Tumor_classifier_model_v2.h5", image_path="archive/validat... | [
"evaluate.Evaluator"
] | [((206, 226), 'evaluate.Evaluator', 'evaluate.Evaluator', ([], {}), '()\n', (224, 226), False, 'import evaluate\n')] |
from evaluate import evaluate
__author__ = "<NAME>"
__email__ = "<EMAIL>"
data = '[{"state": {"cities": ["Mumbai", "Pune", "Nagpur", "Bhusaval", "Jalgaon"], "name": "Maharashtra"}}, {"state": {"cities": ["Bangalore", "Hubli"], "name": "Karnataka"}}, {"state": {"states": ["Raipur", "Durg"], "name": "Chhattisgarh"}}]'
... | [
"evaluate.evaluate"
] | [((324, 338), 'evaluate.evaluate', 'evaluate', (['data'], {}), '(data)\n', (332, 338), False, 'from evaluate import evaluate\n')] |
from django.contrib.auth import login
from evaluate.models import Result
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from evaluate.forms import TestCreateForm
def findEXT(a):
if a[-4] == '.':
return a[-3:]
if a[-5] == '.':
return a[-4:... | [
"evaluate.models.Result.objects.get",
"evaluate.forms.TestCreateForm"
] | [((1178, 1230), 'django.shortcuts.render', 'render', (['request', '"""evaluate/createTest.html"""', 'context'], {}), "(request, 'evaluate/createTest.html', context)\n", (1184, 1230), False, 'from django.shortcuts import render, redirect\n'), ((1289, 1314), 'evaluate.models.Result.objects.get', 'Result.objects.get', ([]... |
import os
import cv2
import torch
from torch.utils.data import DataLoader
import torch.optim as optim
from torch.nn import CTCLoss
from dataset import Synth90kDataset, synth90k_collate_fn
from model import CRNN
from evaluate import evaluate
from config import train_config as config
def train_batch(crnn, data, optim... | [
"evaluate.evaluate"
] | [((473, 519), 'torch.nn.functional.log_softmax', 'torch.nn.functional.log_softmax', (['logits'], {'dim': '(2)'}), '(logits, dim=2)\n', (504, 519), False, 'import torch\n'), ((642, 671), 'torch.flatten', 'torch.flatten', (['target_lengths'], {}), '(target_lengths)\n', (655, 671), False, 'import torch\n'), ((1508, 1604),... |
from tqdm.auto import tqdm
from crf import CRF
import sys
sys.path.append("../../../")
from utils import *
from evaluate import evaluation
import os
import pickle
import pandas as pd
import collections
import csv
import os
import glob
import pickle
from enum import Enum
from dataclasses import dataclass
from functool... | [
"evaluate.evaluation.get_evaluation"
] | [((60, 88), 'sys.path.append', 'sys.path.append', (['"""../../../"""'], {}), "('../../../')\n", (75, 88), False, 'import sys\n'), ((645, 665), 'torch.manual_seed', 'torch.manual_seed', (['(0)'], {}), '(0)\n', (662, 665), False, 'import torch\n'), ((5274, 5321), 'os.path.join', 'os.path.join', (['exp_name', 'run_name', ... |
#!/usr/bin/env python
import sys
import os
import config
import evaluate
import msd_parse
from pyspark.mllib.recommendation import MatrixFactorizationModel, ALS
def main():
import configspark
sc = configspark.SPARK_CONTEXT
# user/song string ID to int ID mappings
full_text = sc.textFile(config.MSD_... | [
"evaluate.evaluate_model"
] | [((399, 437), 'msd_parse.get_user_song_maps', 'msd_parse.get_user_song_maps', (['full_raw'], {}), '(full_raw)\n', (427, 437), False, 'import msd_parse\n'), ((599, 651), 'msd_parse.replace_raw_ids', 'msd_parse.replace_raw_ids', (['test_parsed', 'users', 'songs'], {}), '(test_parsed, users, songs)\n', (624, 651), False, ... |
import argparse
import itertools
import os.path
import os
import time
import logging
import datetime
import torch
import torch.optim.lr_scheduler
import numpy as np
import os
import evaluate
import trees
import vocabulary
import nkutil
from tqdm import tqdm
import SAPar_model
import random
tokens = SAPar_model
from ... | [
"evaluate.evalb"
] | [((950, 2051), 'nkutil.HParams', 'nkutil.HParams', ([], {'max_len_train': '(0)', 'max_len_dev': '(0)', 'sentence_max_len': '(300)', 'learning_rate': '(0.0008)', 'learning_rate_warmup_steps': '(160)', 'clip_grad_norm': '(0.0)', 'step_decay': '(True)', 'step_decay_factor': '(0.5)', 'step_decay_patience': '(5)', 'max_cons... |
import numpy as np
import sys
import evaluate as EV
matrix_list = ["all", "1_syllable", "2_syllable", "3_syllable", "4_syllable", "2-_syllable"]
def average_cost(costlist, querylist):
querylist_uniq = []
cost_dict = {}
for i in range(len(querylist)):
query_id = querylist[i].strip()
keyword... | [
"evaluate.evaluate",
"evaluate.build_occurance_dict",
"evaluate.build_syllable_num_dict"
] | [((1009, 1045), 'evaluate.build_occurance_dict', 'EV.build_occurance_dict', (['sys.argv[4]'], {}), '(sys.argv[4])\n', (1032, 1045), True, 'import evaluate as EV\n'), ((1070, 1109), 'evaluate.build_syllable_num_dict', 'EV.build_syllable_num_dict', (['sys.argv[5]'], {}), '(sys.argv[5])\n', (1096, 1109), True, 'import eva... |
import os
import json
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from evaluate import evaluate
if __name__ == '__main__':
training_commands, predict_commands = [], []
choices = {"dan": range(1, 4+1), "gru": range(1, 4+1)}
probing_accuracies = {"dan": [], "gru": []}
fo... | [
"evaluate.evaluate"
] | [((40, 63), 'matplotlib.use', 'matplotlib.use', (['"""TkAgg"""'], {}), "('TkAgg')\n", (54, 63), False, 'import matplotlib\n'), ((4146, 4180), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""seaborn-whitegrid"""'], {}), "('seaborn-whitegrid')\n", (4159, 4180), True, 'import matplotlib.pyplot as plt\n'), ((447, 517... |
import os
import pickle
import argparse
import torch
from torch.utils.data import Dataset, DataLoader
from data_processing import prep_dataset, build_second_order_wikidata_graphs
from stockdataset import StockDataset
from model import MANSF
from train import train_model
from evaluate import evaluate_model
STOCKNET_REP... | [
"evaluate.evaluate_model"
] | [((1095, 1337), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Preprocess data, train or evaluate the MAN-SF model. If executed with --train or --evaluate, --model is required. If executed with --preprocess_in, --preprocess_out is required."""'}), "(description=\n 'Pre... |
import pandas as pd
from evaluate.calculator import (
RecallCalculator,
PrecisionCalculator,
EmptyReportError,
)
import pytest
from unittest.mock import patch, Mock
from evaluate.report import (
Report,
PrecisionReport,
RecallReport
)
from tests.common import create_precision_report_row
from io ... | [
"evaluate.calculator.RecallCalculator",
"evaluate.calculator.RecallCalculator._calculate_info_wrt_truth_probes",
"evaluate.calculator.RecallCalculator._calculate_info_wrt_variants",
"evaluate.report.PrecisionReport",
"evaluate.calculator.PrecisionCalculator"
] | [((4740, 5000), 'unittest.mock.patch.object', 'patch.object', (['Report', 'Report.get_classifications_as_list.__name__'], {'return_value': "['unmapped', 'partially_mapped', 'primary_correct', 'primary_incorrect',\n 'secondary_correct', 'secondary_incorrect', 'supplementary_correct',\n 'supplementary_incorrect']"}... |
from data import build_corpus
from evaluate import Metrics
from models.hmm import HMMModel
from models.crf import CRFModel
from models.lstm import BiLSTM
from models.BiLSTM_CRF import BiLSTM_CRF
from utils import *
def main():
print('读取数据...')
train_word_lists, train_tag_lists, word2id, tag2id = ... | [
"evaluate.Metrics"
] | [((320, 341), 'data.build_corpus', 'build_corpus', (['"""train"""'], {}), "('train')\n", (332, 341), False, 'from data import build_corpus\n'), ((379, 416), 'data.build_corpus', 'build_corpus', (['"""dev"""'], {'maek_vocab': '(False)'}), "('dev', maek_vocab=False)\n", (391, 416), False, 'from data import build_corpus\n... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.