code stringlengths 101 5.91M |
|---|
def test_default_edge_func():
(g, n) = pixel_graph(image, spacing=np.array([0.78, 0.78]))
num_edges = (len(g.data) // 2)
assert (num_edges == 12)
np.testing.assert_almost_equal(g[(0, 1)], (0.78 * np.abs((image[(0, 0)] - image[(0, 1)]))))
np.testing.assert_array_equal(n, np.arange(image.size)) |
def paramdec(dec):
(dec)
def layer(*args, **kwargs):
from dace import data
if ((len(kwargs) == 0) and (len(args) == 1) and callable(args[0]) and (not isinstance(args[0], (typeclass, data.Data)))):
return dec(*args, **kwargs)
(dec)
def repl(f):
return dec(f, *args, **kwargs)
return repl
return layer |
class Speech2TextProcessor():
def __init__(self, *args, **kwargs):
requires_sentencepiece(self) |
def tensor1d(min_len=1, max_len=64, dtype=np.float32, elements=None):
return tensor(1, 1, dtype, elements, min_value=min_len, max_value=max_len) |
def ldo_setup(graph: Graph):
n = len(graph)
degrees = None
location = None
max_deg = 0
if isinstance(graph, DictGraph):
degrees = {v: graph.in_degree(v) for v in graph}
location = {v: None for v in graph}
max_deg = max(degrees.values())
else:
degrees = [graph.in_degree(v) for v in graph]
location = [None for _ in graph]
max_deg = max(degrees)
degree_counts = [0 for i in range((max_deg + 1))]
for v in graph:
d = degrees[v]
degree_counts[d] += 1
bin_starts = [sum(degree_counts[:i]) for i in range((max_deg + 1))]
del degree_counts
bin_ptrs = list(bin_starts)
bins = [None for _ in graph]
checkpoint = 0
for (i, v) in enumerate(graph):
loc = bin_ptrs[degrees[v]]
bins[loc] = v
location[v] = loc
bin_ptrs[degrees[v]] += 1
if (v == checkpoint):
print('bucketed {} of {} nodes\r'.format((i + 1), n), end='')
checkpoint += (n // 100)
del bin_ptrs
print('bucketed {} of {} nodes'.format((i + 1), n))
return (bins, bin_starts, degrees, location) |
def load_state_dict(checkpoint_path: str, map_location: str='cpu', model_key='model|module|state_dict'):
checkpoint = torch.load(checkpoint_path, map_location=map_location)
for mk in model_key.split('|'):
if (isinstance(checkpoint, dict) and (mk in checkpoint)):
state_dict = checkpoint[mk]
break
else:
state_dict = checkpoint
if next(iter(state_dict.items()))[0].startswith('module'):
state_dict = {k[7:]: v for (k, v) in state_dict.items()}
return state_dict |
def get_kw_to_default_map(func):
kw_to_default = {}
fsig = inspect.signature(func)
for (name, info) in fsig.parameters.items():
if (info.kind is info.POSITIONAL_OR_KEYWORD):
if (info.default is not info.empty):
kw_to_default[name] = info.default
return kw_to_default |
def DictionaryOfType(ofType: type) -> ConfigDictionaryOfType.__class__:
return ConfigDictionaryOfType.buildWith(ofType) |
def CombineConditions(name, condition_nets, relation):
if (not condition_nets):
return None
if (not isinstance(condition_nets, list)):
raise ValueError('condition_nets must be a list of nets.')
if (len(condition_nets) == 1):
condition_blob = GetConditionBlobFromNet(condition_nets[0])
(condition_net, _) = _CopyConditionBlobNet(condition_blob)
return condition_net
combined_net = core.Net(name)
for i in range(len(condition_nets)):
curr_cond = GetConditionBlobFromNet(condition_nets[i])
if (i == 0):
last_cond = curr_cond
else:
last_cond = combined_net.__getattr__(relation)([last_cond, curr_cond])
combined_net.AddExternalOutput(last_cond)
return combined_net |
def OA_from_Vmt(m, t, V):
(Fq, M) = QDM_from_Vmt(m, t, V)
return OA_from_quasi_difference_matrix(M, Fq, add_col=False) |
def get_op_quantization_configs() -> Tuple[(OpQuantizationConfig, List[OpQuantizationConfig])]:
eight_bits = tp.OpQuantizationConfig(activation_quantization_method=tp.QuantizationMethod.POWER_OF_TWO, weights_quantization_method=tp.QuantizationMethod.SYMMETRIC, activation_n_bits=8, weights_n_bits=8, weights_per_channel_threshold=True, enable_weights_quantization=True, enable_activation_quantization=True, quantization_preserving=False, fixed_scale=None, fixed_zero_point=None, weights_multiplier_nbits=None, simd_size=32)
four_bits = eight_bits.clone_and_edit(weights_n_bits=4, simd_size=(eight_bits.simd_size * 2))
two_bits = eight_bits.clone_and_edit(weights_n_bits=2, simd_size=(eight_bits.simd_size * 4))
mixed_precision_cfg_list = [eight_bits, four_bits, two_bits]
return (eight_bits, mixed_precision_cfg_list) |
def compute_activations(model, train_loader, num_samples):
activation = {}
num_samples_processed = 0
def get_activation(name):
def hook(model, input, output):
print('num of samples seen before', num_samples_processed)
if (name not in activation):
activation[name] = output.detach()
else:
activation[name] = (((num_samples_processed * activation[name]) + output.detach()) / (num_samples_processed + 1))
return hook
model.train()
for (name, layer) in model.named_modules():
if (name == ''):
print('excluded')
continue
layer.register_forward_hook(get_activation(name))
print('set forward hook for layer named: ', name)
for (batch_idx, (data, target)) in enumerate(train_loader):
if (args.gpu_id != (- 1)):
data = data.cuda(args.gpu_id)
model(data)
num_samples_processed += 1
if (num_samples_processed == num_samples):
break
return (activation, None) |
def test_setup(in_model, keras_impl, mixed_precision_candidates_list):
qc = MixedPrecisionQuantizationConfig(DEFAULTCONFIG)
graph = prepare_graph_with_configs(in_model, keras_impl, DEFAULT_KERAS_INFO, representative_dataset, (lambda name, _tp: get_tpc(mixed_precision_candidates_list)), qc=qc, mixed_precision_enabled=True)
split_graph = substitute(copy.deepcopy(graph), [WeightsActivationSplit()])
return (graph, split_graph) |
_utils.test()
def test_python_scope_compare():
v = ti.math.vec3(0, 1, 2)
assert ((v < 1)[0] == 1) |
def collect_rmse_per_dataset(config_multierror_list, algorithms):
algorithm_rmse = {'trans_err': {}, 'rot_err': {}}
print('\n>>> Collecting RMSE per dataset...')
for (idx, alg_i) in enumerate(algorithms):
config_mt_error = config_multierror_list[idx]
algorithm_rmse['trans_err'][alg_i] = []
algorithm_rmse['rot_err'][alg_i] = []
for mt_error in config_mt_error:
algorithm_rmse['trans_err'][alg_i].append(mt_error.abs_errors['rmse_trans'])
algorithm_rmse['rot_err'][alg_i].append(mt_error.abs_errors['rmse_rot'])
return algorithm_rmse |
(torch.backends.xnnpack.enabled, ' XNNPACK must be enabled for these tests. Please build with USE_XNNPACK=1.')
class TestXNNPACKOps(TestCase):
(batch_size=st.integers(0, 3), data_shape=hu.array_shapes(1, 3, 2, 64), weight_output_dim=st.integers(2, 64), use_bias=st.booleans())
def test_linear(self, batch_size, data_shape, weight_output_dim, use_bias):
data_shape = ([batch_size] + list(data_shape))
input_data = torch.rand(data_shape)
weight = torch.rand((weight_output_dim, data_shape[(- 1)]))
if use_bias:
bias = torch.rand(weight_output_dim)
else:
bias = None
ref_result = F.linear(input_data, weight, bias)
packed_weight_bias = torch.ops.prepacked.linear_clamp_prepack(weight, bias)
output_linearprepacked = torch.ops.prepacked.linear_clamp_run(input_data, packed_weight_bias)
torch.testing.assert_allclose(ref_result, output_linearprepacked, rtol=0.01, atol=0.001)
(batch_size=st.integers(0, 3), input_channels_per_group=st.integers(1, 32), height=st.integers(5, 64), width=st.integers(5, 64), output_channels_per_group=st.integers(1, 32), groups=st.integers(1, 16), kernel_h=st.integers(1, 7), kernel_w=st.integers(1, 7), stride_h=st.integers(1, 2), stride_w=st.integers(1, 2), pad_h=st.integers(0, 2), pad_w=st.integers(0, 2), dilation=st.integers(1, 2), use_bias=st.booleans(), format=st.sampled_from([None, torch.preserve_format, torch.contiguous_format, torch.channels_last]))
def test_conv2d(self, batch_size, input_channels_per_group, height, width, output_channels_per_group, groups, kernel_h, kernel_w, stride_h, stride_w, pad_h, pad_w, dilation, use_bias, format):
input_channels = (input_channels_per_group * groups)
output_channels = (output_channels_per_group * groups)
kernels = (kernel_h, kernel_w)
strides = (stride_h, stride_w)
paddings = (pad_h, pad_w)
dilations = (dilation, dilation)
assume(((height + (2 * paddings[0])) >= ((dilations[0] * (kernels[0] - 1)) + 1)))
assume(((width + (2 * paddings[1])) >= ((dilations[1] * (kernels[1] - 1)) + 1)))
input_data = torch.rand((batch_size, input_channels, height, width))
if (format is not None):
input_data = input_data.contiguous(memory_format=format)
weight = torch.rand((output_channels, input_channels_per_group, kernel_h, kernel_w))
bias = None
if use_bias:
bias = torch.rand(output_channels)
ref_result = F.conv2d(input_data, weight, bias, strides, paddings, dilations, groups)
packed_weight_bias = torch.ops.prepacked.conv2d_clamp_prepack(weight, bias, strides, paddings, dilations, groups)
xnnpack_result = torch.ops.prepacked.conv2d_clamp_run(input_data, packed_weight_bias)
torch.testing.assert_allclose(ref_result, xnnpack_result, rtol=0.01, atol=0.001)
(batch_size=st.integers(1, 3), input_channels_per_group=st.integers(1, 32), height=st.integers(5, 64), width=st.integers(5, 64), output_channels_per_group=st.integers(1, 32), groups=st.integers(1, 16), kernel_h=st.integers(1, 7), kernel_w=st.integers(1, 7), stride_h=st.integers(1, 2), stride_w=st.integers(1, 2), pad_h=st.integers(0, 2), pad_w=st.integers(0, 2), output_pad_h=st.integers(0, 2), output_pad_w=st.integers(0, 2), dilation=st.integers(1, 2), use_bias=st.booleans(), format=st.sampled_from([None, torch.preserve_format, torch.contiguous_format, torch.channels_last]))
def test_conv2d_transpose(self, batch_size, input_channels_per_group, height, width, output_channels_per_group, groups, kernel_h, kernel_w, stride_h, stride_w, pad_h, pad_w, output_pad_h, output_pad_w, dilation, use_bias, format):
input_channels = (input_channels_per_group * groups)
output_channels = (output_channels_per_group * groups)
kernels = (kernel_h, kernel_w)
strides = (stride_h, stride_w)
paddings = (pad_h, pad_w)
output_paddings = (output_pad_h, output_pad_w)
dilations = (dilation, dilation)
assume(((height + (2 * paddings[0])) >= ((dilations[0] * (kernels[0] - 1)) + 1)))
assume(((width + (2 * paddings[1])) >= ((dilations[1] * (kernels[1] - 1)) + 1)))
assume(((output_pad_h < stride_h) and (output_pad_h < dilation)))
assume(((output_pad_w < stride_w) and (output_pad_w < dilation)))
input_data = torch.rand((batch_size, input_channels, height, width))
if (format is not None):
input_data = input_data.contiguous(memory_format=format)
weight = torch.rand((input_channels, output_channels_per_group, kernel_h, kernel_w))
bias = None
if use_bias:
bias = torch.rand(output_channels)
ref_result = F.conv_transpose2d(input_data, weight, bias, strides, paddings, output_paddings, groups, dilation)
packed_weight_bias = torch.ops.prepacked.conv2d_transpose_clamp_prepack(weight, bias, strides, paddings, output_paddings, dilations, groups)
xnnpack_result = torch.ops.prepacked.conv2d_transpose_clamp_run(input_data, packed_weight_bias)
torch.testing.assert_allclose(ref_result.contiguous(), xnnpack_result.contiguous(), rtol=0.01, atol=0.001) |
def model_train_mode(args, feeder, hparams, global_step):
with tf.variable_scope('Tacotron_model', reuse=tf.AUTO_REUSE) as scope:
model = create_model('Tacotron', hparams)
model.initialize(feeder.inputs, feeder.input_lengths, feeder.speaker_embeddings, feeder.mel_targets, feeder.token_targets, targets_lengths=feeder.targets_lengths, global_step=global_step, is_training=True, split_infos=feeder.split_infos)
model.add_loss()
model.add_optimizer(global_step)
stats = add_train_stats(model, hparams)
return (model, stats) |
class AffoMiner(LightningModule):
def __init__(self, min_cont_affo_frames=2, max_side_frames=31, max_num_hands=2, hand_state_nms_thresh=0.5, contact_state_threshold=0.99, fps=5):
super().__init__()
self.hand_state_detector = HandStateRCNN(box_detections_per_img=max_num_hands)
self.min_cont_affo_frames = min_cont_affo_frames
self.max_side_frames = max_side_frames
self.hand_state_nms_thresh = hand_state_nms_thresh
self.contact_state_threshold = contact_state_threshold
self.fps = fps
def hand_state_nms(self, boxes, states, scores):
if ((len(boxes) == 2) and (states.sum() == 1)):
iou = box_iou(boxes[(0, None)], boxes[(1, None)])[0]
if (iou > self.hand_state_nms_thresh):
(boxes, states, scores) = (boxes[(0, None)], states[(0, None)], scores[(0, None)])
return (boxes, states, scores)
def judge_contact(self, peri_frame):
peri_scores = peri_frame['hand_scores']
peri_states = peri_frame['hand_states']
contacting = ((peri_scores > self.contact_state_threshold) & (peri_states == 1))
if contacting.any():
return True
return False
def visualize_clip(self, clip, save_dir):
os.makedirs(save_dir, exist_ok=False)
for (i, frame) in enumerate(clip):
v = Visualizer(frame['image'])
hand_bboxes = frame['hand_bboxes']
if ('hand_contacts' not in frame):
labels = ([''] * len(hand_bboxes))
else:
labels = [('Contact' if c else '') for c in frame['hand_contacts']]
v = v.overlay_instances(boxes=hand_bboxes.cpu(), labels=labels).get_image()
cv2.imwrite(f'{save_dir}/{i}.jpg', v)
def save_clip(self, clip, save_dir):
os.makedirs(save_dir, exist_ok=False)
hands = []
for (i, frame) in enumerate(clip):
cv2.imwrite(f'{save_dir}/{i}.jpg', frame['image'])
hands.append(dict(hand_bboxes=frame['hand_bboxes'], hand_states=frame['hand_states'], hand_scores=frame['hand_scores']))
torch.save(hands, f'{save_dir}/hands.pth')
def test_step_per_video(self, video, save_dir):
if os.path.isfile(video):
cap = cv2.VideoCapture(video)
interval = round((cap.get(5) / self.fps))
is_video = True
else:
assert os.path.isdir(video)
interval = round((60 / self.fps))
is_video = False
queue = FrameQueue(maxsize=self.max_side_frames)
frame_idx = (- 1)
(clip, side_frames, clip_idx) = ([], 0, 0)
gpu_flag = f'gpu{self.device.index}'
while True:
frame_idx += 1
if is_video:
(ret, image) = cap.read()
if (not ret):
break
else:
image = f'{video}/frame_{(frame_idx + 1):010}.jpg'
if os.path.exists(image):
image = cv2.imread(image)
else:
break
if ((frame_idx % interval) != 0):
continue
(hand_bboxes, hand_states, hand_scores) = self.hand_state_detector(image)
(hand_bboxes, hand_states, hand_scores) = self.hand_state_nms(hand_bboxes, hand_states, hand_scores)
frame = dict(image=image, hand_bboxes=hand_bboxes, hand_states=hand_states, hand_scores=hand_scores)
contacting = self.judge_contact(frame)
if (contacting and (not len(clip))):
clip = ([f for f in queue.queue] + [frame])
elif len(clip):
side_frames = (0 if contacting else (side_frames + 1))
clip.append(frame)
if (side_frames == self.max_side_frames):
clip_save_dir = os.path.join(save_dir, str(clip_idx))
print(f'{gpu_flag}: clip of {len(clip)} frames are generated! save them to {clip_save_dir}')
if (not os.path.exists(clip_save_dir)):
self.save_clip(clip, clip_save_dir)
(clip, side_frames, clip_idx) = ([], 0, (clip_idx + 1))
queue(frame)
if len(clip):
clip_save_dir = os.path.join(save_dir, str(clip_idx))
print(f'{gpu_flag}: clip of {len(clip)} frames are generated! save them to {clip_save_dir}')
if (not os.path.exists(clip_save_dir)):
self.save_clip(clip, clip_save_dir)
(clip, side_frames, clip_idx) = ([], 0, (clip_idx + 1))
print(f'{gpu_flag}: {save_dir} have just done! {clip_idx} clips are produced.')
def test_step(self, batch, index):
(videos, save_dirs) = batch[0]
for (video, save_dir) in zip(videos, save_dirs):
self.test_step_per_video(video, save_dir) |
def shearx_grid(output_size, ulim=((- 1), 1), vlim=((- 5), 5), out=None, device=None):
(nv, nu) = output_size
urange = torch.linspace(ulim[0], ulim[1], nu, device=device)
vrange = torch.linspace(vlim[0], vlim[1], nv, device=device)
(vs, us) = torch.meshgrid([vrange, urange])
ys = us
xs = (us * vs)
return torch.stack([xs, ys], 2, out=out) |
def query_on_triline(query, feature, min_, max_, use_ste=False, boundary_check=False, ctx=None):
func = CosineQueryOnTriline(ctx, min_, max_, use_ste, boundary_check)
return func(query, feature) |
class UnetBlock(nn.Module):
def __init__(self, input_nc, outer_nc, inner_nc, submodule=None, outermost=False, innermost=False, norm_layer=None, nl_layer=None, use_dropout=False, upsample='basic', padding_type='zero'):
super(UnetBlock, self).__init__()
self.outermost = outermost
p = 0
downconv = []
if (padding_type == 'reflect'):
downconv += [nn.ReflectionPad2d(1)]
elif (padding_type == 'replicate'):
downconv += [nn.ReplicationPad2d(1)]
elif (padding_type == 'zero'):
p = 1
else:
raise NotImplementedError(('padding [%s] is not implemented' % padding_type))
downconv += [nn.Conv2d(input_nc, inner_nc, kernel_size=4, stride=2, padding=p)]
downrelu = nn.LeakyReLU(0.2, True)
downnorm = (norm_layer(inner_nc) if (norm_layer is not None) else None)
uprelu = nl_layer()
upnorm = (norm_layer(outer_nc) if (norm_layer is not None) else None)
if outermost:
upconv = upsampleLayer((inner_nc * 2), outer_nc, upsample=upsample, padding_type=padding_type)
down = downconv
up = (([uprelu] + upconv) + [nn.Tanh()])
model = ((down + [submodule]) + up)
elif innermost:
upconv = upsampleLayer(inner_nc, outer_nc, upsample=upsample, padding_type=padding_type)
down = ([downrelu] + downconv)
up = ([uprelu] + upconv)
if (upnorm is not None):
up += [upnorm]
model = (down + up)
else:
upconv = upsampleLayer((inner_nc * 2), outer_nc, upsample=upsample, padding_type=padding_type)
down = ([downrelu] + downconv)
if (downnorm is not None):
down += [downnorm]
up = ([uprelu] + upconv)
if (upnorm is not None):
up += [upnorm]
if use_dropout:
model = (((down + [submodule]) + up) + [nn.Dropout(0.5)])
else:
model = ((down + [submodule]) + up)
self.model = nn.Sequential(*model)
def forward(self, x):
if self.outermost:
return self.model(x)
else:
return torch.cat([self.model(x), x], 1) |
def transform(s):
if pd.isna(s):
return 4
if (s == 'Macroinvertebrates'):
return 0
if ('Fishes' in s):
return 1
if ('Producer' in s):
return 2
if ('Microfauna' in s):
return 3
return 4 |
def convert_to_localized_md(model_list, localized_model_list, format_str):
def _rep(match):
(title, model_link, paper_affiliations, paper_title_link, paper_authors, supplements) = match.groups()
return format_str.format(title=title, model_link=model_link, paper_affiliations=paper_affiliations, paper_title_link=paper_title_link, paper_authors=paper_authors, supplements=((' ' + supplements.strip()) if (len(supplements) != 0) else ''))
_re_capture_meta = re.compile('\\*\\*\\[([^\\]]*)\\]\\(([^\\)]*)\\)\\*\\* \\(from ([^)]*)\\)[^\\[]*([^\\)]*\\)).*?by (.*?[A-Za-z\\*]{2,}?)\\. (.*)$')
_re_capture_title_link = re.compile('\\*\\*\\[([^\\]]*)\\]\\(([^\\)]*)\\)\\*\\*')
num_models_equal = True
if (len(localized_model_list) == 0):
localized_model_index = {}
else:
try:
localized_model_index = {re.search('\\*\\*\\[([^\\]]*)', line).groups()[0]: line for line in localized_model_list.strip().split('\n')}
except AttributeError:
raise AttributeError('A model name in localized READMEs cannot be recognized.')
for model in model_list.strip().split('\n'):
(title, model_link) = _re_capture_title_link.search(model).groups()
if (title not in localized_model_index):
num_models_equal = False
localized_model_index[title] = _re_capture_meta.sub(_rep, (model + ' '))
else:
localized_model_index[title] = _re_capture_title_link.sub(f'**[{title}]({model_link})**', localized_model_index[title], count=1)
sorted_index = sorted(localized_model_index.items(), key=(lambda x: x[0].lower()))
return (num_models_equal, ('\n'.join(map((lambda x: x[1]), sorted_index)) + '\n')) |
def assign_entities(subfolder, subfolder_entities, nkjp_dir):
morph_path = os.path.join(nkjp_dir, subfolder, MORPH_FILE)
rt = parse_xml(morph_path)
morph_pars = rt.findall(('{%s}TEI/{%s}text/{%s}body/{%s}p' % (NAMESPACE, NAMESPACE, NAMESPACE, NAMESPACE)))
par_id_to_segs = {}
for par in morph_pars:
(_, par_id) = get_node_id(par).split('_')
morph_sents = par.findall(('{%s}s' % NAMESPACE))
sent_id_to_segs = {}
for morph_sent in morph_sents:
(_, sent_id) = get_node_id(morph_sent).split('_')
segs = morph_sent.findall(('{%s}seg' % NAMESPACE))
sent_segs = {}
for (i, seg) in enumerate(segs):
(_, seg_id) = get_node_id(seg).split('morph_')
orth = seg.findall(("{%s}fs/{%s}f[='orth']/{%s}string" % (NAMESPACE, NAMESPACE, NAMESPACE)))[0].text
token = {'seg_id': seg_id, 'i': i, 'orth': orth, 'text': orth, 'tag': '_', 'ner': 'O', 'ner_subtype': None}
sent_segs[seg_id] = token
sent_id_to_segs[sent_id] = sent_segs
par_id_to_segs[par_id] = sent_id_to_segs
if (subfolder_entities is None):
return None
for par_key in subfolder_entities:
par_ents = subfolder_entities[par_key]
for sent_key in par_ents:
sent_entities = par_ents[sent_key]
for entity in sent_entities:
targets = entity['targets']
iob = 'B'
ner_label = entity['ner_type']
matching_tokens = sorted([par_id_to_segs[par_key][sent_key][target] for target in targets], key=(lambda x: x['i']))
for token in matching_tokens:
full_label = f'{iob}-{ner_label}'
token['ner'] = full_label
token['ner_subtype'] = entity['ner_subtype']
iob = 'I'
return par_id_to_segs |
def alias_draw(J, q):
K = len(J)
kk = int(np.floor((np.random.rand() * K)))
if (np.random.rand() < q[kk]):
return kk
else:
return J[kk] |
class LbfgsOptimizer(Serializable):
def __init__(self, max_opt_itr=20, callback=None):
Serializable.quick_init(self, locals())
self._max_opt_itr = max_opt_itr
self._opt_fun = None
self._target = None
self._callback = callback
def update_opt(self, loss, target, inputs, extra_inputs=None, gradients=None, *args, **kwargs):
self._target = target
def get_opt_output(gradients):
if (gradients is None):
gradients = theano.grad(loss, target.get_params(trainable=True))
flat_grad = flatten_tensor_variables(gradients)
return [loss.astype('float64'), flat_grad.astype('float64')]
if (extra_inputs is None):
extra_inputs = list()
self._opt_fun = lazydict(f_loss=(lambda : compile_function((inputs + extra_inputs), loss)), f_opt=(lambda : compile_function(inputs=(inputs + extra_inputs), outputs=get_opt_output(gradients))))
def loss(self, inputs, extra_inputs=None):
if (extra_inputs is None):
extra_inputs = list()
return self._opt_fun['f_loss'](*(list(inputs) + list(extra_inputs)))
def optimize(self, inputs, extra_inputs=None):
f_opt = self._opt_fun['f_opt']
if (extra_inputs is None):
extra_inputs = list()
def f_opt_wrapper(flat_params):
self._target.set_param_values(flat_params, trainable=True)
return f_opt(*inputs)
itr = [0]
start_time = time.time()
if self._callback:
def opt_callback(params):
loss = self._opt_fun['f_loss'](*(inputs + extra_inputs))
elapsed = (time.time() - start_time)
self._callback(dict(loss=loss, params=params, itr=itr[0], elapsed=elapsed))
itr[0] += 1
else:
opt_callback = None
scipy.optimize.fmin_l_bfgs_b(func=f_opt_wrapper, x0=self._target.get_param_values(trainable=True), maxiter=self._max_opt_itr, callback=opt_callback) |
def register_Ns3Histogram_methods(root_module, cls):
cls.add_constructor([param('ns3::Histogram const &', 'arg0')])
cls.add_constructor([param('double', 'binWidth')])
cls.add_constructor([])
cls.add_method('AddValue', 'void', [param('double', 'value')])
cls.add_method('GetBinCount', 'uint32_t', [param('uint32_t', 'index')])
cls.add_method('GetBinEnd', 'double', [param('uint32_t', 'index')])
cls.add_method('GetBinStart', 'double', [param('uint32_t', 'index')])
cls.add_method('GetBinWidth', 'double', [param('uint32_t', 'index')], is_const=True)
cls.add_method('GetNBins', 'uint32_t', [], is_const=True)
cls.add_method('SerializeToXmlStream', 'void', [param('std::ostream &', 'os'), param('uint16_t', 'indent'), param('std::string', 'elementName')], is_const=True)
cls.add_method('SetDefaultBinWidth', 'void', [param('double', 'binWidth')])
return |
class SqueezeExpandDilatedDecoder(nn.Module):
def __init__(self, in_channels, num_classes, inter_channels, feature_scales, foreground_channel=False, ConvType=nn.Conv3d, PoolType=nn.AvgPool3d, NormType=nn.Identity):
super().__init__()
assert (tuple(feature_scales) == (4, 8, 16, 32))
PoolingLayerCallbacks = get_pooling_layer_creator(PoolType)
self.block_32x = nn.Sequential(AtrousPyramid3D(in_channels, 64, ((1, 3, 3), (1, 6, 6), (1, 9, 9)), inter_channels[0]), NormType(inter_channels[0]), nn.ReLU(inplace=True), PoolingLayerCallbacks[0]((3, 1, 1), stride=(2, 1, 1), padding=(1, 0, 0)), AtrousPyramid3D(inter_channels[0], 64, ((1, 3, 3), (1, 6, 6), (1, 9, 9)), inter_channels[0]), NormType(inter_channels[0]), nn.ReLU(inplace=True), PoolingLayerCallbacks[1]((3, 1, 1), stride=(2, 1, 1), padding=(1, 0, 0)), AtrousPyramid3D(inter_channels[0], 64, ((1, 3, 3), (1, 6, 6), (1, 9, 9)), inter_channels[0]), NormType(inter_channels[0]), nn.ReLU(inplace=True), PoolingLayerCallbacks[2]((3, 1, 1), stride=(2, 1, 1), padding=(1, 0, 0)))
self.block_16x = nn.Sequential(AtrousPyramid3D(in_channels, 64, ((1, 4, 4), (1, 8, 8), (1, 12, 12)), inter_channels[1]), NormType(inter_channels[1]), nn.ReLU(inplace=True), PoolingLayerCallbacks[0]((3, 1, 1), stride=(2, 1, 1), padding=(1, 0, 0)), AtrousPyramid3D(in_channels, 64, ((1, 4, 4), (1, 8, 8), (1, 12, 12)), inter_channels[1]), NormType(inter_channels[1]), nn.ReLU(inplace=True), PoolingLayerCallbacks[1]((3, 1, 1), stride=(2, 1, 1), padding=(1, 0, 0)))
self.block_8x = nn.Sequential(ConvType(in_channels, inter_channels[2], 3, stride=1, padding=1), NormType(inter_channels[2]), nn.ReLU(inplace=True), PoolingLayerCallbacks[0](3, stride=(2, 1, 1), padding=1))
self.block_4x = nn.Sequential(ConvType(in_channels, inter_channels[3], 3, stride=1, padding=1), NormType(inter_channels[3]), nn.ReLU(inplace=True))
t_scales = get_temporal_scales()
self.upsample_32_to_16 = nn.Sequential(UpsampleTrilinear3D(scale_factor=(t_scales[0], 2, 2), align_corners=False))
self.conv_16 = nn.Conv3d((inter_channels[0] + inter_channels[1]), inter_channels[1], 1, bias=False)
self.upsample_16_to_8 = nn.Sequential(UpsampleTrilinear3D(scale_factor=(t_scales[1], 2, 2), align_corners=False))
self.conv_8 = nn.Conv3d((inter_channels[1] + inter_channels[2]), inter_channels[2], 1, bias=False)
self.upsample_8_to_4 = nn.Sequential(UpsampleTrilinear3D(scale_factor=(t_scales[2], 2, 2), align_corners=False))
self.conv_4 = nn.Conv3d((inter_channels[2] + inter_channels[3]), inter_channels[3], 1, bias=False)
out_channels = ((num_classes + 1) if foreground_channel else num_classes)
self.conv_out = nn.Conv3d(inter_channels[(- 1)], out_channels, kernel_size=1, padding=0, bias=False)
self.has_foreground_channel = foreground_channel
def forward(self, x):
assert (len(x) == 4), 'Expected 4 feature maps, got {}'.format(len(x))
(feat_map_32x, feat_map_16x, feat_map_8x, feat_map_4x) = x[::(- 1)]
feat_map_32x = self.block_32x(feat_map_32x)
x = self.upsample_32_to_16(feat_map_32x)
feat_map_16x = self.block_16x(feat_map_16x)
x = torch.cat((x, feat_map_16x), 1)
x = self.conv_16(x)
x = self.upsample_16_to_8(x)
feat_map_8x = self.block_8x(feat_map_8x)
x = torch.cat((x, feat_map_8x), 1)
x = self.conv_8(x)
x = self.upsample_8_to_4(x)
feat_map_4x = self.block_4x(feat_map_4x)
x = torch.cat((x, feat_map_4x), 1)
x = self.conv_4(x)
return self.conv_out(x) |
class TestOpenposeComponents(TestCase):
def test_openpose_components_total_points(self):
actual_total_points = 0
for component in OpenPose_Components:
num_keypoints = len(component.points)
actual_total_points += num_keypoints
self.assertEqual(actual_total_points, OPENPOSE_TOTAL_KEYPOINTS)
def test_openpose_components_names(self):
expected_names = OPENPOSE_COMPONENTS_USED
actual_names = [c.name for c in OpenPose_Components]
self.assertEqual(actual_names, expected_names)
def test_openpose_num_points_per_component_pose(self):
expected_value = OPENPOSE_NUM_POINTS_PER_COMPONENT['pose_keypoints_2d']
actual_value = len(OpenPose_Components[0].points)
self.assertEqual(actual_value, expected_value)
def test_openpose_num_points_per_component_face(self):
expected_value = OPENPOSE_NUM_POINTS_PER_COMPONENT['face_keypoints_2d']
actual_value = len(OpenPose_Components[1].points)
self.assertEqual(actual_value, expected_value)
def test_openpose_num_points_per_component_hand_left(self):
expected_value = OPENPOSE_NUM_POINTS_PER_COMPONENT['hand_left_keypoints_2d']
actual_value = len(OpenPose_Components[2].points)
self.assertEqual(actual_value, expected_value)
def test_openpose_num_points_per_component_hand_right(self):
expected_value = OPENPOSE_NUM_POINTS_PER_COMPONENT['hand_right_keypoints_2d']
actual_value = len(OpenPose_Components[3].points)
self.assertEqual(actual_value, expected_value) |
def test_fowlkes_mallows_score():
score = fowlkes_mallows_score([0, 0, 0, 1, 1, 1], [0, 0, 1, 1, 2, 2])
assert_almost_equal(score, (4.0 / np.sqrt((12.0 * 6.0))))
perfect_score = fowlkes_mallows_score([0, 0, 0, 1, 1, 1], [1, 1, 1, 0, 0, 0])
assert_almost_equal(perfect_score, 1.0)
worst_score = fowlkes_mallows_score([0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5])
assert_almost_equal(worst_score, 0.0) |
def resample_uv_tensors_to_bbox(u: torch.Tensor, v: torch.Tensor, labels: torch.Tensor, box_xywh_abs: IntTupleBox) -> torch.Tensor:
(x, y, w, h) = box_xywh_abs
w = max(int(w), 1)
h = max(int(h), 1)
u_bbox = F.interpolate(u, (h, w), mode='bilinear', align_corners=False)
v_bbox = F.interpolate(v, (h, w), mode='bilinear', align_corners=False)
uv = torch.zeros([2, h, w], dtype=torch.float32, device=u.device)
for part_id in range(1, u_bbox.size(1)):
uv[0][(labels == part_id)] = u_bbox[(0, part_id)][(labels == part_id)]
uv[1][(labels == part_id)] = v_bbox[(0, part_id)][(labels == part_id)]
return uv |
def _validate_vector(u, dtype=None):
u = np.asarray(u, dtype=dtype, order='c')
if (u.ndim == 1):
return u
raise ValueError('Input vector should be 1-D.') |
def validate(val_loader, model, criterion, args, logger, epoch):
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: ')
model.eval()
with torch.no_grad():
end = time.time()
for (i, (images, target)) in enumerate(val_loader):
if (args.gpu is not None):
images = images.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
output = model(images)
loss = criterion(output, target)
(acc1, acc5) = accuracy(output, target, topk=(1, 5))
losses.update(loss.item(), images.size(0))
top1.update(acc1[0], images.size(0))
top5.update(acc5[0], images.size(0))
batch_time.update((time.time() - end))
end = time.time()
if ((i % args.print_freq) == 0):
progress.display(i)
print(' * {top1.avg:.3f} {top5.avg:.3f}'.format(top1=top1, top5=top5))
if (args.gpu == 0):
logger.log_value('test_acc', top1.avg, epoch)
logger.log_value('test_acc5', top5.avg, epoch)
return top1.avg |
class ResNet101(TorchVisionModel):
def __init__(self, tasks, model_args):
super(ResNet101, self).__init__(models.resnet101, tasks, model_args) |
def stop_worker(thread_id: int) -> None:
ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(thread_id), ctypes.py_object(SystemExit)) |
class TilerConfigurationCallback(Callback):
def __init__(self, enable: bool=False, tile_size: (int | Sequence)=256, stride: ((int | Sequence) | None)=None, remove_border_count: int=0, mode: str='padding', tile_count: int=4) -> None:
self.enable = enable
self.tile_size = tile_size
self.stride = stride
self.remove_border_count = remove_border_count
self.mode = mode
self.tile_count = tile_count
def setup(self, trainer: pl.Trainer, pl_module: pl.LightningModule, stage: (str | None)=None) -> None:
del trainer, stage
if self.enable:
if (isinstance(pl_module, AnomalyModule) and hasattr(pl_module.model, 'tiler')):
pl_module.model.tiler = Tiler(tile_size=self.tile_size, stride=self.stride, remove_border_count=self.remove_border_count, mode=self.mode, tile_count=self.tile_count)
else:
raise ValueError('Model does not support tiling.') |
class NDCG(object):
def __init__(self, K):
self.K = K
self.name = '{}'.format(K)
def apply(self, suggestions, targets):
def _ndcg_at_k(rank, k):
dcg = 0.0
for (rel, pos) in rank:
if (pos <= k):
dcg += (float(((2 ** rel) - 1)) / numpy.log((pos + 1)))
odcg = sorted(rank, key=(lambda x: x[0]), reverse=True)
odcg = sum([(((2 ** r) - 1) / numpy.log((s + 2))) for (s, (r, _)) in enumerate(odcg[:k])])
return (dcg / odcg)
ranks = _get_ranks(suggestions, targets)
ndcg_k = numpy.mean(map((lambda x: _ndcg_at_k(x, self.K)), ranks))
return ndcg_k |
def _default_key_normalizer(key_class, request_context):
context = request_context.copy()
context['scheme'] = context['scheme'].lower()
context['host'] = context['host'].lower()
for key in ('headers', '_proxy_headers', '_socks_options'):
if ((key in context) and (context[key] is not None)):
context[key] = frozenset(context[key].items())
socket_opts = context.get('socket_options')
if (socket_opts is not None):
context['socket_options'] = tuple(socket_opts)
for key in list(context.keys()):
context[('key_' + key)] = context.pop(key)
for field in key_class._fields:
if (field not in context):
context[field] = None
return key_class(**context) |
def random_crop_params(img, scale, ratio=((3 / 4), (4 / 3))):
(width, height) = img.size
area = (height * width)
for _ in range(10):
target_area = (random.uniform(*scale) * area)
log_ratio = (math.log(ratio[0]), math.log(ratio[1]))
aspect_ratio = math.exp(random.uniform(*log_ratio))
w = int(round(math.sqrt((target_area * aspect_ratio))))
h = int(round(math.sqrt((target_area / aspect_ratio))))
if ((0 < w <= width) and (0 < h <= height)):
i = random.randint(0, (height - h))
j = random.randint(0, (width - w))
return (i, j, h, w)
in_ratio = (float(width) / float(height))
if (in_ratio < min(ratio)):
w = width
h = int(round((w / min(ratio))))
elif (in_ratio > max(ratio)):
h = height
w = int(round((h * max(ratio))))
else:
w = width
h = height
i = ((height - h) // 2)
j = ((width - w) // 2)
return (i, j, h, w) |
class TestIo():
def setup(self):
self.temp_dir = mkdtemp()
self.test_file = join(self.temp_dir, 'some-subdirectory', 'some-file.txt')
def teardown(self):
rmtree(self.temp_dir, ignore_errors=True)
def test_creates_file(self):
makedirs(dirname(self.test_file))
create_file(self.test_file)
assert exists(self.test_file)
def test_creates_path(self):
create_file_path(self.test_file)
assert exists(dirname(self.test_file))
def test_open_file_creates_directories_implicitly(self):
safe_open(self.test_file, 'w+').close()
assert isfile(self.test_file)
def test_writes_file_safely(self):
some_content = 'Some content'
safe_write(some_content, self.test_file, append=False)
with open(self.test_file) as actual_file:
assert (actual_file.read() == (some_content + '\n'))
def test_removes_folder_completely(self):
create_file(join(self.temp_dir, 'dir1', 'dir2', 'file1'))
create_file(join(self.temp_dir, 'dir1', 'file2'))
create_file(join(self.temp_dir, 'file3'))
remove_tree(self.temp_dir)
assert (not exists(self.temp_dir))
def test_copies_tree(self):
src = join(self.temp_dir, 'src')
file1 = join('dir1', 'dir2', 'file1')
file2 = join('dir1', 'file2')
file3 = join('file3')
create_file(join(src, file1))
create_file(join(src, file2))
create_file(join(src, file3))
copy_tree(src, self.temp_dir)
assert exists(join(self.temp_dir, file1))
assert exists(join(self.temp_dir, file2))
assert exists(join(self.temp_dir, file3))
def test_copies_empty_directory(self):
src = join(self.temp_dir, 'src')
makedirs(join(src, 'empty'))
copy_tree(src, self.temp_dir)
assert exists(join(self.temp_dir, 'empty'))
def test_copy_creates_destination(self):
src = join(self.temp_dir, 'src')
makedirs(src)
dst = join(self.temp_dir, 'dst')
copy_tree(src, dst)
assert exists(dst)
def test_copy_fails_if_source_misssing(self):
src = join(self.temp_dir, 'src')
with assert_raises(FileNotFoundError):
copy_tree(src, '-irrelevant-')
def test_zip_dir_contents(self):
src1 = join(self.temp_dir, 'src1')
src2 = join(self.temp_dir, 'src2')
create_file(join(src1, 'file1'))
create_file(join(src2, 'file2'))
sources = [src1, src2]
destination = join(self.temp_dir, 'archive')
zip_dir_contents(sources, destination)
extract_destination = join(self.temp_dir, 'extracted')
with zipfile.ZipFile(destination, 'r') as zip_file:
zip_file.extractall(extract_destination)
assert exists(join(extract_destination, 'file1'))
assert exists(join(extract_destination, 'file2'))
def test_zip_dir_contents_skips_file_on_conflict(self):
src1 = join(self.temp_dir, 'src1')
src2 = join(self.temp_dir, 'src2')
safe_write('a', join(src1, '-conflict-'), False)
safe_write('b', join(src2, '-conflict-'), False)
sources = [src1, src2]
destination = join(self.temp_dir, 'archive')
zip_dir_contents(sources, destination)
extract_destination = join(self.temp_dir, 'extracted')
with zipfile.ZipFile(destination, 'r') as zip_file:
zip_file.extractall(extract_destination)
assert_equals('a\n', safe_read(join(extract_destination, '-conflict-')))
def test_zip_dir_contents_suffix_is_not_a_conflict(self):
src1 = join(self.temp_dir, 'src1')
src2 = join(self.temp_dir, 'src2')
safe_write('b', join(src1, '-subdir-', '-conflict-'), False)
safe_write('a', join(src2, '-conflict-'), False)
sources = [src1, src2]
destination = join(self.temp_dir, 'archive')
zip_dir_contents(sources, destination)
extract_destination = join(self.temp_dir, 'extracted')
with zipfile.ZipFile(destination, 'r') as zip_file:
zip_file.extractall(extract_destination)
assert (exists(join(extract_destination, '-conflict-')) and exists(join(extract_destination, '-subdir-', '-conflict-'))) |
def register_methods(root_module):
register_Ns3Address_methods(root_module, root_module['ns3::Address'])
register_Ns3AllocationRetentionPriority_methods(root_module, root_module['ns3::AllocationRetentionPriority'])
register_Ns3AttributeConstructionList_methods(root_module, root_module['ns3::AttributeConstructionList'])
register_Ns3AttributeConstructionListItem_methods(root_module, root_module['ns3::AttributeConstructionList::Item'])
register_Ns3BandInfo_methods(root_module, root_module['ns3::BandInfo'])
register_Ns3Buffer_methods(root_module, root_module['ns3::Buffer'])
register_Ns3BufferIterator_methods(root_module, root_module['ns3::Buffer::Iterator'])
register_Ns3BufferSizeLevelBsr_methods(root_module, root_module['ns3::BufferSizeLevelBsr'])
register_Ns3BuildBroadcastListElement_s_methods(root_module, root_module['ns3::BuildBroadcastListElement_s'])
register_Ns3BuildDataListElement_s_methods(root_module, root_module['ns3::BuildDataListElement_s'])
register_Ns3BuildRarListElement_s_methods(root_module, root_module['ns3::BuildRarListElement_s'])
register_Ns3BwPart_s_methods(root_module, root_module['ns3::BwPart_s'])
register_Ns3ByteTagIterator_methods(root_module, root_module['ns3::ByteTagIterator'])
register_Ns3ByteTagIteratorItem_methods(root_module, root_module['ns3::ByteTagIterator::Item'])
register_Ns3ByteTagList_methods(root_module, root_module['ns3::ByteTagList'])
register_Ns3ByteTagListIterator_methods(root_module, root_module['ns3::ByteTagList::Iterator'])
register_Ns3ByteTagListIteratorItem_methods(root_module, root_module['ns3::ByteTagList::Iterator::Item'])
register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])
register_Ns3CqasFlowPerf_t_methods(root_module, root_module['ns3::CqasFlowPerf_t'])
register_Ns3CqiConfig_s_methods(root_module, root_module['ns3::CqiConfig_s'])
register_Ns3CqiListElement_s_methods(root_module, root_module['ns3::CqiListElement_s'])
register_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback'])
register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate'])
register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >'])
register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >'])
register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >'])
register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >'])
register_Ns3DefaultDeleter__Ns3EpcTft_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EpcTft >'])
register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >'])
register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >'])
register_Ns3DefaultDeleter__Ns3LteChunkProcessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::LteChunkProcessor >'])
register_Ns3DefaultDeleter__Ns3LteControlMessage_methods(root_module, root_module['ns3::DefaultDeleter< ns3::LteControlMessage >'])
register_Ns3DefaultDeleter__Ns3LteHarqPhy_methods(root_module, root_module['ns3::DefaultDeleter< ns3::LteHarqPhy >'])
register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NixVector >'])
register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Packet >'])
register_Ns3DefaultDeleter__Ns3SpectrumModel_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SpectrumModel >'])
register_Ns3DefaultDeleter__Ns3SpectrumSignalParameters_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SpectrumSignalParameters >'])
register_Ns3DefaultDeleter__Ns3SpectrumValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SpectrumValue >'])
register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >'])
register_Ns3DefaultDeleter__Ns3VendorSpecificValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::VendorSpecificValue >'])
register_Ns3DefaultDeleter__Ns3X2CellInfo_methods(root_module, root_module['ns3::DefaultDeleter< ns3::X2CellInfo >'])
register_Ns3DefaultDeleter__Ns3X2IfaceInfo_methods(root_module, root_module['ns3::DefaultDeleter< ns3::X2IfaceInfo >'])
register_Ns3DlDciListElement_s_methods(root_module, root_module['ns3::DlDciListElement_s'])
register_Ns3DlInfoListElement_s_methods(root_module, root_module['ns3::DlInfoListElement_s'])
register_Ns3DlSchedulingCallbackInfo_methods(root_module, root_module['ns3::DlSchedulingCallbackInfo'])
register_Ns3DrxConfig_s_methods(root_module, root_module['ns3::DrxConfig_s'])
register_Ns3EpcEnbS1SapProvider_methods(root_module, root_module['ns3::EpcEnbS1SapProvider'])
register_Ns3EpcEnbS1SapProviderBearerToBeSwitched_methods(root_module, root_module['ns3::EpcEnbS1SapProvider::BearerToBeSwitched'])
register_Ns3EpcEnbS1SapProviderPathSwitchRequestParameters_methods(root_module, root_module['ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters'])
register_Ns3EpcEnbS1SapUser_methods(root_module, root_module['ns3::EpcEnbS1SapUser'])
register_Ns3EpcEnbS1SapUserDataRadioBearerSetupRequestParameters_methods(root_module, root_module['ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters'])
register_Ns3EpcEnbS1SapUserInitialContextSetupRequestParameters_methods(root_module, root_module['ns3::EpcEnbS1SapUser::InitialContextSetupRequestParameters'])
register_Ns3EpcEnbS1SapUserPathSwitchRequestAcknowledgeParameters_methods(root_module, root_module['ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters'])
register_Ns3EpcS11Sap_methods(root_module, root_module['ns3::EpcS11Sap'])
register_Ns3EpcS11SapFteid_methods(root_module, root_module['ns3::EpcS11Sap::Fteid'])
register_Ns3EpcS11SapGtpcMessage_methods(root_module, root_module['ns3::EpcS11Sap::GtpcMessage'])
register_Ns3EpcS11SapUli_methods(root_module, root_module['ns3::EpcS11Sap::Uli'])
register_Ns3EpcS11SapMme_methods(root_module, root_module['ns3::EpcS11SapMme'])
register_Ns3EpcS11SapMmeBearerContextCreated_methods(root_module, root_module['ns3::EpcS11SapMme::BearerContextCreated'])
register_Ns3EpcS11SapMmeBearerContextRemoved_methods(root_module, root_module['ns3::EpcS11SapMme::BearerContextRemoved'])
register_Ns3EpcS11SapMmeCreateSessionResponseMessage_methods(root_module, root_module['ns3::EpcS11SapMme::CreateSessionResponseMessage'])
register_Ns3EpcS11SapMmeDeleteBearerRequestMessage_methods(root_module, root_module['ns3::EpcS11SapMme::DeleteBearerRequestMessage'])
register_Ns3EpcS11SapMmeModifyBearerResponseMessage_methods(root_module, root_module['ns3::EpcS11SapMme::ModifyBearerResponseMessage'])
register_Ns3EpcS11SapSgw_methods(root_module, root_module['ns3::EpcS11SapSgw'])
register_Ns3EpcS11SapSgwBearerContextRemovedSgwPgw_methods(root_module, root_module['ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw'])
register_Ns3EpcS11SapSgwBearerContextToBeCreated_methods(root_module, root_module['ns3::EpcS11SapSgw::BearerContextToBeCreated'])
register_Ns3EpcS11SapSgwBearerContextToBeRemoved_methods(root_module, root_module['ns3::EpcS11SapSgw::BearerContextToBeRemoved'])
register_Ns3EpcS11SapSgwCreateSessionRequestMessage_methods(root_module, root_module['ns3::EpcS11SapSgw::CreateSessionRequestMessage'])
register_Ns3EpcS11SapSgwDeleteBearerCommandMessage_methods(root_module, root_module['ns3::EpcS11SapSgw::DeleteBearerCommandMessage'])
register_Ns3EpcS11SapSgwDeleteBearerResponseMessage_methods(root_module, root_module['ns3::EpcS11SapSgw::DeleteBearerResponseMessage'])
register_Ns3EpcS11SapSgwModifyBearerRequestMessage_methods(root_module, root_module['ns3::EpcS11SapSgw::ModifyBearerRequestMessage'])
register_Ns3EpcS1apSap_methods(root_module, root_module['ns3::EpcS1apSap'])
register_Ns3EpcS1apSapEnb_methods(root_module, root_module['ns3::EpcS1apSapEnb'])
register_Ns3EpcS1apSapEnbErabSwitchedInUplinkItem_methods(root_module, root_module['ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem'])
register_Ns3EpcS1apSapEnbErabToBeSetupItem_methods(root_module, root_module['ns3::EpcS1apSapEnb::ErabToBeSetupItem'])
register_Ns3EpcS1apSapMme_methods(root_module, root_module['ns3::EpcS1apSapMme'])
register_Ns3EpcS1apSapMmeErabSetupItem_methods(root_module, root_module['ns3::EpcS1apSapMme::ErabSetupItem'])
register_Ns3EpcS1apSapMmeErabSwitchedInDownlinkItem_methods(root_module, root_module['ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem'])
register_Ns3EpcS1apSapMmeErabToBeReleasedIndication_methods(root_module, root_module['ns3::EpcS1apSapMme::ErabToBeReleasedIndication'])
register_Ns3EpcX2Sap_methods(root_module, root_module['ns3::EpcX2Sap'])
register_Ns3EpcX2SapCellInformationItem_methods(root_module, root_module['ns3::EpcX2Sap::CellInformationItem'])
register_Ns3EpcX2SapCellMeasurementResultItem_methods(root_module, root_module['ns3::EpcX2Sap::CellMeasurementResultItem'])
register_Ns3EpcX2SapCompositeAvailCapacity_methods(root_module, root_module['ns3::EpcX2Sap::CompositeAvailCapacity'])
register_Ns3EpcX2SapErabAdmittedItem_methods(root_module, root_module['ns3::EpcX2Sap::ErabAdmittedItem'])
register_Ns3EpcX2SapErabNotAdmittedItem_methods(root_module, root_module['ns3::EpcX2Sap::ErabNotAdmittedItem'])
register_Ns3EpcX2SapErabToBeSetupItem_methods(root_module, root_module['ns3::EpcX2Sap::ErabToBeSetupItem'])
register_Ns3EpcX2SapErabsSubjectToStatusTransferItem_methods(root_module, root_module['ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem'])
register_Ns3EpcX2SapHandoverPreparationFailureParams_methods(root_module, root_module['ns3::EpcX2Sap::HandoverPreparationFailureParams'])
register_Ns3EpcX2SapHandoverRequestAckParams_methods(root_module, root_module['ns3::EpcX2Sap::HandoverRequestAckParams'])
register_Ns3EpcX2SapHandoverRequestParams_methods(root_module, root_module['ns3::EpcX2Sap::HandoverRequestParams'])
register_Ns3EpcX2SapLoadInformationParams_methods(root_module, root_module['ns3::EpcX2Sap::LoadInformationParams'])
register_Ns3EpcX2SapRelativeNarrowbandTxBand_methods(root_module, root_module['ns3::EpcX2Sap::RelativeNarrowbandTxBand'])
register_Ns3EpcX2SapResourceStatusUpdateParams_methods(root_module, root_module['ns3::EpcX2Sap::ResourceStatusUpdateParams'])
register_Ns3EpcX2SapSnStatusTransferParams_methods(root_module, root_module['ns3::EpcX2Sap::SnStatusTransferParams'])
register_Ns3EpcX2SapUeContextReleaseParams_methods(root_module, root_module['ns3::EpcX2Sap::UeContextReleaseParams'])
register_Ns3EpcX2SapUeDataParams_methods(root_module, root_module['ns3::EpcX2Sap::UeDataParams'])
register_Ns3EpcX2SapUlHighInterferenceInformationItem_methods(root_module, root_module['ns3::EpcX2Sap::UlHighInterferenceInformationItem'])
register_Ns3EpcX2SapProvider_methods(root_module, root_module['ns3::EpcX2SapProvider'])
register_Ns3EpcX2SapUser_methods(root_module, root_module['ns3::EpcX2SapUser'])
register_Ns3EutranMeasurementMapping_methods(root_module, root_module['ns3::EutranMeasurementMapping'])
register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])
register_Ns3FfMacCschedSapProvider_methods(root_module, root_module['ns3::FfMacCschedSapProvider'])
register_Ns3FfMacCschedSapProviderCschedCellConfigReqParameters_methods(root_module, root_module['ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters'])
register_Ns3FfMacCschedSapProviderCschedLcConfigReqParameters_methods(root_module, root_module['ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters'])
register_Ns3FfMacCschedSapProviderCschedLcReleaseReqParameters_methods(root_module, root_module['ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters'])
register_Ns3FfMacCschedSapProviderCschedUeConfigReqParameters_methods(root_module, root_module['ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters'])
register_Ns3FfMacCschedSapProviderCschedUeReleaseReqParameters_methods(root_module, root_module['ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters'])
register_Ns3FfMacCschedSapUser_methods(root_module, root_module['ns3::FfMacCschedSapUser'])
register_Ns3FfMacCschedSapUserCschedCellConfigCnfParameters_methods(root_module, root_module['ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters'])
register_Ns3FfMacCschedSapUserCschedCellConfigUpdateIndParameters_methods(root_module, root_module['ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters'])
register_Ns3FfMacCschedSapUserCschedLcConfigCnfParameters_methods(root_module, root_module['ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters'])
register_Ns3FfMacCschedSapUserCschedLcReleaseCnfParameters_methods(root_module, root_module['ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters'])
register_Ns3FfMacCschedSapUserCschedUeConfigCnfParameters_methods(root_module, root_module['ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters'])
register_Ns3FfMacCschedSapUserCschedUeConfigUpdateIndParameters_methods(root_module, root_module['ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters'])
register_Ns3FfMacCschedSapUserCschedUeReleaseCnfParameters_methods(root_module, root_module['ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters'])
register_Ns3FfMacSchedSapProvider_methods(root_module, root_module['ns3::FfMacSchedSapProvider'])
register_Ns3FfMacSchedSapProviderSchedDlCqiInfoReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters'])
register_Ns3FfMacSchedSapProviderSchedDlMacBufferReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters'])
register_Ns3FfMacSchedSapProviderSchedDlPagingBufferReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters'])
register_Ns3FfMacSchedSapProviderSchedDlRachInfoReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters'])
register_Ns3FfMacSchedSapProviderSchedDlRlcBufferReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters'])
register_Ns3FfMacSchedSapProviderSchedDlTriggerReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters'])
register_Ns3FfMacSchedSapProviderSchedUlCqiInfoReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters'])
register_Ns3FfMacSchedSapProviderSchedUlMacCtrlInfoReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters'])
register_Ns3FfMacSchedSapProviderSchedUlNoiseInterferenceReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters'])
register_Ns3FfMacSchedSapProviderSchedUlSrInfoReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters'])
register_Ns3FfMacSchedSapProviderSchedUlTriggerReqParameters_methods(root_module, root_module['ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters'])
register_Ns3FfMacSchedSapUser_methods(root_module, root_module['ns3::FfMacSchedSapUser'])
register_Ns3FfMacSchedSapUserSchedDlConfigIndParameters_methods(root_module, root_module['ns3::FfMacSchedSapUser::SchedDlConfigIndParameters'])
register_Ns3FfMacSchedSapUserSchedUlConfigIndParameters_methods(root_module, root_module['ns3::FfMacSchedSapUser::SchedUlConfigIndParameters'])
register_Ns3GbrQosInformation_methods(root_module, root_module['ns3::GbrQosInformation'])
register_Ns3GtpcIes_methods(root_module, root_module['ns3::GtpcIes'])
register_Ns3HarqProcessInfoElement_t_methods(root_module, root_module['ns3::HarqProcessInfoElement_t'])
register_Ns3Hasher_methods(root_module, root_module['ns3::Hasher'])
register_Ns3HigherLayerSelected_s_methods(root_module, root_module['ns3::HigherLayerSelected_s'])
register_Ns3ImsiLcidPair_t_methods(root_module, root_module['ns3::ImsiLcidPair_t'])
register_Ns3Inet6SocketAddress_methods(root_module, root_module['ns3::Inet6SocketAddress'])
register_Ns3InetSocketAddress_methods(root_module, root_module['ns3::InetSocketAddress'])
register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])
register_Ns3Ipv4AddressHelper_methods(root_module, root_module['ns3::Ipv4AddressHelper'])
register_Ns3Ipv4InterfaceAddress_methods(root_module, root_module['ns3::Ipv4InterfaceAddress'])
register_Ns3Ipv4InterfaceContainer_methods(root_module, root_module['ns3::Ipv4InterfaceContainer'])
register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])
register_Ns3Ipv6AddressHelper_methods(root_module, root_module['ns3::Ipv6AddressHelper'])
register_Ns3Ipv6InterfaceAddress_methods(root_module, root_module['ns3::Ipv6InterfaceAddress'])
register_Ns3Ipv6InterfaceContainer_methods(root_module, root_module['ns3::Ipv6InterfaceContainer'])
register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])
register_Ns3LogComponent_methods(root_module, root_module['ns3::LogComponent'])
register_Ns3LogicalChannelConfigListElement_s_methods(root_module, root_module['ns3::LogicalChannelConfigListElement_s'])
register_Ns3LteAnrSapProvider_methods(root_module, root_module['ns3::LteAnrSapProvider'])
register_Ns3LteAnrSapUser_methods(root_module, root_module['ns3::LteAnrSapUser'])
register_Ns3LteAsSapProvider_methods(root_module, root_module['ns3::LteAsSapProvider'])
register_Ns3LteAsSapUser_methods(root_module, root_module['ns3::LteAsSapUser'])
register_Ns3LteCcmMacSapProvider_methods(root_module, root_module['ns3::LteCcmMacSapProvider'])
register_Ns3LteCcmRrcSapProvider_methods(root_module, root_module['ns3::LteCcmRrcSapProvider'])
register_Ns3LteCcmRrcSapProviderLcsConfig_methods(root_module, root_module['ns3::LteCcmRrcSapProvider::LcsConfig'])
register_Ns3LteCcmRrcSapUser_methods(root_module, root_module['ns3::LteCcmRrcSapUser'])
register_Ns3LteEnbCmacSapProvider_methods(root_module, root_module['ns3::LteEnbCmacSapProvider'])
register_Ns3LteEnbCmacSapProviderAllocateNcRaPreambleReturnValue_methods(root_module, root_module['ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue'])
register_Ns3LteEnbCmacSapProviderLcInfo_methods(root_module, root_module['ns3::LteEnbCmacSapProvider::LcInfo'])
register_Ns3LteEnbCmacSapProviderRachConfig_methods(root_module, root_module['ns3::LteEnbCmacSapProvider::RachConfig'])
register_Ns3LteEnbCmacSapProviderUeConfig_methods(root_module, root_module['ns3::LteEnbCmacSapProvider::UeConfig'])
register_Ns3LteEnbCmacSapUser_methods(root_module, root_module['ns3::LteEnbCmacSapUser'])
register_Ns3LteEnbCmacSapUserUeConfig_methods(root_module, root_module['ns3::LteEnbCmacSapUser::UeConfig'])
register_Ns3LteEnbCphySapProvider_methods(root_module, root_module['ns3::LteEnbCphySapProvider'])
register_Ns3LteEnbCphySapUser_methods(root_module, root_module['ns3::LteEnbCphySapUser'])
register_Ns3LteEnbPhySapProvider_methods(root_module, root_module['ns3::LteEnbPhySapProvider'])
register_Ns3LteEnbPhySapUser_methods(root_module, root_module['ns3::LteEnbPhySapUser'])
register_Ns3LteFfConverter_methods(root_module, root_module['ns3::LteFfConverter'])
register_Ns3LteFfrRrcSapProvider_methods(root_module, root_module['ns3::LteFfrRrcSapProvider'])
register_Ns3LteFfrRrcSapUser_methods(root_module, root_module['ns3::LteFfrRrcSapUser'])
register_Ns3LteFfrSapProvider_methods(root_module, root_module['ns3::LteFfrSapProvider'])
register_Ns3LteFfrSapUser_methods(root_module, root_module['ns3::LteFfrSapUser'])
register_Ns3LteFlowId_t_methods(root_module, root_module['ns3::LteFlowId_t'])
register_Ns3LteGlobalPathlossDatabase_methods(root_module, root_module['ns3::LteGlobalPathlossDatabase'])
register_Ns3LteHandoverManagementSapProvider_methods(root_module, root_module['ns3::LteHandoverManagementSapProvider'])
register_Ns3LteHandoverManagementSapUser_methods(root_module, root_module['ns3::LteHandoverManagementSapUser'])
register_Ns3LteMacSapProvider_methods(root_module, root_module['ns3::LteMacSapProvider'])
register_Ns3LteMacSapProviderReportBufferStatusParameters_methods(root_module, root_module['ns3::LteMacSapProvider::ReportBufferStatusParameters'])
register_Ns3LteMacSapProviderTransmitPduParameters_methods(root_module, root_module['ns3::LteMacSapProvider::TransmitPduParameters'])
register_Ns3LteMacSapUser_methods(root_module, root_module['ns3::LteMacSapUser'])
register_Ns3LteMacSapUserReceivePduParameters_methods(root_module, root_module['ns3::LteMacSapUser::ReceivePduParameters'])
register_Ns3LteMacSapUserTxOpportunityParameters_methods(root_module, root_module['ns3::LteMacSapUser::TxOpportunityParameters'])
register_Ns3LteMiErrorModel_methods(root_module, root_module['ns3::LteMiErrorModel'])
register_Ns3LtePdcpSapProvider_methods(root_module, root_module['ns3::LtePdcpSapProvider'])
register_Ns3LtePdcpSapProviderTransmitPdcpSduParameters_methods(root_module, root_module['ns3::LtePdcpSapProvider::TransmitPdcpSduParameters'])
register_Ns3LtePdcpSapUser_methods(root_module, root_module['ns3::LtePdcpSapUser'])
register_Ns3LtePdcpSapUserReceivePdcpSduParameters_methods(root_module, root_module['ns3::LtePdcpSapUser::ReceivePdcpSduParameters'])
register_Ns3LteRlcSapProvider_methods(root_module, root_module['ns3::LteRlcSapProvider'])
register_Ns3LteRlcSapProviderTransmitPdcpPduParameters_methods(root_module, root_module['ns3::LteRlcSapProvider::TransmitPdcpPduParameters'])
register_Ns3LteRlcSapUser_methods(root_module, root_module['ns3::LteRlcSapUser'])
register_Ns3LteRrcSap_methods(root_module, root_module['ns3::LteRrcSap'])
register_Ns3LteRrcSapAntennaInfoCommon_methods(root_module, root_module['ns3::LteRrcSap::AntennaInfoCommon'])
register_Ns3LteRrcSapAntennaInfoDedicated_methods(root_module, root_module['ns3::LteRrcSap::AntennaInfoDedicated'])
register_Ns3LteRrcSapAntennaInfoUl_methods(root_module, root_module['ns3::LteRrcSap::AntennaInfoUl'])
register_Ns3LteRrcSapAsConfig_methods(root_module, root_module['ns3::LteRrcSap::AsConfig'])
register_Ns3LteRrcSapBlackCellsToAddMod_methods(root_module, root_module['ns3::LteRrcSap::BlackCellsToAddMod'])
register_Ns3LteRrcSapCarrierBandwidthEutra_methods(root_module, root_module['ns3::LteRrcSap::CarrierBandwidthEutra'])
register_Ns3LteRrcSapCarrierFreqEutra_methods(root_module, root_module['ns3::LteRrcSap::CarrierFreqEutra'])
register_Ns3LteRrcSapCellAccessRelatedInfo_methods(root_module, root_module['ns3::LteRrcSap::CellAccessRelatedInfo'])
register_Ns3LteRrcSapCellIdentification_methods(root_module, root_module['ns3::LteRrcSap::CellIdentification'])
register_Ns3LteRrcSapCellSelectionInfo_methods(root_module, root_module['ns3::LteRrcSap::CellSelectionInfo'])
register_Ns3LteRrcSapCellsToAddMod_methods(root_module, root_module['ns3::LteRrcSap::CellsToAddMod'])
register_Ns3LteRrcSapCgiInfo_methods(root_module, root_module['ns3::LteRrcSap::CgiInfo'])
register_Ns3LteRrcSapDrbToAddMod_methods(root_module, root_module['ns3::LteRrcSap::DrbToAddMod'])
register_Ns3LteRrcSapFreqInfo_methods(root_module, root_module['ns3::LteRrcSap::FreqInfo'])
register_Ns3LteRrcSapHandoverPreparationInfo_methods(root_module, root_module['ns3::LteRrcSap::HandoverPreparationInfo'])
register_Ns3LteRrcSapLogicalChannelConfig_methods(root_module, root_module['ns3::LteRrcSap::LogicalChannelConfig'])
register_Ns3LteRrcSapMasterInformationBlock_methods(root_module, root_module['ns3::LteRrcSap::MasterInformationBlock'])
register_Ns3LteRrcSapMeasConfig_methods(root_module, root_module['ns3::LteRrcSap::MeasConfig'])
register_Ns3LteRrcSapMeasGapConfig_methods(root_module, root_module['ns3::LteRrcSap::MeasGapConfig'])
register_Ns3LteRrcSapMeasIdToAddMod_methods(root_module, root_module['ns3::LteRrcSap::MeasIdToAddMod'])
register_Ns3LteRrcSapMeasObjectEutra_methods(root_module, root_module['ns3::LteRrcSap::MeasObjectEutra'])
register_Ns3LteRrcSapMeasObjectToAddMod_methods(root_module, root_module['ns3::LteRrcSap::MeasObjectToAddMod'])
register_Ns3LteRrcSapMeasResultBestNeighCell_methods(root_module, root_module['ns3::LteRrcSap::MeasResultBestNeighCell'])
register_Ns3LteRrcSapMeasResultEutra_methods(root_module, root_module['ns3::LteRrcSap::MeasResultEutra'])
register_Ns3LteRrcSapMeasResultScell_methods(root_module, root_module['ns3::LteRrcSap::MeasResultScell'])
register_Ns3LteRrcSapMeasResultServFreqList_methods(root_module, root_module['ns3::LteRrcSap::MeasResultServFreqList'])
register_Ns3LteRrcSapMeasResults_methods(root_module, root_module['ns3::LteRrcSap::MeasResults'])
register_Ns3LteRrcSapMeasurementReport_methods(root_module, root_module['ns3::LteRrcSap::MeasurementReport'])
register_Ns3LteRrcSapMobilityControlInfo_methods(root_module, root_module['ns3::LteRrcSap::MobilityControlInfo'])
register_Ns3LteRrcSapMobilityStateParameters_methods(root_module, root_module['ns3::LteRrcSap::MobilityStateParameters'])
register_Ns3LteRrcSapNonCriticalExtensionConfiguration_methods(root_module, root_module['ns3::LteRrcSap::NonCriticalExtensionConfiguration'])
register_Ns3LteRrcSapNonUlConfiguration_methods(root_module, root_module['ns3::LteRrcSap::NonUlConfiguration'])
register_Ns3LteRrcSapPdschConfigCommon_methods(root_module, root_module['ns3::LteRrcSap::PdschConfigCommon'])
register_Ns3LteRrcSapPdschConfigDedicated_methods(root_module, root_module['ns3::LteRrcSap::PdschConfigDedicated'])
register_Ns3LteRrcSapPhysCellIdRange_methods(root_module, root_module['ns3::LteRrcSap::PhysCellIdRange'])
register_Ns3LteRrcSapPhysicalConfigDedicated_methods(root_module, root_module['ns3::LteRrcSap::PhysicalConfigDedicated'])
register_Ns3LteRrcSapPhysicalConfigDedicatedSCell_methods(root_module, root_module['ns3::LteRrcSap::PhysicalConfigDedicatedSCell'])
register_Ns3LteRrcSapPlmnIdentityInfo_methods(root_module, root_module['ns3::LteRrcSap::PlmnIdentityInfo'])
register_Ns3LteRrcSapPrachConfigSCell_methods(root_module, root_module['ns3::LteRrcSap::PrachConfigSCell'])
register_Ns3LteRrcSapPreambleInfo_methods(root_module, root_module['ns3::LteRrcSap::PreambleInfo'])
register_Ns3LteRrcSapPuschConfigDedicatedSCell_methods(root_module, root_module['ns3::LteRrcSap::PuschConfigDedicatedSCell'])
register_Ns3LteRrcSapQuantityConfig_methods(root_module, root_module['ns3::LteRrcSap::QuantityConfig'])
register_Ns3LteRrcSapRaSupervisionInfo_methods(root_module, root_module['ns3::LteRrcSap::RaSupervisionInfo'])
register_Ns3LteRrcSapRachConfigCommon_methods(root_module, root_module['ns3::LteRrcSap::RachConfigCommon'])
register_Ns3LteRrcSapRachConfigDedicated_methods(root_module, root_module['ns3::LteRrcSap::RachConfigDedicated'])
register_Ns3LteRrcSapRadioResourceConfigCommon_methods(root_module, root_module['ns3::LteRrcSap::RadioResourceConfigCommon'])
register_Ns3LteRrcSapRadioResourceConfigCommonSCell_methods(root_module, root_module['ns3::LteRrcSap::RadioResourceConfigCommonSCell'])
register_Ns3LteRrcSapRadioResourceConfigCommonSib_methods(root_module, root_module['ns3::LteRrcSap::RadioResourceConfigCommonSib'])
register_Ns3LteRrcSapRadioResourceConfigDedicated_methods(root_module, root_module['ns3::LteRrcSap::RadioResourceConfigDedicated'])
register_Ns3LteRrcSapRadioResourceConfigDedicatedSCell_methods(root_module, root_module['ns3::LteRrcSap::RadioResourceConfigDedicatedSCell'])
register_Ns3LteRrcSapReestabUeIdentity_methods(root_module, root_module['ns3::LteRrcSap::ReestabUeIdentity'])
register_Ns3LteRrcSapReportConfigEutra_methods(root_module, root_module['ns3::LteRrcSap::ReportConfigEutra'])
register_Ns3LteRrcSapReportConfigToAddMod_methods(root_module, root_module['ns3::LteRrcSap::ReportConfigToAddMod'])
register_Ns3LteRrcSapRlcConfig_methods(root_module, root_module['ns3::LteRrcSap::RlcConfig'])
register_Ns3LteRrcSapRrcConnectionReconfiguration_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionReconfiguration'])
register_Ns3LteRrcSapRrcConnectionReconfigurationCompleted_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionReconfigurationCompleted'])
register_Ns3LteRrcSapRrcConnectionReestablishment_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionReestablishment'])
register_Ns3LteRrcSapRrcConnectionReestablishmentComplete_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionReestablishmentComplete'])
register_Ns3LteRrcSapRrcConnectionReestablishmentReject_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionReestablishmentReject'])
register_Ns3LteRrcSapRrcConnectionReestablishmentRequest_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionReestablishmentRequest'])
register_Ns3LteRrcSapRrcConnectionReject_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionReject'])
register_Ns3LteRrcSapRrcConnectionRelease_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionRelease'])
register_Ns3LteRrcSapRrcConnectionRequest_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionRequest'])
register_Ns3LteRrcSapRrcConnectionSetup_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionSetup'])
register_Ns3LteRrcSapRrcConnectionSetupCompleted_methods(root_module, root_module['ns3::LteRrcSap::RrcConnectionSetupCompleted'])
register_Ns3LteRrcSapSCellToAddMod_methods(root_module, root_module['ns3::LteRrcSap::SCellToAddMod'])
register_Ns3LteRrcSapSoundingRsUlConfigCommon_methods(root_module, root_module['ns3::LteRrcSap::SoundingRsUlConfigCommon'])
register_Ns3LteRrcSapSoundingRsUlConfigDedicated_methods(root_module, root_module['ns3::LteRrcSap::SoundingRsUlConfigDedicated'])
register_Ns3LteRrcSapSpeedStatePars_methods(root_module, root_module['ns3::LteRrcSap::SpeedStatePars'])
register_Ns3LteRrcSapSpeedStateScaleFactors_methods(root_module, root_module['ns3::LteRrcSap::SpeedStateScaleFactors'])
register_Ns3LteRrcSapSrbToAddMod_methods(root_module, root_module['ns3::LteRrcSap::SrbToAddMod'])
register_Ns3LteRrcSapSystemInformation_methods(root_module, root_module['ns3::LteRrcSap::SystemInformation'])
register_Ns3LteRrcSapSystemInformationBlockType1_methods(root_module, root_module['ns3::LteRrcSap::SystemInformationBlockType1'])
register_Ns3LteRrcSapSystemInformationBlockType2_methods(root_module, root_module['ns3::LteRrcSap::SystemInformationBlockType2'])
register_Ns3LteRrcSapThresholdEutra_methods(root_module, root_module['ns3::LteRrcSap::ThresholdEutra'])
register_Ns3LteRrcSapUlConfiguration_methods(root_module, root_module['ns3::LteRrcSap::UlConfiguration'])
register_Ns3LteRrcSapUlPowerControlCommonSCell_methods(root_module, root_module['ns3::LteRrcSap::UlPowerControlCommonSCell'])
register_Ns3LteRrcSapUlPowerControlDedicatedSCell_methods(root_module, root_module['ns3::LteRrcSap::UlPowerControlDedicatedSCell'])
register_Ns3LteSpectrumValueCatcher_methods(root_module, root_module['ns3::LteSpectrumValueCatcher'])
register_Ns3LteSpectrumValueHelper_methods(root_module, root_module['ns3::LteSpectrumValueHelper'])
register_Ns3LteUeCcmRrcSapProvider_methods(root_module, root_module['ns3::LteUeCcmRrcSapProvider'])
register_Ns3LteUeCcmRrcSapProviderLcsConfig_methods(root_module, root_module['ns3::LteUeCcmRrcSapProvider::LcsConfig'])
register_Ns3LteUeCcmRrcSapUser_methods(root_module, root_module['ns3::LteUeCcmRrcSapUser'])
register_Ns3LteUeCmacSapProvider_methods(root_module, root_module['ns3::LteUeCmacSapProvider'])
register_Ns3LteUeCmacSapProviderLogicalChannelConfig_methods(root_module, root_module['ns3::LteUeCmacSapProvider::LogicalChannelConfig'])
register_Ns3LteUeCmacSapProviderRachConfig_methods(root_module, root_module['ns3::LteUeCmacSapProvider::RachConfig'])
register_Ns3LteUeCmacSapUser_methods(root_module, root_module['ns3::LteUeCmacSapUser'])
register_Ns3LteUeConfig_t_methods(root_module, root_module['ns3::LteUeConfig_t'])
register_Ns3LteUeCphySapProvider_methods(root_module, root_module['ns3::LteUeCphySapProvider'])
register_Ns3LteUeCphySapUser_methods(root_module, root_module['ns3::LteUeCphySapUser'])
register_Ns3LteUeCphySapUserUeMeasurementsElement_methods(root_module, root_module['ns3::LteUeCphySapUser::UeMeasurementsElement'])
register_Ns3LteUeCphySapUserUeMeasurementsParameters_methods(root_module, root_module['ns3::LteUeCphySapUser::UeMeasurementsParameters'])
register_Ns3LteUePhySapProvider_methods(root_module, root_module['ns3::LteUePhySapProvider'])
register_Ns3LteUePhySapUser_methods(root_module, root_module['ns3::LteUePhySapUser'])
register_Ns3LteUeRrcSapProvider_methods(root_module, root_module['ns3::LteUeRrcSapProvider'])
register_Ns3LteUeRrcSapProviderCompleteSetupParameters_methods(root_module, root_module['ns3::LteUeRrcSapProvider::CompleteSetupParameters'])
register_Ns3LteUeRrcSapUser_methods(root_module, root_module['ns3::LteUeRrcSapUser'])
register_Ns3LteUeRrcSapUserSetupParameters_methods(root_module, root_module['ns3::LteUeRrcSapUser::SetupParameters'])
register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address'])
register_Ns3Mac8Address_methods(root_module, root_module['ns3::Mac8Address'])
register_Ns3MacCeListElement_s_methods(root_module, root_module['ns3::MacCeListElement_s'])
register_Ns3MacCeValue_u_methods(root_module, root_module['ns3::MacCeValue_u'])
register_Ns3Names_methods(root_module, root_module['ns3::Names'])
register_Ns3NetDeviceContainer_methods(root_module, root_module['ns3::NetDeviceContainer'])
register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer'])
register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
register_Ns3ObjectDeleter_methods(root_module, root_module['ns3::ObjectDeleter'])
register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory'])
register_Ns3PacketMetadata_methods(root_module, root_module['ns3::PacketMetadata'])
register_Ns3PacketMetadataItem_methods(root_module, root_module['ns3::PacketMetadata::Item'])
register_Ns3PacketMetadataItemIterator_methods(root_module, root_module['ns3::PacketMetadata::ItemIterator'])
register_Ns3PacketTagIterator_methods(root_module, root_module['ns3::PacketTagIterator'])
register_Ns3PacketTagIteratorItem_methods(root_module, root_module['ns3::PacketTagIterator::Item'])
register_Ns3PacketTagList_methods(root_module, root_module['ns3::PacketTagList'])
register_Ns3PacketTagListTagData_methods(root_module, root_module['ns3::PacketTagList::TagData'])
register_Ns3PagingInfoListElement_s_methods(root_module, root_module['ns3::PagingInfoListElement_s'])
register_Ns3ParameterLogger_methods(root_module, root_module['ns3::ParameterLogger'])
register_Ns3PhichListElement_s_methods(root_module, root_module['ns3::PhichListElement_s'])
register_Ns3PhyReceptionStatParameters_methods(root_module, root_module['ns3::PhyReceptionStatParameters'])
register_Ns3PhyTransmissionStatParameters_methods(root_module, root_module['ns3::PhyTransmissionStatParameters'])
register_Ns3RachListElement_s_methods(root_module, root_module['ns3::RachListElement_s'])
register_Ns3RadioBearerStatsConnector_methods(root_module, root_module['ns3::RadioBearerStatsConnector'])
register_Ns3RealProtocolRlcSapUser_methods(root_module, root_module['ns3::RealProtocolRlcSapUser'])
register_Ns3RlcPduListElement_s_methods(root_module, root_module['ns3::RlcPduListElement_s'])
register_Ns3SbMeasResult_s_methods(root_module, root_module['ns3::SbMeasResult_s'])
register_Ns3SequenceNumber10_methods(root_module, root_module['ns3::SequenceNumber10'])
register_Ns3SiConfiguration_s_methods(root_module, root_module['ns3::SiConfiguration_s'])
register_Ns3SiMessageListElement_s_methods(root_module, root_module['ns3::SiMessageListElement_s'])
register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
register_Ns3SpsConfig_s_methods(root_module, root_module['ns3::SpsConfig_s'])
register_Ns3SrConfig_s_methods(root_module, root_module['ns3::SrConfig_s'])
register_Ns3SrListElement_s_methods(root_module, root_module['ns3::SrListElement_s'])
register_Ns3StatisticalSummary_methods(root_module, root_module['ns3::StatisticalSummary'])
register_Ns3Tag_methods(root_module, root_module['ns3::Tag'])
register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
register_Ns3TbId_t_methods(root_module, root_module['ns3::TbId_t'])
register_Ns3TbStats_t_methods(root_module, root_module['ns3::TbStats_t'])
register_Ns3TimeWithUnit_methods(root_module, root_module['ns3::TimeWithUnit'])
register_Ns3TransmissionModesLayers_methods(root_module, root_module['ns3::TransmissionModesLayers'])
register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
register_Ns3TypeIdAttributeInformation_methods(root_module, root_module['ns3::TypeId::AttributeInformation'])
register_Ns3TypeIdTraceSourceInformation_methods(root_module, root_module['ns3::TypeId::TraceSourceInformation'])
register_Ns3UeCapabilities_s_methods(root_module, root_module['ns3::UeCapabilities_s'])
register_Ns3UeSelected_s_methods(root_module, root_module['ns3::UeSelected_s'])
register_Ns3UlCqi_s_methods(root_module, root_module['ns3::UlCqi_s'])
register_Ns3UlDciListElement_s_methods(root_module, root_module['ns3::UlDciListElement_s'])
register_Ns3UlGrant_s_methods(root_module, root_module['ns3::UlGrant_s'])
register_Ns3UlInfoListElement_s_methods(root_module, root_module['ns3::UlInfoListElement_s'])
register_Ns3UplinkLteGlobalPathlossDatabase_methods(root_module, root_module['ns3::UplinkLteGlobalPathlossDatabase'])
register_Ns3Vector2D_methods(root_module, root_module['ns3::Vector2D'])
register_Ns3Vector3D_methods(root_module, root_module['ns3::Vector3D'])
register_Ns3VendorSpecificListElement_s_methods(root_module, root_module['ns3::VendorSpecificListElement_s'])
register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
register_Ns3FdbetsFlowPerf_t_methods(root_module, root_module['ns3::fdbetsFlowPerf_t'])
register_Ns3FdtbfqsFlowPerf_t_methods(root_module, root_module['ns3::fdtbfqsFlowPerf_t'])
register_Ns3Int64x64_t_methods(root_module, root_module['ns3::int64x64_t'])
register_Ns3PfsFlowPerf_t_methods(root_module, root_module['ns3::pfsFlowPerf_t'])
register_Ns3PssFlowPerf_t_methods(root_module, root_module['ns3::pssFlowPerf_t'])
register_Ns3TbInfo_t_methods(root_module, root_module['ns3::tbInfo_t'])
register_Ns3TdbetsFlowPerf_t_methods(root_module, root_module['ns3::tdbetsFlowPerf_t'])
register_Ns3TdtbfqsFlowPerf_t_methods(root_module, root_module['ns3::tdtbfqsFlowPerf_t'])
register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
register_Ns3DownlinkLteGlobalPathlossDatabase_methods(root_module, root_module['ns3::DownlinkLteGlobalPathlossDatabase'])
register_Ns3EpsBearer_methods(root_module, root_module['ns3::EpsBearer'])
register_Ns3EpsBearerTag_methods(root_module, root_module['ns3::EpsBearerTag'])
register_Ns3Header_methods(root_module, root_module['ns3::Header'])
register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])
register_Ns3LteCcmMacSapUser_methods(root_module, root_module['ns3::LteCcmMacSapUser'])
register_Ns3LteEnbRrcSapProvider_methods(root_module, root_module['ns3::LteEnbRrcSapProvider'])
register_Ns3LteEnbRrcSapProviderCompleteSetupUeParameters_methods(root_module, root_module['ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters'])
register_Ns3LteEnbRrcSapUser_methods(root_module, root_module['ns3::LteEnbRrcSapUser'])
register_Ns3LteEnbRrcSapUserSetupUeParameters_methods(root_module, root_module['ns3::LteEnbRrcSapUser::SetupUeParameters'])
register_Ns3LtePdcpHeader_methods(root_module, root_module['ns3::LtePdcpHeader'])
register_Ns3LtePhyTag_methods(root_module, root_module['ns3::LtePhyTag'])
register_Ns3LteRadioBearerTag_methods(root_module, root_module['ns3::LteRadioBearerTag'])
register_Ns3LteRlcAmHeader_methods(root_module, root_module['ns3::LteRlcAmHeader'])
register_Ns3LteRlcHeader_methods(root_module, root_module['ns3::LteRlcHeader'])
register_Ns3LteRlcSduStatusTag_methods(root_module, root_module['ns3::LteRlcSduStatusTag'])
register_Ns3Object_methods(root_module, root_module['ns3::Object'])
register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
register_Ns3PacketBurst_methods(root_module, root_module['ns3::PacketBurst'])
register_Ns3PdcpTag_methods(root_module, root_module['ns3::PdcpTag'])
register_Ns3PropagationDelayModel_methods(root_module, root_module['ns3::PropagationDelayModel'])
register_Ns3PropagationLossModel_methods(root_module, root_module['ns3::PropagationLossModel'])
register_Ns3RadioEnvironmentMapHelper_methods(root_module, root_module['ns3::RadioEnvironmentMapHelper'])
register_Ns3RandomPropagationDelayModel_methods(root_module, root_module['ns3::RandomPropagationDelayModel'])
register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])
register_Ns3RandomVariableStream_methods(root_module, root_module['ns3::RandomVariableStream'])
register_Ns3RangePropagationLossModel_methods(root_module, root_module['ns3::RangePropagationLossModel'])
register_Ns3RlcTag_methods(root_module, root_module['ns3::RlcTag'])
register_Ns3SequentialRandomVariable_methods(root_module, root_module['ns3::SequentialRandomVariable'])
register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])
register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])
register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])
register_Ns3SimpleRefCount__Ns3EpcTft_Ns3Empty_Ns3DefaultDeleter__lt__ns3EpcTft__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::EpcTft, ns3::empty, ns3::DefaultDeleter<ns3::EpcTft> >'])
register_Ns3SimpleRefCount__Ns3EpcTftClassifier_Ns3Empty_Ns3DefaultDeleter__lt__ns3EpcTftClassifier__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::EpcTftClassifier, ns3::empty, ns3::DefaultDeleter<ns3::EpcTftClassifier> >'])
register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])
register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter<ns3::Hash::Implementation> >'])
register_Ns3SimpleRefCount__Ns3Ipv4MulticastRoute_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv4MulticastRoute__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Ipv4MulticastRoute, ns3::empty, ns3::DefaultDeleter<ns3::Ipv4MulticastRoute> >'])
register_Ns3SimpleRefCount__Ns3Ipv4Route_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv4Route__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Ipv4Route, ns3::empty, ns3::DefaultDeleter<ns3::Ipv4Route> >'])
register_Ns3SimpleRefCount__Ns3LteChunkProcessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteChunkProcessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::LteChunkProcessor, ns3::empty, ns3::DefaultDeleter<ns3::LteChunkProcessor> >'])
register_Ns3SimpleRefCount__Ns3LteControlMessage_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteControlMessage__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::LteControlMessage, ns3::empty, ns3::DefaultDeleter<ns3::LteControlMessage> >'])
register_Ns3SimpleRefCount__Ns3LteHarqPhy_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteHarqPhy__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::LteHarqPhy, ns3::empty, ns3::DefaultDeleter<ns3::LteHarqPhy> >'])
register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >'])
register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
register_Ns3SimpleRefCount__Ns3SpectrumModel_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumModel__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::SpectrumModel, ns3::empty, ns3::DefaultDeleter<ns3::SpectrumModel> >'])
register_Ns3SimpleRefCount__Ns3SpectrumSignalParameters_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumSignalParameters__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::SpectrumSignalParameters, ns3::empty, ns3::DefaultDeleter<ns3::SpectrumSignalParameters> >'])
register_Ns3SimpleRefCount__Ns3SpectrumValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::SpectrumValue, ns3::empty, ns3::DefaultDeleter<ns3::SpectrumValue> >'])
register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])
register_Ns3SimpleRefCount__Ns3VendorSpecificValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3VendorSpecificValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::VendorSpecificValue, ns3::empty, ns3::DefaultDeleter<ns3::VendorSpecificValue> >'])
register_Ns3SimpleRefCount__Ns3X2CellInfo_Ns3Empty_Ns3DefaultDeleter__lt__ns3X2CellInfo__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::X2CellInfo, ns3::empty, ns3::DefaultDeleter<ns3::X2CellInfo> >'])
register_Ns3SimpleRefCount__Ns3X2IfaceInfo_Ns3Empty_Ns3DefaultDeleter__lt__ns3X2IfaceInfo__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::X2IfaceInfo, ns3::empty, ns3::DefaultDeleter<ns3::X2IfaceInfo> >'])
register_Ns3Socket_methods(root_module, root_module['ns3::Socket'])
register_Ns3SocketIpTosTag_methods(root_module, root_module['ns3::SocketIpTosTag'])
register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])
register_Ns3SocketIpv6HopLimitTag_methods(root_module, root_module['ns3::SocketIpv6HopLimitTag'])
register_Ns3SocketIpv6TclassTag_methods(root_module, root_module['ns3::SocketIpv6TclassTag'])
register_Ns3SocketPriorityTag_methods(root_module, root_module['ns3::SocketPriorityTag'])
register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])
register_Ns3SpectrumInterference_methods(root_module, root_module['ns3::SpectrumInterference'])
register_Ns3SpectrumModel_methods(root_module, root_module['ns3::SpectrumModel'])
register_Ns3SpectrumPhy_methods(root_module, root_module['ns3::SpectrumPhy'])
register_Ns3SpectrumPropagationLossModel_methods(root_module, root_module['ns3::SpectrumPropagationLossModel'])
register_Ns3SpectrumSignalParameters_methods(root_module, root_module['ns3::SpectrumSignalParameters'])
register_Ns3SpectrumValue_methods(root_module, root_module['ns3::SpectrumValue'])
register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer'])
register_Ns3TriangularRandomVariable_methods(root_module, root_module['ns3::TriangularRandomVariable'])
register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, root_module['ns3::TwoRayGroundPropagationLossModel'])
register_Ns3UeManager_methods(root_module, root_module['ns3::UeManager'])
register_Ns3UniformRandomVariable_methods(root_module, root_module['ns3::UniformRandomVariable'])
register_Ns3VendorSpecificValue_methods(root_module, root_module['ns3::VendorSpecificValue'])
register_Ns3WeibullRandomVariable_methods(root_module, root_module['ns3::WeibullRandomVariable'])
register_Ns3X2CellInfo_methods(root_module, root_module['ns3::X2CellInfo'])
register_Ns3X2IfaceInfo_methods(root_module, root_module['ns3::X2IfaceInfo'])
register_Ns3ZetaRandomVariable_methods(root_module, root_module['ns3::ZetaRandomVariable'])
register_Ns3ZipfRandomVariable_methods(root_module, root_module['ns3::ZipfRandomVariable'])
register_Ns3Application_methods(root_module, root_module['ns3::Application'])
register_Ns3Asn1Header_methods(root_module, root_module['ns3::Asn1Header'])
register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])
register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker'])
register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue'])
register_Ns3BooleanChecker_methods(root_module, root_module['ns3::BooleanChecker'])
register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue'])
register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker'])
register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])
register_Ns3CallbackValue_methods(root_module, root_module['ns3::CallbackValue'])
register_Ns3CcHelper_methods(root_module, root_module['ns3::CcHelper'])
register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])
register_Ns3ComponentCarrier_methods(root_module, root_module['ns3::ComponentCarrier'])
register_Ns3ComponentCarrierBaseStation_methods(root_module, root_module['ns3::ComponentCarrierBaseStation'])
register_Ns3ComponentCarrierEnb_methods(root_module, root_module['ns3::ComponentCarrierEnb'])
register_Ns3ComponentCarrierUe_methods(root_module, root_module['ns3::ComponentCarrierUe'])
register_Ns3ConstantRandomVariable_methods(root_module, root_module['ns3::ConstantRandomVariable'])
register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, root_module['ns3::ConstantSpeedPropagationDelayModel'])
register_Ns3DataCalculator_methods(root_module, root_module['ns3::DataCalculator'])
register_Ns3DataOutputInterface_methods(root_module, root_module['ns3::DataOutputInterface'])
register_Ns3DataRateChecker_methods(root_module, root_module['ns3::DataRateChecker'])
register_Ns3DataRateValue_methods(root_module, root_module['ns3::DataRateValue'])
register_Ns3DeterministicRandomVariable_methods(root_module, root_module['ns3::DeterministicRandomVariable'])
register_Ns3DoubleValue_methods(root_module, root_module['ns3::DoubleValue'])
register_Ns3EmpiricalRandomVariable_methods(root_module, root_module['ns3::EmpiricalRandomVariable'])
register_Ns3EmptyAttributeAccessor_methods(root_module, root_module['ns3::EmptyAttributeAccessor'])
register_Ns3EmptyAttributeChecker_methods(root_module, root_module['ns3::EmptyAttributeChecker'])
register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])
register_Ns3EnumChecker_methods(root_module, root_module['ns3::EnumChecker'])
register_Ns3EnumValue_methods(root_module, root_module['ns3::EnumValue'])
register_Ns3EpcEnbApplication_methods(root_module, root_module['ns3::EpcEnbApplication'])
register_Ns3EpcEnbApplicationEpsFlowId_t_methods(root_module, root_module['ns3::EpcEnbApplication::EpsFlowId_t'])
register_Ns3EpcHelper_methods(root_module, root_module['ns3::EpcHelper'])
register_Ns3EpcMme_methods(root_module, root_module['ns3::EpcMme'])
register_Ns3EpcMmeApplication_methods(root_module, root_module['ns3::EpcMmeApplication'])
register_Ns3EpcPgwApplication_methods(root_module, root_module['ns3::EpcPgwApplication'])
register_Ns3EpcSgwApplication_methods(root_module, root_module['ns3::EpcSgwApplication'])
register_Ns3EpcSgwPgwApplication_methods(root_module, root_module['ns3::EpcSgwPgwApplication'])
register_Ns3EpcTft_methods(root_module, root_module['ns3::EpcTft'])
register_Ns3EpcTftPacketFilter_methods(root_module, root_module['ns3::EpcTft::PacketFilter'])
register_Ns3EpcTftClassifier_methods(root_module, root_module['ns3::EpcTftClassifier'])
register_Ns3EpcUeNas_methods(root_module, root_module['ns3::EpcUeNas'])
register_Ns3EpcX2_methods(root_module, root_module['ns3::EpcX2'])
register_Ns3EpcX2HandoverPreparationFailureHeader_methods(root_module, root_module['ns3::EpcX2HandoverPreparationFailureHeader'])
register_Ns3EpcX2HandoverRequestAckHeader_methods(root_module, root_module['ns3::EpcX2HandoverRequestAckHeader'])
register_Ns3EpcX2HandoverRequestHeader_methods(root_module, root_module['ns3::EpcX2HandoverRequestHeader'])
register_Ns3EpcX2Header_methods(root_module, root_module['ns3::EpcX2Header'])
register_Ns3EpcX2LoadInformationHeader_methods(root_module, root_module['ns3::EpcX2LoadInformationHeader'])
register_Ns3EpcX2ResourceStatusUpdateHeader_methods(root_module, root_module['ns3::EpcX2ResourceStatusUpdateHeader'])
register_Ns3EpcX2SnStatusTransferHeader_methods(root_module, root_module['ns3::EpcX2SnStatusTransferHeader'])
register_Ns3EpcX2UeContextReleaseHeader_methods(root_module, root_module['ns3::EpcX2UeContextReleaseHeader'])
register_Ns3ErlangRandomVariable_methods(root_module, root_module['ns3::ErlangRandomVariable'])
register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])
register_Ns3ExponentialRandomVariable_methods(root_module, root_module['ns3::ExponentialRandomVariable'])
register_Ns3FfMacScheduler_methods(root_module, root_module['ns3::FfMacScheduler'])
register_Ns3FixedRssLossModel_methods(root_module, root_module['ns3::FixedRssLossModel'])
register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel'])
register_Ns3GammaRandomVariable_methods(root_module, root_module['ns3::GammaRandomVariable'])
register_Ns3GtpcHeader_methods(root_module, root_module['ns3::GtpcHeader'])
register_Ns3GtpcHeaderFteid_t_methods(root_module, root_module['ns3::GtpcHeader::Fteid_t'])
register_Ns3GtpcModifyBearerRequestMessage_methods(root_module, root_module['ns3::GtpcModifyBearerRequestMessage'])
register_Ns3GtpcModifyBearerRequestMessageBearerContextToBeModified_methods(root_module, root_module['ns3::GtpcModifyBearerRequestMessage::BearerContextToBeModified'])
register_Ns3GtpcModifyBearerResponseMessage_methods(root_module, root_module['ns3::GtpcModifyBearerResponseMessage'])
register_Ns3GtpuHeader_methods(root_module, root_module['ns3::GtpuHeader'])
register_Ns3IntegerValue_methods(root_module, root_module['ns3::IntegerValue'])
register_Ns3Ipv4_methods(root_module, root_module['ns3::Ipv4'])
register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])
register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])
register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])
register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])
register_Ns3Ipv6_methods(root_module, root_module['ns3::Ipv6'])
register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])
register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])
register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])
register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])
register_Ns3LogDistancePropagationLossModel_methods(root_module, root_module['ns3::LogDistancePropagationLossModel'])
register_Ns3LogNormalRandomVariable_methods(root_module, root_module['ns3::LogNormalRandomVariable'])
register_Ns3LteAmc_methods(root_module, root_module['ns3::LteAmc'])
register_Ns3LteAnr_methods(root_module, root_module['ns3::LteAnr'])
register_Ns3LteChunkProcessor_methods(root_module, root_module['ns3::LteChunkProcessor'])
register_Ns3LteControlMessage_methods(root_module, root_module['ns3::LteControlMessage'])
register_Ns3LteEnbComponentCarrierManager_methods(root_module, root_module['ns3::LteEnbComponentCarrierManager'])
register_Ns3LteEnbMac_methods(root_module, root_module['ns3::LteEnbMac'])
register_Ns3LteEnbRrc_methods(root_module, root_module['ns3::LteEnbRrc'])
register_Ns3LteEnbRrcProtocolIdeal_methods(root_module, root_module['ns3::LteEnbRrcProtocolIdeal'])
register_Ns3LteEnbRrcProtocolReal_methods(root_module, root_module['ns3::LteEnbRrcProtocolReal'])
register_Ns3LteFfrAlgorithm_methods(root_module, root_module['ns3::LteFfrAlgorithm'])
register_Ns3LteFfrDistributedAlgorithm_methods(root_module, root_module['ns3::LteFfrDistributedAlgorithm'])
register_Ns3LteFfrEnhancedAlgorithm_methods(root_module, root_module['ns3::LteFfrEnhancedAlgorithm'])
register_Ns3LteFfrSoftAlgorithm_methods(root_module, root_module['ns3::LteFfrSoftAlgorithm'])
register_Ns3LteFrHardAlgorithm_methods(root_module, root_module['ns3::LteFrHardAlgorithm'])
register_Ns3LteFrNoOpAlgorithm_methods(root_module, root_module['ns3::LteFrNoOpAlgorithm'])
register_Ns3LteFrSoftAlgorithm_methods(root_module, root_module['ns3::LteFrSoftAlgorithm'])
register_Ns3LteFrStrictAlgorithm_methods(root_module, root_module['ns3::LteFrStrictAlgorithm'])
register_Ns3LteHandoverAlgorithm_methods(root_module, root_module['ns3::LteHandoverAlgorithm'])
register_Ns3LteHarqPhy_methods(root_module, root_module['ns3::LteHarqPhy'])
register_Ns3LteHelper_methods(root_module, root_module['ns3::LteHelper'])
register_Ns3LteHexGridEnbTopologyHelper_methods(root_module, root_module['ns3::LteHexGridEnbTopologyHelper'])
register_Ns3LteInterference_methods(root_module, root_module['ns3::LteInterference'])
register_Ns3LtePdcp_methods(root_module, root_module['ns3::LtePdcp'])
register_Ns3LtePdcpStatus_methods(root_module, root_module['ns3::LtePdcp::Status'])
register_Ns3LtePhy_methods(root_module, root_module['ns3::LtePhy'])
register_Ns3LteRadioBearerInfo_methods(root_module, root_module['ns3::LteRadioBearerInfo'])
register_Ns3LteRlc_methods(root_module, root_module['ns3::LteRlc'])
register_Ns3LteRlcAm_methods(root_module, root_module['ns3::LteRlcAm'])
register_Ns3LteRlcSm_methods(root_module, root_module['ns3::LteRlcSm'])
register_Ns3LteRlcTm_methods(root_module, root_module['ns3::LteRlcTm'])
register_Ns3LteRlcUm_methods(root_module, root_module['ns3::LteRlcUm'])
register_Ns3LteSignalingRadioBearerInfo_methods(root_module, root_module['ns3::LteSignalingRadioBearerInfo'])
register_Ns3LteSpectrumPhy_methods(root_module, root_module['ns3::LteSpectrumPhy'])
register_Ns3LteSpectrumSignalParameters_methods(root_module, root_module['ns3::LteSpectrumSignalParameters'])
register_Ns3LteSpectrumSignalParametersDataFrame_methods(root_module, root_module['ns3::LteSpectrumSignalParametersDataFrame'])
register_Ns3LteSpectrumSignalParametersDlCtrlFrame_methods(root_module, root_module['ns3::LteSpectrumSignalParametersDlCtrlFrame'])
register_Ns3LteSpectrumSignalParametersUlSrsFrame_methods(root_module, root_module['ns3::LteSpectrumSignalParametersUlSrsFrame'])
register_Ns3LteStatsCalculator_methods(root_module, root_module['ns3::LteStatsCalculator'])
register_Ns3LteUeComponentCarrierManager_methods(root_module, root_module['ns3::LteUeComponentCarrierManager'])
register_Ns3LteUeMac_methods(root_module, root_module['ns3::LteUeMac'])
register_Ns3LteUePhy_methods(root_module, root_module['ns3::LteUePhy'])
register_Ns3LteUePowerControl_methods(root_module, root_module['ns3::LteUePowerControl'])
register_Ns3LteUeRrc_methods(root_module, root_module['ns3::LteUeRrc'])
register_Ns3LteUeRrcProtocolIdeal_methods(root_module, root_module['ns3::LteUeRrcProtocolIdeal'])
register_Ns3LteUeRrcProtocolReal_methods(root_module, root_module['ns3::LteUeRrcProtocolReal'])
register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])
register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
register_Ns3Mac64AddressChecker_methods(root_module, root_module['ns3::Mac64AddressChecker'])
register_Ns3Mac64AddressValue_methods(root_module, root_module['ns3::Mac64AddressValue'])
register_Ns3MacStatsCalculator_methods(root_module, root_module['ns3::MacStatsCalculator'])
register_Ns3MatrixPropagationLossModel_methods(root_module, root_module['ns3::MatrixPropagationLossModel'])
register_Ns3MibLteControlMessage_methods(root_module, root_module['ns3::MibLteControlMessage'])
register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >'])
register_Ns3MinMaxAvgTotalCalculator__Unsigned_long_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned long >'])
register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel'])
register_Ns3NakagamiPropagationLossModel_methods(root_module, root_module['ns3::NakagamiPropagationLossModel'])
register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])
register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector'])
register_Ns3NoOpComponentCarrierManager_methods(root_module, root_module['ns3::NoOpComponentCarrierManager'])
register_Ns3NoOpHandoverAlgorithm_methods(root_module, root_module['ns3::NoOpHandoverAlgorithm'])
register_Ns3Node_methods(root_module, root_module['ns3::Node'])
register_Ns3NormalRandomVariable_methods(root_module, root_module['ns3::NormalRandomVariable'])
register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker'])
register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue'])
register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
register_Ns3ParetoRandomVariable_methods(root_module, root_module['ns3::ParetoRandomVariable'])
register_Ns3PfFfMacScheduler_methods(root_module, root_module['ns3::PfFfMacScheduler'])
register_Ns3PhyRxStatsCalculator_methods(root_module, root_module['ns3::PhyRxStatsCalculator'])
register_Ns3PhyStatsCalculator_methods(root_module, root_module['ns3::PhyStatsCalculator'])
register_Ns3PhyTxStatsCalculator_methods(root_module, root_module['ns3::PhyTxStatsCalculator'])
register_Ns3PointToPointEpcHelper_methods(root_module, root_module['ns3::PointToPointEpcHelper'])
register_Ns3PointerChecker_methods(root_module, root_module['ns3::PointerChecker'])
register_Ns3PointerValue_methods(root_module, root_module['ns3::PointerValue'])
register_Ns3PssFfMacScheduler_methods(root_module, root_module['ns3::PssFfMacScheduler'])
register_Ns3RachPreambleLteControlMessage_methods(root_module, root_module['ns3::RachPreambleLteControlMessage'])
register_Ns3RadioBearerStatsCalculator_methods(root_module, root_module['ns3::RadioBearerStatsCalculator'])
register_Ns3RarLteControlMessage_methods(root_module, root_module['ns3::RarLteControlMessage'])
register_Ns3RarLteControlMessageRar_methods(root_module, root_module['ns3::RarLteControlMessage::Rar'])
register_Ns3RemSpectrumPhy_methods(root_module, root_module['ns3::RemSpectrumPhy'])
register_Ns3RrComponentCarrierManager_methods(root_module, root_module['ns3::RrComponentCarrierManager'])
register_Ns3RrFfMacScheduler_methods(root_module, root_module['ns3::RrFfMacScheduler'])
register_Ns3RrcAsn1Header_methods(root_module, root_module['ns3::RrcAsn1Header'])
register_Ns3RrcDlCcchMessage_methods(root_module, root_module['ns3::RrcDlCcchMessage'])
register_Ns3RrcDlDcchMessage_methods(root_module, root_module['ns3::RrcDlDcchMessage'])
register_Ns3RrcUlCcchMessage_methods(root_module, root_module['ns3::RrcUlCcchMessage'])
register_Ns3RrcUlDcchMessage_methods(root_module, root_module['ns3::RrcUlDcchMessage'])
register_Ns3Sib1LteControlMessage_methods(root_module, root_module['ns3::Sib1LteControlMessage'])
register_Ns3SimpleUeComponentCarrierManager_methods(root_module, root_module['ns3::SimpleUeComponentCarrierManager'])
register_Ns3SpectrumChannel_methods(root_module, root_module['ns3::SpectrumChannel'])
register_Ns3SrsCqiRntiVsp_methods(root_module, root_module['ns3::SrsCqiRntiVsp'])
register_Ns3StringChecker_methods(root_module, root_module['ns3::StringChecker'])
register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue'])
register_Ns3TdBetFfMacScheduler_methods(root_module, root_module['ns3::TdBetFfMacScheduler'])
register_Ns3TdMtFfMacScheduler_methods(root_module, root_module['ns3::TdMtFfMacScheduler'])
register_Ns3TdTbfqFfMacScheduler_methods(root_module, root_module['ns3::TdTbfqFfMacScheduler'])
register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
register_Ns3TtaFfMacScheduler_methods(root_module, root_module['ns3::TtaFfMacScheduler'])
register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])
register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])
register_Ns3UintegerValue_methods(root_module, root_module['ns3::UintegerValue'])
register_Ns3UlDciLteControlMessage_methods(root_module, root_module['ns3::UlDciLteControlMessage'])
register_Ns3Vector2DChecker_methods(root_module, root_module['ns3::Vector2DChecker'])
register_Ns3Vector2DValue_methods(root_module, root_module['ns3::Vector2DValue'])
register_Ns3Vector3DChecker_methods(root_module, root_module['ns3::Vector3DChecker'])
register_Ns3Vector3DValue_methods(root_module, root_module['ns3::Vector3DValue'])
register_Ns3VirtualNetDevice_methods(root_module, root_module['ns3::VirtualNetDevice'])
register_Ns3A2A4RsrqHandoverAlgorithm_methods(root_module, root_module['ns3::A2A4RsrqHandoverAlgorithm'])
register_Ns3A3RsrpHandoverAlgorithm_methods(root_module, root_module['ns3::A3RsrpHandoverAlgorithm'])
register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])
register_Ns3BsrLteControlMessage_methods(root_module, root_module['ns3::BsrLteControlMessage'])
register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<const ns3::Packet>, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<const ns3::Packet>, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Packet__gt___Const_ns3Address___amp___Const_ns3Address___amp___Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr<ns3::Packet>, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr<ns3::Socket>, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Const_ns3SpectrumValue___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, const ns3::SpectrumValue &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3DlSchedulingCallbackInfo_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::DlSchedulingCallbackInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3EpcUeNasState_Ns3EpcUeNasState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::EpcUeNas::State, ns3::EpcUeNas::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3PhyReceptionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::PhyReceptionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3PhyTransmissionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::PhyTransmissionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Ptr__lt__const_ns3MobilityModel__gt___Double_Double_Double_Double_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<const ns3::MobilityModel>, ns3::Ptr<const ns3::MobilityModel>, double, double, double, double, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<const ns3::MobilityModel>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<const ns3::Packet>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3PacketBurst__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<const ns3::PacketBurst>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3SpectrumPhy__gt___Ns3Ptr__lt__const_ns3SpectrumPhy__gt___Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<const ns3::SpectrumPhy>, ns3::Ptr<const ns3::SpectrumPhy>, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3LteUeRrc__gt___StdList__lt__ns3LteRrcSapSCellToAddMod__stdAllocator__lt__ns3LteRrcSapSCellToAddMod__gt_____gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<ns3::LteUeRrc>, std::list<ns3::LteRrcSap::SCellToAddMod, std::allocator<ns3::LteRrcSap::SCellToAddMod> >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<ns3::NetDevice>, ns3::Ptr<const ns3::Packet>, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<ns3::NetDevice>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<ns3::Packet>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<ns3::Socket>, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<ns3::Socket>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<ns3::Socket>, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3SpectrumSignalParameters__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr<ns3::SpectrumSignalParameters>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Unsigned_short_Unsigned_char_Unsigned_short_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned int, unsigned int, unsigned short, unsigned char, unsigned short, unsigned char, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteRrcSapMeasurementReport_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::LteRrcSap::MeasurementReport, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteUeRrcState_Ns3LteUeRrcState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::LteUeRrc::State, ns3::LteUeRrc::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3UeManagerState_Ns3UeManagerState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::UeManager::State, ns3::UeManager::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_short_Ns3Ptr__lt__ns3SpectrumValue__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, ns3::Ptr<ns3::SpectrumValue>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Unsigned_long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, unsigned long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Bool_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, bool, unsigned char, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3LteUePhyState_Ns3LteUePhyState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::LteUePhy::State, ns3::LteUePhy::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >'])
register_Ns3CqaFfMacScheduler_methods(root_module, root_module['ns3::CqaFfMacScheduler'])
register_Ns3DlCqiLteControlMessage_methods(root_module, root_module['ns3::DlCqiLteControlMessage'])
register_Ns3DlDciLteControlMessage_methods(root_module, root_module['ns3::DlDciLteControlMessage'])
register_Ns3DlHarqFeedbackLteControlMessage_methods(root_module, root_module['ns3::DlHarqFeedbackLteControlMessage'])
register_Ns3EmuEpcHelper_methods(root_module, root_module['ns3::EmuEpcHelper'])
register_Ns3FdBetFfMacScheduler_methods(root_module, root_module['ns3::FdBetFfMacScheduler'])
register_Ns3FdMtFfMacScheduler_methods(root_module, root_module['ns3::FdMtFfMacScheduler'])
register_Ns3FdTbfqFfMacScheduler_methods(root_module, root_module['ns3::FdTbfqFfMacScheduler'])
register_Ns3GtpcCreateSessionRequestMessage_methods(root_module, root_module['ns3::GtpcCreateSessionRequestMessage'])
register_Ns3GtpcCreateSessionRequestMessageBearerContextToBeCreated_methods(root_module, root_module['ns3::GtpcCreateSessionRequestMessage::BearerContextToBeCreated'])
register_Ns3GtpcCreateSessionResponseMessage_methods(root_module, root_module['ns3::GtpcCreateSessionResponseMessage'])
register_Ns3GtpcCreateSessionResponseMessageBearerContextCreated_methods(root_module, root_module['ns3::GtpcCreateSessionResponseMessage::BearerContextCreated'])
register_Ns3GtpcDeleteBearerCommandMessage_methods(root_module, root_module['ns3::GtpcDeleteBearerCommandMessage'])
register_Ns3GtpcDeleteBearerCommandMessageBearerContext_methods(root_module, root_module['ns3::GtpcDeleteBearerCommandMessage::BearerContext'])
register_Ns3GtpcDeleteBearerRequestMessage_methods(root_module, root_module['ns3::GtpcDeleteBearerRequestMessage'])
register_Ns3GtpcDeleteBearerResponseMessage_methods(root_module, root_module['ns3::GtpcDeleteBearerResponseMessage'])
register_Ns3HandoverPreparationInfoHeader_methods(root_module, root_module['ns3::HandoverPreparationInfoHeader'])
register_Ns3LteDataRadioBearerInfo_methods(root_module, root_module['ns3::LteDataRadioBearerInfo'])
register_Ns3LteEnbPhy_methods(root_module, root_module['ns3::LteEnbPhy'])
register_Ns3LteNetDevice_methods(root_module, root_module['ns3::LteNetDevice'])
register_Ns3LteUeNetDevice_methods(root_module, root_module['ns3::LteUeNetDevice'])
register_Ns3MeasurementReportHeader_methods(root_module, root_module['ns3::MeasurementReportHeader'])
register_Ns3RrcConnectionReconfigurationCompleteHeader_methods(root_module, root_module['ns3::RrcConnectionReconfigurationCompleteHeader'])
register_Ns3RrcConnectionReconfigurationHeader_methods(root_module, root_module['ns3::RrcConnectionReconfigurationHeader'])
register_Ns3RrcConnectionReestablishmentCompleteHeader_methods(root_module, root_module['ns3::RrcConnectionReestablishmentCompleteHeader'])
register_Ns3RrcConnectionReestablishmentHeader_methods(root_module, root_module['ns3::RrcConnectionReestablishmentHeader'])
register_Ns3RrcConnectionReestablishmentRejectHeader_methods(root_module, root_module['ns3::RrcConnectionReestablishmentRejectHeader'])
register_Ns3RrcConnectionReestablishmentRequestHeader_methods(root_module, root_module['ns3::RrcConnectionReestablishmentRequestHeader'])
register_Ns3RrcConnectionRejectHeader_methods(root_module, root_module['ns3::RrcConnectionRejectHeader'])
register_Ns3RrcConnectionReleaseHeader_methods(root_module, root_module['ns3::RrcConnectionReleaseHeader'])
register_Ns3RrcConnectionRequestHeader_methods(root_module, root_module['ns3::RrcConnectionRequestHeader'])
register_Ns3RrcConnectionSetupCompleteHeader_methods(root_module, root_module['ns3::RrcConnectionSetupCompleteHeader'])
register_Ns3RrcConnectionSetupHeader_methods(root_module, root_module['ns3::RrcConnectionSetupHeader'])
register_Ns3LteEnbNetDevice_methods(root_module, root_module['ns3::LteEnbNetDevice'])
register_Ns3ConfigMatchContainer_methods(root_module, root_module['ns3::Config::MatchContainer'])
register_Ns3HashImplementation_methods(root_module, root_module['ns3::Hash::Implementation'])
register_Ns3HashFunctionFnv1a_methods(root_module, root_module['ns3::Hash::Function::Fnv1a'])
register_Ns3HashFunctionHash32_methods(root_module, root_module['ns3::Hash::Function::Hash32'])
register_Ns3HashFunctionHash64_methods(root_module, root_module['ns3::Hash::Function::Hash64'])
register_Ns3HashFunctionMurmur3_methods(root_module, root_module['ns3::Hash::Function::Murmur3'])
return |
def sample_patches(datas, patch_size, n_samples, valid_inds=None, verbose=False):
((len(patch_size) == datas[0].ndim) or _raise(ValueError()))
if (not all(((a.shape == datas[0].shape) for a in datas))):
raise ValueError(('all input shapes must be the same: %s' % ' / '.join((str(a.shape) for a in datas))))
if (not all(((0 < s <= d) for (s, d) in zip(patch_size, datas[0].shape)))):
raise ValueError(('patch_size %s negative or larger than data shape %s along some dimensions' % (str(patch_size), str(datas[0].shape))))
if (valid_inds is None):
valid_inds = tuple((_s.ravel() for _s in np.meshgrid(*tuple((np.arange((p // 2), ((s - (p // 2)) + 1)) for (s, p) in zip(datas[0].shape, patch_size))))))
n_valid = len(valid_inds[0])
if (n_valid == 0):
raise ValueError('no regions to sample from!')
idx = choice(range(n_valid), n_samples, replace=(n_valid < n_samples))
rand_inds = [v[idx] for v in valid_inds]
res = [np.stack([data[tuple((slice((_r - (_p // 2)), ((_r + _p) - (_p // 2))) for (_r, _p) in zip(r, patch_size)))] for r in zip(*rand_inds)]) for data in datas]
return res |
.parametrize('dtype_in, dtype_out', [(np.float32, np.float32), (np.float64, np.float64), (int, np.float64)])
def test_transformer_dtypes_casting(dtype_in, dtype_out):
X = Xdigits[:100].astype(dtype_in)
rbm = BernoulliRBM(n_components=16, batch_size=5, n_iter=5, random_state=42)
Xt = rbm.fit_transform(X)
assert (Xt.dtype == dtype_out), 'transform dtype: {} - original dtype: {}'.format(Xt.dtype, X.dtype) |
class SrcInfoGuard():
def __init__(self, info_stack, info):
self.info_stack = info_stack
self.info = info
def __enter__(self):
self.info_stack.append(self.info)
def __exit__(self, exc_type, exc_val, exc_tb):
self.info_stack.pop() |
def createButtonsInfig(fig):
basis_ax = plt.axes([0.88, 0.44, 0.1, 0.075])
end_ax = plt.axes([0.78, 0.44, 0.1, 0.075])
bell2_ax = plt.axes([0.78, 0.365, 0.1, 0.075])
bell3_ax = plt.axes([0.88, 0.365, 0.1, 0.075])
h_ax_p = plt.axes([0.78, 0.83, 0.1, 0.075])
x_ax_p = plt.axes([0.78, 0.755, 0.1, 0.075])
cx_ax_p = plt.axes([0.78, 0.68, 0.1, 0.075])
zh_ax_p = plt.axes([0.78, 0.605, 0.1, 0.075])
ch_ax_p = plt.axes([0.78, 0.53, 0.1, 0.075])
h_button_p = Button(h_ax_p, 'H: ')
x_button_p = Button(x_ax_p, 'X: ')
cx_button_p = Button(cx_ax_p, 'CX: ')
ch_button_p = Button(ch_ax_p, 'CH: ')
zh_button_p = Button(zh_ax_p, 'ZH: ')
basis_button = Button(basis_ax, '0,1')
bell2_button = Button(bell2_ax, 'Bell2')
bell3_button = Button(bell3_ax, 'Bell3')
end_button = Button(end_ax, 'End')
buttonsDict = {'H': h_button_p, 'X': x_button_p, 'CX': cx_button_p, 'ZH': zh_button_p, 'CH': ch_button_p, 'Basis': basis_button, 'End': end_button, 'Bell2': bell2_button, 'Bell3': bell3_button}
h_patch = plt.Rectangle((0.88, 0.83), lw=0.75, width=0.1, height=0.075, edgecolor='black', linewidth=0.75, facecolor='White', transform=fig.transFigure)
x_patch = plt.Rectangle((0.88, 0.755), lw=0.75, width=0.1, height=0.075, edgecolor='black', linewidth=0.75, facecolor='White', transform=fig.transFigure)
cx_patch = plt.Rectangle((0.88, 0.68), lw=0.75, width=0.1, height=0.075, edgecolor='black', linewidth=0.75, facecolor='White', transform=fig.transFigure)
zh_patch = plt.Rectangle((0.88, 0.605), lw=0.75, width=0.1, height=0.075, edgecolor='black', linewidth=0.75, facecolor='White', transform=fig.transFigure)
ch_patch = plt.Rectangle((0.88, 0.53), lw=0.75, width=0.1, height=0.075, edgecolor='black', linewidth=0.75, facecolor='White', transform=fig.transFigure)
fig.patches.extend([h_patch])
fig.patches.extend([x_patch])
fig.patches.extend([cx_patch])
fig.patches.extend([zh_patch])
fig.patches.extend([ch_patch])
h_text = fig.text((0.88 + 0.05), (0.83 + (0.07 / 2)), 'H: ', horizontalalignment='center', verticalalignment='center', fontsize=12)
x_text = fig.text((0.88 + 0.05), (0.755 + (0.07 / 2)), 'X: ', horizontalalignment='center', verticalalignment='center', fontsize=12)
cx_text = fig.text((0.88 + 0.05), (0.68 + (0.07 / 2)), 'CX: ', horizontalalignment='center', verticalalignment='center', fontsize=12)
zh_text = fig.text((0.88 + 0.05), (0.605 + (0.07 / 2)), 'ZH: ', horizontalalignment='center', verticalalignment='center', fontsize=12)
ch_text = fig.text((0.88 + 0.05), (0.53 + (0.07 / 2)), 'CH: ', horizontalalignment='center', verticalalignment='center', fontsize=12)
patchDict = {'H_patch': h_patch, 'X_patch': x_patch, 'CX_patch': cx_patch, 'ZH_patch': zh_patch, 'CH_patch': ch_patch, 'H_text': h_text, 'X_text': x_text, 'CX_text': cx_text, 'ZH_text': zh_text, 'CH_text': ch_text}
fig.text((0.78 + 0.05), 0.93, 'Your Hand:', horizontalalignment='center', verticalalignment='center', fontsize=14)
fig.text((0.88 + 0.05), 0.93, 'Deck:', horizontalalignment='center', verticalalignment='center', fontsize=14)
gates = ['H', 'X', 'CX', 'CH', 'ZH']
notGates = ['Basis', 'End', 'Bell2', 'Bell3']
return (buttonsDict, gates, notGates, patchDict) |
class GrabBGZF_Random(object):
def __init__(self, filename):
self.reader = BgzfReader(filename, 'rt')
ch = self.reader.read(1)
if (ch == '>'):
iter_fn = my_fasta_iter
elif (ch == ''):
iter_fn = my_fastq_iter
else:
raise Exception('unknown start chr {}'.format(ch))
self.iter_fn = iter_fn
def get_sequence_at(self, pos):
self.reader.seek(pos)
record = next(self.iter_fn(self.reader))
return record |
def sac(variant):
expl_env = gym.make(variant['env_name'])
eval_env = gym.make(variant['env_name'])
expl_env.seed(variant['seed'])
eval_env.set_eval()
mode = variant['mode']
archi = variant['archi']
if (mode == 'her'):
variant['her'] = dict(observation_key='observation', desired_goal_key='desired_goal', achieved_goal_key='achieved_goal', representation_goal_key='representation_goal')
replay_buffer = get_replay_buffer(variant, expl_env)
(qf1, qf2, target_qf1, target_qf2, policy, shared_base) = get_networks(variant, expl_env)
expl_policy = policy
eval_policy = MakeDeterministic(policy)
(expl_path_collector, eval_path_collector) = get_path_collector(variant, expl_env, eval_env, expl_policy, eval_policy)
mode = variant['mode']
trainer = SACTrainer(env=eval_env, policy=policy, qf1=qf1, qf2=qf2, target_qf1=target_qf1, target_qf2=target_qf2, **variant['trainer_kwargs'])
if (mode == 'her'):
trainer = HERTrainer(trainer)
algorithm = TorchBatchRLAlgorithm(trainer=trainer, exploration_env=expl_env, evaluation_env=eval_env, exploration_data_collector=expl_path_collector, evaluation_data_collector=eval_path_collector, replay_buffer=replay_buffer, **variant['algorithm_kwargs'])
algorithm.to(ptu.device)
algorithm.train() |
def flow_through_node(flow_seq, target_node):
for i in range(len(flow_seq)):
((u, v), l) = flow_seq[i]
if (v == target_node):
assert (i < len(flow_seq))
((u_next, v_next), l_next) = flow_seq[(i + 1)]
assert (l == l_next)
assert (v == u_next)
return l
return 0.0 |
class BaseOptions():
def __init__(self):
self.parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
self.initialized = False
def initialize(self):
self.parser.add_argument('--dataroot', type=str, default='/home/u176443/Documents/ARPE/soccer_tracking/data/soccer_seg_detection/', help='path to images (should have subfolders trainA, trainB, valA, valB, etc)')
self.parser.add_argument('--loadSize', type=int, default=286, help='scale images to this size')
self.parser.add_argument('--fineSize', type=int, default=256, help='then crop to this size')
self.parser.add_argument('--input_nc', type=int, default=3, help='# of input image channels')
self.parser.add_argument('--output_nc', type=int, default=3, help='# of output image channels')
self.parser.add_argument('--ngf', type=int, default=64, help='# of gen filters in first conv layer')
self.parser.add_argument('--ndf', type=int, default=64, help='# of discrim filters in first conv layer')
self.parser.add_argument('--which_model_netD', type=str, default='basic', help='selects model to use for netD')
self.parser.add_argument('--which_model_netG', type=str, default='unet_256', help='selects model to use for netG')
self.parser.add_argument('--n_layers_D', type=int, default=3, help='only used if which_model_netD==n_layers')
self.parser.add_argument('--gpu_ids', type=str, default='0', help='gpu ids: e.g. 0 0,1,2, 0,2. use -1 for CPU')
self.parser.add_argument('--name', type=str, default='soccer_seg_detection_pix2pix', help='name of the experiment. It decides where to store samples and models')
self.parser.add_argument('--dataset_mode', type=str, default='two_aligned', help='chooses how datasets are loaded. [unaligned | aligned | single]')
self.parser.add_argument('--model', type=str, default='two_pix2pix', help='chooses which model to use. cycle_gan, pix2pix, test, ')
self.parser.add_argument('--which_direction', type=str, default='AtoB', help='AtoB or BtoA')
self.parser.add_argument('--nThreads', default=2, type=int, help='# threads for loading data')
self.parser.add_argument('--checkpoints_dir', type=str, default='./checkpoints', help='models are saved here')
self.parser.add_argument('--norm', type=str, default='instance', help='instance normalization or batch normalization')
self.parser.add_argument('--serial_batches', action='store_true', help='if true, takes images in order to make batches, otherwise takes them randomly')
self.parser.add_argument('--display_winsize', type=int, default=256, help='display window size')
self.parser.add_argument('--display_id', type=int, default=1, help='window id of the web display')
self.parser.add_argument('--display_port', type=int, default=8097, help='visdom port of the web display')
self.parser.add_argument('--no_dropout', action='store_true', help='no dropout for the generator')
self.parser.add_argument('--max_dataset_size', type=int, default=float('inf'), help='Maximum number of samples allowed per dataset. If the dataset directory contains more than max_dataset_size, only a subset is loaded.')
self.parser.add_argument('--resize_or_crop', type=str, default='resize_and_crop', help='scaling and cropping of images at load time [resize_and_crop|crop|scale_width|scale_width_and_crop]')
self.parser.add_argument('--no_flip', action='store_true', help='if specified, do not flip the images for data augmentation')
self.parser.add_argument('--init_type', type=str, default='normal', help='network initialization [normal|xavier|kaiming|orthogonal]')
self.parser.add_argument('--batchSize', type=int, default=1, help='input batch size')
self.initialized = True
def parse(self):
if (not self.initialized):
self.initialize()
self.opt = self.parser.parse_args()
self.opt.isTrain = self.isTrain
str_ids = self.opt.gpu_ids.split(',')
self.opt.gpu_ids = []
for str_id in str_ids:
id = int(str_id)
if (id >= 0):
self.opt.gpu_ids.append(id)
if (len(self.opt.gpu_ids) > 0):
torch.cuda.set_device(self.opt.gpu_ids[0])
args = vars(self.opt)
print(' Options ')
for (k, v) in sorted(args.items()):
print(('%s: %s' % (str(k), str(v))))
print(' End ')
expr_dir = os.path.join(self.opt.checkpoints_dir, self.opt.name)
util.mkdirs(expr_dir)
file_name = os.path.join(expr_dir, 'opt.txt')
with open(file_name, 'wt') as opt_file:
opt_file.write(' Options \n')
for (k, v) in sorted(args.items()):
opt_file.write(('%s: %s\n' % (str(k), str(v))))
opt_file.write(' End \n')
return self.opt |
def test_get_component_order_mapping():
dataset = sbd.DummyDataset(missing_components='pad')
with pytest.raises(AssertionError):
get_component_order_mapping(dataset)
dataset.missing_components = 'ignore'
dataset._metadata.loc[(0, 'trace_component_order')] = 'Z'
dataset._metadata.loc[(1, 'trace_component_order')] = 'ZN'
dataset._metadata.loc[(2, 'trace_component_order')] = 'EN'
dataset._metadata.loc[(3, 'trace_component_order')] = 'NEZ'
dataset._metadata.loc[(4, 'trace_component_order')] = 'NZ'
mapping = get_component_order_mapping(dataset)
assert (len(mapping) == 6)
assert (mapping['Z'] == 'Z')
assert (mapping['ZN'] == 'ZN')
assert (mapping['ZNE'] == 'ZNE')
assert (mapping['EN'] == 'NE')
assert (mapping['NEZ'] == 'ZNE')
assert (mapping['NZ'] == 'ZN')
dataset._metadata.loc[(1, 'trace_component_order')] = 'ZH'
with pytest.raises(ValueError):
get_component_order_mapping(dataset) |
def profiling(model, use_cuda):
print('Start model profiling, use_cuda:{}.'.format(use_cuda))
for width_mult in sorted(FLAGS.width_mult_list, reverse=True):
model.apply((lambda m: setattr(m, 'width_mult', width_mult)))
print('Model profiling with width mult {}x:'.format(width_mult))
verbose = (width_mult == max(FLAGS.width_mult_list))
model_profiling(model, FLAGS.image_size, FLAGS.image_size, verbose=getattr(FLAGS, 'model_profiling_verbose', verbose)) |
_model_architecture('masked_lm', 'bert_base')
def bert_base_architecture(args):
args.encoder_embed_dim = getattr(args, 'encoder_embed_dim', 768)
args.share_encoder_input_output_embed = getattr(args, 'share_encoder_input_output_embed', True)
args.no_token_positional_embeddings = getattr(args, 'no_token_positional_embeddings', False)
args.encoder_learned_pos = getattr(args, 'encoder_learned_pos', True)
args.num_segment = getattr(args, 'num_segment', 2)
args.encoder_layers = getattr(args, 'encoder_layers', 12)
args.encoder_attention_heads = getattr(args, 'encoder_attention_heads', 12)
args.encoder_ffn_embed_dim = getattr(args, 'encoder_ffn_embed_dim', 3072)
args.sentence_class_num = getattr(args, 'sentence_class_num', 2)
args.sent_loss = getattr(args, 'sent_loss', True)
args.apply_bert_init = getattr(args, 'apply_bert_init', True)
args.activation_fn = getattr(args, 'activation_fn', 'gelu')
args.pooler_activation_fn = getattr(args, 'pooler_activation_fn', 'tanh')
args.encoder_normalize_before = getattr(args, 'encoder_normalize_before', True)
base_architecture(args) |
class TestSimpleInterpreter(unittest.TestCase):
def setUp(self):
self._builder = D.Builder(spec)
self._interp = BoolInterpreter()
self._domain = [False, True]
def test_interpreter0(self):
b = self._builder
p0 = b.make_param(0)
p1 = b.make_param(1)
p = b.make_apply('and', [p0, p1])
for (x, y) in product(self._domain, self._domain):
out_value = self._interp.eval(p, [x, y])
expect_value = (x and y)
self.assertEqual(out_value, expect_value)
def test_interpreter1(self):
b = self._builder
p = b.from_sexp_string('(and (const (BoolLit "true")) (const (BoolLit "false")))')
for (x, y) in product(self._domain, self._domain):
out_value = self._interp.eval(p, [x, y])
expect_value = False
self.assertEqual(out_value, expect_value)
def test_interpreter2(self):
b = self._builder
p0 = b.make_param(0)
p1 = b.make_param(1)
np0 = b.make_apply('not', [p0])
p = b.make_apply('or', [np0, p1])
for (x, y) in product(self._domain, self._domain):
out_value = self._interp.eval(p, [x, y])
expect_value = ((not x) or y)
self.assertEqual(out_value, expect_value)
def test_context(self):
b = self._builder
p0 = b.make_param(0)
p1 = b.make_param(1)
lit = b.make_enum('BoolLit', 'true')
c = b.make_apply('const', [lit])
ap0 = b.make_apply('assertTrue', [p0])
acap0 = b.make_apply('and', [c, ap0])
nacap0 = b.make_apply('not', [acap0])
p = b.make_apply('or', [nacap0, p1])
try:
self._interp.eval(p, [False, True])
except GeneralError as e:
ctx = e.context
self.assertIsNotNone(ctx)
self.assertListEqual(ctx.stack, [p, nacap0, acap0])
self.assertListEqual(ctx.observed, [p, nacap0, acap0, c, lit, ap0, p0])
self.assertListEqual(ctx.evaluated, [lit, c, p0]) |
class Preprocess():
def __init__(self, dialect, script, numeral='Latin'):
with open(klpt.get_data('data/preprocess_map.json'), encoding='utf-8') as preprocess_file:
self.preprocess_map = json.load(preprocess_file)
configuration = Configuration({'dialect': dialect, 'script': script, 'numeral': numeral})
self.dialect = configuration.dialect
self.script = configuration.script
self.numeral = configuration.numeral
with open(klpt.data_directory['stopwords'], 'r', encoding='utf-8') as f:
self.stopwords = json.load(f)[dialect][script]
def standardize(self, text):
temp_text = ((' ' + self.unify_numerals(text)) + ' ')
for standardization_type in [self.dialect]:
for rep in self.preprocess_map['standardizer'][standardization_type][self.script]:
rep_tar = self.preprocess_map['standardizer'][standardization_type][self.script][rep]
temp_text = re.sub(f'{rep}', f'{rep_tar}', temp_text, flags=re.I)
return temp_text.strip()
def normalize(self, text):
temp_text = ((' ' + self.unify_numerals(text)) + ' ')
for normalization_type in ['universal', self.dialect]:
for rep in self.preprocess_map['normalizer'][normalization_type][self.script]:
rep_tar = self.preprocess_map['normalizer'][normalization_type][self.script][rep]
temp_text = re.sub(f'{rep}', f'{rep_tar}', temp_text, flags=re.I)
return temp_text.strip()
def unify_numerals(self, text):
for (i, j) in self.preprocess_map['normalizer']['universal']['numerals'][self.numeral].items():
text = text.replace(i, j)
return text
def preprocess(self, text):
return self.unify_numerals(self.standardize(self.normalize(text))) |
def sequence_to_code(sequence, code_dict):
id_to_code = {i: c for (c, i) in code_dict.items()}
return ' '.join([id_to_code[i] for i in sequence]) |
class TestSequenceGenerator(unittest.TestCase):
def setUp(self):
(self.tgt_dict, self.w1, self.w2, src_tokens, src_lengths, self.model) = test_utils.sequence_generator_setup()
self.encoder_input = {'src_tokens': src_tokens, 'src_lengths': src_lengths}
def test_with_normalization(self):
generator = SequenceGenerator([self.model], self.tgt_dict)
hypos = generator.generate(self.encoder_input, beam_size=2)
(eos, w1, w2) = (self.tgt_dict.eos(), self.w1, self.w2)
self.assertHypoTokens(hypos[0][0], [w1, eos])
self.assertHypoScore(hypos[0][0], [0.9, 1.0])
self.assertHypoTokens(hypos[0][1], [w2, w1, w2, eos])
self.assertHypoScore(hypos[0][1], [0.1, 0.9, 0.9, 1.0])
self.assertHypoTokens(hypos[1][0], [w1, w2, w1, eos])
self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.4, 1.0])
self.assertHypoTokens(hypos[1][1], [w1, w2, eos])
self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.6])
def test_without_normalization(self):
generator = SequenceGenerator([self.model], self.tgt_dict, normalize_scores=False)
hypos = generator.generate(self.encoder_input, beam_size=2)
(eos, w1, w2) = (self.tgt_dict.eos(), self.w1, self.w2)
self.assertHypoTokens(hypos[0][0], [w1, eos])
self.assertHypoScore(hypos[0][0], [0.9, 1.0], normalized=False)
self.assertHypoTokens(hypos[0][1], [w2, w1, w2, eos])
self.assertHypoScore(hypos[0][1], [0.1, 0.9, 0.9, 1.0], normalized=False)
self.assertHypoTokens(hypos[1][0], [w1, w2, eos])
self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.6], normalized=False)
self.assertHypoTokens(hypos[1][1], [w1, w2, w1, eos])
self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.4, 1.0], normalized=False)
def test_with_lenpen_favoring_short_hypos(self):
lenpen = 0.6
generator = SequenceGenerator([self.model], self.tgt_dict, len_penalty=lenpen)
hypos = generator.generate(self.encoder_input, beam_size=2)
(eos, w1, w2) = (self.tgt_dict.eos(), self.w1, self.w2)
self.assertHypoTokens(hypos[0][0], [w1, eos])
self.assertHypoScore(hypos[0][0], [0.9, 1.0], lenpen=lenpen)
self.assertHypoTokens(hypos[0][1], [w2, w1, w2, eos])
self.assertHypoScore(hypos[0][1], [0.1, 0.9, 0.9, 1.0], lenpen=lenpen)
self.assertHypoTokens(hypos[1][0], [w1, w2, eos])
self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.6], lenpen=lenpen)
self.assertHypoTokens(hypos[1][1], [w1, w2, w1, eos])
self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.4, 1.0], lenpen=lenpen)
def test_with_lenpen_favoring_long_hypos(self):
lenpen = 5.0
generator = SequenceGenerator([self.model], self.tgt_dict, len_penalty=lenpen)
hypos = generator.generate(self.encoder_input, beam_size=2)
(eos, w1, w2) = (self.tgt_dict.eos(), self.w1, self.w2)
self.assertHypoTokens(hypos[0][0], [w2, w1, w2, eos])
self.assertHypoScore(hypos[0][0], [0.1, 0.9, 0.9, 1.0], lenpen=lenpen)
self.assertHypoTokens(hypos[0][1], [w1, eos])
self.assertHypoScore(hypos[0][1], [0.9, 1.0], lenpen=lenpen)
self.assertHypoTokens(hypos[1][0], [w1, w2, w1, eos])
self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.4, 1.0], lenpen=lenpen)
self.assertHypoTokens(hypos[1][1], [w1, w2, eos])
self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.6], lenpen=lenpen)
def test_maxlen(self):
generator = SequenceGenerator([self.model], self.tgt_dict, maxlen=2)
hypos = generator.generate(self.encoder_input, beam_size=2)
(eos, w1, w2) = (self.tgt_dict.eos(), self.w1, self.w2)
self.assertHypoTokens(hypos[0][0], [w1, eos])
self.assertHypoScore(hypos[0][0], [0.9, 1.0])
self.assertHypoTokens(hypos[0][1], [w2, w2, eos])
self.assertHypoScore(hypos[0][1], [0.1, 0.1, 0.6])
self.assertHypoTokens(hypos[1][0], [w1, w2, eos])
self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.6])
self.assertHypoTokens(hypos[1][1], [w2, w2, eos])
self.assertHypoScore(hypos[1][1], [0.3, 0.9, 0.01])
def test_no_stop_early(self):
generator = SequenceGenerator([self.model], self.tgt_dict, stop_early=False)
hypos = generator.generate(self.encoder_input, beam_size=2)
(eos, w1, w2) = (self.tgt_dict.eos(), self.w1, self.w2)
self.assertHypoTokens(hypos[0][0], [w1, eos])
self.assertHypoScore(hypos[0][0], [0.9, 1.0])
self.assertHypoTokens(hypos[0][1], [w2, w1, w2, eos])
self.assertHypoScore(hypos[0][1], [0.1, 0.9, 0.9, 1.0])
self.assertHypoTokens(hypos[1][0], [w2, w2, w2, w2, eos])
self.assertHypoScore(hypos[1][0], [0.3, 0.9, 0.99, 0.4, 1.0])
self.assertHypoTokens(hypos[1][1], [w1, w2, w1, eos])
self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.4, 1.0])
def assertHypoTokens(self, hypo, tokens):
self.assertTensorEqual(hypo['tokens'], torch.LongTensor(tokens))
def assertHypoScore(self, hypo, pos_probs, normalized=True, lenpen=1.0):
pos_scores = torch.FloatTensor(pos_probs).log()
self.assertAlmostEqual(hypo['positional_scores'], pos_scores)
self.assertEqual(pos_scores.numel(), hypo['tokens'].numel())
score = pos_scores.sum()
if normalized:
score /= (pos_scores.numel() ** lenpen)
self.assertLess(abs((score - hypo['score'])), 1e-06)
def assertAlmostEqual(self, t1, t2):
self.assertEqual(t1.size(), t2.size(), 'size mismatch')
self.assertLess((t1 - t2).abs().max(), 0.0001)
def assertTensorEqual(self, t1, t2):
self.assertEqual(t1.size(), t2.size(), 'size mismatch')
self.assertEqual(t1.ne(t2).long().sum(), 0) |
class ResNet(nn.Module):
def __init__(self, orig_resnet):
super(ResNet, self).__init__()
self.conv1 = orig_resnet.conv1
self.bn1 = orig_resnet.bn1
self.relu1 = orig_resnet.relu1
self.conv2 = orig_resnet.conv2
self.bn2 = orig_resnet.bn2
self.relu2 = orig_resnet.relu2
self.conv3 = orig_resnet.conv3
self.bn3 = orig_resnet.bn3
self.relu3 = orig_resnet.relu3
self.maxpool = orig_resnet.maxpool
self.layer1 = orig_resnet.layer1
self.layer2 = orig_resnet.layer2
self.layer3 = orig_resnet.layer3
self.layer4 = orig_resnet.layer4
def forward(self, x):
x = self.relu1(self.bn1(self.conv1(x)))
x = self.relu2(self.bn2(self.conv2(x)))
x1 = self.relu3(self.bn3(self.conv3(x)))
x = self.maxpool(x1)
x2 = self.layer1(x)
x3 = self.layer2(x2)
x4 = self.layer3(x3)
x5 = self.layer4(x4)
return (x1, x2, x3, x4, x5) |
class Extractor():
keepLinks = False
keepSections = True
HtmlFormatting = False
toJson = False
def __init__(self, id, revid, urlbase, title, page):
self.id = id
self.revid = revid
self.url = get_url(urlbase, id)
self.title = title
self.page = page
self.magicWords = MagicWords()
self.frame = []
self.recursion_exceeded_1_errs = 0
self.recursion_exceeded_2_errs = 0
self.recursion_exceeded_3_errs = 0
self.template_title_errs = 0
def clean_text(self, text, mark_headers=False, expand_templates=False, html_safe=True):
self.magicWords['pagename'] = self.title
self.magicWords['fullpagename'] = self.title
self.magicWords['currentyear'] = time.strftime('%Y')
self.magicWords['currentmonth'] = time.strftime('%m')
self.magicWords['currentday'] = time.strftime('%d')
self.magicWords['currenthour'] = time.strftime('%H')
self.magicWords['currenttime'] = time.strftime('%H:%M:%S')
text = clean(self, text, expand_templates=expand_templates, html_safe=html_safe)
text = compact(text, mark_headers=mark_headers)
return text
def extract(self, out, html_safe=True):
logging.debug('%s\t%s', self.id, self.title)
text = ''.join(self.page)
text = self.clean_text(text, html_safe=html_safe)
if self.to_json:
json_data = {'id': self.id, 'revid': self.revid, 'url': self.url, 'title': self.title, 'text': '\n'.join(text)}
out_str = json.dumps(json_data)
out.write(out_str)
out.write('\n')
else:
header = ('<doc id="%s" url="%s" title="%s">\n' % (self.id, self.url, self.title))
header += (self.title + '\n\n')
footer = '\n</doc>\n'
out.write(header)
out.write('\n'.join(text))
out.write('\n')
out.write(footer)
errs = (self.template_title_errs, self.recursion_exceeded_1_errs, self.recursion_exceeded_2_errs, self.recursion_exceeded_3_errs)
if any(errs):
logging.warn("Template errors in article '%s' (%s): title(%d) recursion(%d, %d, %d)", self.title, self.id, *errs)
maxTemplateRecursionLevels = 30
maxParameterRecursionLevels = 10
reOpen = re.compile('(?<!{){{(?!{)', re.DOTALL)
def expandTemplates(self, wikitext):
res = ''
if (len(self.frame) >= self.maxTemplateRecursionLevels):
self.recursion_exceeded_1_errs += 1
return res
cur = 0
for (s, e) in findMatchingBraces(wikitext, 2):
res += (wikitext[cur:s] + self.expandTemplate(wikitext[(s + 2):(e - 2)]))
cur = e
res += wikitext[cur:]
return res
def templateParams(self, parameters):
templateParams = {}
if (not parameters):
return templateParams
logging.debug('<templateParams: %s', '|'.join(parameters))
unnamedParameterCounter = 0
for param in parameters:
m = re.match(' *([^=]*?) *=(.*)', param, re.DOTALL)
if m:
parameterName = m.group(1).strip()
parameterValue = m.group(2)
if (']]' not in parameterValue):
parameterValue = parameterValue.strip()
templateParams[parameterName] = parameterValue
else:
unnamedParameterCounter += 1
if (']]' not in param):
param = param.strip()
templateParams[str(unnamedParameterCounter)] = param
logging.debug(' templateParams> %s', '|'.join(templateParams.values()))
return templateParams
def expandTemplate(self, body):
if (len(self.frame) >= self.maxTemplateRecursionLevels):
self.recursion_exceeded_2_errs += 1
return ''
logging.debug('INVOCATION %d %s', len(self.frame), body)
parts = splitParts(body)
logging.debug('TITLE %s', parts[0].strip())
title = self.expandTemplates(parts[0].strip())
subst = False
if re.match(substWords, title, re.IGNORECASE):
title = re.sub(substWords, '', title, 1, re.IGNORECASE)
subst = True
if (title.lower() in self.magicWords.values):
return self.magicWords[title.lower()]
colon = title.find(':')
if (colon > 1):
funct = title[:colon]
parts[0] = title[(colon + 1):].strip()
ret = callParserFunction(funct, parts, self.frame)
return self.expandTemplates(ret)
title = fullyQualifiedTemplateTitle(title)
if (not title):
self.template_title_errs += 1
return ''
redirected = redirects.get(title)
if redirected:
title = redirected
if (title in templateCache):
template = templateCache[title]
elif (title in templates):
template = Template.parse(templates[title])
templateCache[title] = template
del templates[title]
else:
return ''
params = parts[1:]
if (not subst):
params = [self.expandTemplates(p) for p in params]
params = self.templateParams(params)
self.frame.append((title, params))
instantiated = template.subst(params, self)
value = self.expandTemplates(instantiated)
self.frame.pop()
return value |
def infer_dataset_impl(path):
if IndexedRawTextDataset.exists(path):
return 'raw'
elif IndexedDataset.exists(path):
with open(index_file_path(path), 'rb') as f:
magic = f.read(8)
if (magic == IndexedDataset._HDR_MAGIC):
return 'cached'
elif (magic == MMapIndexedDataset.Index._HDR_MAGIC[:8]):
return 'mmap'
else:
return None
else:
return None |
class FP16Compressor(Compressor):
def compress(tensor, name=None):
tensor_compressed = tensor
if tensor.dtype.is_floating_point:
tensor_compressed = tensor.type(torch.float16)
return (tensor_compressed, tensor.dtype)
def decompress(tensor, ctx):
tensor_decompressed = tensor
dtype = ctx
if dtype.is_floating_point:
tensor_decompressed = tensor.type(dtype)
return tensor_decompressed |
class TestVoronoiFPS(TestFPS):
def setUp(self):
super().setUp()
def test_restart(self):
selector = VoronoiFPS(n_to_select=1, initialize=self.idx[0])
selector.fit(self.X)
for i in range(2, len(self.idx)):
selector.n_to_select = i
selector.fit(self.X, warm_start=True)
self.assertEqual(selector.selected_idx_[(i - 1)], self.idx[(i - 1)])
def test_initialize(self):
for initialize in [self.idx[0], 'random']:
with self.subTest(initialize=initialize):
selector = VoronoiFPS(n_to_select=1, initialize=initialize)
selector.fit(self.X)
with self.assertRaises(ValueError) as cm:
selector = VoronoiFPS(n_to_select=1, initialize='bad')
selector.fit(self.X)
self.assertEquals(str(cm.exception), 'Invalid value of the initialize parameter')
def test_switching_point(self):
selector = VoronoiFPS(n_to_select=1)
selector.fit(self.X)
self.assertTrue((1 > selector.full_fraction))
selector = VoronoiFPS(n_to_select=1, full_fraction=0.5)
selector.fit(self.X)
self.assertEqual(selector.full_fraction, 0.5)
with self.subTest(name='bad_ntrial'):
with self.assertRaises(ValueError) as cm:
selector = VoronoiFPS(n_to_select=1, n_trial_calculation=0)
selector.fit(self.X)
self.assertEqual(str(cm.exception), 'Number of trial calculation should be more or equal to 1')
with self.subTest(name='float_ntrial'):
with self.assertRaises(TypeError) as cm:
selector = VoronoiFPS(n_to_select=1, n_trial_calculation=0.3)
selector.fit(self.X)
self.assertEqual(str(cm.exception), 'Number of trial calculation should be integer')
with self.subTest(name='large_ff'):
with self.assertRaises(ValueError) as cm:
selector = VoronoiFPS(n_to_select=1, full_fraction=1.1)
selector.fit(self.X)
self.assertEqual(str(cm.exception), f'Switching point should be real and more than 0 and less than 1. Received {selector.full_fraction}')
with self.subTest(name='string_ff'):
with self.assertRaises(ValueError) as cm:
selector = VoronoiFPS(n_to_select=1, full_fraction='STRING')
selector.fit(self.X)
self.assertEqual(str(cm.exception), f'Switching point should be real and more than 0 and less than 1. Received {selector.full_fraction}')
def test_get_distances(self):
selector = VoronoiFPS(n_to_select=1)
selector.fit(self.X)
_ = selector.get_select_distance()
with self.assertRaises(NotFittedError):
selector = VoronoiFPS(n_to_select=1)
_ = selector.get_select_distance()
def test_comparison(self):
vselector = VoronoiFPS(n_to_select=(self.X.shape[0] - 1))
vselector.fit(self.X)
selector = FPS(n_to_select=(self.X.shape[0] - 1))
selector.fit(self.X)
self.assertTrue(np.allclose(vselector.selected_idx_, selector.selected_idx_))
def test_nothing_updated_points(self):
X = np.array([[1, 1], [4, 4], [10, 10], [100, 100]])
selector = VoronoiFPS(n_to_select=3, initialize=0)
try:
selector.fit(X)
f = 1
except Exception:
f = 0
self.assertEqual(f, 1)
self.assertEqual(len(np.where((selector.vlocation_of_idx == (selector.n_selected_ - 2)))[0]), 1)
def test_calculate_dSL(self):
selector = VoronoiFPS(n_to_select=3)
selector.fit(self.X)
active_points = np.where((selector.dSL_[selector.vlocation_of_idx] < selector.hausdorff_))[0]
ap = selector._get_active(self.X, selector.selected_idx_[(- 1)])
self.assertTrue(np.allclose(active_points, ap))
selector = VoronoiFPS(n_to_select=1)
ap = selector._get_active(self.X, 0)
self.assertTrue(np.allclose(np.arange(self.X.shape[0]), ap))
def test_score(self):
selector = VoronoiFPS(n_to_select=3, initialize=0)
selector.fit(self.X)
self.assertTrue(np.allclose(selector.hausdorff_, selector.score(self.X, selector.selected_idx_[(- 1)]))) |
class ExtraTreesForecasterConfig(_TreeEnsembleForecasterConfig):
def __init__(self, min_samples_split: int=2, **kwargs):
super().__init__(**kwargs)
self.min_samples_split = min_samples_split |
def points_in_boxes_gpu(points, boxes):
assert (boxes.shape[0] == points.shape[0])
assert ((boxes.shape[2] == 7) and (points.shape[2] == 3))
(batch_size, num_points, _) = points.shape
box_idxs_of_pts = points.new_zeros((batch_size, num_points), dtype=torch.int).fill_((- 1))
roiaware_pool3d_cuda.points_in_boxes_gpu(boxes.contiguous(), points.contiguous(), box_idxs_of_pts)
return box_idxs_of_pts |
def main(args):
cfg = setup(args)
if args.eval_only:
model = Trainer.build_model(cfg)
DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(cfg.MODEL.WEIGHTS, resume=args.resume)
res = Trainer.test(cfg, model)
if cfg.TEST.AUG.ENABLED:
res.update(Trainer.test_with_TTA(cfg, model))
if comm.is_main_process():
verify_results(cfg, res)
return res
trainer = Trainer(cfg)
trainer.resume_or_load(resume=args.resume)
return trainer.train() |
class Dataset():
def compute_batches(self, batch_size, vocabs, max_camel, rank, num_gpus, decoder_type, randomize=True, trunc=(- 1), no_filter=False):
timer = time.process_time()
self.batches = []
curr_batch = []
total = 0
for i in range(rank, len(self.examples), num_gpus):
if ((not no_filter) and (decoder_type in ['concode', 'prod']) and (len(self.examples[i]['next_rules']) > 200)):
continue
total += 1
curr_batch.append(self.examples[i])
if ((len(curr_batch) == batch_size) or (i == (len(self.examples) - 1)) or (i == trunc)):
self.batches.append(self.make_batch_into_tensor(curr_batch, vocabs, max_camel))
curr_batch = []
if (i == trunc):
break
if randomize:
random.shuffle(self.batches)
print((('Computed batched in :' + str((time.process_time() - timer))) + ' secs'))
return total |
class DWConv2d_BN(nn.Module):
def __init__(self, in_ch, out_ch, kernel_size=1, stride=1, norm_layer=nn.BatchNorm2d, act_layer=nn.Hardswish, bn_weight_init=1):
super().__init__()
self.dwconv = nn.Conv2d(in_ch, out_ch, kernel_size, stride, ((kernel_size - 1) // 2), groups=out_ch, bias=False)
self.pwconv = nn.Conv2d(out_ch, out_ch, 1, 1, 0, bias=False)
self.bn = norm_layer(out_ch)
self.act = (act_layer() if (act_layer is not None) else nn.Identity())
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)))
if (m.bias is not None):
m.bias.data.zero_()
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(bn_weight_init)
m.bias.data.zero_()
def forward(self, x):
x = self.dwconv(x)
x = self.pwconv(x)
x = self.bn(x)
x = self.act(x)
return x |
def check_consistent_length(*arrays):
lengths = [_num_samples(X) for X in arrays if (X is not None)]
uniques = np.unique(lengths)
if (len(uniques) > 1):
raise ValueError(('Found input variables with inconsistent numbers of samples: %r' % [int(l) for l in lengths])) |
def test_data_format():
adata = synthetic_iid()
protein_adata = synthetic_iid()
mdata = mudata.MuData({'rna': adata, 'protein': protein_adata})
old_x = adata.X
old_pro = protein_adata.X
old_obs = adata.obs
adata.X = np.asfortranarray(old_x)
protein_adata.X = np.asfortranarray(old_pro)
assert (adata.X.flags['C_CONTIGUOUS'] is False)
assert (protein_adata.X.flags['C_CONTIGUOUS'] is False)
adata_manager = generic_setup_mudata_manager(mdata, layer_mod='rna', protein_expression_mod='protein')
assert (adata.X.flags['C_CONTIGUOUS'] is True)
assert (protein_adata.X.flags['C_CONTIGUOUS'] is True)
assert np.array_equal(old_x, adata.X)
assert np.array_equal(old_pro, protein_adata.X)
assert np.array_equal(old_obs, adata.obs)
assert np.array_equal(adata.X, adata_manager.get_from_registry(REGISTRY_KEYS.X_KEY))
assert np.array_equal(protein_adata.X, adata_manager.get_from_registry(REGISTRY_KEYS.PROTEIN_EXP_KEY))
adata = synthetic_iid()
protein_adata = synthetic_iid()
mdata = mudata.MuData({'rna': adata, 'protein': protein_adata})
pe = np.asfortranarray(protein_adata.X)
protein_adata.X = pe
assert (protein_adata.X.flags['C_CONTIGUOUS'] is False)
adata_manager = generic_setup_mudata_manager(mdata, layer_mod='rna', protein_expression_mod='protein')
new_pe = adata_manager.get_from_registry(REGISTRY_KEYS.PROTEIN_EXP_KEY)
assert (new_pe.flags['C_CONTIGUOUS'] is True)
assert np.array_equal(pe, new_pe)
assert np.array_equal(adata.X, adata_manager.get_from_registry(REGISTRY_KEYS.X_KEY))
assert np.array_equal(protein_adata.X, adata_manager.get_from_registry(REGISTRY_KEYS.PROTEIN_EXP_KEY))
assert (adata.X.flags['C_CONTIGUOUS'] is True)
assert (protein_adata.X.flags['C_CONTIGUOUS'] is True) |
def get_embedding(wav_path, encoder):
wav = preprocess_wav(wav_path)
embedding = encoder.embed_utterance(wav)
return embedding |
def toks_to_words(token_ids):
indices = []
for (i, token_id) in enumerate(token_ids):
token_text = v[token_id]
if token_text.startswith('##'):
indices.append(i)
else:
if indices:
toks = [v[token_ids[t]] for t in indices]
word = ''.join(([toks[0]] + [t[2:] for t in toks[1:]]))
(yield (indices, word))
indices = [i] |
def test_reassignment_view():
anarray = np.ones((3,))
anotherarray = np.ones((3,))
def func(new_sym):
new_sym[...] = 7.0
func = func.to_sdfg(new_sym=dace.data.Array(shape=(3,), dtype=dace.float64))
def testf(maybe_none=None):
if (maybe_none is None):
new_sym = anotherarray
else:
new_sym = anarray
func(new_sym)
with pytest.raises(DaceSyntaxError):
testf(maybe_none=1.0)
testf()
assert np.allclose(anotherarray, 7.0) |
def azimuthalAverage(image, center=None):
(y, x) = np.indices(image.shape)
if (not center):
center = np.array([((x.max() - x.min()) / 2.0), ((y.max() - y.min()) / 2.0)])
r = np.hypot((x - center[0]), (y - center[1]))
ind = np.argsort(r.flat)
r_sorted = r.flat[ind]
i_sorted = image.flat[ind]
r_int = r_sorted.astype(int)
deltar = (r_int[1:] - r_int[:(- 1)])
rind = np.where(deltar)[0]
nr = (rind[1:] - rind[:(- 1)])
csim = np.cumsum(i_sorted, dtype=float)
tbin = (csim[rind[1:]] - csim[rind[:(- 1)]])
radial_prof = (tbin / nr)
return radial_prof |
class Gdma(Dma):
def __init__(self, core_id, writer, sheet_name):
super().__init__(core_id, writer)
self.sheet_name = ((sheet_name + '_') + str(core_id))
def load(self, reg_info_file, gdma_layer_map):
super().load(reg_info_file, gdma_layer_map)
new_reg_list = []
for reg_dict in self.reg_list:
if (reg_dict['Engine Id'] == '1'):
new_reg_list.append(reg_dict)
self.reg_list = new_reg_list
return self.chip_arch_dict
def set_style(cls, file_path, core_id, engine_type='GDMA', sheet_color='FFA500', chip_arch=None, frozen=True):
super().set_style(file_path, core_id, engine_type, sheet_color, chip_arch, frozen=frozen) |
class IonNumberDensityHeNLTE(ProcessingPlasmaProperty):
outputs = ('ion_number_density', 'electron_densities', 'helium_population_updated')
latex_name = ('N_{i,j}', 'n_{e}')
def __init__(self, plasma_parent, ion_zero_threshold=1e-20, electron_densities=None):
super(IonNumberDensityHeNLTE, self).__init__(plasma_parent)
self.ion_zero_threshold = ion_zero_threshold
self.block_ids = None
self._electron_densities = electron_densities
def update_he_population(self, helium_population, n_electron, number_density):
helium_population_updated = helium_population.copy()
he_one_population = helium_population_updated.loc[0].mul(n_electron)
he_three_population = helium_population_updated.loc[2].mul((1.0 / n_electron))
helium_population_updated.loc[0].update(he_one_population)
helium_population_updated.loc[2].update(he_three_population)
unnormalised = helium_population_updated.sum()
normalised = helium_population_updated.mul((number_density.loc[2] / unnormalised))
helium_population_updated.update(normalised)
return helium_population_updated
def calculate(self, phi, partition_function, number_density, helium_population):
if (self._electron_densities is None):
n_e_convergence_threshold = 0.05
n_electron = number_density.sum(axis=0)
n_electron_iterations = 0
while True:
(ion_number_density, self.block_ids) = IonNumberDensity.calculate_with_n_electron(phi, partition_function, number_density, n_electron, self.block_ids, self.ion_zero_threshold)
helium_population_updated = self.update_he_population(helium_population, n_electron, number_density)
ion_number_density.loc[(2, 0)].update(helium_population_updated.loc[0].sum(axis=0))
ion_number_density.loc[(2, 1)].update(helium_population_updated.loc[1].sum(axis=0))
ion_number_density.loc[(2, 2)].update(helium_population_updated.loc[(2, 0)])
ion_numbers = ion_number_density.index.get_level_values(1).values
ion_numbers = ion_numbers.reshape((ion_numbers.shape[0], 1))
new_n_electron = (ion_number_density.values * ion_numbers).sum(axis=0)
if np.any(np.isnan(new_n_electron)):
raise PlasmaIonizationError('n_electron just turned "nan" - aborting')
n_electron_iterations += 1
if (n_electron_iterations > 100):
logger.warn(f'n_electron iterations above 100 ({n_electron_iterations}) - something is probably wrong')
if np.all(((np.abs((new_n_electron - n_electron)) / n_electron) < n_e_convergence_threshold)):
break
n_electron = (0.5 * (new_n_electron + n_electron))
else:
n_electron = self._electron_densities
(ion_number_density, self.block_ids) = IonNumberDensity.calculate_with_n_electron(phi, partition_function, number_density, n_electron, self.block_ids, self.ion_zero_threshold)
helium_population_updated = self.update_he_population(helium_population, n_electron, number_density)
ion_number_density.loc[(2, 0)].update(helium_population_updated.loc[0].sum(axis=0))
ion_number_density.loc[(2, 1)].update(helium_population_updated.loc[1].sum(axis=0))
ion_number_density.loc[(2, 2)].update(helium_population_updated.loc[(2, 0)])
return (ion_number_density, n_electron, helium_population_updated) |
def extract_domain_type_facts(entity_lexicon_file):
for line in open(entity_lexicon_file):
entity = line.split('\t')[0]
entities.add(entity)
for line in sys.stdin:
parts = line.strip().split('\t')
parts[2] = parts[2].strip('.')
if ((parts[0] in entities) or (parts[2] in entities)):
sys.stdout.write((' '.join(parts) + ' .\n')) |
def test_mmd():
(X, Y) = sample_blobs_same(n=1000)
mmd_1 = mmd(X=X, Y=Y, implementation='tp_sutherland')
mmd_2 = mmd(X=X, Y=Y, implementation='tp_djolonga')
assert torch.allclose(mmd_1, mmd_2, rtol=0.0001, atol=0.0001) |
def is_lean_def_first_line(line: str) -> bool:
if ((not line) or line.isspace()):
return False
line = strip_def_attr(line)
tokens = re.split('[:\\s]+', line.strip())
return (tokens[0] in LEAN_DEF_PREFIXES) |
def main(args):
mt = sacremoses.MosesTokenizer(lang=args.lang)
def tok(s):
return mt.tokenize(s, return_str=True)
for line in sys.stdin:
parts = list(map(tok, line.split('\t')))
print(*parts, sep='\t', flush=True) |
class NumericFactor():
def __init__(self, keys: T.Sequence[str], optimized_keys: T.Sequence[str], linearization_function: T.Callable[(..., T.Tuple[(np.ndarray, np.ndarray, np.ndarray, np.ndarray)])]) -> None:
self.keys = keys
self.optimized_keys = optimized_keys
self.linearization_function = linearization_function
def from_file_python(cls, keys: T.Sequence[str], optimized_keys: T.Sequence[str], output_dir: T.Openable, namespace: str, name: str) -> NumericFactor:
assert all(((opt_key in keys) for opt_key in optimized_keys))
function_dir = (((Path(output_dir) / 'python') / 'symforce') / namespace)
linearization_function = getattr(codegen_util.load_generated_package(f'{namespace}.{name}', function_dir), name)
return cls(keys=keys, optimized_keys=optimized_keys, linearization_function=linearization_function)
def linearize(self, inputs: Values) -> T.Tuple[(np.ndarray, np.ndarray, np.ndarray, np.ndarray)]:
if (inputs.keys_recursive() != self.keys):
raise ValueError('Keys in inputs must match keys used to construct the factor.')
(residual, jacobian, hessian, rhs) = self.linearization_function(*inputs.to_numerical().values_recursive())
if (jacobian.ndim != 2):
raise ValueError(f'Jacobian must have 2 dimensions, got {jacobian.ndim}. If the linearization function was generated by SymForce, make sure to set return_2d_vectors=True')
return (residual, jacobian, hessian, rhs)
def cc_factor(self, cc_key_map: T.Mapping[(str, cc_sym.Key)]) -> cc_sym.Factor:
def wrapped(values: cc_sym.Values, _: T.Any) -> T.Tuple[(np.ndarray, np.ndarray, np.ndarray, np.ndarray)]:
return self.linearization_function(*[values.at(cc_key_map[key]) for key in self.keys])
return cc_sym.Factor(wrapped, [cc_key_map[key] for key in self.optimized_keys]) |
def all_extracted_files(split, src, tgt, extracted_folders, split_urls):
def get_url(url):
if isinstance(url, tuple):
(url, downloaded_file) = url
return url
return [f for url in split_urls for f in my_glob(extracted_folders[str(get_url(url))])] |
def pearson_and_spearman(preds, labels):
warnings.warn(DEPRECATION_WARNING, FutureWarning)
requires_backends(pearson_and_spearman, 'sklearn')
pearson_corr = pearsonr(preds, labels)[0]
spearman_corr = spearmanr(preds, labels)[0]
return {'pearson': pearson_corr, 'spearmanr': spearman_corr, 'corr': ((pearson_corr + spearman_corr) / 2)} |
def _get_intent(text):
scores = intent_classifier.get_scores(text)
(max_intent, max_intent_score) = intent_classifier.knn(text)
print(scores, max_intent, max_intent_score)
return (max_intent, max_intent_score) |
def plot_total_contribution_sums(ax, total_comp_sums, bar_order, top_n, bar_dims, plot_params):
comp_bar_heights = []
for b in bar_order:
if (b == 'total'):
h = 0
elif (b == 'neg_total'):
h = ((total_comp_sums['neg_s'] + total_comp_sums['neg_s_pos_p']) + total_comp_sums['pos_s_neg_p'])
elif (b == 'pos_total'):
h = ((total_comp_sums['pos_s'] + total_comp_sums['neg_s_neg_p']) + total_comp_sums['pos_s_pos_p'])
elif (b == 'all_pos_pos'):
a = np.array(bar_dims['total_heights'])
h = np.sum(a[(a > 0)])
elif (b == 'all_pos_neg'):
a = np.array(bar_dims['total_heights'])
h = np.sum(a[(a < 0)])
else:
h = total_comp_sums[b]
comp_bar_heights.append(h)
if ('total' in bar_order):
total_index = bar_order.index('total')
total = sum(comp_bar_heights)
comp_bar_heights[total_index] = total
if (not plot_params['all_pos_contributions']):
max_bar_height = np.max(np.abs(bar_dims['label_heights']))
else:
max_bar_height = np.max(np.abs(bar_dims['total_heights']))
comp_scaling = (max_bar_height / np.max(np.abs(comp_bar_heights)))
comp_bar_heights = [(comp_scaling * h) for h in comp_bar_heights]
if plot_params['show_total']:
min_y = (top_n + 3.5)
ys = [(top_n + 2)]
else:
min_y = (top_n + 2)
ys = []
for n_h in range(int((len(comp_bar_heights) / 2))):
y = (min_y + (1.5 * n_h))
ys += [y, y]
comp_colors = [plot_params['score_colors'][b] for b in bar_order]
width = plot_params['bar_width']
linewidth = plot_params['bar_linewidth']
edgecolor = (['black'] * len(comp_bar_heights))
ax.barh(ys, comp_bar_heights, width, align='center', color=comp_colors, linewidth=linewidth, edgecolor=edgecolor)
return (ax, comp_bar_heights, bar_order) |
class BaseDetector(ABC):
def compute_score(self, caption: str, image_location: str, references: Dict[(str, Any)]) -> float:
pass |
class GoogleSearchNewsSearch(VirtualFunctionTool):
name = 'GoogleSearchNewsSearch'
summary = 'Perform a news search on Google with a given keyword or phrase and return the search results.'
parameters: List[ArgParameter] = [{'name': 'keyword', 'type': 'string', 'description': 'The keyword or phrase to search.', 'required': True}, {'name': 'num_results', 'type': 'integer', 'description': 'The maximum number of results to return. Default is 10.', 'required': False}, {'name': 'filters', 'type': 'object', 'description': "The filters to apply, includes 'time_range' (string, in the format of 'YYYY-MM-DD..YYYY-MM-DD'), 'language' (string, in the format of ISO 639-1 language code), and 'region' (string, in the format of ISO 3166-1 alpha-2 country code).", 'required': False}]
returns: List[ArgReturn] = [{'name': 'results', 'type': 'array', 'description': "The search results, each includes 'title', 'snippet', 'url' (string, the unique identifier of the search result), and 'source'."}]
exceptions: List[ArgException] = [{'name': 'InvalidRequestException', 'description': "The 'keyword' is empty or the 'num_results' is not a positive integer."}, {'name': 'NotFoundException', 'description': 'No search results are found.'}] |
def test_repr_mimebundle_():
tree = DecisionTreeClassifier()
output = tree._repr_mimebundle_()
assert ('text/plain' in output)
assert ('text/html' in output)
with config_context(display='text'):
output = tree._repr_mimebundle_()
assert ('text/plain' in output)
assert ('text/html' not in output) |
def overwrite_model(model_from, model_to):
model_from_vars = tf.trainable_variables(model_from.scope)
model_to_vars = tf.trainable_variables(model_to.scope)
overwrite_variables(model_from_vars, model_to_vars) |
def looking_at_call(s):
position = (s.start_line, s.start_col)
result = (looking_at_expr(s) == u'(')
if (not result):
(s.start_line, s.start_col) = position
return result |
.parametrize('observation_shape', [(100,), ((100,), (200,))])
.parametrize('action_size', [2])
.parametrize('batch_size', [32])
.parametrize('gamma', [0.99])
def test_continuous_mean_q_function_forwarder(observation_shape: Shape, action_size: int, batch_size: int, gamma: float) -> None:
encoder = DummyEncoderWithAction(observation_shape, action_size)
q_func = ContinuousMeanQFunction(encoder, encoder.get_feature_size())
forwarder = ContinuousMeanQFunctionForwarder(q_func)
x = create_torch_observations(observation_shape, batch_size)
action = torch.rand(batch_size, action_size)
y = forwarder.compute_expected_q(x, action)
assert (y.shape == (batch_size, 1))
target = forwarder.compute_target(x, action)
assert (target.shape == (batch_size, 1))
assert (target == y).all()
q_tp1 = np.random.random((batch_size, 1))
rew_tp1 = np.random.random((batch_size, 1))
ter_tp1 = np.random.randint(2, size=(batch_size, 1))
target = (rew_tp1 + ((gamma * q_tp1) * (1 - ter_tp1)))
obs_t = create_torch_observations(observation_shape, batch_size)
act_t = torch.rand(batch_size, action_size)
q_t = q_func(obs_t, act_t).q_value.detach().numpy()
ref_loss = ((q_t - target) ** 2).mean()
rew_tp1 = torch.tensor(rew_tp1, dtype=torch.float32)
q_tp1 = torch.tensor(q_tp1, dtype=torch.float32)
ter_tp1 = torch.tensor(ter_tp1, dtype=torch.float32)
loss = forwarder.compute_error(observations=obs_t, actions=act_t, rewards=rew_tp1, target=q_tp1, terminals=ter_tp1, gamma=gamma)
assert np.allclose(loss.detach().numpy(), ref_loss) |
.parametrize('dropout_rate', [0.2, 0.5, 0.8])
def test_locked_dropout(dropout_rate):
BATCH_SIZE = 100
MAX_LEN = 200
HID_DIM = 500
x = torch.ones(BATCH_SIZE, MAX_LEN, HID_DIM)
dropout = LockedDropout(p=dropout_rate)
dropout.eval()
x_locked_dropouted = dropout(x)
assert (x_locked_dropouted == x).all().item()
dropout.train()
x_locked_dropouted = dropout(x)
assert (set(x_locked_dropouted.sum(dim=1).long().flatten().tolist()) == {0, int(round((MAX_LEN / (1 - dropout_rate))))})
assert (abs((x_locked_dropouted.mean().item() - 1)) < 0.05) |
class BaseChangeQuantizationMethodQCAttrTest(BaseKerasFeatureNetworkTest):
def __init__(self, unit_test, edit_filter, action, prepare_graph_func):
self.edit_filter = edit_filter
self.action = action
self.prepare_graph_func = prepare_graph_func
super().__init__(unit_test)
def get_debug_config(self):
return DebugConfig(network_editor=[EditRule(filter=self.edit_filter, action=self.action)])
def create_networks(self):
inputs = layers.Input(shape=self.get_input_shapes()[0][1:])
x = layers.Conv2D(3, 4, use_bias=False)(inputs)
model = keras.Model(inputs=inputs, outputs=x)
return model
def run_test(self, experimental_exporter=False):
feature_networks = self.create_networks()
feature_networks = (feature_networks if isinstance(feature_networks, list) else [feature_networks])
for model_float in feature_networks:
core_config = self.get_core_config()
ptq_graph = self.prepare_graph_func(in_model=model_float, representative_data_gen=self.representative_data_gen_experimental, core_config=core_config, fw_info=self.get_fw_info(), fw_impl=self.get_fw_impl(), target_kpi=self.get_kpi(), tpc=self.get_tpc())
filtered_nodes = ptq_graph.filter(self.edit_filter)
for node in filtered_nodes:
if ((node.final_weights_quantization_cfg is not None) and hasattr(self.action, 'weights_quantization_method')):
self.unit_test.assertTrue((node.final_weights_quantization_cfg.weights_quantization_method == self.action.weights_quantization_method))
elif ((node.final_activation_quantization_cfg is not None) and hasattr(self.action, 'activation_quantization_method')):
self.unit_test.assertTrue((node.final_activation_quantization_cfg.activation_quantization_method == self.action.activation_quantization_method))
else:
for nqc in node.candidates_quantization_cfg:
if hasattr(self.action, 'activation_quantization_method'):
self.unit_test.assertTrue((nqc.activation_quantization_cfg.activation_quantization_method == self.action.activation_quantization_method))
if hasattr(self.action, 'weights_quantization_method'):
self.unit_test.assertTrue((nqc.weights_quantization_cfg.weights_quantization_method == self.action.weights_quantization_method)) |
def test_singletons():
array = ak.Array([None, [None], [{'x': None, 'y': None}], [{'x': [None], 'y': [None]}], [{'x': [1], 'y': [[None]]}], [{'x': [2], 'y': [[1, 2, 3]]}]])
assert (ak.singletons(array, axis=0).tolist() == [[], [[None]], [[{'x': None, 'y': None}]], [[{'x': [None], 'y': [None]}]], [[{'x': [1], 'y': [[None]]}]], [[{'x': [2], 'y': [[1, 2, 3]]}]]])
assert (ak.singletons(array, axis=1).tolist() == [None, [[]], [[{'x': None, 'y': None}]], [[{'x': [None], 'y': [None]}]], [[{'x': [1], 'y': [[None]]}]], [[{'x': [2], 'y': [[1, 2, 3]]}]]])
assert (ak.singletons(array, axis=2).tolist() == [None, [None], [{'x': None, 'y': None}], [{'x': [[]], 'y': [[]]}], [{'x': [[1]], 'y': [[[None]]]}], [{'x': [[2]], 'y': [[[1, 2, 3]]]}]])
with pytest.raises(np.AxisError):
ak.singletons(array, axis=3)
assert (ak.singletons(array, axis=(- 1)).tolist() == [None, [None], [{'x': None, 'y': None}], [{'x': [[]], 'y': [None]}], [{'x': [[1]], 'y': [[[]]]}], [{'x': [[2]], 'y': [[[1], [2], [3]]]}]])
assert (ak.singletons(array, axis=(- 2)).tolist() == [None, [None], [{'x': [], 'y': None}], [{'x': [[None]], 'y': [[]]}], [{'x': [[1]], 'y': [[[None]]]}], [{'x': [[2]], 'y': [[[1, 2, 3]]]}]])
with pytest.raises(np.AxisError):
ak.singletons(array, axis=(- 3)) |
def get_left_span(span, sentence=None, window=None):
sentence = (sentence if sentence else span.sentence)
j = span.char_to_word_index(span.char_start)
i = (max((j - window), 0) if window else 0)
if (i == j == 0):
return Span(char_start=0, char_end=(- 1), sentence=sentence)
(start, end) = (sentence.char_offsets[i], ((sentence.char_offsets[(j - 1)] + len(sentence.words[(j - 1)])) - 1))
return Span(char_start=start, char_end=end, sentence=sentence) |
def set_last_dropout(model, dropout):
if isinstance(model, ElectraForSequenceClassification):
if isinstance(model.classifier, ElectraClassificationHeadCustom):
model.classifier.dropout2 = dropout
else:
model.classifier.dropout
else:
model.dropout = dropout |
def create_model(opt):
model = opt['model']
if (model == 'srgan'):
from .SRGAN_model import SRGANModel as M
else:
raise NotImplementedError('Model [{:s}] not recognized.'.format(model))
m = M(opt)
logger.info('Model [{:s}] is created.'.format(m.__class__.__name__))
return m |
def _coerce_seq(s, ctx=None):
if isinstance(s, str):
ctx = _get_ctx(ctx)
s = StringVal(s, ctx)
if (not is_expr(s)):
raise Z3Exception('Non-expression passed as a sequence')
if (not is_seq(s)):
raise Z3Exception('Non-sequence passed as a sequence')
return s |
class MetricStats():
def __init__(self, metric, n_jobs=1, batch_eval=True):
self.metric = metric
self.n_jobs = n_jobs
self.batch_eval = batch_eval
self.clear()
def clear(self):
self.scores = []
self.ids = []
self.summary = {}
def append(self, ids, *args, **kwargs):
self.ids.extend(ids)
if self.batch_eval:
scores = self.metric(*args, **kwargs).detach()
else:
if (('predict' not in kwargs) or ('target' not in kwargs)):
raise ValueError("Must pass 'predict' and 'target' as kwargs if batch_eval=False")
if (self.n_jobs == 1):
scores = sequence_evaluation(metric=self.metric, **kwargs)
else:
scores = multiprocess_evaluation(metric=self.metric, n_jobs=self.n_jobs, **kwargs)
self.scores.extend(scores)
def summarize(self, field=None):
min_index = torch.argmin(torch.tensor(self.scores))
max_index = torch.argmax(torch.tensor(self.scores))
self.summary = {'average': float((sum(self.scores) / len(self.scores))), 'min_score': float(self.scores[min_index]), 'min_id': self.ids[min_index], 'max_score': float(self.scores[max_index]), 'max_id': self.ids[max_index]}
if (field is not None):
return self.summary[field]
else:
return self.summary
def write_stats(self, filestream, verbose=False):
if (not self.summary):
self.summarize()
message = f'''Average score: {self.summary['average']}
'''
message += f"Min error: {self.summary['min_score']} "
message += f'''id: {self.summary['min_id']}
'''
message += f"Max error: {self.summary['max_score']} "
message += f'''id: {self.summary['max_id']}
'''
filestream.write(message)
if verbose:
print(message) |
def get_feature_and_linear_resnet50(model: nn.Module):
m = model
feature = nn.Sequential(m.conv1, m.bn1, m.relu, m.maxpool, m.layer1, m.layer2, m.layer3, m.layer4)
linear = m.fc
factor = 32
return (feature, linear, factor) |
class TestUfunclike(object):
def test_isposinf(self):
a = nx.array([nx.inf, (- nx.inf), nx.nan, 0.0, 3.0, (- 3.0)])
out = nx.zeros(a.shape, bool)
tgt = nx.array([True, False, False, False, False, False])
res = ufl.isposinf(a)
assert_equal(res, tgt)
res = ufl.isposinf(a, out)
assert_equal(res, tgt)
assert_equal(out, tgt)
a = a.astype(np.complex)
with assert_raises(TypeError):
ufl.isposinf(a)
def test_isneginf(self):
a = nx.array([nx.inf, (- nx.inf), nx.nan, 0.0, 3.0, (- 3.0)])
out = nx.zeros(a.shape, bool)
tgt = nx.array([False, True, False, False, False, False])
res = ufl.isneginf(a)
assert_equal(res, tgt)
res = ufl.isneginf(a, out)
assert_equal(res, tgt)
assert_equal(out, tgt)
a = a.astype(np.complex)
with assert_raises(TypeError):
ufl.isneginf(a)
def test_fix(self):
a = nx.array([[1.0, 1.1, 1.5, 1.8], [(- 1.0), (- 1.1), (- 1.5), (- 1.8)]])
out = nx.zeros(a.shape, float)
tgt = nx.array([[1.0, 1.0, 1.0, 1.0], [(- 1.0), (- 1.0), (- 1.0), (- 1.0)]])
res = ufl.fix(a)
assert_equal(res, tgt)
res = ufl.fix(a, out)
assert_equal(res, tgt)
assert_equal(out, tgt)
assert_equal(ufl.fix(3.14), 3)
def test_fix_with_subclass(self):
class MyArray(nx.ndarray):
def __new__(cls, data, metadata=None):
res = nx.array(data, copy=True).view(cls)
res.metadata = metadata
return res
def __array_wrap__(self, obj, context=None):
if isinstance(obj, MyArray):
obj.metadata = self.metadata
return obj
def __array_finalize__(self, obj):
self.metadata = getattr(obj, 'metadata', None)
return self
a = nx.array([1.1, (- 1.1)])
m = MyArray(a, metadata='foo')
f = ufl.fix(m)
assert_array_equal(f, nx.array([1, (- 1)]))
assert_(isinstance(f, MyArray))
assert_equal(f.metadata, 'foo')
m0d = m[(0, ...)]
m0d.metadata = 'bar'
f0d = ufl.fix(m0d)
assert_(isinstance(f0d, MyArray))
assert_equal(f0d.metadata, 'bar')
def test_deprecated(self):
assert_warns(DeprecationWarning, ufl.fix, [1, 2], y=nx.empty(2))
assert_warns(DeprecationWarning, ufl.isposinf, [1, 2], y=nx.empty(2))
assert_warns(DeprecationWarning, ufl.isneginf, [1, 2], y=nx.empty(2))
def test_scalar(self):
x = np.inf
actual = np.isposinf(x)
expected = np.True_
assert_equal(actual, expected)
assert_equal(type(actual), type(expected))
x = (- 3.4)
actual = np.fix(x)
expected = np.float64((- 3.0))
assert_equal(actual, expected)
assert_equal(type(actual), type(expected))
out = np.array(0.0)
actual = np.fix(x, out=out)
assert_((actual is out)) |
def update_alpha_parameters(model, vision_layers, transformer_layers, p, pi, print_info=True):
standarlization = (lambda x, mean, std: ((x - mean) / std))
alpha_grad_attn_vision = torch.stack([getattr(model.module.visual.transformer.resblocks, str(i)).attn.alpha.grad for i in range(vision_layers)])
alpha_grad_attn_language = torch.stack([getattr(model.module.transformer.resblocks, str(i)).attn.alpha.grad for i in range(transformer_layers)])
alpha_grad_attn = torch.cat([alpha_grad_attn_vision.view((- 1)), alpha_grad_attn_language.view((- 1))])
(mean, std) = (torch.mean(alpha_grad_attn), torch.std(alpha_grad_attn))
(alpha_grad_attn_vision, alpha_grad_attn_language) = (standarlization(alpha_grad_attn_vision, mean, std), standarlization(alpha_grad_attn_language, mean, std))
alpha_grad_mlp_vision = torch.stack([getattr(model.module.visual.transformer.resblocks, str(i)).alpha.grad for i in range(vision_layers)])
alpha_grad_mlp_language = torch.stack([getattr(model.module.transformer.resblocks, str(i)).alpha.grad for i in range(transformer_layers)])
alpha_grad_mlp = torch.cat([alpha_grad_mlp_vision.view((- 1)), alpha_grad_mlp_language.view((- 1))])
(mean, std) = (torch.mean(alpha_grad_mlp), torch.std(alpha_grad_mlp))
(alpha_grad_mlp_vision, alpha_grad_mlp_language) = (standarlization(alpha_grad_mlp_vision, mean, std), standarlization(alpha_grad_mlp_language, mean, std))
alpha_grad = torch.cat([alpha_grad_attn_vision.view((- 1)), alpha_grad_attn_language.view((- 1)), alpha_grad_mlp_vision.view((- 1)), alpha_grad_mlp_language.view((- 1))])
(sorted_alpha_grad, indices) = torch.sort(alpha_grad, descending=True)
compression_weight = torch.ones_like(indices)
compression_weight[(indices < alpha_grad_attn.numel())] = 36
threshold = sorted_alpha_grad[torch.argmin(torch.abs((torch.cumsum(compression_weight, 0) - (torch.sum(compression_weight) * pi))))]
def update(module, grad):
mask = ((grad <= threshold) | (grad <= torch.min(grad)))
module.data.copy_((mask + ((~ mask) * (1 - (pi / p)))))
for i in range(vision_layers):
update(getattr(model.module.visual.transformer.resblocks, str(i)).attn.alpha, alpha_grad_attn_vision[i])
update(getattr(model.module.visual.transformer.resblocks, str(i)).alpha, alpha_grad_mlp_vision[i])
for i in range(transformer_layers):
update(getattr(model.module.transformer.resblocks, str(i)).attn.alpha, alpha_grad_attn_language[i])
update(getattr(model.module.transformer.resblocks, str(i)).alpha, alpha_grad_mlp_language[i])
if print_info:
(attn, mlp) = ([], [])
for i in range(vision_layers):
attn.append(getattr(model.module.visual.transformer.resblocks, str(i)).attn.alpha.flatten())
mlp.append(getattr(model.module.visual.transformer.resblocks, str(i)).alpha.flatten())
for i in range(transformer_layers):
attn.append(getattr(model.module.transformer.resblocks, str(i)).attn.alpha.flatten())
mlp.append(getattr(model.module.transformer.resblocks, str(i)).alpha.flatten())
print('Current compression ratio of attn: ', (1 - torch.mean(torch.cat(attn))))
print('Current compression ratio of mlp: ', (1 - torch.mean(torch.cat(mlp))))
print('Current compression ratio: ', pi) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.