code stringlengths 42 43.2k | apis list | extract_api stringlengths 115 61.9k |
|---|---|---|
import chess
from math import inf
from time import time
from evaluate import evaluate
def minimax(game, depth, player, timeout):
moves = game.board.legal_moves
best_move = None
if player == chess.WHITE:
best_score = -inf
for move in moves:
game.move(move)
score = minimiser(game, depth, inf,... | [
"evaluate.evaluate"
] | [((822, 836), 'evaluate.evaluate', 'evaluate', (['game'], {}), '(game)\n', (830, 836), False, 'from evaluate import evaluate\n'), ((1223, 1237), 'evaluate.evaluate', 'evaluate', (['game'], {}), '(game)\n', (1231, 1237), False, 'from evaluate import evaluate\n'), ((1532, 1538), 'time.time', 'time', ([], {}), '()\n', (15... |
import argparse
import datetime
import os
import copy
import time
import json
# import visdom
import torch
import numpy as np
import tempfile
from os.path import join as pjoin
from distutils.dir_util import copy_tree
import gym
import textworld
from textworld.gym import register_game, make_batch2
from agent import Age... | [
"evaluate.evaluate"
] | [((446, 770), 'textworld.EnvInfos', 'textworld.EnvInfos', ([], {'description': '(True)', 'inventory': '(True)', 'verbs': '(True)', 'location_names': '(True)', 'location_nouns': '(True)', 'location_adjs': '(True)', 'object_names': '(True)', 'object_nouns': '(True)', 'object_adjs': '(True)', 'facts': '(True)', 'last_acti... |
import os
import time
import torch
from torch import nn
from cifar10 import load_data_cifar10
from evaluate import Accumulator, accurate_num, evaluate_accuracy
from alex import Alexnet
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
root_path = os.getcwd()
model_name = 'alexnet.pth'
... | [
"evaluate.Accumulator",
"evaluate.accurate_num",
"evaluate.evaluate_accuracy"
] | [((279, 290), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (288, 290), False, 'import os\n'), ((333, 377), 'os.path.join', 'os.path.join', (['root_path', '"""model"""', 'model_name'], {}), "(root_path, 'model', model_name)\n", (345, 377), False, 'import os\n'), ((556, 585), 'cifar10.load_data_cifar10', 'load_data_cifar1... |
from load import LoadData
from preprocess import PreprocessData
from model import BidaF
from evaluate import evaluate as eval
from load import ptbtokenizer
import torch.optim as optim
import torch.nn as nn
import torch
import pickle
import time
import sys
import argparse
import copy
import numpy as np
import datetime
... | [
"evaluate.evaluate"
] | [((6793, 6920), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""BiDaF for Machine Comprehension & Cloze-Style Reading Comprehension - Training"""'}), "(description=\n 'BiDaF for Machine Comprehension & Cloze-Style Reading Comprehension - Training'\n )\n", (6816, 6920), False, 'impor... |
"""
Main code for weakly supervised object localization
===================================================
*Author*: <NAME>, Northwestern Polytechnical University
"""
import torch
import os
import numpy as np
import time
import datetime
from model.model import WSL, load_pretrained
import data_utils.load_voc as load_v... | [
"evaluate.corloc_eval.corloc",
"evaluate.rst_for_corloc.spn_torch_rst"
] | [((524, 588), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""test torch version of spn"""'}), "(description='test torch version of spn')\n", (547, 588), False, 'import argparse\n'), ((816, 866), 'os.path.join', 'os.path.join', (['root_dir', '"""rst/h5/attention_maps.h5"""'], {}), "(root_... |
import os
import logging
import time
import random
import json
from copy import deepcopy
import numpy as np
import torch
from tqdm import tqdm
from transformers import BertTokenizer
from dora import DORA
from config import Config
from reader import Reader
import ontology
from db import DB
from evaluate import MultiWo... | [
"evaluate.MultiWozEvaluator"
] | [((364, 389), 'logging.getLogger', 'logging.getLogger', (['"""DORA"""'], {}), "('DORA')\n", (381, 389), False, 'import logging\n'), ((445, 468), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (466, 468), False, 'import logging\n'), ((516, 557), 'torch.cuda.set_device', 'torch.cuda.set_device', (['c... |
#!/usr/bin/python
import sys,os
import argparse
import glob
from generate_windows import Generate_windows,Get_block_position,split_chr_bedGraph2
from evaluate import Evaluate
from scanTranscriptome_forward import Scan_Forward
from scanTranscriptome_reverse import Scan_Backward
from postprocess import Postprocess
#
fro... | [
"evaluate.Evaluate"
] | [((1262, 1287), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1285, 1287), False, 'import argparse\n'), ((3742, 3765), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (3763, 3765), False, 'import datetime\n'), ((3778, 3887), 'generate_windows.split_chr_bedGraph2', 'split_c... |
import pandas as pd
import matplotlib.pyplot as plt
import keras
from keras import layers
from keras.utils import plot_model
from keras.callbacks import ModelCheckpoint
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
imp... | [
"evaluate.normalized_dcg",
"evaluate.mean_average_precision",
"evaluate.roc_auc"
] | [((632, 656), 'load_ratings.load', 'load_ratings.load', (['"""../"""'], {}), "('../')\n", (649, 656), False, 'import load_ratings\n'), ((696, 719), 'load_movies.load', 'load_movies.load', (['"""../"""'], {}), "('../')\n", (712, 719), False, 'import load_movies\n'), ((795, 851), 'sklearn.model_selection.train_test_split... |
# Standard Libraries
import os
import subprocess
# import datetime
# Third Libraries
# import pandas as pd
# import numpy as np
# Local Libraries
import define
import analyze
import prepare
import fselect
import evaluate
import improve
import tools
import pandas as pd
from flask import Flask, render_template, \
... | [
"evaluate.Evaluate"
] | [((456, 471), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (461, 471), False, 'from flask import Flask, render_template, redirect, request, url_for, jsonify, flash\n'), ((554, 587), 'os.path.join', 'os.path.join', (['APP_PATH', '"""uploads"""'], {}), "(APP_PATH, 'uploads')\n", (566, 587), False, 'import ... |
# Standard libraries
from argparse import ArgumentParser
import logging
from typing import Callable
# Third-party libraries
import numpy as np
from pymoo.operators.crossover import erx
from pymoo.factory import get_crossover
# Local dependencies
from evaluate import get_env, get_state_action_size, evaluate
from polic... | [
"evaluate.get_state_action_size",
"evaluate.evaluate",
"evaluate.get_env"
] | [((2981, 3006), 'pymoo.factory.get_crossover', 'get_crossover', (['"""perm_erx"""'], {}), "('perm_erx')\n", (2994, 3006), False, 'from pymoo.factory import get_crossover\n'), ((402, 425), 'numpy.random.default_rng', 'np.random.default_rng', ([], {}), '()\n', (423, 425), True, 'import numpy as np\n'), ((764, 787), 'nump... |
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, random_split
import torch
from torch.utils.data import DataLoader, random_split
import os
import sys
import random
import argparse
from pytorch_nndct.apis import torch_quantizer, dump_xmodel
from evaluate import evaluate
from unet import UNet
f... | [
"evaluate.evaluate"
] | [((626, 649), 'pathlib.Path', 'Path', (['"""fyp_data/crops/"""'], {}), "('fyp_data/crops/')\n", (630, 649), False, 'from pathlib import Path\n'), ((665, 688), 'pathlib.Path', 'Path', (['"""fyp_data/masks/"""'], {}), "('fyp_data/masks/')\n", (669, 688), False, 'from pathlib import Path\n'), ((793, 837), 'utils.data_load... |
import matplotlib.pyplot as plt
import numpy as np
import matplotlib as mpl
import pandas as pd
import sys
sys.path.append("..")
sys.path.append("../technical-analysis_python/")
mpl.use('tkagg') # issues with Big Sur
# technical analysis
from strategy.macd_crossover import macdCrossover
from backtest import Backtest... | [
"evaluate.SharpeRatio",
"evaluate.MaxDrawdown",
"evaluate.PortfolioReturn",
"evaluate.CAGR"
] | [((108, 129), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (123, 129), False, 'import sys\n'), ((130, 178), 'sys.path.append', 'sys.path.append', (['"""../technical-analysis_python/"""'], {}), "('../technical-analysis_python/')\n", (145, 178), False, 'import sys\n'), ((179, 195), 'matplotlib.us... |
'''This script tunes the L2 reg weight of the final classifier.'''
import argparse
import os
import math
import torch
import torch.backends.cudnn as cudnn
from configs import get_datasets
from evaluate import encode_train_set, train_clf, test
from models import *
parser = argparse.ArgumentParser(description='Tune re... | [
"evaluate.encode_train_set",
"evaluate.test",
"evaluate.train_clf"
] | [((276, 377), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Tune regularization coefficient of downstream classifier."""'}), "(description=\n 'Tune regularization coefficient of downstream classifier.')\n", (299, 377), False, 'import argparse\n'), ((667, 694), 'os.path.isdir', 'os.pa... |
import numpy as np
import os
import paddle.fluid as fluid
from gmf import GMF
from mlp import MLP
from neumf import NeuMF
from Dataset import Dataset
from evaluate import evaluate_model
import logging
import paddle
import args
import utils
import time
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)... | [
"evaluate.evaluate_model"
] | [((252, 323), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(asctime)s - %(levelname)s - %(message)s"""'}), "(format='%(asctime)s - %(levelname)s - %(message)s')\n", (271, 323), False, 'import logging\n'), ((333, 359), 'logging.getLogger', 'logging.getLogger', (['"""fluid"""'], {}), "('fluid')\n", ... |
from evaluate import evaluate
evaluate() | [
"evaluate.evaluate"
] | [((32, 42), 'evaluate.evaluate', 'evaluate', ([], {}), '()\n', (40, 42), False, 'from evaluate import evaluate\n')] |
from unittest.mock import Mock, patch, PropertyMock
from evaluate.filtered_vcf_file import FilteredVCFFile
from evaluate.vcf_filters import VCF_Filters
from evaluate.vcf_file import VCFFile, VCFFactory
import pytest
import pysam
from io import StringIO
from evaluate.coverage_filter import CoverageFilter
@pytest.fixtur... | [
"evaluate.filtered_vcf_file.FilteredVCFFile",
"evaluate.coverage_filter.CoverageFilter",
"evaluate.vcf_filters.VCF_Filters",
"evaluate.filtered_vcf_file.FilteredVCFFile._filter_records"
] | [((387, 393), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (391, 393), False, 'from unittest.mock import Mock, patch, PropertyMock\n'), ((589, 595), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (593, 595), False, 'from unittest.mock import Mock, patch, PropertyMock\n'), ((1268, 1274), 'unittest.mock.Mock', 'Mock'... |
import numpy as np
import lasagne
import theano
import theano.tensor as T
import random
import sys
import batch_char as batch
import time
import cPickle as pkl
import io
import evaluate
from collections import OrderedDict
from t2v import tweet2vec, init_params, load_params
from settings_char import N_BATCH, MAX_LENGTH... | [
"evaluate.main"
] | [((430, 471), 't2v.tweet2vec', 'tweet2vec', (['tweet', 't_mask', 'params', 'n_chars'], {}), '(tweet, t_mask, params, n_chars)\n', (439, 471), False, 'from t2v import tweet2vec, init_params, load_params\n'), ((516, 649), 'lasagne.layers.DenseLayer', 'lasagne.layers.DenseLayer', (['emb_layer', 'n_classes'], {'W': "params... |
import json
from evaluate import Evaluator
input_path = './input/input.json' # input file path
output_path = './output/length2.tsv' # output file path
evaluator = Evaluator()
def calculate_rouge_all(score):
rouge_all = 0.2 * score["rouge-1"] + 0.4 * score["rouge-2"] + 0.4 * score["rouge-l"]
return rouge_a... | [
"evaluate.Evaluator"
] | [((167, 178), 'evaluate.Evaluator', 'Evaluator', ([], {}), '()\n', (176, 178), False, 'from evaluate import Evaluator\n'), ((666, 682), 'json.loads', 'json.loads', (['line'], {}), '(line)\n', (676, 682), False, 'import json\n')] |
"""
Like described in the :mod:`parsing_representation` module, there's a need for
an ast like module to represent the states of parsed modules.
But now there are also structures in Python that need a little bit more than
that. An ``Instance`` for example is only a ``Class`` before it is
instantiated. This class repre... | [
"evaluate.follow_call_list",
"evaluate.follow_statement",
"evaluate.find_name"
] | [((1490, 1538), 'jedi._compatibility.use_metaclass', 'use_metaclass', (['cache.CachedMetaClass', 'Executable'], {}), '(cache.CachedMetaClass, Executable)\n', (1503, 1538), False, 'from jedi._compatibility import use_metaclass, next, hasattr, unicode\n'), ((6775, 6820), 'jedi._compatibility.use_metaclass', 'use_metaclas... |
import tqdm
import struct
import os
import numpy as np
import pickle
import json
import random
import argparse
from collections import Counter
#from lightfm import LightFM
from scipy import sparse
from evaluate import evaluate, coverage
from implicit.als import AlternatingLeastSquares
from scipy.linalg import norm
os... | [
"evaluate.evaluate",
"evaluate.coverage"
] | [((1370, 1389), 'numpy.mean', 'np.mean', (['popularity'], {}), '(popularity)\n', (1377, 1389), True, 'import numpy as np\n'), ((2153, 2167), 'numpy.sort', 'np.sort', (['array'], {}), '(array)\n', (2160, 2167), True, 'import numpy as np\n'), ((2203, 2235), 'numpy.arange', 'np.arange', (['(1)', '(array.shape[0] + 1)'], {... |
import os
import re
import sys
sys.path.append('.')
import cv2
import math
import time
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 collections import OrderedDict
from sci... | [
"evaluate.coco_eval.get_outputs"
] | [((31, 51), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (46, 51), False, 'import sys\n'), ((788, 813), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (811, 813), False, 'import argparse\n'), ((1278, 1302), 'lib.config.update_config', 'update_config', (['cfg', 'args'], {}... |
# coding=utf-8
from __future__ import absolute_import, division, print_function
import paddle
from utils import setup, get_loader
from train import train_model
from evaluate import valid
import os
def main():
# Model & Tokenizer Setup
args, model = setup()
if args.mode=='train':
# Training
... | [
"evaluate.valid"
] | [((264, 271), 'utils.setup', 'setup', ([], {}), '()\n', (269, 271), False, 'from utils import setup, get_loader\n'), ((327, 351), 'train.train_model', 'train_model', (['args', 'model'], {}), '(args, model)\n', (338, 351), False, 'from train import train_model\n'), ((427, 462), 'os.path.exists', 'os.path.exists', (['arg... |
import os
import time
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 ContentVaeDataGenerator
from data import CollaborativeVAEDataGenerator
from pretrain_vae imp... | [
"evaluate.EvaluateCold",
"evaluate.EvaluateModel"
] | [((71, 94), 'sys.path.append', 'sys.path.append', (['"""libs"""'], {}), "('libs')\n", (86, 94), False, 'import sys\n'), ((589, 614), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (612, 614), False, 'import argparse\n'), ((1425, 1441), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([], {}), '()\n... |
import argparse
import numpy as np
import os
import pandas as pd
import time
import torch
from data import (
eval_collate_fn,
EvalDataset,
TrainCollator,
TrainDataset,
)
from evaluate import predict, make_word_outputs_final
from transformers import (
AdamW,
AutoConfig,
AutoModelWithLMHead,
... | [
"evaluate.predict",
"evaluate.make_word_outputs_final"
] | [((442, 467), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (465, 467), False, 'import argparse\n'), ((1636, 1655), 'transformers.set_seed', 'set_seed', (['args.seed'], {}), '(args.seed)\n', (1644, 1655), False, 'from transformers import AdamW, AutoConfig, AutoModelWithLMHead, AutoTokenizer, g... |
import os
from collections import defaultdict
import logging
from time import time
import numpy as np
import torch
from matplotlib import pyplot as plt
from tqdm import tqdm
from evaluate import evaluate
from config import *
from metrics import VolumeLoss
TRAIN_LOSS_TAG = 'Train-Loss'
VALIDATION_LOSS_TAG = 'Val-Loss... | [
"evaluate.evaluate"
] | [((803, 905), 'metrics.VolumeLoss', 'VolumeLoss', (['self.config.dice_loss_weight', 'self.config.wce_loss_weight', 'self.config.ce_loss_weight'], {}), '(self.config.dice_loss_weight, self.config.wce_loss_weight, self.\n config.ce_loss_weight)\n', (813, 905), False, 'from metrics import VolumeLoss\n'), ((948, 965), '... |
"""1) Include/define any dependencies for catacomb.System class"""
import torch
import catacomb
from data import str_to_array, tensor_from_list
from evaluate import evaluate
from models.encoder import Encoder
from models.ptr_decoder import PtrDecoder
"""2) Implementing catacomb.System class with initialization and o... | [
"evaluate.evaluate"
] | [((481, 560), 'models.encoder.Encoder', 'Encoder', ([], {'input_dim': 'data_dim', 'embedding_dim': 'embedding_dim', 'hidden_dim': 'hidden_dim'}), '(input_dim=data_dim, embedding_dim=embedding_dim, hidden_dim=hidden_dim)\n', (488, 560), False, 'from models.encoder import Encoder\n'), ((625, 713), 'models.ptr_decoder.Ptr... |
import os
import numpy as np
import torch
import torch.nn as nn
from constants import Constants
from datasets import load_data
from evaluate import evaluate
from models import CoVA
from train import train_model
from utils import cmdline_args_parser, print_and_log, set_all_seeds
parser = cmdline_args_parser()
args = ... | [
"evaluate.evaluate"
] | [((291, 312), 'utils.cmdline_args_parser', 'cmdline_args_parser', ([], {}), '()\n', (310, 312), False, 'from utils import cmdline_args_parser, print_and_log, set_all_seeds\n'), ((428, 457), 'utils.set_all_seeds', 'set_all_seeds', (['Constants.SEED'], {}), '(Constants.SEED)\n', (441, 457), False, 'from utils import cmdl... |
# Copyright (c) Facebook, Inc. and its affiliates.
import regex
from data import AlignDataset
from evaluate import evaluate
from models import Aligner
import collections
resdict = collections.defaultdict(None)
aligner = Aligner(
'criss-align', distortion=0,
path='criss/criss-3rd.pt',
args_path='criss/ar... | [
"evaluate.evaluate"
] | [((183, 212), 'collections.defaultdict', 'collections.defaultdict', (['None'], {}), '(None)\n', (206, 212), False, 'import collections\n'), ((224, 340), 'models.Aligner', 'Aligner', (['"""criss-align"""'], {'distortion': '(0)', 'path': '"""criss/criss-3rd.pt"""', 'args_path': '"""criss/args.pt"""', 'matching_method': '... |
from http.server import BaseHTTPRequestHandler, HTTPServer
import evaluate
import os
import base64
import json
# HTTPRequestHandler class
class testHTTPServer_RequestHandler(BaseHTTPRequestHandler):
# GET
def do_GET(self):
impath = self.path[1:]
try:
q = json.loads(base64.b64decode(... | [
"evaluate.ffwd"
] | [((1167, 1224), 'http.server.HTTPServer', 'HTTPServer', (['server_address', 'testHTTPServer_RequestHandler'], {}), '(server_address, testHTTPServer_RequestHandler)\n', (1177, 1224), False, 'from http.server import BaseHTTPRequestHandler, HTTPServer\n'), ((519, 607), 'evaluate.ffwd', 'evaluate.ffwd', (["[q['path']]", "[... |
from typing import Dict
import argparse
import itertools
import logging
import os
import os.path
import sys
import time
import dynet as dy
import numpy as np
import yaml
import evaluate
import loader
import parse
import trees
import vocabulary
LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
logger = logging.ge... | [
"evaluate.calc_frs",
"evaluate.evalb"
] | [((310, 350), 'logging.getLogger', 'logging.getLogger', (['"""minimal-span-parser"""'], {}), "('minimal-span-parser')\n", (327, 350), False, 'import logging\n'), ((395, 428), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stdout'], {}), '(sys.stdout)\n', (416, 428), False, 'import logging\n'), ((2034, 2053), ... |
import argparse
import os.path
import time
import numpy as np
import torch
import torch.nn as nn
import sys
from nltk import tree
import evaluate
import treebanks
from benepar import Parser, InputSentence
from benepar.partitioned_transformer import PartitionedMultiHeadAttention
def format_elapsed(start_time):
... | [
"evaluate.evalb",
"evaluate.FScore"
] | [((1086, 1165), 'treebanks.load_trees', 'treebanks.load_trees', (['args.test_path', 'args.test_path_text', 'args.text_processing'], {}), '(args.test_path, args.test_path_text, args.text_processing)\n', (1106, 1165), False, 'import treebanks\n'), ((1307, 1358), 'benepar.Parser', 'Parser', (['args.model_path'], {'batch_s... |
"""
This script demonstrates initialisation, training, evaluation, and forecasting of ForecastNet. The dataset used for the
time-invariance test in section 6.1 of the ForecastNet paper is used for this demonstration.
Paper:
"ForecastNet: A Time-Variant Deep Feed-Forward Neural Network Architecture for Multi-Step-Ahead... | [
"evaluate.evaluate"
] | [((868, 975), 'pandas.read_parquet', 'pd.read_parquet', (['"""/Users/ryadhkhisb/Dev/workspaces/m/finance-scrape/data/nasdaq100_15min.parquet"""'], {}), "(\n '/Users/ryadhkhisb/Dev/workspaces/m/finance-scrape/data/nasdaq100_15min.parquet'\n )\n", (883, 975), True, 'import pandas as pd\n'), ((1486, 1651), 'window_g... |
import data as Data
from model import Model
from loss import PairwiseRankingLoss as Loss
from optimizer import Optimizer
import evaluate
from settings import config
# load data
data = Data.Loader()
data.create_dictionaries()
data.save_dictionaries()
# load evaluation data
evaluation_data = Data.Loader()
evaluation_da... | [
"evaluate.recall_score",
"evaluate.text_to_image",
"evaluate.image_to_text"
] | [((185, 198), 'data.Loader', 'Data.Loader', ([], {}), '()\n', (196, 198), True, 'import data as Data\n'), ((293, 306), 'data.Loader', 'Data.Loader', ([], {}), '()\n', (304, 306), True, 'import data as Data\n'), ((365, 372), 'model.Model', 'Model', ([], {}), '()\n', (370, 372), False, 'from model import Model\n'), ((393... |
import torch
import torch.nn as nn
import torch.distributed as dist
from torch.utils.tensorboard import SummaryWriter
import torch.multiprocessing as mp
import torch.distributed as dist
import torch.utils.data.distributed
import argparse
import os
import json
from models.StyleSpeech import StyleSpeech
fr... | [
"evaluate.evaluate"
] | [((610, 641), 'os.path.isfile', 'os.path.isfile', (['checkpoint_path'], {}), '(checkpoint_path)\n', (624, 641), False, 'import os\n'), ((2609, 2635), 'utils.get_param_num', 'utils.get_param_num', (['model'], {}), '(model)\n', (2628, 2635), False, 'import utils\n'), ((2655, 2689), 'utils.get_param_num', 'utils.get_param... |
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",
)
import pysam
from eva... | [
"evaluate.classifier.RecallClassifier",
"evaluate.masker.RecallMasker.from_bed",
"evaluate.reporter.RecallReporter"
] | [((701, 754), 'logging.info', 'logging.info', (['f"""Creating masker from {mask_filepath}"""'], {}), "(f'Creating masker from {mask_filepath}')\n", (713, 754), False, 'import logging\n'), ((1744, 1764), 'logging.info', 'logging.info', (['"""Done"""'], {}), "('Done')\n", (1756, 1764), False, 'import logging\n'), ((801, ... |
import torch
import torch.nn as nn
from helper import *
from lstm import LSTM
from evaluate import evaluate
def train(model, model_optimizer, inp, target):
model.zero_grad()
loss = 0
for c in range(chunk_len):
output = model(inp[c])
loss += criterion(output, target[c].unsqueeze(0))
lo... | [
"evaluate.evaluate"
] | [((711, 766), 'lstm.LSTM', 'LSTM', (['input_dim', 'hidden_dim', 'n_characters', 'n_characters'], {}), '(input_dim, hidden_dim, n_characters, n_characters)\n', (715, 766), False, 'from lstm import LSTM\n'), ((889, 910), 'torch.nn.CrossEntropyLoss', 'nn.CrossEntropyLoss', ([], {}), '()\n', (908, 910), True, 'import torch... |
"""
This script demonstrates initialisation, training, evaluation, and forecasting of ForecastNet. The dataset used for the
time-invariance test in section 6.1 of the ForecastNet paper is used for this demonstration.
Paper:
"ForecastNet: A Time-Variant Deep Feed-Forward Neural Network Architecture for Multi-Step-Ahead... | [
"evaluate.evaluate"
] | [((690, 707), 'numpy.random.seed', 'np.random.seed', (['(1)'], {}), '(1)\n', (704, 707), True, 'import numpy as np\n'), ((1003, 1110), 'pandas.read_parquet', 'pd.read_parquet', (['"""/Users/ryadhkhisb/Dev/workspaces/m/finance-scrape/data/nasdaq100_15min.parquet"""'], {}), "(\n '/Users/ryadhkhisb/Dev/workspaces/m/fin... |
from typing import Dict, List, Any
import chess
import sys
import time
from evaluate import evaluate_board, move_value, check_end_game
debug_info: Dict[str, Any] = {}
MATE_SCORE = 1000000000
MATE_THRESHOLD = 999000000
def next_move(depth: int, board: chess.Board, debug=True) -> chess.Move:
debug_info.clear(... | [
"evaluate.evaluate_board",
"evaluate.move_value",
"evaluate.check_end_game"
] | [((359, 370), 'time.time', 'time.time', ([], {}), '()\n', (368, 370), False, 'import time\n'), ((606, 627), 'evaluate.check_end_game', 'check_end_game', (['board'], {}), '(board)\n', (620, 627), False, 'from evaluate import evaluate_board, move_value, check_end_game\n'), ((436, 447), 'time.time', 'time.time', ([], {}),... |
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by appli... | [
"evaluate.evaluate"
] | [((1737, 1832), 'data.ATISDataset', 'ATISDataset', (["args['train_path']", "args['vocab_path']", "args['intent_path']", "args['slot_path']"], {}), "(args['train_path'], args['vocab_path'], args['intent_path'],\n args['slot_path'])\n", (1748, 1832), False, 'from data import ATISDataset\n'), ((1844, 1938), 'data.ATISD... |
from evaluate import evaluate_model
from models import *
from train import train_model
from visualize import visualize_model_performance
num_epochs = 50
model0 = model_0()
model1 = model_1()
model2 = model_2()
model3 = model_3()
baseline_model_path = train_model(model0, str(model0.name) + "_p3_baseline_balanced_weig... | [
"evaluate.evaluate_model"
] | [((828, 888), 'evaluate.evaluate_model', 'evaluate_model', (['baseline_model_path'], {'class_weights': '[1, 0, 1]'}), '(baseline_model_path, class_weights=[1, 0, 1])\n', (842, 888), False, 'from evaluate import evaluate_model\n'), ((889, 946), 'evaluate.evaluate_model', 'evaluate_model', (['prelu_model_path'], {'class_... |
import numpy as np
import pickle
import tensorflow as tf
from time import time
from evaluate import evaluate_model, evaluate_model_recall_precision
class MF():
def __init__(self, rating_matrix):
#### 參數設定
self.num_u = rating_matrix.shape[0] # 5551
self.num_v = rating_matrix.shape[1] # 169... | [
"evaluate.evaluate_model",
"evaluate.evaluate_model_recall_precision"
] | [((10047, 10064), 'numpy.random.seed', 'np.random.seed', (['(5)'], {}), '(5)\n', (10061, 10064), True, 'import numpy as np\n'), ((10113, 10160), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Run CDL."""'}), "(description='Run CDL.')\n", (10136, 10160), False, 'import argparse\n'), ((195... |
# Project hiatus
# script used to evaluate our models and analyse the results
# 16/11/2020
# <NAME>
# loading required packages
import os
import numpy as np
from sklearn.model_selection import train_test_split
from torch.utils.data import Subset
import torch
from sklearn.linear_model import LinearRegression
import skl... | [
"evaluate.evaluate_model",
"evaluate.generate_prediction_baseline",
"evaluate.generate_prediction_model",
"evaluate.generate_prediction_baseline_model"
] | [((436, 499), 'os.chdir', 'os.chdir', (['"""/home/adminlocal/Bureau/GIT/hiatus_change_detection"""'], {}), "('/home/adminlocal/Bureau/GIT/hiatus_change_detection')\n", (444, 499), False, 'import os\n'), ((648, 681), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (671, 681)... |
import logging
import os
import random
import torch
import numpy as np
from dataset import Dataset
from dcparser import Parser
from domain import DomainEngine
from detect import DetectEngine
from repair import RepairEngine
from evaluate import EvalEngine
# if not os.path.exists('examples/hospital.log'):
# with o... | [
"evaluate.EvalEngine"
] | [((361, 484), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(asctime)s - [%(levelname)5s] - %(message)s"""', 'datefmt': '"""%H:%M:%S"""', 'filename': '"""usecase1.log"""'}), "(format='%(asctime)s - [%(levelname)5s] - %(message)s',\n datefmt='%H:%M:%S', filename='usecase1.log')\n", (380, 484), Fa... |
import SimpleITK as sitk
import numpy as np
import tensorflow as tf
from medpy.metric import hd,asd
from config.Defines import Get_Name_By_Index
from dirutil.helper import get_name_wo_suffix
from evaluate.metric import calculate_binary_dice, neg_jac, print_mean_and_std
from excelutil.output2excel import outpu2excel
fr... | [
"evaluate.metric.print_mean_and_std",
"evaluate.metric.calculate_binary_dice",
"evaluate.metric.neg_jac"
] | [((760, 798), 'model.base_model.BaseModelV2.__init__', 'BaseModelV2.__init__', (['self', 'sess', 'args'], {}), '(self, sess, args)\n', (780, 798), False, 'from model.base_model import BaseModelV2\n'), ((829, 858), 'learn2reg.sampler.MMSampler', 'MMSampler', (['self.args', '"""train"""'], {}), "(self.args, 'train')\n", ... |
# MIT License
#
# Copyright (c) 2018 <NAME>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publi... | [
"evaluate.Evaluate"
] | [((1816, 1842), 'neural_net.NeuralNetworkWrapper', 'NeuralNetworkWrapper', (['game'], {}), '(game)\n', (1836, 1842), False, 'from neural_net import NeuralNetworkWrapper\n'), ((4048, 4078), 'mcts.MonteCarloTreeSearch', 'MonteCarloTreeSearch', (['self.net'], {}), '(self.net)\n', (4068, 4078), False, 'from mcts import Mon... |
from skimage.segmentation._watershed import watershed
from i3Deep import utils
import os
from evaluate import evaluate
import numpy as np
from tqdm import tqdm
def compute_predictions(image_path, mask_path, gt_path, save_path, nr_modalities, class_labels):
image_filenames = utils.load_filenames(image_path)... | [
"evaluate.evaluate"
] | [((360, 391), 'i3Deep.utils.load_filenames', 'utils.load_filenames', (['mask_path'], {}), '(mask_path)\n', (380, 391), False, 'from i3Deep import utils\n'), ((1059, 1101), 'evaluate.evaluate', 'evaluate', (['gt_path', 'save_path', 'class_labels'], {}), '(gt_path, save_path, class_labels)\n', (1067, 1101), False, 'from ... |
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by appli... | [
"evaluate.evaluate"
] | [((1129, 1162), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (1152, 1162), False, 'import warnings\n'), ((1189, 1221), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['__doc__'], {}), '(__doc__)\n', (1212, 1221), False, 'import argparse\n'), ((2804, 2834), 'paddl... |
import argparse
from datetime import datetime
from pathlib import Path
from collections import defaultdict
import numpy as np
import torch as th
import torch.nn as nn
from torch.nn.utils import clip_grad_norm_
from torch.optim.lr_scheduler import StepLR
from torch.utils.data import DataLoader
from tqdm import tqdm
fr... | [
"evaluate.evaluate"
] | [((1710, 1755), 'torch.utils.data.DataLoader', 'DataLoader', (['dataset', 'batch_size'], {'shuffle': '(True)'}), '(dataset, batch_size, shuffle=True)\n', (1720, 1755), False, 'from torch.utils.data import DataLoader\n'), ((2338, 2383), 'torch.optim.lr_scheduler.StepLR', 'StepLR', (['optimizer'], {'step_size': '(1000)',... |
# coding=utf-8
# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless r... | [
"evaluate.load"
] | [((2841, 2889), 'transformers.AutoTokenizer.from_pretrained', 'AutoTokenizer.from_pretrained', (['"""bert-base-cased"""'], {}), "('bert-base-cased')\n", (2870, 2889), False, 'from transformers import AdamW, AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\n'), ((4246, 4349), ... |
"""
This script demonstrates initialisation, training, evaluation, and forecasting of ForecastNet. The dataset used for the
time-invariance test in section 6.1 of the ForecastNet paper is used for this demonstration.
Paper:
"ForecastNet: A Time-Variant Deep Feed-Forward Neural Network Architecture for Multi-Step-Ahead... | [
"evaluate.evaluate"
] | [((656, 673), 'numpy.random.seed', 'np.random.seed', (['(1)'], {}), '(1)\n', (670, 673), True, 'import numpy as np\n'), ((742, 774), 'demoDataset.generate_data', 'generate_data', ([], {'T': '(2750)', 'period': '(50)'}), '(T=2750, period=50)\n', (755, 774), False, 'from demoDataset import generate_data\n'), ((993, 1194)... |
import os, sys
root_path = os.path.realpath(__file__).split('/evaluate/multipose_keypoint_val.py')[0]
os.chdir(root_path)
sys.path.append(root_path)
from training.batch_processor import batch_processor
from network.posenet import poseNet
from datasets.coco import get_loader
from evaluate.tester import Tester
# Hyper-... | [
"evaluate.tester.Tester",
"evaluate.tester.Tester.TestParams"
] | [((102, 121), 'os.chdir', 'os.chdir', (['root_path'], {}), '(root_path)\n', (110, 121), False, 'import os, sys\n'), ((122, 148), 'sys.path.append', 'sys.path.append', (['root_path'], {}), '(root_path)\n', (137, 148), False, 'import os, sys\n'), ((565, 584), 'evaluate.tester.Tester.TestParams', 'Tester.TestParams', ([],... |
#!/usr/bin/env python3
import sys
sys.path.append('./lib')
import argparse
import os
import datetime
import numpy as np
import time
import pickle
import torch
from torch import optim
from param_stamp import get_param_stamp, get_param_stamp_from_args
import evaluate
from lib.encoder import Classifier
from lib.vae_mod... | [
"evaluate.initiate_precision_dict"
] | [((35, 59), 'sys.path.append', 'sys.path.append', (['"""./lib"""'], {}), "('./lib')\n", (50, 59), False, 'import sys\n'), ((564, 666), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""./main.py"""'], {'description': '"""Run individual continual learning experiment."""'}), "('./main.py', description=\n 'Ru... |
import torch
import torch.nn.utils.prune as prune
import numpy as np
from copy import deepcopy
import sys
sys.path.append('../src')
from train import train
from evaluate import test
class PruneModel:
def __init__(self, network, batch_size, train_loader, val_loader, test_loader, optimizer, epochs, scheduler, devi... | [
"evaluate.test"
] | [((107, 132), 'sys.path.append', 'sys.path.append', (['"""../src"""'], {}), "('../src')\n", (122, 132), False, 'import sys\n'), ((644, 661), 'copy.deepcopy', 'deepcopy', (['network'], {}), '(network)\n', (652, 661), False, 'from copy import deepcopy\n'), ((5405, 5436), 'copy.deepcopy', 'deepcopy', (['self.original_netw... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.