code stringlengths 101 5.91M |
|---|
def torch_argmin(tensor):
flat_tensor = tensor.view(tensor.numel())
(_, argmin) = flat_tensor.min(0)
return np.unravel_index(int(argmin), tensor.shape) |
def _get_test_opt():
parser = argparse.ArgumentParser(description='Evaluate performance of SARPN on NYU-D v2 test set')
parser.add_argument('--backbone', default='SENet154', help='select a network as backbone')
parser.add_argument('--testlist_path', required=True, help='the path of testlist')
parser.add... |
def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state, nesting_state, error):
line = clean_lines.elided[linenum]
if (not line):
return
match = _RE_PATTERN_INCLUDE.search(line)
if match:
CheckIncludeLine(filename, clean_lines, linenum, include_state, error)
... |
class Clause_Rate(object):
def __init__(self, sentence_objs):
self.sentence_objs = sentence_objs
def handle(self):
tot_num_clauses = 0
for so in self.sentence_objs:
tot_num_clauses += num_clauses(so.const_pt)
return (tot_num_clauses / len(self.sentence_objs)) |
class _unzip_overlays(dist_build):
description = 'Unzip downloaded overlays'
user_options = []
boolean_options = []
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
cmd = self.get_finalized_command('build_py')
for (package, f, bui... |
class HardData(tx.data.DatasetBase[(Example, Example)]):
def __init__(self, hparams=None, device: Optional[torch.device]=None):
self._hparams = HParams(hparams, self.default_hparams())
data_source = HardDataSource(self._hparams.dataset.files, compression_type=self._hparams.dataset.compression_type)
... |
class NetFlowCoarse(nn.Module):
def __init__(self, kernelSize):
super(NetFlowCoarse, self).__init__()
assert ((kernelSize % 2) == 1)
self.conv1 = conv3x3((kernelSize * kernelSize), 512)
self.bn1 = nn.BatchNorm2d(512, eps=1e-05)
self.relu = nn.ReLU(inplace=True)
self.c... |
class InputFeatures(object):
def __init__(self, input_ids, input_mask, segment_ids, label_id, tokens, baseline_ids=None):
self.input_ids = input_ids
self.input_mask = input_mask
self.segment_ids = segment_ids
self.label_id = label_id
self.baseline_ids = baseline_ids
s... |
def test_digits_sqrt_modular_sparse():
model = GraphCutSelection(100, 'precomputed', optimizer='modular', random_state=0)
model.fit(X_digits_cosine_sparse)
assert_array_equal(model.ranking, digits_cosine_modular_ranking)
assert_array_almost_equal(model.gains, digits_cosine_modular_gains, 4) |
def rand_init_delta(delta, x, ord, eps, clip_min, clip_max):
if isinstance(eps, torch.Tensor):
assert (len(eps) == len(delta))
if (ord == np.inf):
delta.data.uniform_((- 1), 1)
delta.data = batch_multiply(eps, delta.data)
elif (ord == 2):
delta.data.uniform_(clip_min, clip_ma... |
def create_agent(sess, environment, summary_writer=None):
if (not FLAGS.debug_mode):
summary_writer = None
if (FLAGS.agent_name == 'dqn'):
return dqn_agent.DQNAgent(sess, num_actions=environment.action_space.n, summary_writer=summary_writer)
elif (FLAGS.agent_name == 'rainbow'):
retu... |
def test_connector__step_blocked(connector: Connector, state: State, path0: int, path1: int, path2: int, targ0: int, targ1: int, targ2: int, posi0: int, posi1: int, posi2: int) -> None:
step_fn = jax.jit(connector.step)
actions = jnp.array([[constants.LEFT, constants.LEFT, constants.RIGHT], [constants.DOWN, con... |
class CorpusDataset(Dataset):
def __init__(self, corpus: List[str], tokenizer: PreTrainedTokenizer, max_seq_length: int):
self.corpus = corpus
self.tokenizer = tokenizer
self.max_token_len = (max_seq_length - 2)
logging.getLogger('transformers.tokenization_utils_base').setLevel(loggi... |
class MergeLayer(Module):
def __init__(self, dense: bool=False):
self.dense = dense
def forward(self, x):
return (torch.cat([x, x.orig], dim=1) if self.dense else (x + x.orig)) |
def applyGrad(losses, AIM, optim, tape):
var_AutoEencoder = (AIM.encoder.variables + AIM.decoder.variables)
var_E = AIM.encoder.variables
var_G = AIM.decoder.variables
var_dz = AIM.dis_z.variables
var_dimg = AIM.dis_img.variables
var_age = AIM.age_classifier.variables
variables = [var_AutoEe... |
class AutoModelForImageSegmentation(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_IMAGE_SEGMENTATION_MAPPING |
class nlvr_dataset(Dataset):
def __init__(self, ann_file, transform, image_root):
self.ann = []
for f in ann_file:
self.ann += json.load(open(f, 'r'))
self.transform = transform
self.image_root = image_root
self.max_words = 30
def __len__(self):
return... |
def fast_rcnn_losses(cls_score, bbox_pred, label_int32, bbox_targets, bbox_inside_weights, bbox_outside_weights):
device_id = cls_score.get_device()
rois_label = Variable(torch.from_numpy(label_int32.astype('int64'))).cuda(device_id)
loss_cls = F.cross_entropy(cls_score, rois_label)
bbox_targets = Varia... |
def test_unet_valid():
batch_size = 1
in_channels = 1
out_channels = 2
input_spatial_dim = 572
expected_spatial_dim = 388
unet = UNet(in_channels=in_channels, out_channels=out_channels, n_blocks=5, start_filters=32, activation=ActivationFunction.RELU, normalization=NormalizationLayer.BATCH, conv... |
def parse_args():
parser = argparse.ArgumentParser(description='Convert benchmark model json to script')
parser.add_argument('txt_path', type=str, help='txt path output by benchmark_filter')
parser.add_argument('--run', action='store_true', help='run script directly')
parser.add_argument('--out', type=s... |
.very_slow
def test_run_molecule_pmapped(mocker, tmp_path):
vmc_nchains = (3 * jax.local_device_count())
eval_nchains = (2 * jax.local_device_count())
mocker.patch('os.curdir', tmp_path)
config = _get_config(vmc_nchains, eval_nchains, True)
_run_and_check_output_files(mocker, tmp_path, config) |
def _get_test_ions():
ion_pos = jnp.array([[(- 4.0), 0.0], [0.0, 0.0], [2.0, 1.0]])
ion_charges = jnp.array([1.0, 2.0, 3.0])
return (ion_pos, ion_charges) |
class BatchCollator(object):
def __init__(self, dataset, append_ind=False):
self.dataset = dataset
self.test_mode = self.dataset.test_mode
self.task = self.dataset.task
self.data_names = self.dataset.data_names
self.append_ind = append_ind
def __call__(self, batch):
... |
def train(net, X, lbls, train_idx, optimizer, epoch):
net.train()
st = time.time()
optimizer.zero_grad()
outs = net(X)
(outs, lbls) = (outs[train_idx], lbls[train_idx])
loss = F.cross_entropy(outs, lbls)
loss.backward()
optimizer.step()
print(f'Epoch: {epoch}, Time: {(time.time() - s... |
class QLinear_o(nn.Linear):
def __init__(self, in_features, out_features, bias=True, num_bits=8, num_bits_weight=8, num_bits_grad=None, biprecision=False, measure=False):
super(QLinear_o, self).__init__(in_features, out_features, bias)
self.num_bits = num_bits
self.num_bits_weight = (num_bit... |
def create_dataset(dataset_opt):
mode = dataset_opt['mode']
if (mode == 'LR'):
from data.LR_dataset import LRDataset as D
elif (mode == 'LQGT'):
from data.LQGT_dataset import LQGTDataset as D
else:
raise NotImplementedError('Dataset [{:s}] is not recognized.'.format(mode))
da... |
def add_NNServiceServicer_to_server(servicer, server):
rpc_method_handlers = {'train': grpc.unary_unary_rpc_method_handler(servicer.train, request_deserializer=nn__service__pb2.TrainRequest.FromString, response_serializer=nn__service__pb2.TrainResponse.SerializeToString), 'evaluate': grpc.unary_unary_rpc_method_han... |
class FlaxViTModelTester(unittest.TestCase):
def __init__(self, parent, batch_size=13, image_size=30, patch_size=2, num_channels=3, is_training=True, use_labels=True, hidden_size=32, num_hidden_layers=5, num_attention_heads=4, intermediate_size=37, hidden_act='gelu', hidden_dropout_prob=0.1, attention_probs_dropout... |
class TrainerMemoryTracker():
stages = {'__init__': 'init', 'train': 'train', 'evaluate': 'eval', 'predict': 'test'}
def __init__(self, skip_memory_metrics=False):
self.skip_memory_metrics = skip_memory_metrics
if (not is_psutil_available()):
self.skip_memory_metrics = True
i... |
def truncate_or_pad(sequence, block_size, pad_token_id):
if (len(sequence) > block_size):
return sequence[:block_size]
else:
sequence.extend(([pad_token_id] * (block_size - len(sequence))))
return sequence |
class DistributedArguments():
multinode: bool = field(default=False, metadata={'help': 'Whether to use the mutltinode mode.'})
worker: str = field(default=None, metadata={'help': 'List of node ip addressesg, using comma to split.'})
task_index: int = field(default=0, metadata={'help': 'Worker index, and wor... |
class planarDissipativeForce(planarForce):
def __init__(self, amp, ro=None, vo=None, amp_units=None):
planarForce.__init__(self, amp=amp, ro=ro, vo=vo)
_physical_input
_conversion('force', pop=True)
def Rforce(self, R, phi=0.0, t=0.0, v=None):
return self._Rforce_nodecorator(R, phi=phi, ... |
def conv_layer(inDim, outDim, ks, s, p, norm_layer='none'):
conv = nn.Conv2d(inDim, outDim, kernel_size=ks, stride=s, padding=p)
relu = nn.ReLU(True)
assert (norm_layer in ('batch', 'instance', 'none'))
if (norm_layer == 'none'):
seq = nn.Sequential(*[conv, relu])
else:
if (norm_laye... |
def quaddobl_start_diagonal_cascade(gamma=0, tasks=0):
from phcpy.phcpy2c3 import py2c_create_quaddobl_homotopy
from phcpy.phcpy2c3 import py2c_create_quaddobl_homotopy_with_gamma
from phcpy.phcpy2c3 import py2c_solve_by_quaddobl_homotopy_continuation
from phcpy.phcpy2c3 import py2c_solcon_clear_quaddob... |
def test__init_custom():
cnn = CNN(model_config=CustomModel(model=EfficientNet(), transform=EfficientNet.transform, name=EfficientNet.name))
assert (cnn.model_config.name == EfficientNet.name)
cnn = CNN(model_config=CustomModel(model=ViT(), transform=ViT.transform, name=ViT.name))
assert (cnn.model_conf... |
class DoubleConv(torch.nn.Module):
def __init__(self, in_channels, out_channels, mid_channels=None):
super(DoubleConv, self).__init__()
if (not mid_channels):
mid_channels = out_channels
self.double_conv = torch.nn.Sequential(torch.nn.Conv2d(in_channels, mid_channels, kernel_size... |
def create_plane(location: Tuple[(float, float, float)]=(0.0, 0.0, 0.0), rotation: Tuple[(float, float, float)]=(0.0, 0.0, 0.0), size: float=2.0, name: Optional[str]=None) -> bpy.types.Object:
bpy.ops.mesh.primitive_plane_add(size=size, location=location, rotation=rotation)
current_object = bpy.context.object
... |
class CosineDistance(Distance):
def __init__(self, reference_point: []):
self.reference_point = reference_point
def get_distance(self, list1: [], list2: []):
total = sum(numpy.multiply([(x - r) for (x, r) in zip(list1, self.reference_point)], [(y - r) for (y, r) in zip(list2, self.reference_poin... |
class LanguagePairDataset(FairseqDataset):
def __init__(self, src, src_sizes, src_dict, tgt=None, tgt_sizes=None, tgt_dict=None, left_pad_source=True, left_pad_target=False, max_source_positions=1024, max_target_positions=1024, shuffle=True, input_feeding=True, remove_eos_from_source=False, append_eos_to_target=Fal... |
def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer, n_class, do_lower_case, output_mode, is_multi_choice=True):
print('#examples', len(examples))
label_map = {}
for (i, label) in enumerate(label_list):
label_map[label] = i
if is_multi_choice:
features = [[]]... |
def scalability():
threads = np.array([1, 2, 4, 8, 16, 32], dtype=np.float64)
times = np.empty_like(threads)
for (i, j) in enumerate(threads):
data = read_only_json_in_dir(f'output_parallel/mt{int(j)}')
times[i] = data['time_solve']
(fig, ax) = plt.subplots(figsize=(8, 5))
ax.set_xti... |
def accuracy(output, labels, batch=False):
preds = output.max(1)[1].type_as(labels)
correct = preds.eq(labels).double()
correct = correct.sum()
if (batch == True):
return correct
return (correct / len(labels)) |
class FashionMNIST(DATASET):
_target_: str = 'dataset_loaders.load_fashion_mnist'
name: str = 'FashionMNIST'
IN_CHANNEL: int = 1
N_CLASSES: int = 10
IMG_SIZE: Tuple[int] = field(default_factory=(lambda : (28, 28))) |
def _process_image(directory, split, name):
filename = os.path.join(directory, 'image_2', (name + '.png'))
image_data = tf.gfile.FastGFile(filename, 'r').read()
img = cv2.imread(filename)
shape = np.shape(img)
label_list = []
type_list = []
bbox_x1_list = []
bbox_y1_list = []
bbox_x2... |
class Scorer(object):
def __init__(self, args):
self.data = {'src': self.load_text_file(args.source), 'tgt': self.load_text_file(args.target)}
self.data_type = args.data_type
self.eval_latency_unit = args.eval_latency_unit
self.sacrebleu_tokenizer = args.sacrebleu_tokenizer
s... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--max_epsilon', default=32.0, type=float, help='Maximum size of adversarial perturbation.')
parser.add_argument('--num_iter', default=10, type=int, help='Number of iterations.')
parser.add_argument('--batch_size', default=256, type=int,... |
def get_lr_policy(lr_schedule):
d = {'constant': constant_schedule, 'cosine': cosine_schedule, 'step': step_schedule}
return d[lr_schedule] |
def is_private(estimator):
return isinstance(estimator, (DPExplainableBoostingClassifier, DPExplainableBoostingRegressor)) |
class positive_odd_int_or_none(_ParseType):
_none
def __call__(self, string: str) -> (int | None):
num = int(string)
if ((num <= 0) or (not (num % 2))):
msg = f"'{string}' needs to be a positive odd integer."
raise argparse.ArgumentTypeError(msg)
return num |
def update_neural_insights_workload_accuracy_data(workload_uuid: str, baseline_accuracy: float, optimized_accuracy: float) -> None:
try:
from neural_insights import NeuralInsights
from neural_insights.utils.consts import WORKDIR_LOCATION
neural_insights = NeuralInsights(workdir_location=WORK... |
(name='test_batting_stats_html')
def _test_batting_stats_html(get_data_file_contents: Callable[([str], str)]) -> str:
return get_data_file_contents('batting_leaders.html') |
class ControlClass(ABC):
def reset(self):
pass
def step(self, state: np.ndarray, setpoint: np.ndarray) -> np.ndarray:
pass |
class CariSegmentation(BaseDataset):
NUM_CLASS = 11
def __init__(self, root='dataset/cari/', split='train', mode=None, transform=None, target_transform=None):
super(CariSegmentation, self).__init__(root, split, mode, transform, target_transform, base_size=256, crop_size=256)
_mask_dir = os.path.... |
class MLP(nn.Module):
def __init__(self, num_classes):
super(MLP, self).__init__()
self.fc1 = nn.Linear(768, 100)
self.relu1 = nn.Tanh()
self.fc2 = nn.Linear(100, num_classes)
def forward(self, x):
x = self.fc1(x)
x = self.relu1(x)
x = self.fc2(x)
... |
def _import_class_0(name):
components = name.split('.')
mod = __import__(components[0])
for comp in components[1:]:
mod = getattr(mod, comp)
return mod |
def load_waveforms_from_paths(paths, sample_rate):
progress_bar = tqdm(paths, desc='Loading waveforms...')
return [Waveform(path=p, sample_rate=sample_rate) for p in progress_bar] |
class ASPP(nn.Module):
def __init__(self, C, depth, num_classes, conv=nn.Conv2d, norm=nn.BatchNorm2d, momentum=0.0003, mult=1, phase='train'):
super(ASPP, self).__init__()
self._C = C
self._depth = depth
self._num_classes = num_classes
self.phase = phase
self.global_p... |
class _ROIAlign(Function):
def forward(ctx, input, rois, output_size, spatial_scale, sampling_ratio):
ctx.save_for_backward(rois)
ctx.output_size = _pair(output_size)
ctx.spatial_scale = spatial_scale
ctx.sampling_ratio = sampling_ratio
ctx.input_shape = input.size()
... |
def reduce_model(model_path):
from kito import reduce_keras_model
from keras.models import load_model
m = load_model(model_path)
m_red = reduce_keras_model(m)
m_red.save((model_path[:(- 3)] + '_reduced.h5')) |
class PredictorFactory(object):
def __init__(self, sess, model, towers):
self.sess = sess
self.model = model
self.towers = towers
self.tower_built = False
def get_predictor(self, input_names, output_names, tower):
if (not self.tower_built):
self._build_predict... |
def initialize_exp(params, *args, dump_params=True):
if dump_params:
pickle.dump(params, open(os.path.join(params.dump_path, 'params.pkl'), 'wb'))
params.dump_checkpoints = os.path.join(params.dump_path, 'checkpoints')
if ((not params.rank) and (not os.path.isdir(params.dump_checkpoints))):
... |
class modelClassifier():
def __init__(self):
self.learning_rate = FIXED_PARAMETERS['learning_rate']
self.display_epoch_freq = 1
self.display_step = config.display_step
self.eval_step = config.eval_step
self.save_step = config.eval_step
self.embedding_dim = FIXED_PARAM... |
def _create_dummy_dict_file(dict_file):
characters = list('helowrd')
with open(dict_file, 'w') as fw:
for char in characters:
fw.write((char + '\n')) |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--data_dir', default=None, type=str, required=True, help='The input data dir. Should contain the .tsv files (or other data files) for the task.')
parser.add_argument('--lang_type', default=None, type=str, required=True, help='the language t... |
def _make_batches(x, y, batch_size, test=False):
(sample_x, sample_y) = tf.train.slice_input_producer([x, y], shuffle=True)
sample = [sample_x, sample_y]
(x_batch, y_batch) = tf.train.batch(sample, batch_size)
return (x_batch, y_batch) |
class T2TAttention(nn.Module):
def __init__(self, dim, num_heads=8, in_dim=None, qkv_bias=False, qk_scale=None, attn_drop=0.0, proj_drop=0.0, attn_cfg=None):
super().__init__()
self.num_heads = num_heads
self.in_dim = (in_dim if (in_dim is not None) else dim)
head_dim = (dim // num_h... |
class MMD_DIM(Regulariser):
def __init__(self):
super(MMD_DIM, self).__init__(imq_dim_kernel)
self.samples = True
self.name = 'mmd_dim'
def __call__(self, i1, i2):
return self.f(i1, i2) |
class HourglassBlock(nn.Module):
def __init__(self, block, num_blocks, planes, depth, make_bn):
super(HourglassBlock, self).__init__()
self.block = block
self.layernames = []
self.num_blocks = num_blocks
self.planes = planes
self.outputs = {}
self.make_bn = ma... |
class ParallelRunner():
def __init__(self, args, logger):
self.args = args
self.logger = logger
self.batch_size = self.args.batch_size_run
(self.parent_conns, self.worker_conns) = zip(*[Pipe() for _ in range(self.batch_size)])
env_fn = env_REGISTRY[self.args.env]
self... |
def make_latest_self_attn_gnn():
return latest_self_attention_gnn(kq_dim=FLAGS.attn_kq_dim, v_dim=FLAGS.attn_v_dim, concat_heads_output_dim=FLAGS.attn_concat_heads_output_dim, make_mlp_fn=partial(make_mlp_model, FLAGS.gnn_latent_dim, (FLAGS.node_embedding_dim / 2), FLAGS.gnn_num_layers, tf.nn.relu, FLAGS.gnn_l2_reg... |
class CARAFENaiveFunction(Function):
def symbolic(g, features, masks, kernel_size, group_size, scale_factor):
return g.op('mmcv::MMCVCARAFENaive', features, masks, kernel_size_i=kernel_size, group_size_i=group_size, scale_factor_f=scale_factor)
def forward(ctx, features, masks, kernel_size, group_size, ... |
def check_number(model_file, tot_num):
cur_num = 0
max_ngram_order = 0
with open(model_file) as model:
lines = model.readlines()
for line in lines[1:]:
if ('=' not in line):
return ((cur_num == tot_num), max_ngram_order)
cur_num += int(line.split('=')[... |
class VideoMAEForVideoClassification(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def sp_split_paragraph(text, document_store):
documents = []
for (c_index, data) in enumerate(text):
data.replace('#', ' ')
data = re.sub('\\s+', ' ', data)
new_doc = SDocument(content=data, meta={'source': c_index})
documents.append(new_doc)
document_store.write_documents(do... |
def ReadFileSL(x_axis, tthread, batchInterval, NUM_ITEMS, deposit_ratio, key_skewness, overlap_ratio, abort_ratio, isCyclic, complexity):
(w, h) = (3, len(x_axis))
y = [[] for _ in range(w)]
for isCyclic in ['true', 'false']:
inputEvents = (tthread * batchInterval)
op_gs_path = getPathSL('OP... |
def main():
args = parse_args()
assert (not args.provide_description)
if args.limit:
print('WARNING: --limit SHOULD ONLY BE USED FOR TESTING. REAL METRICS SHOULD NOT BE COMPUTED USING LIMIT.')
print(f'Selected Tasks: {args.tasks}')
description_dict = {}
if args.description_dict_path:
... |
def _Pool_initialize_worker(augseq, seed_start):
if (seed_start is None):
process_name = multiprocessing.current_process().name
if ((sys.version_info[0] == 3) and (sys.version_info[1] >= 7)):
seed_offset = time.time_ns()
else:
seed_offset = (int((time.time() * (10 ** ... |
class UnitTestSpace(unittest.TestCase):
def setUp(self):
p.reset_shapeid_counter()
self.s = p.Space()
(self.b1, self.b2) = (p.Body(1, 3), p.Body(10, 100))
self.s.add(self.b1, self.b2)
self.b1.position = (10, 0)
self.b2.position = (20, 0)
(self.s1, self.s2) = (... |
def create_runner(base_dir, create_agent_fn, random_seed, agent_name, game_name, num_iterations):
assert (base_dir is not None)
if (FLAGS.schedule == 'continuous_train_and_eval'):
return run_experiment.Runner(base_dir, create_agent_fn, random_seed, agent_name, game_name, num_iterations)
elif (FLAGS.... |
def quicksave(true_images, colors, masks, schedule, file_name, quicksave_type):
if (np.max(schedule) == 2):
schedule = (schedule // 2)
recons = (colors * masks).sum(1)
true_images = torch.cat([true_images, torch.zeros_like(true_images[:1].to(true_images.device))], dim=0)
tmp = np.where((np.cumsu... |
class NormConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0):
super().__init__()
self.beta = nn.Parameter(torch.zeros([1, out_channels, 1, 1], dtype=torch.float32))
self.gamma = nn.Parameter(torch.ones([1, out_channels, 1, 1], dtype=torch.float... |
def cifar_model_resnet(conv_layer, linear_layer, init_type, N=5, factor=1, **kwargs):
def block(in_filters, out_filters, k, downsample):
if (not downsample):
k_first = 3
skip_stride = 1
k_skip = 1
else:
k_first = 4
skip_stride = 2
... |
class FilterVariablesTest(tf.test.TestCase):
def _create_variables(self):
return [tf.Variable(1.0, name='FeatureExtractor/InceptionV3/weights'), tf.Variable(1.0, name='FeatureExtractor/InceptionV3/biases'), tf.Variable(1.0, name='StackProposalGenerator/weights'), tf.Variable(1.0, name='StackProposalGenerato... |
def instrument(name, func, out_dir):
name_for_path = name.replace('.', '_')
def wrapper(*args, **kwargs):
global is_instrumenting
if is_instrumenting:
return func(*args, **kwargs)
out_api_dir = os.path.join(out_dir, name_for_path)
os.makedirs(out_api_dir, exist_ok=Tru... |
def resnet50(**kwargs):
model = ResNet(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs)
return model |
def reduce_dict(input_dict, average=True):
world_size = get_world_size()
if (world_size < 2):
return input_dict
with torch.no_grad():
names = []
values = []
for k in sorted(input_dict.keys()):
names.append(k)
values.append(input_dict[k])
values... |
def load_training(root_path, dir, batch_size, kwargs):
transform = transforms.Compose([transforms.Resize([256, 256]), transforms.RandomCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor()])
data = datasets.ImageFolder(root=os.path.join(root_path, dir), transform=transform)
train_loader = torc... |
def classification_cross_entropy_softmax(y_pred, y_data):
loss = ((- y_data) * tf.log(tf.clip_by_value(y_pred, 1e-09, 1.0)))
return tf.reduce_mean(tf.reduce_sum(loss, 1)) |
def getTruthlist(lbs, f2list):
total = 0
res = []
assert (len(lbs) == len(f2list))
for i in range(len(lbs)):
if (lbs[i] == f2list[i]):
res.append(1)
total += 1
else:
res.append(0)
print('Accuracy:', (total / len(f2list)))
return res |
_model
def vovnet57a(pretrained=False, **kwargs):
return _create_vovnet('vovnet57a', pretrained=pretrained, **kwargs) |
def debug():
import json
with open('data/didemo/train_data.json') as fp:
data = json.load(fp)
for (k, v) in data.items():
print(v.keys())
exit(0) |
class SGD(Optimizer):
def __init__(self, params, lr=required, momentum=0, dampening=0, weight_decay=0, nesterov=False, use_gc=False, gc_conv_only=False):
if ((lr is not required) and (lr < 0.0)):
raise ValueError('Invalid learning rate: {}'.format(lr))
if (momentum < 0.0):
ra... |
def Merge_Label(inputFile):
merging_dict = {}
merging_dict['Library_Function'] = 'Function'
merging_dict['Function_Name'] = 'Function'
merging_dict['Class_Name'] = 'Class'
merging_dict['Library_Class'] = 'Class'
merging_dict['Library_Variable'] = 'Variable'
merging_dict['Variable_Name'] = 'V... |
def pcmworker(pcmqueue):
global enable
global audio_format
p = pyaudio.PyAudio()
stream = p.open(format=audio_format, channels=hl2ss.Parameters_MICROPHONE.CHANNELS, rate=hl2ss.Parameters_MICROPHONE.SAMPLE_RATE, output=True)
stream.start_stream()
while enable:
stream.write(pcmqueue.get())... |
class Mask():
def __init__(self, landmarks, face, channels=4):
self.landmarks = landmarks
self.face = face
self.channels = channels
mask = self.build_mask()
self.mask = self.merge_mask(mask)
def build_mask(self):
raise NotImplementedError
def merge_mask(self, ... |
class KerasBasePruner(BasePruner):
def __init__(self, config, modules):
super().__init__(config, modules)
for key in self.modules.keys():
module = self.modules[key]
self.masks[key] = np.ones(module.get_weights()[0].shape)
self._init()
def mask_weights(self):
... |
class LexicalMap(object):
def __init__(self):
pass
def get(concept, vocab=None):
cp_seq = []
for conc in concept:
cp_seq.append(conc)
if (vocab is None):
return cp_seq
new_tokens = set((cp for cp in cp_seq if (vocab.token2idx(cp) == vocab.unk_idx))... |
class Bottleneck(_Bottleneck):
def __init__(self, inplanes, planes, groups=1, base_width=4, **kwargs):
super(Bottleneck, self).__init__(inplanes, planes, **kwargs)
if (groups == 1):
width = self.planes
else:
width = (math.floor((self.planes * (base_width / 64))) * gro... |
class GaussPlusNoisePNGenerator(nn.Module):
def __init__(self, device, alpha=1.0):
super(GaussPlusNoisePNGenerator, self).__init__()
self.device = device
self.alpha = torch.Tensor([alpha]).to(self.device)
def forward(self, emb):
z_i = (torch.randn(emb.size(), device=emb.device) *... |
class EMA():
def __init__(self, beta):
super().__init__()
self.beta = beta
def update_average(self, old, new):
if (old is None):
return new
return ((old * self.beta) + ((1 - self.beta) * new)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.