code stringlengths 101 5.91M |
|---|
def flat_waveform():
wave = np.ones((24000,))
return sound.Waveform(signal=wave, sample_rate=24000) |
def main(args):
models = [x[0] for x in args.model]
tokenizer = AutoTokenizer.from_pretrained(models[0], model_max_length=sys.maxsize, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.pad_token_id = tokenizer.eos_token_id
dataset = load_dataset('emozilla/quality', split=ar... |
class ObservableState(object):
def __init__(self, px, py, vx, vy, radius):
self.px = px
self.py = py
self.vx = vx
self.vy = vy
self.radius = radius
self.position = (self.px, self.py)
self.velocity = (self.vx, self.vy)
def __add__(self, other):
retu... |
(InducingImages, Conv2d, object)
def _Kfu_conv2d(feat: InducingImages, kern: Conv2d, Xnew: tf.Tensor, full_spatial: bool=False):
if (not isinstance(kern.kernel, kernels.Stationary)):
return _Kfu_conv2d_fallback(feat, kern, Xnew, full_spatial)
patch_shape = list(kern.patch_shape)
channels_in = Xnew.s... |
def s2_equatorial_grid(max_beta=0, n_alpha=32, n_beta=1):
beta = np.linspace(start=((np.pi / 2) - max_beta), stop=((np.pi / 2) + max_beta), num=n_beta, endpoint=True)
alpha = np.linspace(start=0, stop=(2 * np.pi), num=n_alpha, endpoint=False)
(B, A) = np.meshgrid(beta, alpha, indexing='ij')
B = B.flatte... |
def write_body(fd, shape, out_strings):
bytes_cnt = 0
bytes_cnt = write_uints(fd, (shape[0], shape[1], len(out_strings)))
for s in out_strings:
bytes_cnt += write_uints(fd, (len(s[0]),))
bytes_cnt += write_bytes(fd, s[0])
return bytes_cnt |
def _construct_dataset(num_episodes, num_groups=10):
episodes = []
for i in range(num_episodes):
episode = Episode(episode_id=str(i), scene_id=('scene_id_' + str((i % num_groups))), start_position=[0, 0, 0], start_rotation=[0, 0, 0, 1])
episodes.append(episode)
dataset = Dataset()
datase... |
class TrainingModule():
ALL_METRICS = ['Bleu_1', 'Bleu_2', 'Bleu_3', 'Bleu_4', 'METEOR', 'ROUGE_L', 'CIDEr', 'SPICE']
SCST_SAMPLE = ['beam_search', 'random']
SCST_BASELINE = ['greedy', 'sample']
config: Config
data: KarpathyDataset
collate_fn: Dict[(str, Callable)]
model: nn.Module
optim... |
_module()
class ShuffleNetV1(BaseBackbone):
def __init__(self, groups=3, widen_factor=1.0, out_indices=(2,), frozen_stages=(- 1), conv_cfg=None, norm_cfg=dict(type='BN'), act_cfg=dict(type='ReLU'), norm_eval=False, with_cp=False):
norm_cfg = copy.deepcopy(norm_cfg)
act_cfg = copy.deepcopy(act_cfg)
... |
class ResNet(nn.Module):
def __init__(self, conv_layer, linear_layer, block, num_blocks, num_classes=10):
super(ResNet, self).__init__()
self.in_planes = 64
self.conv_layer = conv_layer
self.conv1 = conv_layer(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
self.bn1 = ... |
def print_step_info(world, vehicle):
snapshot = world.get_snapshot()
print(('%d %06.03f %+8.03f %+8.03f %+8.03f %+8.03f %+8.03f %+8.03f %+8.03f %+8.03f %+8.03f' % (snapshot.frame, snapshot.timestamp.elapsed_seconds, vehicle.get_acceleration().x, vehicle.get_acceleration().y, vehicle.get_acceleration().z, vehicl... |
def calculate(file_list, gt_file_list, args, MCD):
for (i, cvt_path) in enumerate(file_list):
corresponding_list = list(filter((lambda gt_path: (get_basename(gt_path) in cvt_path)), gt_file_list))
assert (len(corresponding_list) == 1)
gt_path = corresponding_list[0]
gt_basename = get... |
class RandomSizedEarser(object):
def __init__(self, sl=0.02, sh=0.2, asratio=0.3, p=0.5):
self.sl = sl
self.sh = sh
self.asratio = asratio
self.p = p
def __call__(self, img):
p1 = random.uniform((- 1), 1.0)
W = img.size[0]
H = img.size[1]
area = (H... |
def get_lights_colors_from_cmds(cmds: VehicleCommands, t: Timestamp) -> LightsColors:
try:
lights_colors = lights_colors_from_lights_cmd(cmds.lights, cmds.acc, t)
except AttributeError:
lights_colors = None
return lights_colors |
class SqueezeBertForSequenceClassification():
def __init__(self, *args, **kwargs):
requires_pytorch(self)
def from_pretrained(self, *args, **kwargs):
requires_pytorch(self) |
def mnist_test_data(num_max=None):
x_test = np.load((common.user_home_dir() + '/EvalDNN-data/MNIST/tensorflow/x_test.npy'))
y_test = np.load((common.user_home_dir() + '/EvalDNN-data/MNIST/tensorflow/y_test.npy'))
if (num_max is not None):
x_test = x_test[:num_max]
y_test = y_test[:num_max]
... |
def is_feasible(solution: Solution) -> bool:
return (number_of_violated_constraints(solution) == 0) |
def test_move_fallback():
m2 = m.get_moveissue2(2)
assert (m2.value == 2)
m1 = m.get_moveissue1(1)
assert (m1.value == 1) |
def add_wire(x, y, name):
global num_wires
wire_idx = num_wires
num_wires = (num_wires + 1)
wname = (x, y, name)
wire_names[wname] = wire_idx
wire_names_r[wire_idx] = wname
wire_segments[wire_idx] = dict()
if (('TILE_WIRE_' + wname[2].upper().replace('/', '_')) in gfx_wire_ids):
... |
class Spaces(object):
def __getattr__(self, k):
warnings.warn('DEPRECATION WARNING: to improve load times, gym no longer automatically loads gym.spaces. Please run "import gym.spaces" to load gym.spaces on your own. This warning will turn into an error in a future version of gym.')
import gym.spaces... |
def main():
parser = HfArgumentParser((Args, GenerationConfig))
(args, generation_config) = cast(tuple[(Args, GenerationConfig)], parser.parse_args_into_dataclasses())
(raw_problem_fn, map_problem_fn) = ((get_humaneval_raw_problems, map_humaneval_problem) if (args.dataset == 'humaneval') else (get_mbpp_raw_... |
def get_model_sparsity(model):
prunables = 0
nnzs = 0
for m in model.modules():
if _is_prunable_module(m):
prunables += m.weight.data.numel()
nnzs += m.weight.data.nonzero().size(0)
return (nnzs / prunables) |
class ScalarTypeNode(ExprNode):
def __init__(self, parse_info=None, raw_text=None):
super().__init__(IRNodeType.ScalarType, parse_info=parse_info, raw_text=raw_text)
self.is_int = False |
def get_dataset_info(dir_path, name):
file_list = get_dir_info(os.path.join(dir_path, name))
return dict(name=name, path=((('/' + dir_path) + '/') + name), sessions=list(filter((lambda f: f['is_session']), file_list))) |
class AverageMeter(object):
def __init__(self, momentum=0.999):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
self.long_count = 0
self.momentum = momentum
self.moving_avg = 0
def reset(self):
self.val = 0
self.avg = 0
self.s... |
class DEEPLABHead(nn.Module):
def __init__(self, in_channels, out_channels, lateral=True, norm_layer=None, up_kwargs=None):
super(DEEPLABHead, self).__init__()
self.lateral = lateral
self.conv5 = nn.Sequential(nn.Conv2d(in_channels, 512, 3, padding=1, bias=False), norm_layer(512), nn.ReLU(in... |
def densenet201(num_classes=1000, pretrained='imagenet'):
model = models.densenet201(pretrained=False)
if (pretrained is not None):
settings = pretrained_settings['densenet201'][pretrained]
model = load_pretrained(model, num_classes, settings)
model = modify_densenets(model)
return model |
class TopDownGlobalChaFuse(HybridBlock):
def __init__(self, channels=64):
super(TopDownGlobalChaFuse, self).__init__()
self.channels = channels
with self.name_scope():
self.global_att = nn.HybridSequential(prefix='global_att')
self.global_att.add(nn.GlobalAvgPool2D())... |
def print_hashes(instances, only_one=(- 1)):
print(((('=' * 80) + '\n') + 'Printing hashes '))
kl = []
for i in instances:
if is_running_instance(i):
if (only_one >= 0):
c1 = ((' "cd node_cpp_code/_Hashes;find . -name \'*\' -type f -exec grep \'^' + str(only_one)) + ':\' ... |
class Baseline(nn.Module):
def __init__(self, input_dim, latent_dim, device, obsrv_std=0.01, use_binary_classif=False, classif_per_tp=False, use_poisson_proc=False, linear_classifier=False, n_labels=1, train_classif_w_reconstr=False):
super(Baseline, self).__init__()
self.input_dim = input_dim
... |
def quantize_with_min_and_max(data, device, non_zero, in_min, in_max):
np_data = np.array(data).astype(float)
(scale, zero, out_min, out_max) = adjust_range(in_min, in_max, device, non_zero=non_zero)
output = np.clip(np.round((zero + (np_data / scale))).astype(np.int32), 0, 255)
quantized_data = Quantiz... |
(config_path='../eztorch/configs/run/supervised/resnet3d50', config_name='ucf101')
def main(config: DictConfig) -> None:
rundir = Path(to_absolute_path(config.dir.run))
rundir.mkdir(parents=True, exist_ok=True)
os.chdir(rundir)
rank_zero_info(f'Run directory: {rundir}')
hydradir = (rundir / 'config/... |
def get_parse_args():
parser = argparse.ArgumentParser(description='PyTorch training script')
parser.add_argument('--dataset', default='h36m', type=str, metavar='NAME', help='target dataset')
parser.add_argument('--keypoints', default='gt', type=str, metavar='NAME', help='2D detections to use, gt/hr/cpn... |
def lora_merge_unmerge_state_dict(engine, state_dict, peft_config, merge=True):
for worker in engine.workers:
lora_reassign_weights(worker.model, state_dict, r=peft_config['r'], lora_alpha=peft_config['lora_alpha'], fan_in_fan_out=peft_config['fan_in_fan_out'], merge=merge) |
def recenter(mesh: Type[trimesh.base.Trimesh], center_fn: Callable[([Type[trimesh.base.Trimesh]], Type[np.ndarray])], in_place: bool=True) -> Type[trimesh.base.Trimesh]:
center = center_fn(mesh)
mesh_ = (mesh if in_place else copy.deepcopy(mesh))
mesh_.vertices = (mesh.vertices - center)
mesh = mesh_
... |
def drn_c_26(BatchNorm, pretrained=True):
model = DRN(BasicBlock, [1, 1, 2, 2, 2, 2, 1, 1], arch='C', BatchNorm=BatchNorm)
if pretrained:
pretrained = model_zoo.load_url(model_urls['drn-c-26'])
del pretrained['fc.weight']
del pretrained['fc.bias']
model.load_state_dict(pretrained... |
class RandomSampler(object):
def __init__(self, data_source, state=None, seed=None):
self.data_source = data_source
self.rng = np.random.RandomSatate(seed)
def __iter__(self):
return iter(torch.randperm(len(self.data_source)).long())
def __len__(self):
return len(self.data_so... |
def render_git_describe_long(pieces):
if pieces['closest-tag']:
rendered = pieces['closest-tag']
rendered += ('-%d-g%s' % (pieces['distance'], pieces['short']))
else:
rendered = pieces['short']
if pieces['dirty']:
rendered += '-dirty'
return rendered |
def collate_fn(examples):
pixel_values = torch.stack([example['pixel_values'] for example in examples])
return {'pixel_values': pixel_values} |
def is_hf_dataset(dataset):
if (not is_datasets_available()):
return False
from datasets import Dataset
return isinstance(dataset, Dataset) |
_optimizer('lamb')
class FairseqLAMB(FairseqOptimizer):
def __init__(self, args, params):
super().__init__(args)
try:
from apex.optimizers import FusedLAMB
self._optimizer = FusedLAMB(params, **self.optimizer_config)
except ImportError:
raise ImportError('... |
class Partition():
def __init__(self, partitionId, chipCounter, sizeInterleaved, parentLayer, isInhibitory=False, resetMode='hard'):
assert isinstance(parentLayer, Layer)
self.id = partitionId
self.sizeInterleaved = sizeInterleaved
self._layer = parentLayer
self._inputAxonGro... |
def test_batting_stats_bref() -> None:
result = league_batting_stats.batting_stats_bref(2019)
assert (result is not None)
assert (not result.empty)
assert (len(result.columns) == 28)
assert (len(result) == 991) |
def evaluate_caption_json(res_file, ann_file):
assert ann_file.endswith('.json'), '`ann_file` should end with `.json`, saw `{}` instead.'.format(ann_file)
assert res_file.endswith('.json'), '`res_file` should end with `.json`, saw `{}` instead.'.format(res_file)
default_ann_dir = os.path.join(COCO_DIR, 'ann... |
def stable_resize_token_embeddings(model: transformers.PreTrainedModel, target_size: int):
num_new_tokens = (target_size - model.get_input_embeddings().weight.size(0))
model.resize_token_embeddings(target_size)
if (num_new_tokens > 0):
input_embeddings = model.get_input_embeddings().weight.data
... |
def get_linear_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps, last_epoch=(- 1)):
def lr_lambda(current_step):
if (current_step < num_warmup_steps):
return (float(current_step) / float(max(1, num_warmup_steps)))
return max(0.0, (float((num_training_steps - current_s... |
def main():
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments, AdapterTrainingArguments))
if ((len(sys.argv) == 2) and sys.argv[1].endswith('.json')):
(model_args, data_args, training_args, adapter_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
... |
def _imagenet(split: str) -> Dataset:
if (not (IMAGENET_LOC_ENV in os.environ)):
raise RuntimeError('environment variable for ImageNet directory not set')
dir = os.environ[IMAGENET_LOC_ENV]
if (split == 'train'):
subdir = os.path.join(dir, 'train')
transform = transforms.Compose([tra... |
def get_model(args, config):
model = None
if args.model_name_or_path:
model = AutoModelForCausalLM.from_pretrained(args.model_name_or_path, from_tf=bool(('.ckpt' in args.model_name_or_path)), config=config, trust_remote_code=args.trust_remote_code, ignore_mismatched_sizes=args.ignore_mismatched_sizes)
... |
class LaVisualizer(object):
def __init__(self):
self.node = []
self.ps = []
self.tags = {}
self.index = 0
self.queue = []
def visualize(self, node):
self.reset()
self.node = node
self.ps = Digraph(name='pet-shop', node_attr={'shape': 'plaintext', '... |
def parse_args():
parser = argparse.ArgumentParser(description='Convert benchmark model list to script')
parser.add_argument('config', help='test config file path')
parser.add_argument('--port', type=int, default=29666, help='dist port')
parser.add_argument('--run', action='store_true', help='run script... |
def motar(df: DataFrame, num_matches: int, num_misses: int, num_switches: int, num_false_positives: int, num_objects: int, alpha: float=1.0) -> float:
recall = (num_matches / num_objects)
nominator = (((num_misses + num_switches) + num_false_positives) - ((1 - recall) * num_objects))
denominator = (recall *... |
def cmpm_loss_compute(text_embeddings, image_embeddings, labels):
batch_size = image_embeddings.get_shape().as_list()[0]
mylabels = tf.cast(tf.reshape(labels, [batch_size, 1]), tf.float32)
labelD = pairwise_distance(mylabels, mylabels)
label_mask = tf.cast(tf.less(labelD, 0.5), tf.float32)
image_emb... |
class Linear(torch.nn.Linear):
def forward(self, x):
if (x.numel() == 0):
out_shape = [x.shape[0], self.out_features]
empty = NewEmptyTensorOp.apply(x, out_shape)
if self.training:
dummy = (sum((x.view((- 1))[0] for x in self.parameters())) * 0.0)
... |
def register_coco_instances_with_attributes(name, metadata, json_file, image_root):
DatasetCatalog.register(name, (lambda : load_coco_with_attributes_json(json_file, image_root, name)))
MetadataCatalog.get(name).set(json_file=json_file, image_root=image_root, evaluator_type='coco', **metadata) |
def read_examples(input_file):
examples = []
unique_id = 0
with open(input_file, 'r') as reader:
while True:
line = tokenization.convert_to_unicode(reader.readline())
if (not line):
break
line = line.strip()
text_a = None
te... |
def setup_default_logging(default_level=logging.INFO, log_path=''):
console_handler = logging.StreamHandler()
console_handler.setFormatter(FormatterNoInfo())
logging.root.addHandler(console_handler)
logging.root.setLevel(default_level)
if log_path:
file_handler = logging.handlers.RotatingFil... |
def save_checkpoint(P, step, best, model_state, optim_state, logdir, is_best=False):
if is_best:
prefix = 'best'
else:
prefix = 'last'
last_model = os.path.join(logdir, f'{prefix}.model')
last_optim = os.path.join(logdir, f'{prefix}.optim')
last_config = os.path.join(logdir, f'{prefi... |
class ConcatDataset(Dataset):
def cumsum(sequence):
(r, s) = ([], 0)
for e in sequence:
l = len(e)
r.append((l + s))
s += l
return r
def __init__(self, datasets):
super(ConcatDataset, self).__init__()
assert (len(datasets) > 0), 'datase... |
class TFFunnelForSequenceClassification(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
.register('tile_as')
class TileAsProp(mx.operator.CustomOpProp):
def __init__(self):
super(TileAsProp, self).__init__(need_top_grad=False)
def list_arguments(self):
return ['data_content', 'data_shape']
def list_outputs(self):
return ['data_tiled']
def infer_shape(self, in_shape)... |
def test_set_literal():
run_cell('x, y, z = 1, 2, 3')
run_cell('s = {x + 1, y + 7}')
run_cell('z = 42')
run_cell('logging.info(s)')
assert_not_detected()
run_cell('x = 17')
run_cell('logging.info(s)')
assert_detected() |
def densenet201(pretrained=False, **kwargs):
model = DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 48, 32), **kwargs)
return model |
def predict_type_facenet(image_perturbed, cleancrop):
device = torch.device(('cuda:0' if torch.cuda.is_available() else 'cpu'))
def collate_fn(x):
return x
loader = DataLoader(image_perturbed, batch_size=42, shuffle=False, collate_fn=collate_fn)
mtcnn = MTCNN(image_size=160, margin=0, min_face_s... |
class Quantization_Conf(Conf):
def __init__(self, cfg=None):
if isinstance(cfg, str):
self.usr_cfg = DotDict(self._read_cfg(cfg))
elif isinstance(cfg, DotDict):
self.usr_cfg = DotDict(schema.validate(self._convert_cfg(cfg, copy.deepcopy(quantization_default_schema.validate(di... |
def predict_classes(model, img, xs, watermark, target_class, sl):
imgs_perturbed = add_watermark_to_image(img, xs, watermark, sl)
imgs_perturbed = imgs_perturbed.convert('RGB')
predictions = label_model(model, imgs_perturbed).cpu().detach().numpy()
predictions = predictions[0][target_class]
return p... |
def iplot(figure_or_data, show_link=True, link_text='Export to plot.ly', validate=True, image=None, filename='plot_image', image_width=800, image_height=600):
if (not __PLOTLY_OFFLINE_INITIALIZED):
raise PlotlyError('\n'.join(['Plotly Offline mode has not been initialized in this notebook. Run: ', '', 'impo... |
class Image():
def __init__(self, image_id, features_idx):
self.image_id = image_id
self.features_idx = features_idx
self.features = np.array([])
def load(self, images_features, mem=True):
if len(self.features):
return self.features
else:
features ... |
class MAML():
def __init__(self, inner_algo, env, policy, meta_optimizer, meta_batch_size=40, inner_lr=0.1, outer_lr=0.001, num_grad_updates=1, meta_evaluator=None, evaluate_every_n_epochs=1):
self.sampler_cls = OnPolicyVectorizedSampler
self.max_path_length = inner_algo.max_path_length
self... |
def kitti_labels_to_yolo(dataroot):
from cv2 import imread
print('Converting KITTI labels to YOLO label format.')
imgs_dir = join(dataroot, 'raw', 'training', 'image_2')
labels_dir = join(dataroot, 'raw', 'training', 'label_2')
save_at_dir = join(dataroot, 'raw', 'yolo_style_labels')
make_dirs(s... |
def get_downsample_factor(model_config):
try:
neck_cfg = model_config['neck']
except:
model_config = model_config['first_stage_cfg']
neck_cfg = model_config['neck']
downsample_factor = np.prod(neck_cfg.get('ds_layer_strides', [1]))
if (len(neck_cfg.get('us_layer_strides', [])) > ... |
def get_model(name, pretrained, num_channels, num_classes):
function = getattr(models, name)
model = function(pretrained=pretrained)
if ('resnet' in name):
if (num_channels == 1):
model = ResNet18Grayscale(models.resnet.BasicBlock, [2, 2, 2, 2], num_classes)
else:
mod... |
class UnicodeRegex(object):
def __init__(self) -> None:
punctuation = self.property_chars('P')
self.nondigit_punct_re = re.compile((('([^\\d])([' + punctuation) + '])'))
self.punct_nondigit_re = re.compile((('([' + punctuation) + '])([^\\d])'))
self.symbol_re = re.compile((('([' + se... |
class ResFeaturePyramidBlock(nn.Module):
def __init__(self, in_channels: int, out_channels: int, feature_channels: int, convolution: Type=nn.Conv2d, normalization: Type=nn.InstanceNorm2d, activation: Type=nn.PReLU, dropout: float=0.0) -> None:
super(ResFeaturePyramidBlock, self).__init__()
self.drop... |
def make_weights(N, weights):
assert ((len(weights) % 2) == 1), f'Expected odd number of weights, got: {weights}'
center = int(((len(weights) - 1) / 2))
tokens = np.zeros((N, N))
for i in range(N):
token = np.zeros(N)
for (j, w) in enumerate(weights):
ind = ((i + j) - center)... |
class ReductionBUnit(nn.Module):
def __init__(self):
super(ReductionBUnit, self).__init__()
in_channels = 1088
self.branches = Concurrent()
self.branches.add_module('branch1', ConvSeqBranch(in_channels=in_channels, out_channels_list=(256, 384), kernel_size_list=(1, 3), strides_list=(... |
class TrainingSampler(Sampler):
def __init__(self, size: int, shuffle: bool=True, seed: Optional[int]=None):
self._size = size
assert (size > 0)
self._shuffle = shuffle
if (seed is None):
seed = comm.shared_random_seed()
self._seed = int(seed)
self._rank =... |
class BuildCommand(build):
def run(self):
script_path = os.path.dirname(os.path.abspath(__file__))
sym_path = os.path.join(script_path, 'interpret', 'root', 'shared', 'libebm')
if os.path.exists(sym_path):
build_libebm()
build_vis_if_needed()
build.run(self) |
def test_standard_anchor_generator():
from mmdet.core.anchor import build_anchor_generator
anchor_generator_cfg = dict(type='AnchorGenerator', scales=[8], ratios=[0.5, 1.0, 2.0], strides=[4, 8])
anchor_generator = build_anchor_generator(anchor_generator_cfg)
assert (anchor_generator is not None) |
def validate_on_data(model: Model, data: Dataset, batch_size: int, use_cuda: bool, max_output_length: int, level: str, eval_metric: Optional[str], n_gpu: int, batch_class: Batch=Batch, compute_loss: bool=False, beam_size: int=1, beam_alpha: int=(- 1), batch_type: str='sentence', postprocess: bool=True, bpe_type: str='s... |
def compute_joint(x_out: Tensor, x_tf_out: Tensor) -> Tensor:
assert simplex(x_out), f'x_out not normalized.'
assert simplex(x_tf_out), f'x_tf_out not normalized.'
(bn, k) = x_out.shape
assert ((x_tf_out.size(0) == bn) and (x_tf_out.size(1) == k))
p_i_j = (x_out.unsqueeze(2) * x_tf_out.unsqueeze(1))... |
def sql_window_api(spark):
print('Start running Window and WindowSpec API')
sc = spark.sparkContext
sqlContext = SQLContext(sc)
df = spark.createDataFrame([('Alice', 2, 50), ('Alice', 3, 50), ('Alice', 2, 60), ('Alice', 3, 60), ('Alice', 2, 70), ('Bob', 3, 50), ('Bob', 3, 60), ('Bob', 4, 50)], ['name', ... |
class ComplicatedInputDataset(torch.utils.data.Dataset):
def __init__(self, size=1000, nested_input=True) -> None:
super().__init__()
self.size = size
X1_1 = torch.rand((self.size // 2), 1)
X1_2 = (torch.rand((self.size // 2), 1) + 1.5)
self.X1 = torch.cat([X1_1, X1_2], dim=0... |
class LineActiveSchedulerND(_SubspacePointActiveSchedulerND):
name = 'Line'
def __init__(self, N_STEPS, D, point, iaxis):
if (D.nd < 2):
raise Exception('ERROR: requires nd >=2')
if (len(point) != (D.nd - 1)):
raise Exception(('ERROR: point incorrect shape %s' % (point.sh... |
def add_dataset_args(parser, train=False, gen=False):
group = parser.add_argument_group('Dataset and data loading')
group.add_argument('--num-workers', default=0, type=int, metavar='N', help='how many subprocesses to use for data loading')
group.add_argument('--skip-invalid-size-inputs-valid-test', action='... |
def _get_triplet_mask(labels):
indices_equal = tf.cast(tf.eye(tf.shape(labels)[0]), tf.bool)
indices_not_equal = tf.logical_not(indices_equal)
i_not_equal_j = tf.expand_dims(indices_not_equal, 2)
i_not_equal_k = tf.expand_dims(indices_not_equal, 1)
j_not_equal_k = tf.expand_dims(indices_not_equal, 0... |
class TestInputFn(tf.test.TestCase):
def _test_with_args(self, **kwargs):
(sources_file, targets_file) = test_utils.create_temp_parallel_data(sources=['Hello World .'], targets=['Goodbye .'])
pipeline = input_pipeline.ParallelTextInputPipeline(params={'source_files': [sources_file.name], 'target_fil... |
def get_last_ckpt_in_dir(dir: str, ckpt_pattern: str='*.ckpt', key_sort: Callable=(lambda x: x.stat().st_mtime)) -> Optional[Path]:
ckpts = get_ckpts_in_dir(dir, ckpt_pattern)
if (ckpts == []):
return None
ckpts.sort(key=key_sort, reverse=False)
return ckpts[(- 1)] |
class RPNLogLossMetric(mx.metric.EvalMetric):
def __init__(self):
super(RPNLogLossMetric, self).__init__('RPNLogLoss')
(self.pred, self.label) = get_rpn_names()
def update(self, labels, preds):
pred = preds[self.pred.index('rpn_cls_prob')]
label = labels[self.label.index('rpn_lab... |
def build_and_train(slot_affinity_code, log_dir, run_ID, config_key):
affinity = affinity_from_code(slot_affinity_code)
config = configs[config_key]
variant = load_variant(log_dir)
config = update_config(config, variant)
sampler = GpuParallelSampler(EnvCls=gym_make, env_kwargs=config['env'], Collect... |
class Pyramids(object):
def __init__(self, levels=1):
assert (levels >= 1)
self.levels = levels
def __call__(self, img) -> list:
img_pyd = [img]
for i in range((self.levels - 1)):
img_pyd.append(Image.fromarray(cv2.pyrDown(np.array(img_pyd[(- 1)]))))
return im... |
def treeFromFile(filename):
with open(filename) as urdf_file:
return treeFromUrdfModel(urdf.URDF.from_xml_string(urdf_file.read())) |
def create_default_local_file():
comment = {'results_path': 'Where to store tracking results', 'network_path': 'Where tracking networks are stored.'}
path = os.path.join(os.path.dirname(__file__), 'local.py')
with open(path, 'w') as f:
settings = EnvSettings()
f.write('from pytracking.evalua... |
class TestTransformerEncoder(unittest.TestCase):
def test_full_attention_forward(self):
d_model = 128
n_heads = 4
transformer = TransformerEncoder([TransformerEncoderLayer(AttentionLayer(ClusteredAttention(clusters=10), d_model, n_heads), d_model, n_heads) for i in range(6)])
x = tra... |
_vision
class CLIPProcessorTest(unittest.TestCase):
def setUp(self):
self.tmpdirname = tempfile.mkdtemp()
vocab = ['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'lo', 'low</w>', 'er</w>', 'lowest</w>', 'newer</w>', 'wider', '<unk>', '<|endoftext|>']
vocab_tokens = dict(zip(vocab, range(l... |
def extract_into_tensor(a, t, x_shape):
(b, *_) = t.shape
out = a.gather((- 1), t)
return out.reshape(b, *((1,) * (len(x_shape) - 1))) |
def mdetr_efficientnetB3_refcocoplus(pretrained=False, return_postprocessor=False):
model = _make_detr('timm_tf_efficientnet_b3_ns')
if pretrained:
checkpoint = torch.hub.load_state_dict_from_url(url=' map_location='cpu', check_hash=True)
model.load_state_dict(checkpoint['model'])
if return_... |
class BertEmbeddings(nn.Module):
def __init__(self, bert_model):
super().__init__()
config = bert_model.config
self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.laye... |
def check_integrity(fpath, md5=None):
if (md5 is None):
return True
if (not os.path.isfile(fpath)):
return False
md5o = hashlib.md5()
with open(fpath, 'rb') as f:
for chunk in iter((lambda : f.read((1024 * 1024))), b''):
md5o.update(chunk)
md5c = md5o.hexdigest()
... |
class SGLD(Optimizer):
def __init__(self, params, lr=0.01, std_dev=0.0, decay=None) -> None:
if (lr < 0.0):
raise ValueError('Invalid learning rate: {}'.format(lr))
defaults = dict(lr=lr, std_dev=std_dev)
super().__init__(params, defaults)
def step(self, closure=None):
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.