code stringlengths 101 5.91M |
|---|
def create_Y(instances=1000, categs=5, seed=0):
rs = np.random.RandomState(seed)
size = (instances, 1)
Y = rs.randint(0, categs, size=size)
return Y |
class SN(object):
def __init__(self, num_svs, num_itrs, num_outputs, transpose=False, eps=1e-12):
self.num_itrs = num_itrs
self.num_svs = num_svs
self.transpose = transpose
self.eps = eps
for i in range(self.num_svs):
self.register_buffer(('u%d' % i), torch.randn(1, num_outputs))
self.register_buffer(('sv%d' % i), torch.ones(1))
def u(self):
return [getattr(self, ('u%d' % i)) for i in range(self.num_svs)]
def sv(self):
return [getattr(self, ('sv%d' % i)) for i in range(self.num_svs)]
def W_(self):
W_mat = self.weight.view(self.weight.size(0), (- 1))
if self.transpose:
W_mat = W_mat.t()
for _ in range(self.num_itrs):
(svs, us, vs) = power_iteration(W_mat, self.u, update=self.training, eps=self.eps)
if self.training:
with torch.no_grad():
for (i, sv) in enumerate(svs):
self.sv[i][:] = sv
return (self.weight / svs[0]) |
_end_docstrings(CUSTOM_DPR_READER_DOCSTRING)
class DPRReaderTokenizerFast(CustomDPRReaderTokenizerMixin, BertTokenizerFast):
vocab_files_names = VOCAB_FILES_NAMES
pretrained_vocab_files_map = READER_PRETRAINED_VOCAB_FILES_MAP
max_model_input_sizes = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
pretrained_init_configuration = READER_PRETRAINED_INIT_CONFIGURATION
model_input_names = ['attention_mask']
slow_tokenizer_class = DPRReaderTokenizer |
def test_kernel_expand():
k = fk.Carls_Mauna_kernel()
k_expanded = grammar.expand_kernels(1, [k])
assert (len(k_expanded) > 1) |
def any(t: TensorType, axis: Optional[AxisAxes]=None, keepdims: bool=False) -> TensorType:
return t.any(axis=axis, keepdims=keepdims) |
_module()
class BoxFormatProcess(BaseTargetProcessFunc):
def __call__(self, raw_conv: List[Dict[(str, Any)]], target: Dict[(str, Any)], preprocessor: Dict[(str, Any)], multimage_mode=False) -> Tuple[(List[Dict[(str, Any)]], Dict[(str, Any)])]:
box_formatter = preprocessor['target']['boxes']
if multimage_mode:
target = typing.cast(list, target)
outer_normalized_boxes = []
for tgt in target:
normalized_boxes = []
if ((tgt is not None) and ('boxes' in tgt)):
for box in tgt['boxes']:
normalized_boxes.append(norm_box_xyxy(box, w=tgt['width'], h=tgt['height']))
outer_normalized_boxes.append(normalized_boxes)
normalized_boxes = outer_normalized_boxes
outer_normalized_points = []
for tgt in target:
normalized_points = []
if ((tgt is not None) and ('boxes' in tgt)):
for box in tgt['boxes']:
normalized_points.append(norm_box_xyxy(box, w=tgt['width'], h=tgt['height']))
outer_normalized_points.append(normalized_points)
normalized_points = outer_normalized_points
else:
normalized_boxes = []
if ((target is not None) and ('boxes' in target)):
for box in target['boxes']:
normalized_boxes.append(norm_box_xyxy(box, w=target['width'], h=target['height']))
normalized_points = []
if ((target is not None) and ('points' in target)):
for point in target['points']:
normalized_points.append(norm_point_xyxy(point, w=target['width'], h=target['height']))
for sentence in raw_conv:
words: str = sentence['value']
boxes_seq: List[List[int]] = sentence.get('boxes_seq', None)
if (boxes_seq is not None):
boxes_seq: List[Boxes] = map_obj(normalized_boxes, boxes_seq)
converted = box_formatter(words, boxes_seq)
words = converted
points_seq: List[List[int]] = sentence.get('points_seq', None)
if (points_seq is not None):
points_seq: List[Boxes] = map_obj(normalized_points, points_seq)
converted = box_formatter.call_on_point(words, points_seq)
words = converted
if ((boxes_seq is not None) or (points_seq is not None)):
sentence['raw_value'] = sentence['value']
sentence['value'] = words
return (raw_conv, target) |
def mm_covisible_tri(h_lrgp, tri_ids_tar, tri_ids_src):
batch_size = h_lrgp.batch_size
tri_ids_tar = tf.reshape(tri_ids_tar, [(- 1)])
ver_ids_tar = tf.gather(h_lrgp.h_fore.mesh_tri, tri_ids_tar)
ver_ids_tar = tf.reshape(ver_ids_tar, [batch_size, (- 1)])
tri_ids_src = tf.reshape(tri_ids_src, [batch_size, (- 1)])
ver_ids_src = tf.gather(h_lrgp.h_fore.mesh_tri, tri_ids_src)
ver_ids_src = tf.reshape(ver_ids_src, [batch_size, (- 1)])
ver_ids_consistency = tf.sets.set_intersection(ver_ids_tar, ver_ids_src, False)
ver_ids_consistency = tf.sparse_tensor_to_dense(ver_ids_consistency, validate_indices=False)
tri_consistency = []
for j in range(batch_size):
tri_ids_consistency_b = tf.gather(h_lrgp.h_fore.mesh_vertex_refer_face_pad, ver_ids_consistency[j])
tri_ids_consistency_b = tf.reshape(tri_ids_consistency_b, [(- 1)])
tri_consistency_b = tf.gather(h_lrgp.h_fore.mesh_tri, tri_ids_consistency_b)
tri_consistency.append(tri_consistency_b)
tri_consistency = tf.stack(tri_consistency, axis=0)
return tri_consistency |
def validate_pytorch_loss(loss):
import types
if isinstance(loss, str):
if (loss in PYTORCH_LOSS_NAMES):
return getattr(torch.nn.modules, loss)()
invalidInputError(False, f'Must provide a valid torch loss name among {PYTORCH_LOSS_NAMES}')
if (isinstance(loss, torch.nn.modules.loss._Loss) or isinstance(loss, types.FunctionType)):
return loss
invalidInputError(False, 'Must provide a valid pytorch loss name or a pytorch loss instanceor a pytorch loss creator function.') |
def run_command(command):
result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, shell=True)
return result.stdout.strip() |
def imputation_performance(ori_x, imputed_x, m, metric_name):
assert (metric_name in ['mae', 'mse', 'rmse'])
(no, seq_len, dim) = ori_x.shape
ori_x = np.reshape(ori_x, [(no * seq_len), dim])
imputed_x = np.reshape(imputed_x, [(no * seq_len), dim])
m = np.reshape(m, [(no * seq_len), dim])
if (metric_name == 'mae'):
performance = mean_absolute_error(ori_x, imputed_x, (1 - m))
elif (metric_name == 'mse'):
performance = mean_squared_error(ori_x, imputed_x, (1 - m))
elif (metric_name == 'rmse'):
performance = np.sqrt(mean_squared_error(ori_x, imputed_x, (1 - m)))
return performance |
def total_yngve_depth(yngve_tree_root):
tot_score = 0
for leaf in yngve_tree_root.leaves:
tot_score += leaf.score
return tot_score |
def append_suffix(prefix, path):
splits = path.split('.')
if (len(splits) > 0):
file_name = ((prefix + '.') + splits[(- 1)])
else:
file_name = prefix
return file_name |
def pyramidnet164_a270_bn_svhn(num_classes=10, **kwargs):
return get_pyramidnet_cifar(num_classes=num_classes, blocks=164, alpha=270, bottleneck=True, model_name='pyramidnet164_a270_bn_svhn', **kwargs) |
def process_browsing_train(browsing_train_path):
print('Processing {}'.format(browsing_train_path))
df = read_from_parquet(browsing_train_path, limit=1000000)
df = df[['session_id_hash', 'event_type', 'product_action', 'server_timestamp_epoch_ms']]
df['product_action'].fillna(value='', inplace=True)
print(df.shape)
print(df.dtypes)
print(df.head(2))
print('\n')
df = df.sort_values(by=['session_id_hash', 'server_timestamp_epoch_ms'])
df = df.reset_index(drop=True)
print(df[['session_id_hash', 'server_timestamp_epoch_ms']].head(10))
print('\n')
return return_df(df) |
def StandardIni(L=4, t=1, U=4, nelec=4, TwoSz=0, J=1, Model='"Fermion Hubbard"'):
Info = {}
Info['L'] = L
Info['model'] = Model
Info['method'] = '"Lanczos"'
Info['lattice'] = '"chain"'
if (Model == '"Fermion Hubbard"'):
Info['t'] = t
Info['U'] = U
Info['nelec'] = nelec
elif (Model == '"Spin"'):
Info['L'] = (2 * L)
Info['J'] = J
elif (Model == '"Kondo"'):
Info['t'] = t
Info['U'] = U
Info['J'] = t
Info['nelec'] = (nelec / 2)
Info['EigenVecIO'] = '"Out"'
Info['2Sz'] = TwoSz
return Info |
def image_to_pixmap(image):
b = BytesIO()
utils.enlarge_image(Image.fromarray(image), scale_factor=2).save(b, format='PNG')
return QtGui.QPixmap.fromImage(QtGui.QImage.fromData(b.getvalue())) |
def test_lookup_symbol_simple():
run_cell('x = y = 42')
run_cell("assert lift(x).readable_name == 'x'")
run_cell("assert lift(y).readable_name == 'y'") |
def vectorize_force(f):
ndim = len(getfullargspec(f).args)
signature = ','.join((['()'] * ndim))
signature += '->(N)'
vec_f = np.vectorize(f, signature=signature)
def new_func(*args):
return np.rollaxis(vec_f(*args), axis=(- 1), start=0)
return new_func |
def count_convtranspose2d(m, x, y):
x = x[0]
cin = m.in_channels
cout = m.out_channels
(kh, kw) = m.kernel_size
out_h = y.size(2)
out_w = y.size(3)
kernel_ops = ((((multiply_adds * kh) * kw) * cin) // m.groups)
bias_ops = (1 if (m.bias is not None) else 0)
ops_per_element = (kernel_ops + bias_ops)
ops_per_element = m.weight.nelement()
output_elements = y.nelement()
total_ops = (output_elements * ops_per_element)
m.total_ops = torch.Tensor([int(total_ops)])
import pdb
pdb.set_trace()
print(m.total_ops) |
class EdgeBlock(nn.Module):
def __init__(self, in_chs, out_chs, kernel_size=3, stride=1, dilation=(1, 1), bottle_ratio=1.0, group_size=None, downsample='avg', linear_out=False, layers: LayerFn=None, drop_block=None, drop_path_rate=0.0):
super(EdgeBlock, self).__init__()
layers = (layers or LayerFn())
mid_chs = make_divisible((out_chs * bottle_ratio))
groups = num_groups(group_size, mid_chs)
if ((in_chs != out_chs) or (stride != 1) or (dilation[0] != dilation[1])):
self.shortcut = create_downsample(downsample, in_chs=in_chs, out_chs=out_chs, stride=stride, dilation=dilation[0], apply_act=False, layers=layers)
else:
self.shortcut = nn.Identity()
self.conv1_kxk = layers.conv_norm_act(in_chs, mid_chs, kernel_size, stride=stride, dilation=dilation[0], groups=groups, drop_block=drop_block)
self.attn = (nn.Identity() if (layers.attn is None) else layers.attn(out_chs))
self.conv2_1x1 = layers.conv_norm_act(mid_chs, out_chs, 1, apply_act=False)
self.drop_path = (DropPath(drop_path_rate) if (drop_path_rate > 0.0) else nn.Identity())
self.act = (nn.Identity() if linear_out else layers.act(inplace=True))
def init_weights(self, zero_init_last_bn=False):
if zero_init_last_bn:
nn.init.zeros_(self.conv2_1x1.bn.weight)
def forward(self, x):
shortcut = self.shortcut(x)
x = self.conv1_kxk(x)
x = self.attn(x)
x = self.conv2_1x1(x)
x = self.drop_path(x)
x = self.act((x + shortcut))
return x |
def validate(val_loader, model, criterion, args):
batch_time = AverageMeter('Time', ':6.3f')
losses = AverageMeter('Loss', ':.4e')
top1 = AverageMeter('', ':6.2f')
top5 = AverageMeter('', ':6.2f')
progress = ProgressMeter(len(val_loader), batch_time, losses, top1, top5, prefix='Test: ')
with torch.no_grad():
for (i, (input, target)) in enumerate(val_loader):
input = input.contiguous(memory_format=torch.channels_last)
if (i >= args.warmup_iter):
start = time.time()
if (args.gpu is not None):
input = input.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
if args.xpu:
input = input.to('xpu')
target = target.to('xpu')
output = model(input)
if (i >= args.warmup_iter):
batch_time.update((time.time() - start))
loss = criterion(output, target)
(acc1, acc5) = accuracy(output, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(acc1[0], input.size(0))
top5.update(acc5[0], input.size(0))
if ((i % args.print_freq) == 0):
progress.print(i)
if ((args.iter > 0) and (i >= ((args.warmup_iter + args.iter) - 1))):
break
print(('Batch size = %d' % args.batch_size))
print('Accuracy: {top1:.5f} {top5:.5f}'.format(top1=(top1.avg / 100), top5=(top5.avg / 100)))
return (top1.avg / 100) |
_start_docstrings('Roberta Model with a multiple choice classification head on top (a linear layer on top of\n the pooled output and a softmax) e.g. for RocStories/SWAG tasks. ', XLM_ROBERTA_START_DOCSTRING)
class TFXLMRobertaForMultipleChoice(TFRobertaForMultipleChoice):
config_class = XLMRobertaConfig |
def jsonify_lists(vals):
if (len(vals) != 0):
if isinstance(vals[0], float):
for (idx, val) in enumerate(vals):
if isnan(val):
vals[idx] = 'nan'
elif (val == np.inf):
vals[idx] = '+inf'
elif (val == (- np.inf)):
vals[idx] = '-inf'
else:
for nested in vals:
jsonify_lists(nested)
return vals |
class TFGPT2ForSequenceClassification():
def __init__(self, *args, **kwargs):
requires_tf(self)
def from_pretrained(self, *args, **kwargs):
requires_tf(self) |
def CHECKDIM(tensor, dim, val):
if (type(tensor) == list):
for t in tensor:
CHECKDIM(t, dim, val)
else:
assert (len(tensor.shape) >= dim), 'expect {} to have {} dim shape {}'.format(tensor.shape, dim, val)
assert (tensor.shape[dim] == val), 'expect {} to have {} dim shape {}'.format(tensor.shape, dim, val) |
def _decode(buffer_, enc_byte):
size = sum((((256 ** ((enc_byte - i) - 1)) * buffer_[i].item()) for i in range(enc_byte)))
bytes_list = bytes(buffer_[enc_byte:(enc_byte + size)].tolist())
shift = (size + enc_byte)
return (bytes_list, shift) |
def main() -> None:
parser = argparse.ArgumentParser(prog=config.PACKAGE_NAME, description='Netloc investigation')
parser.add_argument('--config-path', required=True, help='Configuration file path, e.g. /some/dir/config.yaml')
instance_config_path = Path(parser.parse_args().config_path)
log.debug('Reading instance configuration file %s', instance_config_path)
instance_config = YAML().load(instance_config_path)
instance_config = json.loads(json.dumps(instance_config))
logged_instance_config = instance_config.copy()
del logged_instance_config['feeds']
log.info('Read user configuration file %s having excerpted configuration %s for %s channels %s with %s feeds.', instance_config_path, logged_instance_config, len(instance_config['feeds']), list(instance_config['feeds']), len([feed for channel in instance_config['feeds'].values() for feed in channel]))
config.INSTANCE = instance_config
investigate_etags() |
def extract_poses(vid_file: Path, new_fps: int):
video = cv2.VideoCapture(vid_file.as_posix())
fps = int(video.get(cv2.CAP_PROP_FPS))
print(f'Video FPS: {fps}')
(success, image) = video.read()
frames = []
while success:
frames.append(image)
(success, image) = video.read()
poses = load_holistic(frames, fps=fps, width=frames[0].shape[1], height=frames[0].shape[0], depth=10, progress=True, additional_holistic_config={'min_detection_confidence': 0.2, 'min_tracking_confidence': 0.3})
return poses |
def gpt_palm_completion(messages, temperature, model):
backoff_time = 1
while True:
try:
return palm.chat(messages=messages, temperature=temperature, model=model)
except:
print(f' Sleeping {backoff_time} seconds...')
time.sleep(backoff_time)
backoff_time *= 1.5 |
def beamsearch_hp(datapath, benchmark, backbone, thres, alpha, logpath, candidate_base, candidate_layers, beamsize, maxdepth):
device = torch.device(('cuda:0' if torch.cuda.is_available() else 'cpu'))
model = hpflow.HyperpixelFlow(backbone, '0', benchmark, device)
download.download_dataset(os.path.abspath(datapath), benchmark)
dset = download.load_dataset(benchmark, datapath, thres, device, 'val')
dataloader = DataLoader(dset, batch_size=1, num_workers=0)
membuf_cand = []
for base in candidate_base:
start = time.time()
hyperpixel = parse_layers(base)
score = evaluate.run(datapath, benchmark, backbone, thres, alpha, hyperpixel, logpath, True, model, dataloader)
log_evaluation(base, score, (time.time() - start))
membuf_cand.append((score, base))
membuf_topk = find_topk(membuf_cand, beamsize)
(score_sel, layer_sel) = find_topk(membuf_cand, 1)[0]
log_selected(0, membuf_topk)
for depth in range(1, maxdepth):
membuf_cand = []
for (_, test_layer) in membuf_topk:
for cand_layer in candidate_layers:
if ((cand_layer not in test_layer) and (cand_layer > min(test_layer))):
start = time.time()
test_layers = sorted((test_layer + [cand_layer]))
if (test_layers in list(map((lambda x: x[1]), membuf_cand))):
break
hyperpixel = parse_layers(test_layers)
score = evaluate.run(datapath, benchmark, backbone, thres, alpha, hyperpixel, logpath, True, model, dataloader)
log_evaluation(test_layers, score, (time.time() - start))
membuf_cand.append((score, test_layers))
membuf_topk = find_topk(membuf_cand, beamsize)
(score_tmp, layer_tmp) = find_topk(membuf_cand, 1)[0]
if (score_tmp > score_sel):
layer_sel = layer_tmp
score_sel = score_tmp
log_selected(depth, membuf_topk)
logging.info(('\nBest layers, score: %s %5.3f' % (layer_sel, score_sel)))
return layer_sel |
def main():
from .profile_func import profile_slimmable_models
print(f'profile model GFLOPs (forward complexity) and size (#param)')
model = SlimmableAlexNet(track_running_stats=False, bn_type='bn', share_affine=False)
model.eval()
print(f"model {model.__class__.__name__} on {('training' if model.training else 'eval')} mode")
input_shape = model.input_shape
profile_slimmable_models(model, model.slimmable_ratios)
print(f'''
==footprint==''')
model.switch_slim_mode(1.0)
model.print_footprint()
print(f'''
==footprint==''')
model.switch_slim_mode(0.125)
model.print_footprint()
print(f'''
''')
full_net = model
model = EnsembleGroupSubnet(full_net, [0.125, 0.125, 0.25, 0.5], [0, 1, 1, 1])
model.eval()
print(f"model {model.__class__.__name__} on {('training' if model.training else 'eval')} mode")
profile_slimmable_models(model, model.full_net.slimmable_ratios)
print(f'''
''')
model = EnsembleSubnet(full_net, 0.125)
model.eval()
print(f"model {model.__class__.__name__} on {('training' if model.training else 'eval')} mode")
profile_slimmable_models(model, model.full_net.slimmable_ratios) |
class CIDErEvalCap():
def __init__(self, gts, res, df):
print('tokenization...')
tokenizer = PTBTokenizer('gts')
_gts = tokenizer.tokenize(gts)
print('tokenized refs')
tokenizer = PTBTokenizer('res')
_res = tokenizer.tokenize(res)
print('tokenized cands')
self.gts = _gts
self.res = _res
self.df = df
def evaluate(self):
print('setting up scorers...')
scorers = [(Cider(df=self.df), 'CIDEr'), (CiderD(df=self.df), 'CIDErD')]
metric_scores = {}
for (scorer, method) in scorers:
print(('computing %s score...' % scorer.method()))
(score, scores) = scorer.compute_score(self.gts, self.res)
print(('Mean %s score: %0.3f' % (method, score)))
metric_scores[method] = list(scores)
return metric_scores |
_model
def repvgg_b3g4(pretrained=False, **kwargs):
return _create_byobnet('repvgg_b3g4', pretrained=pretrained, **kwargs) |
def infinite_iter(iterable):
it = iter(iterable)
while True:
try:
ret = next(it)
(yield ret)
except StopIteration:
it = iter(iterable) |
class Glove(vcb.Vocab):
def __init__(self, fname):
super().__init__()
if (fname is not None):
self.read_vectors(fname)
else:
self.dim = 0
def read_vectors(self, fname):
glove = []
print('Loading glove vectors')
with open(fname) as f:
for line in f:
line = line.strip().split()
word = line[0]
vector = [float(v) for v in line[1:]]
self.add(word)
glove.append(vector)
print('Done')
self.dim = len(glove[0])
self.data = torch.tensor(glove, requires_grad=False) |
class GaussianNoise(ZooKerasLayer):
def __init__(self, sigma, input_shape=None, **kwargs):
super(GaussianNoise, self).__init__(None, float(sigma), (list(input_shape) if input_shape else None), **kwargs) |
def simxQuery(clientID, signalName, signalValue, retSignalName, timeOutInMs):
retSignalLength = ct.c_int()
retSignalValue = ct.POINTER(ct.c_ubyte)()
sigV = signalValue
if (sys.version_info[0] == 3):
if (type(signalName) is str):
signalName = signalName.encode('utf-8')
if (type(retSignalName) is str):
retSignalName = retSignalName.encode('utf-8')
if (type(signalValue) is bytearray):
sigV = (ct.c_ubyte * len(signalValue))(*signalValue)
if (type(signalValue) is str):
signalValue = signalValue.encode('utf-8')
sigV = (ct.c_ubyte * len(signalValue))(*signalValue)
else:
if (type(signalValue) is bytearray):
sigV = (ct.c_ubyte * len(signalValue))(*signalValue)
if (type(signalValue) is str):
signalValue = bytearray(signalValue)
sigV = (ct.c_ubyte * len(signalValue))(*signalValue)
sigV = ct.cast(sigV, ct.POINTER(ct.c_ubyte))
ret = c_Query(clientID, signalName, sigV, len(signalValue), retSignalName, ct.byref(retSignalValue), ct.byref(retSignalLength), timeOutInMs)
a = bytearray()
if (ret == 0):
for i in range(retSignalLength.value):
a.append(retSignalValue[i])
if (sys.version_info[0] != 3):
a = str(a)
return (ret, a) |
def sample(a=[], temperature=1.0):
b = np.copy(a)
try:
if (temperature == 1):
return np.argmax(np.random.multinomial(1, a, 1))
if (temperature is None):
return np.argmax(a)
else:
a = (np.log(a) / temperature)
a = (np.exp(a) / np.sum(np.exp(a)))
return np.argmax(np.random.multinomial(1, a, 1))
except:
message = 'For large vocabulary_size, choice a higher temperature to avoid log error. Hint : use ``sample_top``. '
warnings.warn(message, Warning)
return np.argmax(np.random.multinomial(1, b, 1)) |
class Predict(Subcommand):
def add_subparser(self, name: str, parser: argparse._SubParsersAction) -> argparse.ArgumentParser:
description = 'Run the specified model against a JSON-lines input file.'
subparser = parser.add_parser(name, description=description, help='Use a trained model to make predictions.')
subparser.add_argument('--archive-file', required=True, type=str, help='the archived model to make predictions with')
subparser.add_argument('--input-file', type=str, help='path to input file')
subparser.add_argument('--output-file', type=str, help='path to output file')
subparser.add_argument('--weights-file', type=str, help='a path that overrides which weights file to use')
batch_size = subparser.add_mutually_exclusive_group(required=False)
batch_size.add_argument('--batch-size', type=int, default=1, help='The batch size to use for processing')
subparser.add_argument('--silent', action='store_true', help='do not print output to stdout')
cuda_device = subparser.add_mutually_exclusive_group(required=False)
cuda_device.add_argument('--cuda-device', type=int, default=(- 1), help='id of GPU to use (if any)')
subparser.add_argument('--use-dataset-reader', action='store_true', help='Whether to use the dataset reader of the original model to load Instances')
subparser.add_argument('-o', '--overrides', type=str, default='', help='a JSON structure used to override the experiment configuration')
subparser.set_defaults(func=_predict)
return subparser |
def vgg(cfg, batch_norm=False):
layers = []
in_channels = 3
for v in cfg:
if (v == 'M'):
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
elif (v == 'C'):
layers += [nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)]
else:
conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
else:
layers += [conv2d, nn.ReLU(inplace=True)]
in_channels = v
pool5 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)
conv7 = nn.Conv2d(1024, 1024, kernel_size=1)
layers += [pool5, conv6, nn.ReLU(inplace=True), conv7, nn.ReLU(inplace=True)]
return layers |
def densenet169(pretrained=False, **kwargs):
model = DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 32, 32), **kwargs)
if pretrained:
pattern = re.compile('^(.*denselayer\\d+\\.(?:norm|relu|conv))\\.((?:[12])\\.(?:weight|bias|running_mean|running_var))$')
state_dict = model_zoo.load_url(model_urls['densenet169'])
for key in list(state_dict.keys()):
res = pattern.match(key)
if res:
new_key = (res.group(1) + res.group(2))
state_dict[new_key] = state_dict[key]
del state_dict[key]
model.load_state_dict(state_dict)
return model |
_module()
class HRNet(BaseModule):
blocks_dict = {'BASIC': BasicBlock, 'BOTTLENECK': Bottleneck}
def __init__(self, extra, in_channels=3, conv_cfg=None, norm_cfg=dict(type='BN', requires_grad=True), norm_eval=False, with_cp=False, frozen_stages=(- 1), zero_init_residual=False, multiscale_output=True, pretrained=None, init_cfg=None):
super(HRNet, self).__init__(init_cfg)
self.pretrained = pretrained
self.zero_init_residual = zero_init_residual
assert (not (init_cfg and pretrained)), 'init_cfg and pretrained cannot be setting at the same time'
if isinstance(pretrained, str):
warnings.warn('DeprecationWarning: pretrained is deprecated, please use "init_cfg" instead')
self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
elif (pretrained is None):
if (init_cfg is None):
self.init_cfg = [dict(type='Kaiming', layer='Conv2d'), dict(type='Constant', val=1, layer=['_BatchNorm', 'GroupNorm'])]
else:
raise TypeError('pretrained must be a str or None')
assert (('stage1' in extra) and ('stage2' in extra) and ('stage3' in extra) and ('stage4' in extra))
for i in range(4):
cfg = extra[f'stage{(i + 1)}']
assert ((len(cfg['num_blocks']) == cfg['num_branches']) and (len(cfg['num_channels']) == cfg['num_branches']))
self.extra = extra
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.norm_eval = norm_eval
self.with_cp = with_cp
self.frozen_stages = frozen_stages
(self.norm1_name, norm1) = build_norm_layer(self.norm_cfg, 64, postfix=1)
(self.norm2_name, norm2) = build_norm_layer(self.norm_cfg, 64, postfix=2)
self.conv1 = build_conv_layer(self.conv_cfg, in_channels, 64, kernel_size=3, stride=2, padding=1, bias=False)
self.add_module(self.norm1_name, norm1)
self.conv2 = build_conv_layer(self.conv_cfg, 64, 64, kernel_size=3, stride=2, padding=1, bias=False)
self.add_module(self.norm2_name, norm2)
self.relu = nn.ReLU(inplace=True)
self.stage1_cfg = self.extra['stage1']
num_channels = self.stage1_cfg['num_channels'][0]
block_type = self.stage1_cfg['block']
num_blocks = self.stage1_cfg['num_blocks'][0]
block = self.blocks_dict[block_type]
stage1_out_channels = (num_channels * block.expansion)
self.layer1 = self._make_layer(block, 64, num_channels, num_blocks)
self.stage2_cfg = self.extra['stage2']
num_channels = self.stage2_cfg['num_channels']
block_type = self.stage2_cfg['block']
block = self.blocks_dict[block_type]
num_channels = [(channel * block.expansion) for channel in num_channels]
self.transition1 = self._make_transition_layer([stage1_out_channels], num_channels)
(self.stage2, pre_stage_channels) = self._make_stage(self.stage2_cfg, num_channels)
self.stage3_cfg = self.extra['stage3']
num_channels = self.stage3_cfg['num_channels']
block_type = self.stage3_cfg['block']
block = self.blocks_dict[block_type]
num_channels = [(channel * block.expansion) for channel in num_channels]
self.transition2 = self._make_transition_layer(pre_stage_channels, num_channels)
(self.stage3, pre_stage_channels) = self._make_stage(self.stage3_cfg, num_channels)
self.stage4_cfg = self.extra['stage4']
num_channels = self.stage4_cfg['num_channels']
block_type = self.stage4_cfg['block']
block = self.blocks_dict[block_type]
num_channels = [(channel * block.expansion) for channel in num_channels]
self.transition3 = self._make_transition_layer(pre_stage_channels, num_channels)
(self.stage4, pre_stage_channels) = self._make_stage(self.stage4_cfg, num_channels, multiscale_output=multiscale_output)
self._freeze_stages()
def norm1(self):
return getattr(self, self.norm1_name)
def norm2(self):
return getattr(self, self.norm2_name)
def _make_transition_layer(self, num_channels_pre_layer, num_channels_cur_layer):
num_branches_cur = len(num_channels_cur_layer)
num_branches_pre = len(num_channels_pre_layer)
transition_layers = []
for i in range(num_branches_cur):
if (i < num_branches_pre):
if (num_channels_cur_layer[i] != num_channels_pre_layer[i]):
transition_layers.append(nn.Sequential(build_conv_layer(self.conv_cfg, num_channels_pre_layer[i], num_channels_cur_layer[i], kernel_size=3, stride=1, padding=1, bias=False), build_norm_layer(self.norm_cfg, num_channels_cur_layer[i])[1], nn.ReLU(inplace=True)))
else:
transition_layers.append(None)
else:
conv_downsamples = []
for j in range(((i + 1) - num_branches_pre)):
in_channels = num_channels_pre_layer[(- 1)]
out_channels = (num_channels_cur_layer[i] if (j == (i - num_branches_pre)) else in_channels)
conv_downsamples.append(nn.Sequential(build_conv_layer(self.conv_cfg, in_channels, out_channels, kernel_size=3, stride=2, padding=1, bias=False), build_norm_layer(self.norm_cfg, out_channels)[1], nn.ReLU(inplace=True)))
transition_layers.append(nn.Sequential(*conv_downsamples))
return nn.ModuleList(transition_layers)
def _make_layer(self, block, inplanes, planes, blocks, stride=1):
downsample = None
if ((stride != 1) or (inplanes != (planes * block.expansion))):
downsample = nn.Sequential(build_conv_layer(self.conv_cfg, inplanes, (planes * block.expansion), kernel_size=1, stride=stride, bias=False), build_norm_layer(self.norm_cfg, (planes * block.expansion))[1])
layers = []
block_init_cfg = None
if ((self.pretrained is None) and (not hasattr(self, 'init_cfg')) and self.zero_init_residual):
if (block is BasicBlock):
block_init_cfg = dict(type='Constant', val=0, override=dict(name='norm2'))
elif (block is Bottleneck):
block_init_cfg = dict(type='Constant', val=0, override=dict(name='norm3'))
layers.append(block(inplanes, planes, stride, downsample=downsample, with_cp=self.with_cp, norm_cfg=self.norm_cfg, conv_cfg=self.conv_cfg, init_cfg=block_init_cfg))
inplanes = (planes * block.expansion)
for i in range(1, blocks):
layers.append(block(inplanes, planes, with_cp=self.with_cp, norm_cfg=self.norm_cfg, conv_cfg=self.conv_cfg, init_cfg=block_init_cfg))
return Sequential(*layers)
def _make_stage(self, layer_config, in_channels, multiscale_output=True):
num_modules = layer_config['num_modules']
num_branches = layer_config['num_branches']
num_blocks = layer_config['num_blocks']
num_channels = layer_config['num_channels']
block = self.blocks_dict[layer_config['block']]
hr_modules = []
block_init_cfg = None
if ((self.pretrained is None) and (not hasattr(self, 'init_cfg')) and self.zero_init_residual):
if (block is BasicBlock):
block_init_cfg = dict(type='Constant', val=0, override=dict(name='norm2'))
elif (block is Bottleneck):
block_init_cfg = dict(type='Constant', val=0, override=dict(name='norm3'))
for i in range(num_modules):
if ((not multiscale_output) and (i == (num_modules - 1))):
reset_multiscale_output = False
else:
reset_multiscale_output = True
hr_modules.append(HRModule(num_branches, block, num_blocks, in_channels, num_channels, reset_multiscale_output, with_cp=self.with_cp, norm_cfg=self.norm_cfg, conv_cfg=self.conv_cfg, block_init_cfg=block_init_cfg))
return (Sequential(*hr_modules), in_channels)
def _freeze_stages(self):
if (self.frozen_stages >= 0):
self.norm1.eval()
self.norm2.eval()
for m in [self.conv1, self.norm1, self.conv2, self.norm2]:
for param in m.parameters():
param.requires_grad = False
for i in range(1, (self.frozen_stages + 1)):
if (i == 1):
m = getattr(self, f'layer{i}')
t = getattr(self, f'transition{i}')
elif (i == 4):
m = getattr(self, f'stage{i}')
else:
m = getattr(self, f'stage{i}')
t = getattr(self, f'transition{i}')
m.eval()
for param in m.parameters():
param.requires_grad = False
t.eval()
for param in t.parameters():
param.requires_grad = False
def forward(self, x):
x = self.conv1(x)
x = self.norm1(x)
x = self.relu(x)
x = self.conv2(x)
x = self.norm2(x)
x = self.relu(x)
x = self.layer1(x)
x_list = []
for i in range(self.stage2_cfg['num_branches']):
if (self.transition1[i] is not None):
x_list.append(self.transition1[i](x))
else:
x_list.append(x)
y_list = self.stage2(x_list)
x_list = []
for i in range(self.stage3_cfg['num_branches']):
if (self.transition2[i] is not None):
x_list.append(self.transition2[i](y_list[(- 1)]))
else:
x_list.append(y_list[i])
y_list = self.stage3(x_list)
x_list = []
for i in range(self.stage4_cfg['num_branches']):
if (self.transition3[i] is not None):
x_list.append(self.transition3[i](y_list[(- 1)]))
else:
x_list.append(y_list[i])
y_list = self.stage4(x_list)
return y_list
def train(self, mode=True):
super(HRNet, self).train(mode)
self._freeze_stages()
if (mode and self.norm_eval):
for m in self.modules():
if isinstance(m, _BatchNorm):
m.eval() |
def clean_how2sign_vocabulary(path_to_data_sentencelevel):
partition = ['train', 'val', 'test']
print(f'loading: {path_to_data_sentencelevel[partition[0]]}')
data = load_h2s(path_to_data_sentencelevel['train'])
corrected_sentences = []
mpn = MosesPunctNormalizer()
mt = MosesTokenizer(lang='en')
md = MosesDetokenizer(lang='en')
for (index, row) in tqdm(data.iterrows(), total=data.shape[0]):
sentence = row['translation'].lower()
sent_id = row['id']
print(f'Original sentence: {sentence}')
print(f'Sentence id: {sent_id}')
sentence = mpn.normalize(sentence)
print(f'Sentence normalized: {sentence}')
sentence = mt.tokenize(sentence, return_str=True)
print(f'Sentence tokenized,as we would input the model: {sentence}')
corrected_sentences.append(sentence)
sentence = md.detokenize(sentence.split())
print(f'sentence with detokenization: {sentence}')
sentence = truecase.get_true_case(sentence)
print(f'sentence with truecasing: {sentence}')
data.insert(loc=7, column='translation_tokenized', value=corrected_sentences)
data.to_csv(path_to_data_sentencelevel['train'], sep='\t', index=False) |
def _all_broadcastable(*shapes):
for (i, shape1) in enumerate(shapes[:(- 1)]):
for shape2 in shapes[(i + 1):]:
if (not _broadcastable(shape1, shape2)):
return False
return True |
class LoggingCallback(pl.Callback):
def on_batch_end(self, trainer, pl_module):
lr_scheduler = trainer.lr_schedulers[0]['scheduler']
lrs = {f'lr_group_{i}': lr for (i, lr) in enumerate(lr_scheduler.get_lr())}
pl_module.logger.log_metrics(lrs)
def on_validation_end(self, trainer: pl.Trainer, pl_module: pl.LightningModule):
rank_zero_info('***** Validation results *****')
metrics = trainer.callback_metrics
for key in sorted(metrics):
if (key not in ['log', 'progress_bar']):
rank_zero_info('{} = {}\n'.format(key, str(metrics[key])))
def on_test_end(self, trainer: pl.Trainer, pl_module: pl.LightningModule):
rank_zero_info('***** Test results *****')
metrics = trainer.callback_metrics
output_test_results_file = os.path.join(pl_module.hparams.output_dir, 'test_results.txt')
with open(output_test_results_file, 'w') as writer:
for key in sorted(metrics):
if (key not in ['log', 'progress_bar']):
rank_zero_info('{} = {}\n'.format(key, str(metrics[key])))
writer.write('{} = {}\n'.format(key, str(metrics[key]))) |
def select(sequence, iobs):
for (label, iob) in zip(sequence, iobs):
if (iob in 'BI'):
(yield label) |
class RoFormerForTokenClassification(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def save_features(dataset: Dataset, saving_path: (str | Path), features: dict[(int, dict[(int, Tensor)])], filename: str, make_zip: bool) -> None:
saving_path = Path(saving_path)
for video_index in features:
video_path = (saving_path / str(dataset.get_video_metadata(video_index)['video_name']))
video_path.mkdir(exist_ok=True, parents=True)
half_path = f'{filename}.npy'
np.save((video_path / half_path), features[video_index])
if make_zip:
shutil.make_archive(str(saving_path), 'zip', saving_path)
shutil.rmtree(saving_path)
return |
def main(opt):
result_dir = os.path.dirname(opt['model.model_path'])
trace_file = os.path.join(result_dir, 'trace.txt')
trace_vals = load_trace(trace_file)
best_epoch = trace_vals['val']['loss'].argmin()
model_opt_file = os.path.join(os.path.dirname(opt['model.model_path']), 'opt.json')
with open(model_opt_file, 'r') as f:
model_opt = json.load(f)
model_opt = merge_dict(model_opt, {'log.exp_dir': os.path.join(model_opt['log.exp_dir'], 'trainval'), 'data.trainval': True, 'train.epochs': (best_epoch + model_opt['train.patience'])})
subprocess.call((['python', os.path.join(os.getcwd(), 'scripts/train/few_shot/run_train.py')] + format_opts(model_opt))) |
def prune_outside_window(boxlist, window, scope=None):
with tf.name_scope(scope, 'PruneOutsideWindow'):
(y_min, x_min, y_max, x_max) = tf.split(value=boxlist.get(), num_or_size_splits=4, axis=1)
(win_y_min, win_x_min, win_y_max, win_x_max) = tf.unstack(window)
coordinate_violations = tf.concat([tf.less(y_min, win_y_min), tf.less(x_min, win_x_min), tf.greater(y_max, win_y_max), tf.greater(x_max, win_x_max)], 1)
valid_indices = tf.reshape(tf.where(tf.logical_not(tf.reduce_any(coordinate_violations, 1))), [(- 1)])
return (gather(boxlist, valid_indices), valid_indices) |
def flat_nested_json_dict(json_dict, sep='.') -> dict:
flatted = {}
for (k, v) in json_dict.items():
if isinstance(v, dict):
_flat_nested_json_dict(v, flatted, sep, str(k))
else:
flatted[str(k)] = v
return flatted |
class DroneClass(ABC):
def __init__(self, p: bullet_client.BulletClient, start_pos: np.ndarray, start_orn: np.ndarray, control_hz: int, physics_hz: int, drone_model: str, model_dir: (None | str)=None, np_random: (None | np.random.RandomState)=None):
if ((physics_hz % control_hz) != 0):
raise ValueError(f'`physics_hz` ({physics_hz}) must be multiple of `control_hz` ({control_hz}).')
self.p = p
self.np_random = (np.random.RandomState() if (np_random is None) else np_random)
self.physics_control_ratio = int((physics_hz / control_hz))
self.physics_period = (1.0 / physics_hz)
self.control_period = (1.0 / control_hz)
if (model_dir is None):
model_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '../../models/vehicles/')
self.drone_path = os.path.join(model_dir, f'{drone_model}/{drone_model}.urdf')
self.param_path = os.path.join(model_dir, f'{drone_model}/{drone_model}.yaml')
self.camera: Camera
self.start_pos = start_pos
self.start_orn = self.p.getQuaternionFromEuler(start_orn)
self.Id = self.p.loadURDF(self.drone_path, basePosition=self.start_pos, baseOrientation=self.start_orn, useFixedBase=False, flags=self.p.URDF_USE_INERTIA_FROM_FILE)
self.state: np.ndarray
self.aux_state: np.ndarray
self.setpoint: np.ndarray
self.registered_controllers: dict[(int, type[ControlClass])] = dict()
self.instanced_controllers: dict[(int, ControlClass)] = dict()
self.registered_base_modes: dict[(int, int)] = dict()
self.rgbaImg: np.ndarray
self.depthImg: np.ndarray
self.segImg: np.ndarray
def reset(self):
raise NotImplementedError
def update_control(self):
raise NotImplementedError
def update_physics(self):
raise NotImplementedError
def update_state(self):
raise NotImplementedError
def update_last(self):
raise NotImplementedError
def set_mode(self, mode):
if ((mode != 0) and (mode not in self.registered_controllers.keys())):
raise ValueError(f'`mode` must be either 0 or be registered in self.registered_controllers.keys()={self.registered_controllers.keys()!r}, got {mode}.')
self.mode = mode
if (mode in self.registered_controllers.keys()):
self.instanced_controllers[mode] = self.registered_controllers[mode]()
mode = self.registered_base_modes[mode]
def register_controller(self, controller_id: int, controller_constructor: type[ControlClass], base_mode: int):
assert (controller_id > 0), f'`controller_id` must be more than 0, got {controller_id}.'
assert (base_mode == 0), f'`base_mode` must be 0, no other controllers available, got {base_mode}.'
self.registered_controllers[controller_id] = controller_constructor
self.registered_base_modes[controller_id] = base_mode
def get_joint_info(self):
infos = dict()
for idx in range(self.p.getNumJoints(self.Id)):
info = self.p.getJointInfo(self.Id, idx)
infos[idx] = info[12]
infos[(- 1)] = 'base'
from pprint import pprint
pprint(infos)
def disable_artificial_damping(self):
for idx in range((- 1), self.p.getNumJoints(self.Id)):
self.p.changeDynamics(self.Id, idx, linearDamping=0.0, angularDamping=0.0) |
_module()
class SmoothL1Loss(nn.Module):
def __init__(self, beta=1.0, reduction='mean', loss_weight=1.0):
super(SmoothL1Loss, self).__init__()
self.beta = beta
self.reduction = reduction
self.loss_weight = loss_weight
def forward(self, pred, target, weight=None, avg_factor=None, reduction_override=None, **kwargs):
assert (reduction_override in (None, 'none', 'mean', 'sum'))
reduction = (reduction_override if reduction_override else self.reduction)
loss_bbox = (self.loss_weight * smooth_l1_loss(pred, target, weight, beta=self.beta, reduction=reduction, avg_factor=avg_factor, **kwargs))
return loss_bbox |
class Conversions():
def convert_directions_to_degree_lat_lon(data, latitude: Text, longitude: Text):
def decimal_degree_to_decimal(col):
if (col[latitude][(- 1):] == 'N'):
col[latitude] = float(col[latitude][:(- 1)])
else:
col[latitude] = (float(col[latitude][:(- 1)]) * (- 1))
if (col[longitude][(- 1):] == 'E'):
col[longitude] = float(col[longitude][:(- 1)])
else:
col[longitude] = (((float(col[longitude][:(- 1)]) * (- 1)) + 360) if ((float(col[longitude][:(- 1)]) * (- 1)) < (- 180)) else (float(col[longitude][:(- 1)]) * (- 1)))
return col
return data.apply(decimal_degree_to_decimal, axis=1) |
class MNIST_MLP(nn.Module):
def __init__(self, num_classes):
super(MNIST_MLP, self).__init__()
self.layers = nn.ModuleList()
self.layers.append(nn.Linear((28 * 28), 500))
self.layers.append(nn.Linear(500, 500))
self.layers.append(nn.Linear(500, num_classes))
def forward(self, x):
x = x.view((- 1), (28 * 28))
x = F.relu(self.layers[0](x))
x = F.relu(self.layers[1](x))
x = self.layers[2](x)
return x
def get_weights(self):
weights = []
for layer in self.layers:
weights.append(layer.weight)
return weights
def get_gradients(self):
gradients = []
for layer in self.layers:
gradients.append(layer.weight.grad)
return gradients
def assign_gradients(self, gradients):
for (idx, layer) in enumerate(self.layers):
layer.weight.grad.data = gradients[idx]
def update_weights(self, gradients, lr):
for (idx, layer) in enumerate(self.layers):
layer.weight.data -= (lr * gradients[idx].data)
def initialize_new_grads(self):
init_grads = []
for layer in self.layers:
init_grads.append(torch.zeros_like(layer.weight))
return init_grads |
def get_img_path(img_name, voc12_root):
if (not isinstance(img_name, str)):
img_name = decode_int_filename(img_name)
return os.path.join(voc12_root, IMG_FOLDER_NAME, (img_name + '.jpg')) |
def main(config):
random.seed(config.seed)
np.random.seed(config.seed)
torch.manual_seed(config.seed)
device = torch.device(config.device)
source_classes = label_utils.get_classes(cfg.source.split('/')[0], combine_spring_and_winter=cfg.combine_spring_and_winter)
source_data = PixelSetData(cfg.data_root, cfg.source, source_classes)
(labels, counts) = np.unique(source_data.get_labels(), return_counts=True)
source_classes = [source_classes[i] for i in labels[(counts >= 200)]]
print('Using classes:', source_classes)
cfg.classes = source_classes
cfg.num_classes = len(source_classes)
indices = {config.source: len(source_data), config.target: len(PixelSetData(config.data_root, config.target, source_classes))}
folds = create_train_val_test_folds([config.source, config.target], config.num_folds, indices, config.val_ratio, config.test_ratio)
if config.overall:
overall_performance(config)
return
for (fold_num, splits) in enumerate(folds):
print(f'Starting fold {fold_num}...')
config.fold_dir = os.path.join(config.output_dir, f'fold_{fold_num}')
config.fold_num = fold_num
sample_pixels_val = (config.sample_pixels_val or (config.eval and config.temporal_shift))
(val_loader, test_loader) = create_evaluation_loaders(config.target, splits, config, sample_pixels_val)
if (config.model == 'pseltae'):
model = PseLTae(input_dim=config.input_dim, num_classes=config.num_classes, with_extra=config.with_extra)
elif (config.model == 'psetae'):
model = PseTae(input_dim=config.input_dim, num_classes=config.num_classes, with_extra=config.with_extra)
elif (config.model == 'psetcnn'):
model = PseTempCNN(input_dim=config.input_dim, num_classes=config.num_classes, with_extra=config.with_extra)
elif (config.model == 'psegru'):
model = PseGru(input_dim=config.input_dim, num_classes=config.num_classes, with_extra=config.with_extra)
else:
raise NotImplementedError()
model.to(config.device)
best_model_path = os.path.join(config.fold_dir, 'model.pt')
if (not config.eval):
print(model)
print('Number of trainable parameters:', get_num_trainable_params(model))
if os.path.isfile(best_model_path):
answer = input(f'Model already exists at {best_model_path}! Override y/[n]? ')
override = (strtobool(answer) if (len(answer) > 0) else False)
if (not override):
print('Skipping fold', fold_num)
continue
writer = SummaryWriter(log_dir=f'{config.tensorboard_log_dir}_fold{fold_num}', purge_step=0)
if (config.method == 'timematch'):
train_timematch(model, config, writer, val_loader, device, best_model_path, fold_num, splits)
elif (config.method == 'dann'):
train_dann(model, config, writer, val_loader, device, best_model_path, fold_num, splits)
elif (config.method == 'mmd'):
train_mmd(model, config, writer, val_loader, device, best_model_path, fold_num, splits)
elif (config.method == 'jumbot'):
train_jumbot(model, config, writer, val_loader, device, best_model_path, fold_num, splits)
elif (config.method == 'alda'):
train_alda(model, config, writer, val_loader, device, best_model_path, fold_num, splits)
else:
train_supervised(model, config, writer, splits, val_loader, device, best_model_path)
print('Restoring best model weights for testing...')
state_dict = torch.load(best_model_path)['state_dict']
model.load_state_dict(state_dict)
test_metrics = evaluation(model, test_loader, device, config.classes, mode='test')
print(f"Test result for {config.experiment_name}: accuracy={test_metrics['accuracy']:.4f}, f1={test_metrics['macro_f1']:.4f}")
print(test_metrics['classification_report'])
save_results(test_metrics, config)
overall_performance(config) |
def parse_cl():
import argparse
parser = argparse.ArgumentParser(description='Converts a given gate-level verilog to a blif.')
parser.add_argument('-i', action='store', dest='src_v', required=True)
parser.add_argument('-o', action='store', dest='dest_blif', default='out.blif')
parser.add_argument('-t', action='store', dest='src_t', required=False)
opt = parser.parse_args()
return (opt.src_v, opt.dest_blif, opt.src_t) |
def test_example(capsys, example_test):
(ex, call, out) = example_test
ex.run_commandline(call)
(captured_out, captured_err) = capsys.readouterr()
print(captured_out)
print(captured_err)
captured_out = captured_out.split('\n')
captured_err = captured_err.split('\n')
for out_line in out:
assert (out_line in [captured_out[0], captured_err[0]])
if (out_line == captured_out[0]):
captured_out.pop(0)
else:
captured_err.pop(0)
assert (captured_out == [''])
assert (captured_err == ['']) |
def sentence_noise(sentence, p_max=MAX_SENTENCE):
words = sentence.split(' ')
for p in random.sample(SENTENCE_NOISE_TYPES, SENTENCE_MIN_LEN):
repeat_num = p.repeat_num
while True:
if (repeat_num == 0):
break
if (len(words) >= SENTENCE_MIN_LEN):
if (random.random() < p.frequency):
words = p.function(words)
repeat_num = (repeat_num - 1)
sentence = ' '.join(words)
return sentence |
class AutoModelForObjectDetection(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class RL2Env(gym.Wrapper):
def __init__(self, env):
super().__init__(env)
action_space = akro.from_gym(self.env.action_space)
observation_space = self._create_rl2_obs_space()
self._spec = EnvSpec(action_space=action_space, observation_space=observation_space)
def _create_rl2_obs_space(self):
obs_flat_dim = np.prod(self.env.observation_space.shape)
action_flat_dim = np.prod(self.env.action_space.shape)
return akro.Box(low=(- np.inf), high=np.inf, shape=((((obs_flat_dim + action_flat_dim) + 1) + 1),))
def reset(self, **kwargs):
del kwargs
obs = self.env.reset()
return np.concatenate([obs, np.zeros(self.env.action_space.shape), [0], [0]])
def step(self, action):
(next_obs, reward, done, info) = self.env.step(action)
next_obs = np.concatenate([next_obs, action, [reward], [done]])
return (next_obs, reward, done, info)
def spec(self):
return self._spec |
def main():
state = VehicleState()
state.x.x = 1
state.x.y = 2
state.e.psi = (np.pi / 4)
vehicle_body = VehicleBody()
(fig, ax) = plt.subplots(1)
rect = RectangleObstacle(xc=state.x.x, yc=state.x.y, w=vehicle_body.l, h=vehicle_body.w, psi=state.e.psi)
rect.plot_pyplot(ax)
circles = v2c(state, vehicle_body)
for circle in circles:
cir = plt.Circle((circle[0], circle[1]), circle[2], color='b')
ax.add_patch(cir)
plt.show() |
class GenerationConfig(FairseqDataclass):
beam: int = field(default=5, metadata={'help': 'beam size'})
nbest: int = field(default=1, metadata={'help': 'number of hypotheses to output'})
max_len_a: float = field(default=0, metadata={'help': 'generate sequences of maximum length ax + b, where x is the source length'})
max_len_b: int = field(default=200, metadata={'help': 'generate sequences of maximum length ax + b, where x is the source length'})
min_len: int = field(default=1, metadata={'help': 'minimum generation length'})
match_source_len: bool = field(default=False, metadata={'help': 'generations should match the source length'})
unnormalized: bool = field(default=False, metadata={'help': 'compare unnormalized hypothesis scores'})
no_early_stop: bool = field(default=False, metadata={'help': 'deprecated'})
no_beamable_mm: bool = field(default=False, metadata={'help': "don't use BeamableMM in attention layers"})
lenpen: float = field(default=1, metadata={'help': 'length penalty: <1.0 favors shorter, >1.0 favors longer sentences'})
unkpen: float = field(default=0, metadata={'help': 'unknown word penalty: <0 produces more unks, >0 produces fewer'})
replace_unk: Optional[str] = field(default=None, metadata={'help': 'perform unknown replacement (optionally with alignment dictionary)', 'argparse_const': ' '})
sacrebleu: bool = field(default=False, metadata={'help': 'score with sacrebleu'})
score_reference: bool = field(default=False, metadata={'help': 'just score the reference translation'})
prefix_size: int = field(default=0, metadata={'help': 'initialize generation by target prefix of given length'})
no_repeat_ngram_size: int = field(default=0, metadata={'help': 'ngram blocking such that this size ngram cannot be repeated in the generation'})
sampling: bool = field(default=False, metadata={'help': 'sample hypotheses instead of using beam search'})
sampling_topk: int = field(default=(- 1), metadata={'help': 'sample from top K likely next words instead of all words'})
sampling_topp: float = field(default=(- 1.0), metadata={'help': 'sample from the smallest set whose cumulative probability mass exceeds p for next words'})
constraints: Optional[GENERATION_CONSTRAINTS_CHOICES] = field(default=None, metadata={'help': 'enables lexically constrained decoding', 'argparse_const': 'ordered'})
temperature: float = field(default=1.0, metadata={'help': 'temperature for generation'})
diverse_beam_groups: int = field(default=(- 1), metadata={'help': 'number of groups for Diverse Beam Search'})
diverse_beam_strength: float = field(default=0.5, metadata={'help': 'strength of diversity penalty for Diverse Beam Search'})
diversity_rate: float = field(default=(- 1.0), metadata={'help': 'strength of diversity penalty for Diverse Siblings Search'})
print_alignment: Optional[PRINT_ALIGNMENT_CHOICES] = field(default=None, metadata={'help': 'if set, uses attention feedback to compute and print alignment to source tokens (valid options are: hard, soft, otherwise treated as hard alignment)', 'argparse_const': 'hard'})
print_step: bool = field(default=False, metadata={'help': 'print steps'})
lm_path: Optional[str] = field(default=None, metadata={'help': 'path to lm checkpoint for lm fusion'})
lm_weight: float = field(default=0.0, metadata={'help': 'weight for lm probs for lm fusion'})
iter_decode_eos_penalty: float = field(default=0.0, metadata={'help': 'if > 0.0, it penalized early-stopping in decoding.'})
iter_decode_max_iter: int = field(default=10, metadata={'help': 'maximum iterations for iterative refinement.'})
iter_decode_force_max_iter: bool = field(default=False, metadata={'help': 'if set, run exact the maximum number of iterations without early stop'})
iter_decode_with_beam: int = field(default=1, metadata={'help': 'if > 1, model will generate translations varying by the lengths.'})
iter_decode_with_external_reranker: bool = field(default=False, metadata={'help': 'if set, the last checkpoint are assumed to be a reranker to rescore the translations'})
retain_iter_history: bool = field(default=False, metadata={'help': 'if set, decoding returns the whole history of iterative refinement'})
retain_dropout: bool = field(default=False, metadata={'help': 'Use dropout at inference time'})
retain_dropout_modules: Any = field(default=None, metadata={'help': 'if set, only retain dropout for the specified modules; if not set, then dropout will be retained for all modules'})
decoding_format: Optional[GENERATION_DECODING_FORMAT_CHOICES] = field(default=None, metadata={'help': 'special decoding format for advanced decoding.'})
no_seed_provided: bool = field(default=False, metadata={'help': 'if set, dont use seed for initializing random generators'}) |
def sleep_long(secs: (int | float)) -> None:
max_secs =
if (secs <= max_secs):
time.sleep(secs)
else:
while (secs > 0):
sleep_time = min(secs, max_secs)
time.sleep(sleep_time)
secs -= max_secs |
class SuperglueMultiRCProcessor(DataProcessor):
def __init__(self):
super().__init__()
self.labels = ['No', 'Yes']
def get_examples(self, data_dir, split):
if ((split == 'valid') or (split == 'dev')):
split = 'validation'
try:
dataset = load_dataset(path=HUGGING_FACE_SCRIPTS, name='multirc', cache_dir=data_dir, split=split)
except:
dataset = load_from_disk(f'{data_dir}/super_glue.multirc')[split]
return list(map(self.transform, dataset))
def transform(self, example):
text_a = example['paragraph']
text_b = example['question']
meta = {'answer': example['answer']}
label = int(example['label'])
guid = 'p{}-q{}-a{}'.format(example['idx']['paragraph'], example['idx']['question'], example['idx']['answer'])
return InputExample(guid=guid, text_a=text_a, text_b=text_b, meta=meta, label=label) |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model', required=True, help='sentencepiece model to use for decoding')
parser.add_argument('--input', required=True, help='input file to decode')
parser.add_argument('--input_format', choices=['piece', 'id'], default='piece')
args = parser.parse_args()
sp = spm.SentencePieceProcessor()
sp.Load(args.model)
if (args.input_format == 'piece'):
def decode(l):
return ''.join(sp.DecodePieces(l))
elif (args.input_format == 'id'):
def decode(l):
return ''.join(sp.DecodeIds(l))
else:
raise NotImplementedError
def tok2int(tok):
return (int(tok) if (tok != '<<unk>>') else 0)
with open(args.input, 'r', encoding='utf-8') as h:
for line in h:
print(decode(list(map(tok2int, line.rstrip().split())))) |
def adjust_learning_rate(optimizer, epoch, args, learning_rate):
if (args.lradj == 'type1'):
lr_adjust = {epoch: (learning_rate * (0.5 ** ((epoch - 1) // 1)))}
elif (args.lradj == 'type2'):
lr_adjust = {2: 5e-05, 4: 1e-05, 6: 5e-06, 8: 1e-06, 10: 5e-07, 15: 1e-07, 20: 5e-08}
elif (args.lradj == '3'):
lr_adjust = {epoch: (args.learning_rate if (epoch < 10) else (args.learning_rate * 0.1))}
elif (args.lradj == '4'):
lr_adjust = {epoch: (args.learning_rate if (epoch < 15) else (args.learning_rate * 0.1))}
elif (args.lradj == '5'):
lr_adjust = {epoch: (args.learning_rate if (epoch < 25) else (args.learning_rate * 0.1))}
elif (args.lradj == '6'):
lr_adjust = {epoch: (args.learning_rate if (epoch < 5) else (args.learning_rate * 0.1))}
if (epoch in lr_adjust.keys()):
lr = lr_adjust[epoch]
for param_group in optimizer.param_groups:
param_group['lr'] = lr
print('Updating learning rate to {}'.format(lr)) |
def print_results(res):
for (k, l) in res.items():
for e in l:
print(k, ':', e[0], ' ', e[1]) |
class SampleGeneratorFaceXSeg(SampleGeneratorBase):
def __init__(self, paths, debug=False, batch_size=1, resolution=256, face_type=None, generators_count=4, data_format='NHWC', **kwargs):
super().__init__(debug, batch_size)
self.initialized = False
samples = sum([SampleLoader.load(SampleType.FACE, path) for path in paths])
seg_sample_idxs = SegmentedSampleFilterSubprocessor(samples).run()
if (len(seg_sample_idxs) == 0):
seg_sample_idxs = SegmentedSampleFilterSubprocessor(samples, count_xseg_mask=True).run()
if (len(seg_sample_idxs) == 0):
raise Exception(f'No segmented faces found.')
else:
io.log_info(f'Using {len(seg_sample_idxs)} xseg labeled samples.')
else:
io.log_info(f'Using {len(seg_sample_idxs)} segmented samples.')
if self.debug:
self.generators_count = 1
else:
self.generators_count = max(1, generators_count)
args = (samples, seg_sample_idxs, resolution, face_type, data_format)
if self.debug:
self.generators = [ThisThreadGenerator(self.batch_func, args)]
else:
self.generators = [SubprocessGenerator(self.batch_func, args, start_now=False) for i in range(self.generators_count)]
SubprocessGenerator.start_in_parallel(self.generators)
self.generator_counter = (- 1)
self.initialized = True
def is_initialized(self):
return self.initialized
def __iter__(self):
return self
def __next__(self):
self.generator_counter += 1
generator = self.generators[(self.generator_counter % len(self.generators))]
return next(generator)
def batch_func(self, param):
(samples, seg_sample_idxs, resolution, face_type, data_format) = param
shuffle_idxs = []
bg_shuffle_idxs = []
random_flip = True
rotation_range = [(- 10), 10]
scale_range = [(- 0.05), 0.05]
tx_range = [(- 0.05), 0.05]
ty_range = [(- 0.05), 0.05]
(random_bilinear_resize_chance, random_bilinear_resize_max_size_per) = (25, 75)
(sharpen_chance, sharpen_kernel_max_size) = (25, 5)
(motion_blur_chance, motion_blur_mb_max_size) = (25, 5)
(gaussian_blur_chance, gaussian_blur_kernel_max_size) = (25, 5)
random_jpeg_compress_chance = 25
def gen_img_mask(sample):
img = sample.load_bgr()
(h, w, c) = img.shape
if sample.seg_ie_polys.has_polys():
mask = np.zeros((h, w, 1), dtype=np.float32)
sample.seg_ie_polys.overlay_mask(mask)
elif sample.has_xseg_mask():
mask = sample.get_xseg_mask()
mask[(mask < 0.5)] = 0.0
mask[(mask >= 0.5)] = 1.0
else:
raise Exception(f'no mask in sample {sample.filename}')
if (face_type == sample.face_type):
if (w != resolution):
img = cv2.resize(img, (resolution, resolution), interpolation=cv2.INTER_LANCZOS4)
mask = cv2.resize(mask, (resolution, resolution), interpolation=cv2.INTER_LANCZOS4)
else:
mat = LandmarksProcessor.get_transform_mat(sample.landmarks, resolution, face_type)
img = cv2.warpAffine(img, mat, (resolution, resolution), borderMode=cv2.BORDER_CONSTANT, flags=cv2.INTER_LANCZOS4)
mask = cv2.warpAffine(mask, mat, (resolution, resolution), borderMode=cv2.BORDER_CONSTANT, flags=cv2.INTER_LANCZOS4)
if (len(mask.shape) == 2):
mask = mask[(..., None)]
return (img, mask)
bs = self.batch_size
while True:
batches = [[], []]
n_batch = 0
while (n_batch < bs):
try:
if (len(shuffle_idxs) == 0):
shuffle_idxs = seg_sample_idxs.copy()
np.random.shuffle(shuffle_idxs)
sample = samples[shuffle_idxs.pop()]
(img, mask) = gen_img_mask(sample)
if (np.random.randint(2) == 0):
if (len(bg_shuffle_idxs) == 0):
bg_shuffle_idxs = seg_sample_idxs.copy()
np.random.shuffle(bg_shuffle_idxs)
bg_sample = samples[bg_shuffle_idxs.pop()]
(bg_img, bg_mask) = gen_img_mask(bg_sample)
bg_wp = imagelib.gen_warp_params(resolution, True, rotation_range=[(- 180), 180], scale_range=[(- 0.1), 0.1], tx_range=[(- 0.1), 0.1], ty_range=[(- 0.1), 0.1])
bg_img = imagelib.warp_by_params(bg_wp, bg_img, can_warp=False, can_transform=True, can_flip=True, border_replicate=True)
bg_mask = imagelib.warp_by_params(bg_wp, bg_mask, can_warp=False, can_transform=True, can_flip=True, border_replicate=False)
bg_img = (bg_img * (1 - bg_mask))
if (np.random.randint(2) == 0):
bg_img = imagelib.apply_random_hsv_shift(bg_img)
else:
bg_img = imagelib.apply_random_rgb_levels(bg_img)
c_mask = (1.0 - ((1 - bg_mask) * (1 - mask)))
rnd = (0.15 + (np.random.uniform() * 0.85))
img = (((img * c_mask) + ((img * (1 - c_mask)) * rnd)) + ((bg_img * (1 - c_mask)) * (1 - rnd)))
warp_params = imagelib.gen_warp_params(resolution, random_flip, rotation_range=rotation_range, scale_range=scale_range, tx_range=tx_range, ty_range=ty_range)
img = imagelib.warp_by_params(warp_params, img, can_warp=True, can_transform=True, can_flip=True, border_replicate=True)
mask = imagelib.warp_by_params(warp_params, mask, can_warp=True, can_transform=True, can_flip=True, border_replicate=False)
img = np.clip(img.astype(np.float32), 0, 1)
mask[(mask < 0.5)] = 0.0
mask[(mask >= 0.5)] = 1.0
mask = np.clip(mask, 0, 1)
if (np.random.randint(2) == 0):
krn = np.random.randint((resolution // 4), resolution)
krn = ((krn - (krn % 2)) + 1)
img = (img + cv2.GaussianBlur((img * mask), (krn, krn), 0))
if (np.random.randint(2) == 0):
krn = np.random.randint((resolution // 4), resolution)
krn = ((krn - (krn % 2)) + 1)
img = (img + cv2.GaussianBlur((img * (1 - mask)), (krn, krn), 0))
if (np.random.randint(2) == 0):
img = imagelib.apply_random_hsv_shift(img, mask=sd.random_circle_faded([resolution, resolution]))
else:
img = imagelib.apply_random_rgb_levels(img, mask=sd.random_circle_faded([resolution, resolution]))
if (np.random.randint(2) == 0):
img = imagelib.apply_random_sharpen(img, sharpen_chance, sharpen_kernel_max_size, mask=sd.random_circle_faded([resolution, resolution]))
else:
img = imagelib.apply_random_motion_blur(img, motion_blur_chance, motion_blur_mb_max_size, mask=sd.random_circle_faded([resolution, resolution]))
img = imagelib.apply_random_gaussian_blur(img, gaussian_blur_chance, gaussian_blur_kernel_max_size, mask=sd.random_circle_faded([resolution, resolution]))
if (np.random.randint(2) == 0):
img = imagelib.apply_random_nearest_resize(img, random_bilinear_resize_chance, random_bilinear_resize_max_size_per, mask=sd.random_circle_faded([resolution, resolution]))
else:
img = imagelib.apply_random_bilinear_resize(img, random_bilinear_resize_chance, random_bilinear_resize_max_size_per, mask=sd.random_circle_faded([resolution, resolution]))
img = np.clip(img, 0, 1)
img = imagelib.apply_random_jpeg_compress(img, random_jpeg_compress_chance, mask=sd.random_circle_faded([resolution, resolution]))
if (data_format == 'NCHW'):
img = np.transpose(img, (2, 0, 1))
mask = np.transpose(mask, (2, 0, 1))
batches[0].append(img)
batches[1].append(mask)
n_batch += 1
except:
io.log_err(traceback.format_exc())
(yield [np.array(batch) for batch in batches]) |
class BatchData(ProxyDataFlow):
def __init__(self, ds, batch_size, remainder=False):
super(BatchData, self).__init__(ds)
if (not remainder):
try:
s = ds.size()
assert (batch_size <= ds.size())
except NotImplementedError:
pass
self.batch_size = batch_size
self.remainder = remainder
def size(self):
ds_size = self.ds.size()
div = (ds_size // self.batch_size)
rem = (ds_size % self.batch_size)
if (rem == 0):
return div
return (div + int(self.remainder))
def get_data(self):
holder = []
for data in self.ds.get_data():
holder.append(data)
if (len(holder) == self.batch_size):
(yield BatchData._aggregate_batch(holder))
del holder[:]
if (self.remainder and (len(holder) > 0)):
(yield BatchData._aggregate_batch(holder))
def _aggregate_batch(data_holder):
size = len(data_holder[0])
result = []
for k in range(size):
dt = data_holder[0][k]
if (type(dt) in [int, bool]):
tp = 'int32'
elif (type(dt) == float):
tp = 'float32'
else:
tp = dt.dtype
try:
result.append(np.array([x[k] for x in data_holder], dtype=tp))
except KeyboardInterrupt:
raise
except:
logger.exception('Cannot batch data. Perhaps they are of inconsistent shape?')
import IPython as IP
IP.embed(config=IP.terminal.ipapp.load_default_config())
return result |
class VAE(nn.Module):
def __init__(self, prior_dist, likelihood_dist, post_dist, enc, dec, params):
super(VAE, self).__init__()
self.pz = prior_dist
self.px_z = likelihood_dist
self.qz_x = post_dist
self.enc = enc
self.dec = dec
self.modelName = None
self.params = params
self._pz_params = None
self._qz_x_params = None
self.llik_scaling = 1.0
def pz_params(self):
return self._pz_params
def qz_x_params(self):
if (self._qz_x_params is None):
raise NameError('qz_x params not initalised yet!')
return self._qz_x_params
def getDataLoaders(batch_size, shuffle=True, device='cuda'):
raise NotImplementedError
def forward(self, x, K=1):
self._qz_x_params = self.enc(x)
qz_x = self.qz_x(*self._qz_x_params)
zs = qz_x.rsample(torch.Size([K]))
px_z = self.px_z(*self.dec(zs))
return (qz_x, px_z, zs)
def generate(self, N, K):
self.eval()
with torch.no_grad():
pz = self.pz(*self.pz_params)
latents = pz.rsample(torch.Size([N]))
px_z = self.px_z(*self.dec(latents))
data = px_z.sample(torch.Size([K]))
return data.view((- 1), *data.size()[3:])
def reconstruct(self, data):
self.eval()
with torch.no_grad():
qz_x = self.qz_x(*self.enc(data))
latents = qz_x.rsample()
px_z = self.px_z(*self.dec(latents))
recon = get_mean(px_z)
return recon
def analyse(self, data, K):
self.eval()
with torch.no_grad():
(qz_x, _, zs) = self.forward(data, K=K)
pz = self.pz(*self.pz_params)
zss = [pz.sample(torch.Size([K, data.size(0)])).view((- 1), pz.batch_shape[(- 1)]), zs.view((- 1), zs.size((- 1)))]
zsl = [torch.zeros(zs.size(0)).fill_(i) for (i, zs) in enumerate(zss)]
kls_df = tensors_to_df([kl_divergence(qz_x, pz).cpu().numpy()], head='KL', keys=['KL$(q(z|x)\\,||\\,p(z))$'], ax_names=['Dimensions', 'KL$(q\\,||\\,p)$'])
return (embed_umap(torch.cat(zss, 0).cpu().numpy()), torch.cat(zsl, 0).cpu().numpy(), kls_df) |
class ExperimentPlanner3DFabiansResUNet_v21(ExperimentPlanner3D_v21):
def __init__(self, folder_with_cropped_data, preprocessed_output_folder):
super(ExperimentPlanner3DFabiansResUNet_v21, self).__init__(folder_with_cropped_data, preprocessed_output_folder)
self.data_identifier = 'nnUNetData_plans_v2.1'
self.plans_fname = join(self.preprocessed_output_folder, 'nnUNetPlans_FabiansResUNet_v2.1_plans_3D.pkl')
def get_properties_for_stage(self, current_spacing, original_spacing, original_shape, num_cases, num_modalities, num_classes):
new_median_shape = np.round(((original_spacing / current_spacing) * original_shape)).astype(int)
dataset_num_voxels = (np.prod(new_median_shape) * num_cases)
input_patch_size = (1 / np.array(current_spacing))
input_patch_size /= input_patch_size.mean()
input_patch_size *= ((1 / min(input_patch_size)) * 512)
input_patch_size = np.round(input_patch_size).astype(int)
input_patch_size = [min(i, j) for (i, j) in zip(input_patch_size, new_median_shape)]
(network_num_pool_per_axis, pool_op_kernel_sizes, conv_kernel_sizes, new_shp, shape_must_be_divisible_by) = get_pool_and_conv_props(current_spacing, input_patch_size, self.unet_featuremap_min_edge_length, self.unet_max_numpool)
pool_op_kernel_sizes = ([[1, 1, 1]] + pool_op_kernel_sizes)
blocks_per_stage_encoder = FabiansUNet.default_blocks_per_stage_encoder[:len(pool_op_kernel_sizes)]
blocks_per_stage_decoder = FabiansUNet.default_blocks_per_stage_decoder[:(len(pool_op_kernel_sizes) - 1)]
ref = FabiansUNet.use_this_for_3D_configuration
here = FabiansUNet.compute_approx_vram_consumption(input_patch_size, self.unet_base_num_features, self.unet_max_num_filters, num_modalities, num_classes, pool_op_kernel_sizes, blocks_per_stage_encoder, blocks_per_stage_decoder, 2, self.unet_min_batch_size)
while (here > ref):
axis_to_be_reduced = np.argsort((new_shp / new_median_shape))[(- 1)]
tmp = deepcopy(new_shp)
tmp[axis_to_be_reduced] -= shape_must_be_divisible_by[axis_to_be_reduced]
(_, _, _, _, shape_must_be_divisible_by_new) = get_pool_and_conv_props(current_spacing, tmp, self.unet_featuremap_min_edge_length, self.unet_max_numpool)
new_shp[axis_to_be_reduced] -= shape_must_be_divisible_by_new[axis_to_be_reduced]
(network_num_pool_per_axis, pool_op_kernel_sizes, conv_kernel_sizes, new_shp, shape_must_be_divisible_by) = get_pool_and_conv_props(current_spacing, new_shp, self.unet_featuremap_min_edge_length, self.unet_max_numpool)
pool_op_kernel_sizes = ([[1, 1, 1]] + pool_op_kernel_sizes)
blocks_per_stage_encoder = FabiansUNet.default_blocks_per_stage_encoder[:len(pool_op_kernel_sizes)]
blocks_per_stage_decoder = FabiansUNet.default_blocks_per_stage_decoder[:(len(pool_op_kernel_sizes) - 1)]
here = FabiansUNet.compute_approx_vram_consumption(new_shp, self.unet_base_num_features, self.unet_max_num_filters, num_modalities, num_classes, pool_op_kernel_sizes, blocks_per_stage_encoder, blocks_per_stage_decoder, 2, self.unet_min_batch_size)
input_patch_size = new_shp
batch_size = FabiansUNet.default_min_batch_size
batch_size = int(np.floor((max((ref / here), 1) * batch_size)))
max_batch_size = np.round(((self.batch_size_covers_max_percent_of_dataset * dataset_num_voxels) / np.prod(input_patch_size, dtype=np.int64))).astype(int)
max_batch_size = max(max_batch_size, self.unet_min_batch_size)
batch_size = min(batch_size, max_batch_size)
do_dummy_2D_data_aug = ((max(input_patch_size) / input_patch_size[0]) > self.anisotropy_threshold)
plan = {'batch_size': batch_size, 'num_pool_per_axis': network_num_pool_per_axis, 'patch_size': input_patch_size, 'median_patient_size_in_voxels': new_median_shape, 'current_spacing': current_spacing, 'original_spacing': original_spacing, 'do_dummy_2D_data_aug': do_dummy_2D_data_aug, 'pool_op_kernel_sizes': pool_op_kernel_sizes, 'conv_kernel_sizes': conv_kernel_sizes, 'num_blocks_encoder': blocks_per_stage_encoder, 'num_blocks_decoder': blocks_per_stage_decoder}
return plan
def run_preprocessing(self, num_threads):
pass |
class TestEditDistance(unittest.TestCase):
def test_editdistance(self):
import editdistance
self.assertEqual(2, editdistance.eval('abc', 'aec'))
self.assertEqual(np.asarray([[2, 3], [1, 2]], dtype='int64').tolist(), editdistance.eval_all(['ab', 'abc'], ['bc', 'bcd']).tolist())
def test_time(self):
import uuid, editdistance
strings = [uuid.uuid4().hex.lower()[0:6] for _ in range(5000)]
editdistance.eval_all(strings, strings) |
class RepoCreateCommand(BaseUserCommand):
def run(self):
print(ANSI.red('WARNING! Managing repositories through transformers-cli is deprecated. Please use `huggingface-cli` instead.'))
token = HfFolder.get_token()
if (token is None):
print('Not logged in')
exit(1)
try:
stdout = subprocess.check_output(['git', '--version']).decode('utf-8')
print(ANSI.gray(stdout.strip()))
except FileNotFoundError:
print('Looks like you do not have git installed, please install.')
try:
stdout = subprocess.check_output(['git-lfs', '--version']).decode('utf-8')
print(ANSI.gray(stdout.strip()))
except FileNotFoundError:
print(ANSI.red('Looks like you do not have git-lfs installed, please install. You can install from Then run `git lfs install` (you only have to do this once).'))
print('')
(user, _) = whoami(token)
namespace = (self.args.organization if (self.args.organization is not None) else user)
full_name = f'{namespace}/{self.args.name}'
print(f'You are about to create {ANSI.bold(full_name)}')
if (not self.args.yes):
choice = input('Proceed? [Y/n] ').lower()
if (not ((choice == '') or (choice == 'y') or (choice == 'yes'))):
print('Abort')
exit()
try:
url = create_repo(token, name=self.args.name, organization=self.args.organization)
except HTTPError as e:
print(e)
print(ANSI.red(e.response.text))
exit(1)
print('\nYour repo now lives at:')
print(f' {ANSI.bold(url)}')
print('\nYou can clone it locally with the command below, and commit/push as usual.')
print(f'''
git clone {url}''')
print('') |
class DgSampledSequenceBuilder(Generic[X]):
timestamps: list[Timestamp] = field(default_factory=list)
values: list[X] = field(default_factory=list)
sampled_sequence_type: DgSampledSequenceType = DgSampledSequence
def add(self, t: Timestamp, v: X):
if self.timestamps:
if (t <= self.timestamps[(- 1)]):
msg = 'Repeated time stamp'
raise ZValueError(msg, t=t, timestamps=self.timestamps)
self.timestamps.append(t)
self.values.append(v)
def __len__(self) -> int:
return len(self.timestamps)
def XT(self) -> Type[X]:
return get_args(self.__orig_class__)[0]
def as_sequence(self) -> DgSampledSequence:
return self.sampled_sequence_type[self.XT](timestamps=self.timestamps, values=self.values) |
class DeadlockChecker():
def __init__(self):
pass
def reset(self, env):
self._is_deadlocked = np.zeros(len(env.agents))
self._is_far_deadlocked = np.zeros(len(env.agents))
self._old_deadlock = np.zeros(len(env.agents))
self.env = env
self.agent_positions = defaultdict((lambda : (- 1)))
self.far_dep = defaultdict(list)
self.simple_dep = dict()
def is_deadlocked(self, handle):
return self._is_deadlocked[handle]
def is_far_deadlocked(self, handle):
return self._is_far_deadlocked[handle]
def old_deadlock(self, handle):
return self._old_deadlock[handle]
def _check_blocked(self, handle):
agent = self.env.agents[handle]
transitions = self.env.rail.get_transitions(*agent.position, agent.direction)
self.checked[handle] = 1
for (direction, transition) in enumerate(transitions):
if (transition == 0):
continue
new_position = get_new_position(agent.position, direction)
handle_opp_agent = self.agent_positions[new_position]
if (handle_opp_agent == (- 1)):
self.checked[handle] = 2
return False
if self._is_deadlocked[handle_opp_agent]:
continue
if (self.checked[handle_opp_agent] == 0):
self._check_blocked(handle_opp_agent)
if ((self.checked[handle_opp_agent] == 2) and (not self._is_deadlocked[handle_opp_agent])):
self.checked[handle] = 2
return False
self.dep[handle].append(handle_opp_agent)
continue
if (not self.dep[handle]):
self.checked[handle] = 2
if (len(list(filter((lambda t: (t != 0)), transitions))) == 0):
return False
self._is_deadlocked[handle] = 1
self.env.obs_builder.rail_graph.deadlock_agent(handle)
return True
return None
def fix_deps(self):
any_changes = True
while any_changes:
any_changes = False
for (handle, agent) in enumerate(self.env.agents):
if (self.checked[handle] == 1):
cnt = 0
for opp_handle in self.dep[handle]:
if (self.checked[opp_handle] == 2):
if self._is_deadlocked[opp_handle]:
cnt += 1
else:
self.checked[handle] = 2
any_changes = True
if (cnt == len(self.dep[handle])):
self.checked[handle] = 2
self._is_deadlocked[handle] = True
self.env.obs_builder.rail_graph.deadlock_agent(handle)
any_changes = True
for (handle, agent) in enumerate(self.env.agents):
if (self.checked[handle] == 1):
self._is_deadlocked[handle] = True
self.env.obs_builder.rail_graph.deadlock_agent(handle)
self.checked[handle] = 2
def update_deadlocks(self):
self.agent_positions.clear()
self.dep = [list() for _ in range(len(self.env.agents))]
for (handle, agent) in enumerate(self.env.agents):
self._old_deadlock[handle] = self._is_deadlocked[handle]
if (agent.status == RailAgentStatus.ACTIVE):
self.agent_positions[agent.position] = handle
self.checked = ([0] * len(self.env.agents))
for (handle, agent) in enumerate(self.env.agents):
if ((agent.status == RailAgentStatus.ACTIVE) and (not self._is_deadlocked[handle]) and (not self.checked[handle])):
self._check_blocked(handle)
self.fix_deps()
def _far_deadlock(self, handle, observation):
return
agent = self.env.agents[handle]
if ((agent.status == RailAgentStatus.DONE_REMOVED) or self._is_deadlocked[handle] or self._is_far_deadlocked[handle]):
return
depth = self.env.obs_builder.max_depth
far_deadlock = np.zeros(((2 ** (depth + 1)) - 2), dtype=np.bool)
for edge_id in range(len(far_deadlock)):
far_deadlock[edge_id] = ((ObservationDecoder.has_deadlock(observation, edge_id) or (not ObservationDecoder.is_real(observation, edge_id))) and (not ObservationDecoder.is_after_target(observation, edge_id)))
for d in range((depth - 1), 0, (- 1)):
(l, r) = (((2 ** d) - 2), ((2 ** (d + 1)) - 2))
(lc, rc) = (((2 ** (d + 1)) - 2), ((2 ** (d + 2)) - 2))
cfar_deadlock = (far_deadlock[lc:rc:2] * far_deadlock[(lc + 1):rc:2])
far_deadlock[l:r] = (far_deadlock[l:r] + cfar_deadlock)
if (far_deadlock[0] and far_deadlock[1]):
self._is_far_deadlocked[handle] = True
self._is_deadlocked[handle] = True
self._simplest_deadlock(handle, observation)
def _simplest_deadlock(self, handle, observation):
if ((self.env.agents[handle].status == RailAgentStatus.DONE_REMOVED) or self._is_deadlocked[handle] or self._is_far_deadlocked[handle]):
return
if ObservationDecoder.is_real(observation, 1):
return
opp = self.env.obs_builder.encountered[handle][0]
if (opp != (- 1)):
self.simple_dep[handle] = opp
def _fix_simplest_deps(self):
for (handle, opp_handle) in self.simple_dep.items():
if ((opp_handle in self.simple_dep.keys()) and (self.simple_dep[opp_handle] == handle)):
self._is_far_deadlocked[handle] = True
self._is_deadlocked[handle] = True
self.simple_dep.clear() |
class XLMRobertaOnnxConfig(OnnxConfig):
def inputs(self) -> Mapping[(str, Mapping[(int, str)])]:
if (self.task == 'multiple-choice'):
dynamic_axis = {0: 'batch', 1: 'choice', 2: 'sequence'}
else:
dynamic_axis = {0: 'batch', 1: 'sequence'}
return OrderedDict([('input_ids', dynamic_axis), ('attention_mask', dynamic_axis)]) |
def tile_worker(c: List[int], args: SimpleNamespace) -> Optional[Union[(str, Dict)]]:
if args.has_segmentation:
(c, tile_mask) = c
((x, y, grid_x), grid_y) = (c, 0)
else:
tile_mask = None
(x, y, grid_x, grid_y) = c
x_coord = int((x + (args.full_extract_px / 2)))
y_coord = int((y + (args.full_extract_px / 2)))
slide = get_libvips_reader(args.path, args.mpp_override, **args.reader_kwargs)
if ((args.whitespace_fraction < 1) or (args.grayspace_fraction < 1)):
if (args.filter_downsample_ratio > 1):
filter_extract_px = (args.extract_px // args.filter_downsample_ratio)
filter_region = slide.read_region((x, y), args.filter_downsample_level, (filter_extract_px, filter_extract_px))
else:
filter_region = slide.read_region((x, y), args.downsample_level, (args.extract_px, args.extract_px))
if (args.whitespace_fraction < 1):
ws_fraction = (filter_region.bandmean().relational_const('more', args.whitespace_threshold).avg() / 255)
if ((ws_fraction > args.whitespace_fraction) and (args.whitespace_fraction != FORCE_CALCULATE_WHITESPACE)):
return None
if (args.grayspace_fraction < 1):
hsv_region = filter_region.sRGB2HSV()
gs_fraction = (hsv_region[1].relational_const('less', (args.grayspace_threshold * 255)).avg() / 255)
if ((gs_fraction > args.grayspace_fraction) and (args.whitespace_fraction != FORCE_CALCULATE_WHITESPACE)):
return None
return_dict = {'loc': [x_coord, y_coord]}
return_dict.update({'grid': [grid_x, grid_y]})
if (args.grayspace_fraction < 1):
return_dict.update({'gs_fraction': gs_fraction})
if (args.whitespace_fraction < 1):
return_dict.update({'ws_fraction': ws_fraction})
if args.dry_run:
return_dict.update({'loc': [x_coord, y_coord]})
return return_dict
if (tile_mask is not None):
tile_mask = cv2.resize(tile_mask, (args.tile_px, args.tile_px), interpolation=cv2.INTER_NEAREST)
region = slide.read_region((x, y), args.downsample_level, (args.extract_px, args.extract_px))
if (region.bands == 4):
region = region.flatten()
if (int(args.tile_px) != int(args.extract_px)):
region = region.resize((args.tile_px / args.extract_px))
assert (region.width == region.height == args.tile_px)
if (tile_mask is not None):
vips_mask = vips.Image.new_from_array(tile_mask)
region = region.multiply(vips_mask)
if (args.img_format != 'numpy'):
if (args.img_format == 'png'):
image = region.pngsave_buffer()
elif (args.img_format in ('jpg', 'jpeg')):
image = region.jpegsave_buffer(Q=95)
else:
raise ValueError(f'Unknown image format {args.img_format}')
if args.normalizer:
try:
if (args.img_format == 'png'):
image = args.normalizer.png_to_png(image)
elif (args.img_format in ('jpg', 'jpeg')):
image = args.normalizer.jpeg_to_jpeg(image)
else:
raise ValueError(f'Unknown image format {args.img_format}')
except Exception as e:
log.debug(f'Normalization error: {e}')
return None
else:
image = vips2numpy(region).astype(np.uint8)
if args.normalizer:
try:
image = args.normalizer.rgb_to_rgb(image)
except Exception:
return None
if (args.yolo or args.draw_roi):
(coords, boxes, yolo_anns) = roi_coords_from_image(c, args)
if args.draw_roi:
image = draw_roi(image, coords)
return_dict.update({'image': image})
if args.yolo:
return_dict.update({'yolo': yolo_anns})
return return_dict |
class CommonConfig(FairseqDataclass):
no_progress_bar: bool = field(default=False, metadata={'help': 'disable progress bar'})
log_interval: int = field(default=100, metadata={'help': 'log progress every N batches (when progress bar is disabled)'})
log_format: Optional[LOG_FORMAT_CHOICES] = field(default=None, metadata={'help': 'log format to use'})
tensorboard_logdir: Optional[str] = field(default=None, metadata={'help': 'path to save logs for tensorboard, should match --logdir of running tensorboard (default: no tensorboard logging)'})
wandb_project: Optional[str] = field(default=None, metadata={'help': 'Weights and Biases project name to use for logging'})
azureml_logging: Optional[bool] = field(default=False, metadata={'help': 'Log scalars to AzureML context'})
seed: int = field(default=1, metadata={'help': 'pseudo random number generator seed'})
cpu: bool = field(default=False, metadata={'help': 'use CPU instead of CUDA'})
tpu: bool = field(default=False, metadata={'help': 'use TPU instead of CUDA'})
bf16: bool = field(default=False, metadata={'help': 'use bfloat16; implies --tpu'})
memory_efficient_bf16: bool = field(default=False, metadata={'help': 'use a memory-efficient version of BF16 training; implies --bf16'})
fp16: bool = field(default=False, metadata={'help': 'use FP16'})
memory_efficient_fp16: bool = field(default=False, metadata={'help': 'use a memory-efficient version of FP16 training; implies --fp16'})
fp16_no_flatten_grads: bool = field(default=False, metadata={'help': "don't flatten FP16 grads tensor"})
fp16_init_scale: int = field(default=(2 ** 7), metadata={'help': 'default FP16 loss scale'})
fp16_scale_window: Optional[int] = field(default=None, metadata={'help': 'number of updates before increasing loss scale'})
fp16_scale_tolerance: float = field(default=0.0, metadata={'help': 'pct of updates that can overflow before decreasing the loss scale'})
min_loss_scale: float = field(default=0.0001, metadata={'help': 'minimum FP16 loss scale, after which training is stopped'})
threshold_loss_scale: Optional[float] = field(default=None, metadata={'help': 'threshold FP16 loss scale from below'})
user_dir: Optional[str] = field(default=None, metadata={'help': 'path to a python module containing custom extensions (tasks and/or architectures)'})
empty_cache_freq: int = field(default=0, metadata={'help': 'how often to clear the PyTorch CUDA cache (0 to disable)'})
all_gather_list_size: int = field(default=16384, metadata={'help': 'number of bytes reserved for gathering stats from workers'})
model_parallel_size: int = field(default=1, metadata={'help': 'total number of GPUs to parallelize model over'})
quantization_config_path: Optional[str] = field(default=None, metadata={'help': 'path to quantization config file'})
profile: bool = field(default=False, metadata={'help': 'enable autograd profiler emit_nvtx'})
reset_logging: bool = field(default=True, metadata={'help': 'when using Hydra, reset the logging at the beginning of training'})
suppress_crashes: bool = field(default=False, metadata={'help': 'suppress crashes when training with the hydra_train entry point so that the main method can return a value (useful for sweeps)'}) |
def boundaries_to_intervals(boundaries):
intervals = []
j_prev = 0
for j in np.where(boundaries)[0]:
intervals.append((j_prev, (j + 1)))
j_prev = (j + 1)
return intervals |
class DenseNet(nn.Module):
def __init__(self, block_config, num_classes=10, growth_rate=12, compression=1.0):
self.block_config = block_config
self.n_classes = num_classes
self.growth_rate = growth_rate
self.compression = compression
assert (0 < self.compression <= 1), '0 < compression <= 1'
super(DenseNet, self).__init__()
i_channels = (2 * self.growth_rate)
i_features = [('conv0', nn.Conv2d(3, i_channels, kernel_size=3, stride=1, padding=1, bias=False))]
last_pool = 8
self.features = nn.Sequential(OrderedDict(i_features))
n_channels = i_channels
for (i, n_layers) in enumerate(self.block_config):
block = _DenseBlock(n_layers=n_layers, n_channels=n_channels, growth_rate=self.growth_rate)
self.features.add_module(('block%d' % (i + 1)), block)
n_channels = (n_channels + (n_layers * self.growth_rate))
if (i != (len(self.block_config) - 1)):
trans = _Transition(in_channels=n_channels, out_channels=int((n_channels * self.compression)))
self.features.add_module(('trans%d' % (i + 1)), trans)
n_channels = int((n_channels * self.compression))
self.features.add_module('norm_last', nn.BatchNorm2d(n_channels))
self.features.add_module('relu_last', nn.ReLU(inplace=True))
self.features.add_module('pool_last', nn.AvgPool2d(last_pool))
self.classifier = nn.Linear(n_channels, self.n_classes)
self.reset()
def reset(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = ((m.kernel_size[0] * m.kernel_size[1]) * m.out_channels)
m.weight.data.normal_(0, math.sqrt((2.0 / n)))
elif isinstance(m, nn.BatchNorm2d):
if (m.weight is not None):
m.weight.data.fill_(1)
if (m.bias is not None):
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
m.bias.data.zero_()
def forward(self, x):
features = self.features(x)
out = features.view(features.size(0), (- 1))
out = self.classifier(out)
return out |
class BaseRoIHead(nn.Module, metaclass=ABCMeta):
def __init__(self, bbox_roi_extractor=None, bbox_head=None, mask_roi_extractor=None, mask_head=None, shared_head=None, train_cfg=None, test_cfg=None):
super(BaseRoIHead, self).__init__()
self.train_cfg = train_cfg
self.test_cfg = test_cfg
if (shared_head is not None):
self.shared_head = build_shared_head(shared_head)
if (bbox_head is not None):
self.init_bbox_head(bbox_roi_extractor, bbox_head)
if (mask_head is not None):
self.init_mask_head(mask_roi_extractor, mask_head)
self.init_assigner_sampler()
def with_bbox(self):
return (hasattr(self, 'bbox_head') and (self.bbox_head is not None))
def with_mask(self):
return (hasattr(self, 'mask_head') and (self.mask_head is not None))
def with_shared_head(self):
return (hasattr(self, 'shared_head') and (self.shared_head is not None))
def init_weights(self, pretrained):
pass
def init_bbox_head(self):
pass
def init_mask_head(self):
pass
def init_assigner_sampler(self):
pass
def forward_train(self, x, img_meta, proposal_list, gt_bboxes, gt_labels, gt_bboxes_ignore=None, gt_masks=None, **kwargs):
async def async_simple_test(self, x, img_meta, **kwargs):
raise NotImplementedError
def simple_test(self, x, proposal_list, img_meta, proposals=None, rescale=False, **kwargs):
def aug_test(self, x, proposal_list, img_metas, rescale=False, **kwargs): |
class Discriminator():
def __init__(self, patch_size, kernel_size=3):
self.patch_size = patch_size
self.kernel_size = kernel_size
self.block_param = {}
self.block_param['filters'] = (64, 128, 128, 256, 256, 512, 512)
self.block_param['strides'] = (2, 1, 2, 1, 1, 1, 1)
self.block_num = len(self.block_param['filters'])
self.model = self._build_disciminator()
optimizer = Adam(0.0002, 0.5)
self.model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
self.model._name = 'discriminator'
self.name = 'srgan-large'
def _conv_block(self, input, filters, strides, batch_norm=True, count=None):
x = Conv2D(filters, kernel_size=self.kernel_size, strides=strides, padding='same', name='Conv_{}'.format(count))(input)
x = LeakyReLU(alpha=0.2)(x)
if batch_norm:
x = BatchNormalization(momentum=0.8)(x)
return x
def _build_disciminator(self):
HR = Input(shape=(self.patch_size, self.patch_size, 3))
x = self._conv_block(HR, filters=64, strides=1, batch_norm=False, count=1)
for i in range(self.block_num):
x = self._conv_block(x, filters=self.block_param['filters'][i], strides=self.block_param['strides'][i], count=(i + 2))
x = Dense((self.block_param['filters'][(- 1)] * 2), name='Dense_1024')(x)
x = LeakyReLU(alpha=0.2)(x)
x = Dense(1, name='Dense_last')(x)
HR_v_SR = Activation('sigmoid')(x)
discriminator = Model(inputs=HR, outputs=HR_v_SR)
return discriminator |
def masked_mean(mask: torch.Tensor, value: torch.Tensor, dim: int, eps: float=0.0001) -> torch.Tensor:
mask = mask.expand(*value.shape)
return (torch.sum((mask * value), dim=dim) / (eps + torch.sum(mask, dim=dim))) |
def assert_proba_distribution(probabilities, tol=1e-05):
assert (((probabilities.sum() - 1.0).abs() < tol) and (probabilities >= 0).all()), 'tensor was expected to be a proability distribution (sum={}, negatives={})'.format(probabilities.sum(), (probabilities < 0).any()) |
(scope='module')
def all_explanations():
all_explainers = get_all_explainers()
data = synthetic_classification()
binary_model = RandomForestClassifier()
binary_model.fit(data['train']['X'], data['train']['y'])
regression_model = RandomForestRegressor()
regression_model.fit(data['train']['X'], data['train']['y'])
explanations = []
for (explainer_class, is_classification) in all_explainers:
if (explainer_class.explainer_type == 'blackbox'):
if is_classification:
explainer = explainer_class(binary_model, data['train']['X'])
else:
explainer = explainer_class(regression_model, data['train']['X'])
elif (explainer_class.explainer_type == 'model'):
explainer = explainer_class()
explainer.fit(data['train']['X'], data['train']['y'])
elif (explainer_class.explainer_type == 'specific'):
if is_classification:
explainer = explainer_class(binary_model, data['train']['X'])
else:
explainer = explainer_class(regression_model, data['train']['X'])
elif (explainer_class.explainer_type == 'data'):
explainer = explainer_class()
elif (explainer_class.explainer_type == 'perf'):
if is_classification:
explainer = explainer_class(binary_model)
else:
explainer = explainer_class(regression_model)
else:
raise Exception('Not supported explainer type.')
if ('local' in explainer.available_explanations):
with warnings.catch_warnings():
if (type(explainer).__name__ == 'TreeInterpreter'):
warnings.filterwarnings('ignore', 'Conversion of an array with ndim > 0 to a scalar is deprecated*')
explanation = explainer.explain_local(data['test']['X'].head(), data['test']['y'].head())
explanations.append(explanation)
if ('global' in explainer.available_explanations):
explanation = explainer.explain_global()
explanations.append(explanation)
if ('data' in explainer.available_explanations):
explanation = explainer.explain_data(data['train']['X'], data['train']['y'])
explanations.append(explanation)
if ('perf' in explainer.available_explanations):
explanation = explainer.explain_perf(data['test']['X'], data['test']['y'])
explanations.append(explanation)
return explanations |
def get_anchors_idx(mol):
anchors_idx = []
for atom in mol.GetAtoms():
if (atom.GetProp('_Anchor') == '1'):
anchors_idx.append(atom.GetIdx())
return anchors_idx |
class TestClass():
def __init__(self, int_arg, list_arg=None, dict_arg=None, extra_arg=None):
self.int_arg = int_arg
self.list_arg = list_arg
self.dict_arg = dict_arg
self.extra_arg = extra_arg
def __call__(self, call_arg):
return (call_arg + self.int_arg) |
def button(label, width=0, enabled=True):
with grayed_out((not enabled)):
clicked = imgui.button(label, width=width)
clicked = (clicked and enabled)
return clicked |
def config(dataset, use_baseline):
assert (not use_baseline), 'Cannot use baseline model for this config'
return {'pure_cond_affine': False, 'dequantize': False, 'batch_norm': False, 'act_norm': False, 'max_epochs': 2000, 'max_grad_norm': None, 'early_stopping': True, 'max_bad_valid_epochs': 50, 'train_batch_size': 1000, 'valid_batch_size': 1000, 'test_batch_size': 10000, 'opt': 'adam', 'lr': 0.01, 'lr_schedule': 'none', 'weight_decay': 0.0, 'epochs_per_test': 5, 'train_objective': 'iwae', 'num_train_importance_samples': 10, 'num_valid_importance_samples': 10, 'num_test_importance_samples': 100} |
def test_inference_multi_modality_detector():
if (not torch.cuda.is_available()):
pytest.skip('test requires GPU and torch+cuda')
pcd = 'tests/data/sunrgbd/points/000001.bin'
img = 'tests/data/sunrgbd/sunrgbd_trainval/image/000001.jpg'
ann_file = 'tests/data/sunrgbd/sunrgbd_infos.pkl'
detector_cfg = 'configs/imvotenet/imvotenet_stage2_16x8_sunrgbd-3d-10class.py'
detector = init_model(detector_cfg, device='cuda:0')
results = inference_multi_modality_detector(detector, pcd, img, ann_file)
bboxes_3d = results[0][0]['boxes_3d']
scores_3d = results[0][0]['scores_3d']
labels_3d = results[0][0]['labels_3d']
assert (bboxes_3d.tensor.shape[0] >= 0)
assert (bboxes_3d.tensor.shape[1] == 7)
assert (scores_3d.shape[0] >= 0)
assert (labels_3d.shape[0] >= 0)
pcd = 'tests/data/kitti/training/velodyne_reduced/000000.bin'
img = 'tests/data/kitti/training/image_2/000000.png'
ann_file = 'tests/data/kitti/kitti_infos_train.pkl'
detector_cfg = 'configs/mvxnet/dv_mvx-fpn_second_secfpn_adamw_2x8_80e_kitti-3d-3class.py'
detector = init_model(detector_cfg, device='cuda:0')
results = inference_multi_modality_detector(detector, pcd, img, ann_file)
bboxes_3d = results[0][0]['pts_bbox']['boxes_3d']
scores_3d = results[0][0]['pts_bbox']['scores_3d']
labels_3d = results[0][0]['pts_bbox']['labels_3d']
assert (bboxes_3d.tensor.shape[0] >= 0)
assert (bboxes_3d.tensor.shape[1] == 7)
assert (scores_3d.shape[0] >= 0)
assert (labels_3d.shape[0] >= 0) |
def feature_loss(fmap_r, fmap_g):
loss = 0
for (dr, dg) in zip(fmap_r, fmap_g):
for (rl, gl) in zip(dr, dg):
loss += torch.mean(torch.abs((rl - gl)))
return (loss * 2) |
def eval_time_fct():
global poly_class_instances, input_list
for (instance, input) in zip(poly_class_instances, input_list):
instance.eval(input) |
def get_parent(node, all_parents=False):
if (node.inputs() is None):
return None
elif (len(list(node.inputs())) == 0):
return None
if (not all_parents):
return list(node.inputs())[0].node()
else:
return list(node.inputs()) |
class MaskBasedCorrectionReader(Reader):
def __init__(self, labels, test):
super().__init__(labels, test)
self.db = FEVERDocumentDatabase('resources/wikipedia/fever.db')
self.using_pipeline = False
self.using_gold = False
def generate_instances(self, instance):
if ((instance['verdict'] not in self.labels) and (not self.test)):
return None
collected_evidence = []
if ('pipeline_text' in instance):
assert (not self.using_gold)
self.using_pipeline = True
for (page, evidence) in instance['pipeline_text']:
collected_evidence.append(self.maybe_format(page, evidence))
else:
assert (not self.using_pipeline)
self.using_gold = True
for (page, line) in self.deduplicate(instance['evidence']):
if ((page is None) or (line is None)):
continue
found_page = self.db.get_doc_lines(page.split('#')[0])
if (found_page is None):
print('Page {} not found'.format(page))
continue
found_page = found_page.split('\n')
assert (line < len(found_page))
ev_splits = found_page[line].split('\t')
assert (len(ev_splits) > 0)
evidence = found_page[line].split('\t')[1].strip()
if (len(evidence) == 0):
print('Zero evidence for: {} {}'.format(page, line))
continue
assert (len(evidence) > 0)
collected_evidence.append(self.maybe_format(page, evidence))
evidence = ' ### '.join(collected_evidence)
claim_tokens = instance['original_claim'].split()
masked_claim = (instance['master_explanation'] if ('master_explanation' in instance) else instance['claim_tokens'])
if (masked_claim is None):
return
a = {'source': ' '.join([(token if (idx not in masked_claim) else '[MASK]') for (idx, token) in enumerate(claim_tokens)]), 'target': ' '.join(claim_tokens), 'evidence': evidence, 'mutation_type': (instance['mutation'] if ('mutation' in instance) else instance['metadata']['instance']['mutation']), 'veracity': instance['verdict'], 'metadata': recursive_clean(instance)}
(yield a) |
class TestNetSpec(unittest.TestCase):
def load_net(self, net_proto):
f = tempfile.NamedTemporaryFile(mode='w+', delete=False)
f.write(str(net_proto))
f.close()
return caffe.Net(f.name, caffe.TEST)
def test_lenet(self):
net_proto = lenet(50)
self.assertEqual(net_proto.layer[6].bottom, net_proto.layer[6].top)
net = self.load_net(net_proto)
self.assertEqual(len(net.layers), 8)
net_proto = anon_lenet(50)
self.assertEqual(net_proto.layer[6].bottom, net_proto.layer[6].top)
net = self.load_net(net_proto)
self.assertEqual(len(net.layers), 8)
def test_zero_tops(self):
net_proto = silent_net()
net = self.load_net(net_proto)
self.assertEqual(len(net.forward()), 0)
def test_type_error(self):
data = L.DummyData(ntop=2)
r = "^Silence input 0 is not a Top \\(type is <(type|class) 'tuple'>\\)$"
with self.assertRaisesRegexp(TypeError, r):
L.Silence(data, ntop=0)
L.Silence(*data, ntop=0) |
class GAPSF(object):
def __init__(self, args):
self.result_dir = args.result_dir
self.dataset = args.dataset
self.datasetpath = args.datasetpath
self.n_res = args.n_res
self.ch = args.ch
self.img_size = args.img_size
self.have_gt = args.have_gt
print('# dataset : ', self.dataset)
print('# datasetpath : ', self.datasetpath)
def build_model(self):
self.test_transform = transforms.Compose([transforms.Resize((self.img_size, self.img_size)), transforms.ToTensor(), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))])
self.testA = ImageFolder(os.path.join('dataset', self.datasetpath), self.test_transform)
self.testA_loader = DataLoader(self.testA, batch_size=1, shuffle=False)
self.genA2B = ResnetGenerator(input_nc=3, output_nc=3, ngf=self.ch, n_blocks=self.n_res, img_size=self.img_size).to('cuda')
def load(self, dir, name):
params = torch.load(os.path.join(dir, name))
self.genA2B.load_state_dict(params['genA2B'])
def test(self):
model_list = glob(os.path.join(self.result_dir, self.dataset, 'model', '*.pt'))
model_filename = os.path.basename(model_list[(- 1)])
print(os.path.join(self.result_dir, self.dataset, 'model'), model_filename)
self.load(os.path.join(self.result_dir, self.dataset, 'model'), model_filename)
print(' [*] Load SUCCESS')
self.genA2B.eval()
path_realA = os.path.join(self.result_dir, self.dataset, 'input')
if (not os.path.exists(path_realA)):
os.makedirs(path_realA)
path_fakeB = os.path.join(self.result_dir, self.dataset, 'output')
if (not os.path.exists(path_fakeB)):
os.makedirs(path_fakeB)
path_AB = os.path.join(self.result_dir, self.dataset, 'input_output')
if (not os.path.exists(path_AB)):
os.makedirs(path_AB)
self.input_list = [os.path.splitext(f) for f in os.listdir(os.path.join(self.datasetpath)) if any((f.endswith(suffix) for suffix in IMG_EXTENSIONS))]
for (n, in_name) in enumerate(self.input_list):
img_name = in_name[0]
im_suf = in_name[(- 1)]
print(('predicting: %d / %d' % ((n + 1), len(self.input_list))))
img = Image.open(os.path.join('dataset', self.datasetpath, (img_name + im_suf))).convert('RGB')
(img_width, img_height) = img.size
real_A = self.test_transform(img).unsqueeze(0).to('cuda')
(fake_A2B, _, _) = self.genA2B(real_A)
A_real = RGB2BGR(tensor2numpy(denorm(real_A[0])))
B_fake = RGB2BGR(tensor2numpy(denorm(fake_A2B[0])))
A_real = resize(A_real, (img_width, img_height))
B_fake = resize(B_fake, (img_width, img_height))
A2B = np.concatenate((A_real, B_fake), 1)
if (self.have_gt == True):
if (self.dataset == 'NHM'):
print('NHM', os.path.join('dataset', self.datasetpath.replace('testA', 'testB'), (img_name.replace('_NighttimeHazy', '_lowLight') + im_suf)))
ref = Image.open(os.path.join('dataset', self.datasetpath.replace('testA', 'testB'), (img_name.replace('_NighttimeHazy', '_lowLight') + im_suf))).convert('RGB')
elif (self.dataset == 'NHC'):
print('NHC', os.path.join('dataset', self.datasetpath.replace('testA', 'testB'), (img_name.replace('_nightHazy', '_lowLight') + im_suf)))
ref = Image.open(os.path.join('dataset', self.datasetpath.replace('testA', 'testB'), (img_name.replace('_nightHazy', '_lowLight') + im_suf))).convert('RGB')
else:
ref = Image.open(os.path.join('dataset', self.datasetpath.replace('testA', 'testB'), (img_name + im_suf))).convert('RGB')
ref_A = self.test_transform(ref).unsqueeze(0).to('cuda')
A_ref = RGB2BGR(tensor2numpy(denorm(ref_A[0])))
A_ref = resize(A_ref, (img_width, img_height))
A2B = np.concatenate((A_real, A_ref, B_fake), 1)
cv2.imwrite(os.path.join(path_realA, ('%s%s' % (img_name, im_suf))), (A_real * 255.0))
cv2.imwrite(os.path.join(path_fakeB, ('%s%s' % (img_name, im_suf))), (B_fake * 255.0))
cv2.imwrite(os.path.join(path_AB, ('%s%s' % (img_name, im_suf))), (A2B * 255.0)) |
def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
return DenseConv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=dilation, groups=groups, use_bias=False, dilation=dilation) |
class T5Tokenizer(metaclass=DummyObject):
_backends = ['sentencepiece']
def __init__(self, *args, **kwargs):
requires_backends(self, ['sentencepiece']) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.