code stringlengths 101 5.91M |
|---|
def create_animation(file_path: str, sim_context: SimContext, figsize: Optional[Union[(list, tuple)]]=None, dt: float=30, dpi: int=120, plot_limits: Union[(str, Sequence[Sequence[float]], PlayerName)]='auto') -> None:
logger.info('Creating animation...')
sim_viz: SimRenderer = SimRenderer(sim_context, figsize=f... |
_module()
class GFL(SingleStageDetector):
def __init__(self, backbone: ConfigType, neck: ConfigType, bbox_head: ConfigType, train_cfg: OptConfigType=None, test_cfg: OptConfigType=None, data_preprocessor: OptConfigType=None, init_cfg: OptMultiConfig=None) -> None:
super().__init__(backbone=backbone, neck=nec... |
class RandomVerticalFlip(object):
def __init__(self, prob=0.5):
self.prob = prob
def __call__(self, image, target=None, rois=None):
if (random.random() < self.prob):
image = F.vflip(image)
if (target is not None):
target = target.transpose(1)
i... |
def lightgbm_eval_metric_user_defined(preds, dtrain):
target = dtrain.get_label()
weight = dtrain.get_weight()
metric = UserDefinedEvalMetric()
return ('user_defined_metric', metric(target, preds, sample_weight=weight), False) |
class ArdisDataset(torch.utils.data.Dataset):
def __init__(self, transform=None, train=True):
if train:
X = np.loadtxt('../data/ARDIS_DATASET_IV/ARDIS_train_2828.csv', dtype='float')
Y = np.loadtxt('../data/ARDIS_DATASET_IV/ARDIS_train_labels.csv', dtype='float')
else:
... |
def get_confusion_matrix(prediction: np.ndarray, reference: np.ndarray, roi_mask: np.ndarray) -> Tuple[(int, int, int, int)]:
assert (prediction.shape == reference.shape), "'prediction' and 'reference' must have the same shape"
tp = int(((roi_mask * (prediction != 0)) * (reference != 0)).sum())
fp = int(((r... |
class MetaLoader(object):
def __init__(self, loaders, accum_steps=1, distributed=False):
assert isinstance(loaders, dict)
self.name2loader = {}
self.name2iter = {}
self.sampling_pools = []
for (n, l) in loaders.items():
if isinstance(l, tuple):
(l,... |
def track(opt):
result_root = (opt.output_root if (opt.output_root != '') else '.')
mkdir_if_missing(result_root)
cfg_dict = parse_model_cfg(opt.cfg)
opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])]
timer = Timer()
accs = []
n_frame = 0
logger.info('Starting trackin... |
class nnUNetTrainerV2_ResencUNet_DA3_BN(nnUNetTrainerV2_ResencUNet_DA3):
def initialize_network(self):
if self.threeD:
cfg = get_default_network_config(3, None, norm_type='bn')
else:
cfg = get_default_network_config(1, None, norm_type='bn')
stage_plans = self.plans['p... |
class Link(xmlr.Object):
def __init__(self, name=None, visual=None, inertial=None, collision=None, origin=None):
self.name = name
self.visual = visual
self.inertial = inertial
self.collision = collision
self.origin = origin |
def gumbel_softmax(logits, temperature, hard=False):
y = gumbel_softmax_sample(logits, temperature)
if hard:
y_hard = tf.cast(tf.equal(y, tf.reduce_max(y, 1, keep_dims=True)), y.dtype)
y = (tf.stop_gradient((y_hard - y)) + y)
return y |
def get_detection_dataset_dicts(dataset_names, filter_empty=True, min_keypoints=0, proposal_files=None):
assert len(dataset_names)
dataset_dicts = [DatasetCatalog.get(dataset_name) for dataset_name in dataset_names]
for (dataset_name, dicts) in zip(dataset_names, dataset_dicts):
assert len(dicts), "... |
def compute_conv2d_ds(in_h, in_w, in_ch, out_ch, k_w, k_h):
pw = compute_conv2d_pw(in_h, in_w, in_ch, out_ch)
dw = compute_conv2d_dw(in_h, in_w, in_ch, k_w, k_h)
return (pw + dw) |
def printm():
process = psutil.Process(os.getpid())
print(('Gen RAM Free: ' + humanize.naturalsize(psutil.virtual_memory().available)), (' | Proc size: ' + humanize.naturalsize(process.memory_info().rss)))
print('GPU RAM Free: {0:.0f}MB | Used: {1:.0f}MB | Util {2:3.0f}% | Total {3:.0f}MB'.format(gpu.memory... |
def is_method_overridden(method, base_class, derived_class):
assert isinstance(base_class, type), "base_class doesn't accept instance, Please pass class instead."
if (not isinstance(derived_class, type)):
derived_class = derived_class.__class__
base_method = getattr(base_class, method)
derived_m... |
class WarmupMultiStepLR(torch.optim.lr_scheduler._LRScheduler):
def __init__(self, optimizer: torch.optim.Optimizer, milestones: List[int], gamma: float=0.1, warmup_factor: float=0., warmup_epochs: int=5, warmup_method: str='linear', last_epoch: int=(- 1)):
if (not (list(milestones) == sorted(milestones))):... |
class CostarWorld(AbstractWorld):
def __init__(self, reward=NullReward(), namespace='/costar', observe=None, robot_config=None, lfd=None, tf_listener=None, use_default_pose=False, *args, **kwargs):
super(CostarWorld, self).__init__(reward, *args, **kwargs)
self.trajectories = {}
self.objs = ... |
def extract_program(result: str, last_only=True):
if last_only:
return extract_program_simple(result, last_only=True)
program = ''
temp_lines = []
start = False
output_start = False
first_snippet = True
error_in_output = False
for line in result.split('\n'):
if line.start... |
def create_parameter(self, attr, shape, dtype, is_bias=False, default_initializer=None):
mp_state = mixed_precision_global_state()
is_half = ((isinstance(dtype, str) and (dtype == 'float16')) or (isinstance(dtype, core.VarDesc.VarType) and (dtype == core.VarDesc.VarType.FP16)))
if (is_half and (mp_state is ... |
def custom_name_func(func, param_num, param):
param_based_name = parameterized.to_safe_name('_'.join((str(x) for x in param.args)))
return f'{func.__name__}_{param_based_name}' |
class DifferentiableSGD():
def __init__(self, module, lr=0.001):
self.module = module
self.lr = lr
def step(self):
memo = set()
def update(module):
for child in module.children():
if (child not in memo):
memo.add(child)
... |
(scope='module')
def synaptic_hidden_reset_zero_instance():
return snn.Synaptic(alpha=0.5, beta=0.5, init_hidden=True, reset_mechanism='zero') |
def get_runtimes(configs):
runtime_list = []
for (model_name, model_config) in configs[YAMLKeyword.models].items():
subgraphs = model_config[YAMLKeyword.subgraphs]
default_rt = (model_config[YAMLKeyword.runtime] if (YAMLKeyword.runtime in model_config) else RuntimeType.cpu)
for (graph_na... |
def test_D(g1):
assert (g1.D_v[(0, 0)].item() == 2)
assert (g1.D_v[(1, 1)].item() == 1)
assert (g1.D_v_neg_1[(1, 1)].item() == 1)
assert (pytest.approx(g1.D_v_neg_1[(3, 3)].item()) == 0)
assert (g1.D_v_neg_1_2[(1, 1)].item() == 1)
assert (pytest.approx(g1.D_v_neg_1_2[(3, 3)].item()) == 0)
g1... |
class MergerConfig(object):
TYPE_NONE = 0
TYPE_MASKED = 1
TYPE_FACE_AVATAR = 2
TYPE_IMAGE = 3
TYPE_IMAGE_WITH_LANDMARKS = 4
def __init__(self, type=0, sharpen_mode=0, blursharpen_amount=0, **kwargs):
self.type = type
self.sharpen_dict = {0: 'None', 1: 'box', 2: 'gaussian'}
... |
class RunningMeter(object):
def __init__(self, name, val=None, smooth=0.99):
self._name = name
self._sm = smooth
self._val = val
def __call__(self, value):
self._val = (value if (self._val is None) else ((value * (1 - self._sm)) + (self._val * self._sm)))
def __str__(self):
... |
def get_runner_status(target_runners, token):
offline_runners = []
cmd = f'curl -H "Accept: application/vnd.github+json" -H "Authorization: Bearer {token}"
output = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE)
o = output.stdout.decode('utf-8')
status = json.loads(o)
runners = status[... |
class _NonLocalBlockND(nn.Module):
def __init__(self, in_channels, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
super(_NonLocalBlockND, self).__init__()
assert (dimension in [1, 2, 3])
self.dimension = dimension
self.sub_sample = sub_sample
self.in_chann... |
def compute_rouge_L(pred, refs, beta=1.2):
prec = []
rec = []
for ref in refs:
lcs = my_lcs(pred, ref)
prec.append(((lcs / float(len(pred))) if (len(pred) != 0) else 0.0))
rec.append(((lcs / float(len(ref))) if (len(ref) != 0) else 0.0))
prec_max = max(prec)
rec_max = max(rec... |
def test_guided_anchor():
from mmdet.models import build_head
if torch.cuda.is_available():
device = 'cuda'
else:
device = 'cpu'
bbox_head = dict(type='GARetinaHead', num_classes=8, in_channels=4, stacked_convs=1, feat_channels=4, approx_anchor_generator=dict(type='AnchorGenerator', octa... |
def tf_required(func):
(func)
def wrapper(*args, **kwargs):
if is_tf_available():
return func(*args, **kwargs)
else:
raise ImportError(f'Method `{func.__name__}` requires TF.')
return wrapper |
def batch_norm(layer, b=lasagne.init.Constant(0.0), g=lasagne.init.Constant(1.0), **kwargs):
nonlinearity = getattr(layer, 'nonlinearity', None)
if (nonlinearity is not None):
layer.nonlinearity = lasagne.nonlinearities.identity
else:
nonlinearity = lasagne.nonlinearities.identity
if has... |
class BinaryNode(Node):
arity = 2
op = None
def __init__(self, left, right):
super().__init__()
self.left = left
self.right = right
def __str__(self):
return f'({self.left} {self.op} {self.right})'
def to_str(self, namer, sort=False):
left_name = self.left.to_... |
def test_modify_order_quantity_up():
(book, agent, orders) = setup_book_with_orders(bids=[(100, [40, 10]), (200, [10, 30, 20, 10])], asks=[(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
modified_order = deepcopy(orders[0])
modified_order.quantity = 70
book.modify_order(orders[0], modified_order)
... |
_module()
class APCHead(BaseDecodeHead):
def __init__(self, pool_scales=(1, 2, 3, 6), fusion=True, **kwargs):
super(APCHead, self).__init__(**kwargs)
assert isinstance(pool_scales, (list, tuple))
self.pool_scales = pool_scales
self.fusion = fusion
acm_modules = []
for... |
class DummyDataset(Dataset):
def __init__(self, length):
self.length = length
self.shapes = np.random.random((length, 2))
def __len__(self):
return self.length
def __getitem__(self, idx):
return self.shapes[idx]
def get_data_info(self, idx):
return dict(width=self... |
def main(argv):
start_time = time.time()
print('TF Version:', tf.__version__)
with open((FLAGS.input + 'train.pkl'), 'rb') as ftrain:
(train_cascade, train_global, train_label) = pickle.load(ftrain)
with open((FLAGS.input + 'val.pkl'), 'rb') as fval:
(val_cascade, val_global, val_label) ... |
class GraphSage(nn.Module):
'\n\tVanilla GraphSAGE Model\n\tCode partially from
def __init__(self, num_classes, enc):
super(GraphSage, self).__init__()
self.enc = enc
self.xent = nn.CrossEntropyLoss()
self.weight = nn.Parameter(torch.FloatTensor(num_classes, enc.embed_dim))
... |
class StringLiteralAnnotationExample():
foo: int
required_enum: 'BasicEnum' = field()
opt: 'Optional[bool]' = None
baz: 'str' = field(default='toto', metadata={'help': 'help message'})
foo_str: 'List[str]' = list_field(default=['Hallo', 'Bonjour', 'Hello']) |
def test_one_hot():
from lasagne.utils import one_hot
a = np.random.randint(0, 10, 20)
b = np.zeros((a.size, (a.max() + 1)))
b[(np.arange(a.size), a)] = 1
result = one_hot(a).eval()
assert (result == b).all() |
class DenseReward(RewardFn):
def __call__(self, state: State, action: chex.Array, next_state: State, is_valid: bool, is_done: bool) -> float:
del next_state, is_done
(_, item_id) = action
chosen_item_volume = item_volume(tree_slice(state.items, item_id))
container_volume = state.cont... |
def main(argv=None):
parser = argparse.ArgumentParser()
parser.add_argument('-e', '--n-episodes', type=int, default=200)
args = parser.parse_args(argv)
checkpoint_path = (pathlib.Path('pretrained') / 'invariant_official.pkl')
assert checkpoint_path.exists()
with checkpoint_path.open('rb') as f:
... |
def MyDataLoader(root, name, batch_size, num_workers=1, distributed=False, rank=0, world_size=None):
print('----Loading dataset----')
TRAIN_TRANSFORM_IMG = torchvision.transforms.Compose([torchvision.transforms.RandomHorizontalFlip(), torchvision.transforms.RandomVerticalFlip(), torchvision.transforms.RandomRot... |
def get_detection_dataset_dicts(dataset_names, filter_empty=True, min_keypoints=0, proposal_files=None):
assert len(dataset_names)
dataset_dicts = [DatasetCatalog.get(dataset_name) for dataset_name in dataset_names]
for (dataset_name, dicts) in zip(dataset_names, dataset_dicts):
assert len(dicts), "... |
def train_roberta_head(data_dir, arch, num_classes=2, extra_flags=None):
train_parser = options.get_training_parser()
train_args = options.parse_args_and_arch(train_parser, (['--task', 'sentence_prediction', data_dir, '--arch', arch, '--encoder-layers', '2', '--num-classes', str(num_classes), '--optimizer', 'ad... |
def get_pytorch_sut(model, preprocessed_data_dir, performance_count, folds=1, checkpoint_name='model_final_checkpoint'):
return _3DUNET_PyTorch_SUT(model, preprocessed_data_dir, performance_count, folds, checkpoint_name) |
class ResNet(nn.Module):
def __init__(self, block, num_blocks, num_classes=10, device='cpu'):
super(ResNet, self).__init__()
self.in_planes = 64
self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.layer1 = self._mak... |
_torch
_vision
class MobileNetV1ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
image_processing_class = (MobileNetV1ImageProcessor if is_vision_available() else None)
def setUp(self):
self.image_processor_tester = MobileNetV1ImageProcessingTester(self)
def image_processor_di... |
def create_1d_conv_core_model(input_shape, model_name='base_model', use_standard_max_pooling=False):
inputs = tf.keras.Input(shape=input_shape, name='input')
x = inputs
x = tf.keras.layers.Conv1D(32, 24, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(l=0.0001))(x)
x = tf.keras.layers.Dro... |
class DiTPipeline(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch'])
def from_config(cls, *args, **kwargs):
requires_backends(cls, ['torch'])
def from_pretrained(cls, *args, **kwargs):
requires_backends(cls, ['tor... |
def tidy_sequential(model):
for (k, m) in list(model.named_children()):
if isinstance(m, nn.Sequential):
if (m.__len__() == 1):
model._modules[k] = m.__getitem__(0)
tidy_sequential(m) |
def process_win_streak(data: pd.DataFrame) -> pd.DataFrame:
if (data['Streak'].count() > 0):
data['Streak2'] = data['Streak'].str.len()
data.loc[((data['Streak'].str[0] == '-'), 'Streak2')] = (- data['Streak2'])
data['Streak'] = data['Streak2']
data = data.drop(columns='Streak2')
... |
class TestJumanjiSpecsToDmEnvSpecs():
def test_array(self) -> None:
jumanji_spec = specs.Array((1, 2), jnp.int32)
dm_env_spec = dm_env.specs.Array((1, 2), jnp.int32)
converted_spec: dm_env.specs.Array = specs.jumanji_specs_to_dm_env_specs(jumanji_spec)
assert (type(converted_spec) ==... |
class HashEval():
def __init__(self, test: Dict, queries: Dict, distance_function: Callable, verbose: bool=True, threshold: int=5, search_method: str=('brute_force_cython' if (not (sys.platform == 'win32')) else 'bktree'), num_dist_workers: int=cpu_count()) -> None:
self.test = test
self.queries = q... |
class NodeApplyModule(nn.Module):
def __init__(self, in_feats, out_feats, activation):
super(NodeApplyModule, self).__init__()
self.linear = nn.Linear(in_feats, out_feats)
self.activation = activation
def forward(self, node):
h = self.linear(node.data['h'])
h = self.activ... |
def plan_and_preprocess(task_string, processes_lowres=8, processes_fullres=3, no_preprocessing=False):
from nnunet.experiment_planning.experiment_planner_baseline_2DUNet import ExperimentPlanner2D
from nnunet.experiment_planning.experiment_planner_baseline_3DUNet import ExperimentPlanner
preprocessing_outpu... |
class RRCache(Cache):
def __init__(self, maxsize, choice=random.choice, getsizeof=None):
Cache.__init__(self, maxsize, getsizeof)
self.__choice = choice
def choice(self):
return self.__choice
def popitem(self):
try:
key = self.__choice(list(self))
except I... |
def convert_conllu_to_json(conllu_sents):
return [convert_col_sent_to_json(sent) for sent in conllu_sents] |
_materialize('core')
class Where(TernaryOpBase):
in_dtypes = [(DType.bool, i, i) for i in DTYPE_GEN_NON_BOOL]
out_dtypes = [(i,) for i in DTYPE_GEN_NON_BOOL]
def __init__(self):
super().__init__()
self.inp_ranks = [rank_all(), rank_all(), rank_all()]
self.same_inp_dtypes = True
d... |
_module()
class BFP(BaseModule):
def __init__(self, in_channels, num_levels, refine_level=2, refine_type=None, conv_cfg=None, norm_cfg=None, init_cfg=dict(type='Xavier', layer='Conv2d', distribution='uniform')):
super(BFP, self).__init__(init_cfg)
assert (refine_type in [None, 'conv', 'non_local'])
... |
class Preprocess_LC():
def __init__(self, data, mjd, error):
self.N = len(mjd)
self.m = np.mean(error)
self.mjd = mjd
self.data = data
self.error = error
def Preprocess(self):
mjd_out = []
data_out = []
error_out = []
for i in xrange(len(se... |
def print_library_summary(configs):
library_name = configs[YAMLKeyword.library_name]
title = 'Library'
header = ['key', 'value']
data = list()
data.append(['MACE Model Path', ('%s/%s/%s' % (BUILD_OUTPUT_DIR, library_name, MODEL_OUTPUT_DIR_NAME))])
if (configs[YAMLKeyword.model_graph_format] == M... |
class StyleGANRunner(BaseGANRunner):
def __init__(self, config, logger):
super().__init__(config, logger)
self.lod = getattr(self, 'lod', None)
def build_models(self):
super().build_models()
self.g_smooth_img = self.config.modules['generator'].get('g_smooth_img', 10000)
s... |
class ConvBnAct(nn.Module):
def __init__(self, in_chs, out_chs, kernel_size, stride=1, dilation=1, pad_type='', skip=False, act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d, drop_path_rate=0.0):
super(ConvBnAct, self).__init__()
self.has_residual = (skip and (stride == 1) and (in_chs == out_chs))
... |
class ImageCoder(object):
def __init__(self):
self._sess = tf.Session()
self._png_data = tf.placeholder(dtype=tf.string)
image = tf.image.decode_png(self._png_data, channels=3)
self._png_to_jpeg = tf.image.encode_jpeg(image, format='rgb', quality=100)
self._decode_jpeg_data =... |
def main():
mode = (argv[2] if (len(argv) > 2) else 'direct')
if (mode == 'direct'):
words = read_words(argv[1])
find_translations(words)
elif (mode == 'collect'):
table = read_table(argv[1])
find_translations_to_table(table) |
class PlayerActor(Actor):
def __init__(self, terminalGraphics, state, name='P'):
super(PlayerActor, self).__init__(state, name)
self.impatience = 0
self._tg = terminalGraphics
def chooseAction(self, world):
idx = (self._tg.getChar() - 49)
self._tg.stdscr.addstr((self._tg.... |
def _add_to_tfrecord(filename, tfrecord_writer, offset=0):
with tf.gfile.Open(filename, 'r') as f:
data = cPickle.load(f)
images = data['data']
num_images = images.shape[0]
images = images.reshape((num_images, 3, 32, 32))
labels = data['labels']
with tf.Graph().as_default():
imag... |
('AuctionMatch')
def _auction_match_shape(op):
shape1 = op.inputs[0].get_shape().with_rank(3)
shape2 = op.inputs[1].get_shape().with_rank(3)
return [tf.TensorShape([shape1.dims[0], shape1.dims[1]]), tf.TensorShape([shape2.dims[0], shape2.dims[1]])] |
def _convert_sumo_coord_to_car_coord(x_in_sumo_coord, y_in_sumo_coord, a_in_sumo_coord, car_length):
a_in_car_coord = ((- a_in_sumo_coord) + 90.0)
x_in_car_coord = (x_in_sumo_coord - ((math.cos(((a_in_car_coord / 180.0) * math.pi)) * car_length) / 2))
y_in_car_coord = (y_in_sumo_coord - ((math.sin(((a_in_ca... |
class SequentialAppendList(nn.Sequential):
def __init__(self, *args):
super(SequentialAppendList, self).__init__(*args)
def forward(self, x: torch.Tensor, concat_list: List[torch.Tensor]) -> torch.Tensor:
for (i, module) in enumerate(self):
if (i == 0):
concat_list.ap... |
def build_vocab(data_path, data_name, caption_file, threshold):
counter = Counter()
for path in caption_file[data_name]:
full_path = os.path.join(os.path.join(data_path, data_name), path)
captions = from_txt(full_path)
for (i, caption) in enumerate(captions):
tokens = nltk.to... |
def collate_tokens(values, pad_idx, eos_idx=None, left_pad=False, move_eos_to_beginning=False):
size = max((v.size(0) for v in values))
res = values[0].new(len(values), size).fill_(pad_idx)
def copy_tensor(src, dst):
assert (dst.numel() == src.numel())
if move_eos_to_beginning:
d... |
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--lr', type=float, default=0.0002)
parser.add_argument('--beta1', type=float, default=0.5)
parser.add_argument('--beta2', type=float, default=0.999)
parser.add_argument('--lambda1', type=int, default=100)
parser.add_argume... |
_model_architecture('lra', 'flash_lra_imdb')
def flash_lra_imdb(args):
args.apply_bert_init = getattr(args, 'apply_bert_init', False)
args.layer_type = getattr(args, 'layer_type', 'flash')
args.encoder_hidden_dim = getattr(args, 'encoder_hidden_dim', 256)
args.z_dim = getattr(args, 'z_dim', 64)
args... |
class MaxCounter():
__slots__ = ('_c', '_max_element')
def __init__(self, it=None):
self._c = collections.Counter(it)
if (it is None):
self._max_element = (- float('inf'))
else:
self._max_element = max(self._c)
def copy(self):
new = object.__new__(MaxC... |
def convert(src, dst, depth):
if (depth not in arch_settings):
raise ValueError('Only support ResNet-50 and ResNet-101 currently')
block_nums = arch_settings[depth]
caffe_model = load(src, encoding='latin1')
blobs = (caffe_model['blobs'] if ('blobs' in caffe_model) else caffe_model)
state_di... |
def normalityTestF(resid, k_error, t_error):
k = kurtosis(resid)
t = skew(resid)
if ((k > ((- 1) * k_error)) and (k < k_error) and (t > ((- 1) * t_error)) and (t < t_error)):
return True
return False |
def load_single_genre_data(directory, filename_template, genre, filename_test_template=None):
lambda_concepts = (lambda d: {'premise': d[0], 'hypothesis': d[1], 'label': d[2], 'premise_concepts': d[3], 'hypothesis_concepts': d[4]})
lambda_no_concepts = (lambda d: {'premise': d[0], 'hypothesis': d[1], 'label': d... |
class Tensorboard(EventStreamer, EventSink):
folder_name = 'tensorboard'
def __init__(self, dataroot):
from tensorboardX import SummaryWriter
self.writer = SummaryWriter(os.path.join(dataroot, self.folder_name))
self.absolute_iteration_counters = {}
def _add_row(self, key, data, dtyp... |
def get_class_weights(dataset: WideDeepDataset) -> Tuple[(np.ndarray, int, int)]:
weights = (1 / np.unique(dataset.Y, return_counts=True)[1])
minor_class_count = min(np.unique(dataset.Y, return_counts=True)[1])
num_classes = len(np.unique(dataset.Y))
return (weights, minor_class_count, num_classes) |
class Weather(object):
def __init__(self, weather):
self.weather = weather
self._sun = Sun(weather.sun_azimuth_angle, weather.sun_altitude_angle)
self._storm = Storm(weather.precipitation)
def tick(self, delta_seconds):
self._sun.tick(delta_seconds)
self._storm.tick(delta... |
class AutoModelForDepthEstimation(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_DEPTH_ESTIMATION_MAPPING |
_PREDICTOR_REGISTRY.register()
class DensePoseChartPredictor(nn.Module):
def __init__(self, cfg: CfgNode, input_channels: int):
super().__init__()
dim_in = input_channels
n_segm_chan = cfg.MODEL.ROI_DENSEPOSE_HEAD.NUM_COARSE_SEGM_CHANNELS
dim_out_patches = (cfg.MODEL.ROI_DENSEPOSE_HE... |
def modelA():
model = Sequential()
model.add(Conv2D(64, (5, 5), padding='valid', input_shape=(gv.IMAGE_ROWS, gv.IMAGE_COLS, gv.NUM_CHANNELS)))
model.add(Activation('relu'))
model.add(Conv2D(64, (5, 5)))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Flatten())
model.add... |
class LeNetBase(nn.Module):
def __init__(self):
super(LeNetBase, self).__init__()
self.conv_params = nn.Sequential(nn.Conv2d(1, 20, kernel_size=5), nn.MaxPool2d(2), nn.ReLU(), nn.Conv2d(20, 50, kernel_size=5), nn.Dropout2d(p=0.5), nn.MaxPool2d(2), nn.ReLU())
self.in_features = ((50 * 4) * 4)... |
class GaussianCNNBaseline(Baseline):
def __init__(self, env_spec, subsample_factor=1.0, regressor_args=None, name='GaussianCNNBaseline'):
if ((not isinstance(env_spec.observation_space, akro.Box)) or (not (len(env_spec.observation_space.shape) in (2, 3)))):
raise ValueError('{} can only process ... |
def get_scene_layout(carla_map):
def _lateral_shift(transform, shift):
transform.rotation.yaw += 90
return (transform.location + (shift * transform.get_forward_vector()))
topology = [x[0] for x in carla_map.get_topology()]
topology = sorted(topology, key=(lambda w: w.transform.location.z))
... |
def get_world_size():
if (torch.distributed.is_available() and torch.distributed.is_initialized()):
world_size = torch.distributed.get_world_size()
else:
world_size = 1
return world_size |
class InceptionResNetV2(nn.Module):
def __init__(self, num_classes=1001):
super(InceptionResNetV2, self).__init__()
self.input_space = None
self.input_size = (299, 299, 3)
self.mean = None
self.std = None
self.conv2d_1a = BasicConv2d(3, 32, kernel_size=3, stride=2)
... |
def mnasnet0_5(pretrained: bool=False, progress: bool=True, num_classes: int=1000, layer_config=None) -> MNASNet:
print('Converting MNASNet 0.5 to {} mode'.format(MODE_STRING))
return create_torchvision_biomodel(models.mnasnet0_5, MODE, layer_config, pretrained, progress, num_classes) |
def main():
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
if ((len(sys.argv) == 2) and sys.argv[1].endswith('.json')):
(model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
else:
(model_args, data_args,... |
class Adamax(OptimMethod):
def __init__(self, learningrate=0.002, beta1=0.9, beta2=0.999, epsilon=1e-38, bigdl_type='float'):
super(Adamax, self).__init__(None, bigdl_type, learningrate, beta1, beta2, epsilon) |
class BaseBenchmark():
def __init__(self, max_iter: int, log_interval: int, num_warmup: int, logger: Optional[MMLogger]=None):
self.max_iter = max_iter
self.log_interval = log_interval
self.num_warmup = num_warmup
self.logger = logger
def run(self, repeat_num: int=1) -> dict:
... |
def main():
opt = parse_args()
init_logger(opt.log_file)
logger.info('Extracting features...')
src_nfeats = inputters.get_num_features(opt.data_type, opt.train_dir, 'src')
qa_nfeats = inputters.get_num_features(opt.data_type, opt.train_dir, 'qa')
tgt_nfeats = inputters.get_num_features(opt.data_... |
def process_isolate(func: Callable, project: sf.Project, **kwargs) -> bool:
ctx = multiprocessing.get_context('spawn')
passed = ctx.Manager().Value(bool, True)
verbosity = sf.getLoggingLevel()
process = ctx.Process(target=func, args=(project, verbosity, passed), kwargs=kwargs)
process.start()
pr... |
def gptneox_sample_softmax(ctx: gptneox_context_p, candidates):
return _lib.gptneox_sample_softmax(ctx, candidates) |
def get_teacher_predictions(model_path: str, examples: List[str], class_names: List[str], hypothesis_template: str, batch_size: int, temperature: float, multi_label: bool, use_fast_tokenizer: bool, no_cuda: bool, fp16: bool):
model = AutoModelForSequenceClassification.from_pretrained(model_path)
model_config = ... |
def load_ResNet18Model():
model = ResNet(Bottleneck, [2, 2, 2, 2])
copy_parameter_from_resnet(model, torchvision.models.resnet18(pretrained=True).state_dict())
return model |
def get_view_select_parser():
parser = argparse.ArgumentParser()
parser.add_argument('--seed', default=0, type=int)
parser.add_argument('--phase', default='train')
parser.add_argument('--dataset', default='nyu')
parser.add_argument('--num_epoch', default=20, type=int)
parser.add_argument('--batc... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.