code stringlengths 17 6.64M |
|---|
class AlexNet(nn.Module):
def __init__(self, num_classes=1000, filter_size=1, pool_only=False, relu_first=True):
super(AlexNet, self).__init__()
if pool_only:
first_ds = [nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2)]
elif relu_first:
first_ds = [nn.Conv2d(... |
def alexnet(pretrained=False, **kwargs):
'AlexNet model architecture from the\n `"One weird trick..." <https://arxiv.org/abs/1404.5997>`_ paper.\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = AlexNet(**kwargs)
if pretrained:
model.load_s... |
class AlexNetNMP(nn.Module):
def __init__(self, num_classes=1000, filter_size=1):
super(AlexNetNMP, self).__init__()
self.features = nn.Sequential(nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2), nn.ReLU(inplace=True), Downsample(filt_size=filter_size, stride=2, channels=64, pad_off=(- 1), ... |
def alexnetnmp(pretrained=False, **kwargs):
'AlexNet model architecture from the\n `"One weird trick..." <https://arxiv.org/abs/1404.5997>`_ paper.\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = AlexNetNMP(**kwargs)
if pretrained:
model.... |
class _DenseLayer(nn.Sequential):
def __init__(self, num_input_features, growth_rate, bn_size, drop_rate):
super(_DenseLayer, self).__init__()
(self.add_module('norm1', nn.BatchNorm2d(num_input_features)),)
(self.add_module('relu1', nn.ReLU(inplace=True)),)
(self.add_module('conv1... |
class _DenseBlock(nn.Sequential):
def __init__(self, num_layers, num_input_features, bn_size, growth_rate, drop_rate):
super(_DenseBlock, self).__init__()
for i in range(num_layers):
layer = _DenseLayer((num_input_features + (i * growth_rate)), growth_rate, bn_size, drop_rate)
... |
class _Transition(nn.Sequential):
def __init__(self, num_input_features, num_output_features, filter_size=1):
super(_Transition, self).__init__()
self.add_module('norm', nn.BatchNorm2d(num_input_features))
self.add_module('relu', nn.ReLU(inplace=True))
self.add_module('conv', nn.C... |
class DenseNet(nn.Module):
'Densenet-BC model class, based on\n `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_\n Args:\n growth_rate (int) - how many filters to add each layer (`k` in paper)\n block_config (list of 4 ints) - how many layers in each pooling... |
def _load_state_dict(model, model_url):
pattern = re.compile('^(.*denselayer\\d+\\.(?:norm|relu|conv))\\.((?:[12])\\.(?:weight|bias|running_mean|running_var))$')
state_dict = model_zoo.load_url(model_url)
for key in list(state_dict.keys()):
res = pattern.match(key)
if res:
new_... |
def densenet121(pretrained=False, filter_size=1, pool_only=True, **kwargs):
'Densenet-121 model from\n `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = DenseNet(num_ini... |
def densenet169(pretrained=False, filter_size=1, pool_only=True, **kwargs):
'Densenet-169 model from\n `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = DenseNet(num_ini... |
def densenet201(pretrained=False, filter_size=1, pool_only=True, **kwargs):
'Densenet-201 model from\n `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = DenseNet(num_ini... |
def densenet161(pretrained=False, filter_size=1, pool_only=True, **kwargs):
'Densenet-161 model from\n `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = DenseNet(num_ini... |
class ConvBNReLU(nn.Sequential):
def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, groups=1):
padding = ((kernel_size - 1) // 2)
super(ConvBNReLU, self).__init__(nn.Conv2d(in_planes, out_planes, kernel_size, stride, padding, groups=groups, bias=False), nn.BatchNorm2d(out_planes),... |
class InvertedResidual(nn.Module):
def __init__(self, inp, oup, stride, expand_ratio, filter_size=1):
super(InvertedResidual, self).__init__()
self.stride = stride
assert (stride in [1, 2])
hidden_dim = int(round((inp * expand_ratio)))
self.use_res_connect = ((self.stride ... |
class MobileNetV2(nn.Module):
def __init__(self, num_classes=1000, width_mult=1.0, filter_size=1):
super(MobileNetV2, self).__init__()
block = InvertedResidual
input_channel = 32
last_channel = 1280
inverted_residual_setting = [[1, 16, 1, 1], [6, 24, 2, 2], [6, 32, 3, 2], ... |
def mobilenet_v2(pretrained=False, progress=True, filter_size=1, **kwargs):
'\n Constructs a MobileNetV2 architecture from\n `"MobileNetV2: Inverted Residuals and Linear Bottlenecks" <https://arxiv.org/abs/1801.04381>`_.\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet... |
def conv3x3(in_planes, out_planes, stride=1, groups=1):
'3x3 convolution with padding'
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, groups=groups, bias=False)
|
def conv1x1(in_planes, out_planes, stride=1):
'1x1 convolution'
return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
|
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1, norm_layer=None, filter_size=1):
super(BasicBlock, self).__init__()
if (norm_layer is None):
norm_layer = nn.BatchNorm2d
if (groups != 1):
raise... |
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1, norm_layer=None, filter_size=1):
super(Bottleneck, self).__init__()
if (norm_layer is None):
norm_layer = nn.BatchNorm2d
self.conv1 = conv1x1(inplanes, plan... |
class ResNet(nn.Module):
def __init__(self, block, layers, num_classes=1000, zero_init_residual=False, groups=1, width_per_group=64, norm_layer=None, filter_size=1, pool_only=True):
super(ResNet, self).__init__()
if (norm_layer is None):
norm_layer = nn.BatchNorm2d
planes = [i... |
def resnet18(pretrained=False, filter_size=1, pool_only=True, **kwargs):
'Constructs a ResNet-18 model.\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = ResNet(BasicBlock, [2, 2, 2, 2], filter_size=filter_size, pool_only=pool_only, **kwargs)
if pretrai... |
def resnet34(pretrained=False, filter_size=1, pool_only=True, **kwargs):
'Constructs a ResNet-34 model.\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = ResNet(BasicBlock, [3, 4, 6, 3], filter_size=filter_size, pool_only=pool_only, **kwargs)
if pretrai... |
def resnet50(pretrained=False, filter_size=1, pool_only=True, **kwargs):
'Constructs a ResNet-50 model.\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = ResNet(Bottleneck, [3, 4, 6, 3], filter_size=filter_size, pool_only=pool_only, **kwargs)
if pretrai... |
def resnet101(pretrained=False, filter_size=1, pool_only=True, **kwargs):
'Constructs a ResNet-101 model.\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = ResNet(Bottleneck, [3, 4, 23, 3], filter_size=filter_size, pool_only=pool_only, **kwargs)
if pret... |
def resnet152(pretrained=False, filter_size=1, pool_only=True, **kwargs):
'Constructs a ResNet-152 model.\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = ResNet(Bottleneck, [3, 8, 36, 3], filter_size=filter_size, pool_only=pool_only, **kwargs)
if pret... |
def resnext50_32x4d(pretrained=False, filter_size=1, pool_only=True, **kwargs):
model = ResNet(Bottleneck, [3, 4, 6, 3], groups=4, width_per_group=32, filter_size=filter_size, pool_only=pool_only, **kwargs)
return model
|
def resnext101_32x8d(pretrained=False, filter_size=1, pool_only=True, **kwargs):
model = ResNet(Bottleneck, [3, 4, 23, 3], groups=8, width_per_group=32, filter_size=filter_size, pool_only=pool_only, **kwargs)
return model
|
class VGG(nn.Module):
def __init__(self, features, num_classes=1000, init_weights=True):
super(VGG, self).__init__()
self.features = features
self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
self.classifier = nn.Sequential(nn.Linear(((512 * 7) * 7), 4096), nn.ReLU(True), nn.Dropout(), ... |
def make_layers(cfg, batch_norm=False, filter_size=1):
layers = []
in_channels = 3
for v in cfg:
if (v == 'M'):
layers += [nn.MaxPool2d(kernel_size=2, stride=1), Downsample(filt_size=filter_size, stride=2, channels=in_channels)]
else:
conv2d = nn.Conv2d(in_channels,... |
def vgg11(pretrained=False, filter_size=1, **kwargs):
'VGG 11-layer model (configuration "A")\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
if pretrained:
kwargs['init_weights'] = False
model = VGG(make_layers(cfg['A'], filter_size=filter_size), *... |
def vgg11_bn(pretrained=False, filter_size=1, **kwargs):
'VGG 11-layer model (configuration "A") with batch normalization\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
if pretrained:
kwargs['init_weights'] = False
model = VGG(make_layers(cfg['A'],... |
def vgg13(pretrained=False, filter_size=1, **kwargs):
'VGG 13-layer model (configuration "B")\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
if pretrained:
kwargs['init_weights'] = False
model = VGG(make_layers(cfg['B'], filter_size=filter_size), *... |
def vgg13_bn(pretrained=False, filter_size=1, **kwargs):
'VGG 13-layer model (configuration "B") with batch normalization\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
if pretrained:
kwargs['init_weights'] = False
model = VGG(make_layers(cfg['B'],... |
def vgg16(pretrained=False, filter_size=1, **kwargs):
'VGG 16-layer model (configuration "D")\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
if pretrained:
kwargs['init_weights'] = False
model = VGG(make_layers(cfg['D'], filter_size=filter_size), *... |
def vgg16_bn(pretrained=False, filter_size=1, **kwargs):
'VGG 16-layer model (configuration "D") with batch normalization\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
if pretrained:
kwargs['init_weights'] = False
model = VGG(make_layers(cfg['D'],... |
def vgg19(pretrained=False, filter_size=1, **kwargs):
'VGG 19-layer model (configuration "E")\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
if pretrained:
kwargs['init_weights'] = False
model = VGG(make_layers(cfg['E'], filter_size=filter_size), *... |
def vgg19_bn(pretrained=False, filter_size=1, **kwargs):
"VGG 19-layer model (configuration 'E') with batch normalization\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n "
if pretrained:
kwargs['init_weights'] = False
model = VGG(make_layers(cfg['E'],... |
def load_weights(weight_file):
if (weight_file == None):
return
try:
weights_dict = np.load(weight_file, allow_pickle=True).item()
except:
weights_dict = np.load(weight_file, encoding='bytes').item()
return weights_dict
|
class KitModel(nn.Module):
def __init__(self, weight_file):
super(KitModel, self).__init__()
global __weights_dict
__weights_dict = load_weights(weight_file)
self.bn_data = self.__batch_normalization(2, 'bn_data', num_features=3, eps=1.9999999494757503e-05, momentum=0.899999976158... |
def classifier_loader():
return KitModel(load_model_checkpoint_bytes('resnet152-imagenet11k'))
|
def gen_classifier_loader(name, d):
def classifier_loader():
model = torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', name)
load_model_state_dict(model, name)
return model
return classifier_loader
|
class Smooth(nn.Module):
'A smoothed classifier g '
def __init__(self, base_classifier, sigma, n, alpha, mean, std):
'\n :param base_classifier: maps from [batch x channel x height x width] to [batch x num_classes]\n :param sigma: the noise level hyperparameter\n :param n: the nu... |
def gen_classifier_loader(name, d):
def classifier_loader():
model = torch_models.__dict__[d['arch']]()
load_model_state_dict(model, name)
model = Smooth(model, d['noise_sigma'], d['n'], d['alpha'], d['mean'], d['std'])
return model
return classifier_loader
|
def classify(images, model, class_sublist, adversarial_attack):
if adversarial_attack:
images = pgd_style_attack(adversarial_attack, images, model)
return model.predict_batch(images, class_sublist=class_sublist)
|
def gen_classifier_loader(name, d):
def classifier_loader():
model = torch_models.__dict__[d['arch']]()
load_model_state_dict(model, name)
return model
return classifier_loader
|
class TFHider():
tf = None
def __init__(self):
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import tensorflow.python.util.deprecation as deprecation
deprecation._PRINT_DEPRECATION_WARNINGS = False
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()... |
def classifier_loader():
TFHider()
gpus_list = TFHider.tf.config.experimental.list_physical_devices('GPU')
TFHider.tf.config.experimental.set_visible_devices(gpus_list[torch.cuda.current_device()], 'GPU')
with TFHider.tf.gfile.GFile('/data/~/tencent-ml-images/model.pb', 'rb') as f:
graph_def =... |
def classify(images, model, adversarial_attack):
images = images.cpu().numpy().transpose(0, 2, 3, 1)
with TFHider.tf.Session(graph=model) as sess:
logits = sess.run('import/logits/output:0', feed_dict={'import/Placeholder:0': images})
outputs = torch.from_numpy(logits).cuda()
return outputs
|
def gen_classifier_loader(name, d):
def classifier_loader():
if (name == 'googlenet/inceptionv1'):
model = torch_models.__dict__[d['arch']](pretrained=False, aux_logits=False, transform_input=True)
else:
model = torch_models.__dict__[d['arch']](pretrained=False)
lo... |
def gen_classifier_loader(name, d):
def classifier_loader():
model = timm.create_model(name, pretrained=False, qk_scale=(d['qk_scale'] if ('qk_scale' in d) else None))
load_model_state_dict(model, name)
return model
return classifier_loader
|
class TFHider():
tf = None
def __init__(self):
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import tensorflow.python.util.deprecation as deprecation
deprecation._PRINT_DEPRECATION_WARNINGS = False
import tensorflow as tf
TFHider.tf = tf
|
def gen_classifier_loader(name, d):
def classifier_loader():
TFHider()
gpus_list = TFHider.tf.config.experimental.list_physical_devices('GPU')
TFHider.tf.config.experimental.set_visible_devices(gpus_list[torch.cuda.current_device()], 'GPU')
loaded = TFHider.tf.saved_model.load(('/... |
def classify(images, model, adversarial_attack):
images = TFHider.tf.convert_to_tensor(images.cpu().numpy().transpose(0, 2, 3, 1))
outputs = model(images)
outputs = torch.from_numpy(outputs.numpy()).cuda()
return outputs
|
class Registry():
def __init__(self):
self.models = {}
self.eval_settings = {}
def add_model(self, model):
assert (model.name not in self.models), f'Duplicate model {model.name} found. Model names must be unique.'
self.models[model.name] = model
def add_eval_setting(self... |
def build_clip_imagenet_model(ckpt_path):
checkpoint = torch.load(ckpt_path)
args = checkpoint['args']
hparams = checkpoint['model_hparams']
model_class = algorithms.get_algorithm_class(args['algorithm'])
feature_dim = checkpoint['model_feature_dim']
orig_num_classes = checkpoint['model_num_cl... |
def to_rgb(image):
return image.convert('RGB')
|
def clip_transform(n_px):
return Compose([Resize(n_px, interpolation=Image.BICUBIC), CenterCrop(n_px), to_rgb, ToTensor(), Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))])
|
def load_processed_dataset(path):
processed_dataset = np.load(path)
return processed_dataset
|
class L3Attack(torch.autograd.Function):
@staticmethod
def forward(self, model, img, target_lable, dataset, allstep, sink_lr, s_radius):
return L3_function(model, img, target_lable, dataset=dataset, allstep=allstep, lr=sink_lr, s_radius=s_radius)
@staticmethod
def backward(self, grad_output)... |
class L4Attack(torch.autograd.Function):
@staticmethod
def forward(self, model, img, dataset, allstep, sink_lr, u_radius):
return L4_function(model, img, dataset=dataset, allstep=allstep, lr=sink_lr, u_radius=u_radius)
@staticmethod
def backward(self, grad_output):
return (None, grad... |
def L3_function(model, img, target_lable, dataset, allstep, lr, s_radius, margin=20, use_margin=False):
x_var = torch.autograd.Variable(img.clone().cuda(), requires_grad=True)
optimizer_s = optim.SGD([x_var], lr=lr)
with torch.enable_grad():
for step in range(allstep):
optimizer_s.zero... |
def L4_function(model, img, dataset, allstep, lr, u_radius, margin=20, use_margin=False):
x_var = torch.autograd.Variable(img.clone().cuda(), requires_grad=True)
true_label = model(transform(x_var.clone(), dataset=dataset)).data.max(1, keepdim=True)[1][0].item()
optimizer_s = optim.SGD([x_var], lr=lr)
... |
def noisy_img(img, n_radius):
return (img + (n_radius * torch.randn_like(img)))
|
def cross_entropy(pred, target):
logsoftmax = nn.LogSoftmax()
return torch.mean(torch.sum(((- target) * logsoftmax(pred)), dim=1))
|
def target_distribution(original_softmax, target_label):
true_label = original_softmax.max(1, keepdim=True)[1][0].item()
target_l = original_softmax.clone()
temp = target_l.clone()[(0, int(true_label))]
target_l[(0, int(true_label))] = target_l[(0, int(target_label))]
target_l[(0, int(target_label... |
def PGD(model, img, dataset='imagenet', allstep=30, lr=0.03, radius=0.1, lbd=2, setting='white', noise_radius=0.1, targeted_lr=0.005, targeted_radius=0.03, untargeted_lr=0.1, untargeted_radius=0.03):
model.eval()
x_var = torch.autograd.Variable(img.clone().cuda(), requires_grad=True)
true_label = model(tr... |
def CW(model, img, dataset='imagenet', allstep=30, lr=0.03, radius=0.1, margin=20.0, lbd=2, setting='white', noise_radius=0.1, targeted_lr=0.005, targeted_radius=0.03, untargeted_lr=0.1, untargeted_radius=0.03):
model.eval()
x_var = torch.autograd.Variable(img.clone().cuda(), requires_grad=True)
true_labe... |
def l1_detection(model, img, dataset, n_radius):
return torch.norm((F.softmax(model(transform(img, dataset=dataset))) - F.softmax(model(transform(noisy(img, n_radius), dataset=dataset)))), 1).item()
|
def targeted_detection(model, img, dataset, lr, t_radius, cap=200, margin=20, use_margin=False):
model.eval()
x_var = torch.autograd.Variable(img.clone().cuda(), requires_grad=True)
true_label = model(transform(x_var.clone(), dataset=dataset)).data.max(1, keepdim=True)[1][0].item()
optimizer_s = optim... |
def untargeted_detection(model, img, dataset, lr, u_radius, cap=1000, margin=20, use_margin=False):
model.eval()
x_var = torch.autograd.Variable(img.clone().cuda(), requires_grad=True)
true_label = model(transform(x_var.clone(), dataset=dataset)).data.max(1, keepdim=True)[1][0].item()
optimizer_s = op... |
def l1_vals(model, dataset, title, attack, lowind, upind, real_dir, adv_dir, n_radius):
vals = np.zeros(0)
if (attack == 'real'):
for i in range(lowind, upind):
image_dir = os.path.join(real_dir, (str(i) + '_img.pt'))
assert os.path.exists(image_dir)
view_data = tor... |
def targeted_vals(model, dataset, title, attack, lowind, upind, real_dir, adv_dir, targeted_lr, t_radius):
vals = np.zeros(0)
if (attack == 'real'):
for i in range(lowind, upind):
image_dir = os.path.join(real_dir, (str(i) + '_img.pt'))
assert os.path.exists(image_dir)
... |
def untargeted_vals(model, dataset, title, attack, lowind, upind, real_dir, adv_dir, untargeted_lr, u_radius):
vals = np.zeros(0)
if (attack == 'real'):
for i in range(lowind, upind):
image_dir = os.path.join(real_dir, (str(i) + '_img.pt'))
assert os.path.exists(image_dir)
... |
def single_metric_fpr_tpr(fpr, criterions, model, dataset, title, attacks, lowind, upind, real_dir, adv_dir, n_radius, targeted_lr, t_radius, untargeted_lr, u_radius, opt='l1'):
if (opt == 'l1'):
target = l1_vals(model, dataset, title, 'real', lowind, upind, real_dir, adv_dir, n_radius)
threshold ... |
def combined_metric_fpr_tpr(fpr, criterions, model, dataset, title, attacks, lowind, upind, real_dir, adv_dir, n_radius, targeted_lr, t_radius, untargeted_lr, u_radius):
target_1 = l1_vals(model, dataset, title, 'real', lowind, upind, real_dir, adv_dir, n_radius)
target_2 = targeted_vals(model, dataset, title... |
def tune_criterion_thresholds(model, dataset, title, attacks, lowind, upind, real_dir, adv_dir, n_radius, targeted_lr, t_radius, untargeted_lr, u_radius, target_fpr):
target_1 = l1_vals(model, dataset, title, 'real', lowind, upind, real_dir, adv_dir, n_radius)
target_2 = targeted_vals(model, dataset, title, '... |
class VGG(nn.Module):
'\n VGG model\n '
def __init__(self, features):
super(VGG, self).__init__()
self.features = features
self.classifier = nn.Sequential(nn.Dropout(), nn.Linear(512, 512), nn.ReLU(True), nn.Dropout(), nn.Linear(512, 512), nn.ReLU(True), nn.Linear(512, 10))
... |
def make_layers(cfg, batch_norm=False):
layers = []
in_channels = 3
for v in cfg:
if (v == 'M'):
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
if batch_norm:
layers +=... |
def vgg19():
'VGG 19-layer model (configuration "E")'
return VGG(make_layers([64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M']))
|
def main():
global args, best_prec1
args = parser.parse_args()
if (not os.path.exists(args.save_dir)):
os.makedirs(args.save_dir)
if (not os.path.exists(args.real_dir)):
os.makedirs(args.real_dir)
model = vgg19()
model.features = torch.nn.DataParallel(model.features)
if arg... |
def train(train_loader, model, criterion, optimizer, epoch):
'\n Run one train epoch\n '
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
model.train()
end = time.time()
for (i, (input, target)) in enumerate(train_loader):
... |
def validate(val_loader, model, criterion):
'\n Run evaluation\n '
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
model.eval()
end = time.time()
for (i, (input, target)) in enumerate(val_loader):
if (args.cpu == False):
input = input.cud... |
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
'\n Save the training model\n '
torch.save(state, filename)
|
class AverageMeter(object):
'Computes and stores the average and current value'
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += (val... |
def adjust_learning_rate(optimizer, epoch):
'Sets the learning rate to the initial LR decayed by 2 every 30 epochs'
lr = (args.lr * (0.5 ** (epoch // 30)))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
|
def accuracy(output, target, topk=(1,)):
'Computes the precision@k for the specified values of k'
maxk = max(topk)
batch_size = target.size(0)
(_, pred) = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, (- 1)).expand_as(pred))
res = []
for k in topk:
... |
def run_tasks(config_path, cuda_devices):
command = f'HYDRA_CONFIG_PATH={config_path} python run_tasks_on_multiple_gpus.py cuda_devices={cuda_devices}'
log.info(f'Command: {command}')
ret = os.system(command)
if (ret != 0):
raise RuntimeError(ret)
return ret
|
def average_results(config, work_dir):
tasks = []
for model_dir_name in os.listdir(config.model_dir):
model_path = (Path(config.model_dir) / model_dir_name)
model_args_str = config.args
model_args_str += ' '
model_args_str += f'model.model_name_or_path={model_path}'
for... |
@hydra.main(config_path=os.environ['HYDRA_CONFIG_PATH'])
def main(config):
auto_generated_dir = os.getcwd()
log.info(f'Work dir: {auto_generated_dir}')
os.chdir(hydra.utils.get_original_cwd())
average_results(config, auto_generated_dir)
|
def convert_dropouts(model, ue_args):
if (ue_args.dropout_type == 'MC'):
dropout_ctor = (lambda p, activate: DropoutMC(p=ue_args.inference_prob, activate=False))
elif (ue_args.dropout_type == 'DPP'):
def dropout_ctor(p, activate):
return DropoutDPP(p=p, activate=activate, max_n=ue... |
def calculate_dropouts(model):
res = 0
for (i, layer) in enumerate(list(model.children())):
module_name = list(model._modules.items())[i][0]
layer_name = layer._get_name()
if (layer_name == 'Dropout'):
res += 1
else:
res += calculate_dropouts(model=layer... |
def freeze_all_dpp_dropouts(model, freeze):
for layer in model.children():
if isinstance(layer, DropoutDPP):
if freeze:
layer.mask.freeze(dry_run=True)
else:
layer.mask.unfreeze(dry_run=True)
else:
freeze_all_dpp_dropouts(model=la... |
def compute_metrics(is_regression, metric, p: EvalPrediction):
preds = (p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions)
preds = (np.squeeze(preds) if is_regression else np.argmax(preds, axis=1))
result = metric.compute(predictions=preds, references=p.label_ids)
if (len(result)... |
def do_predict_eval(model, tokenizer, trainer, eval_dataset, train_dataset, metric, config, work_dir):
log.info('*** Evaluate ***')
training_args = config.training
true_labels = [example.label for example in eval_dataset]
tagger = TextClassifier(model, tokenizer, training_args=training_args, trainer=t... |
def fix_task_name(task_name):
return ('sst2' if (task_name == 'sst-2') else task_name)
|
def train_eval_glue_model(config, training_args, data_args, work_dir):
ue_args = config.ue
model_args = config.model
log.info(f'Seed: {config.seed}')
set_seed(config.seed)
random.seed(config.seed)
mnli_mm = False
if (data_args.task_name == 'mnli-mm'):
mnli_mm = True
data_ar... |
def update_config(cfg_old, cfg_new):
for (k, v) in cfg_new.items():
if (k in cfg_old.__dict__):
setattr(cfg_old, k, v)
return cfg_old
|
@hydra.main(config_path=os.environ['HYDRA_CONFIG_PATH'])
def main(config):
os.environ['WANDB_WATCH'] = 'False'
auto_generated_dir = os.getcwd()
log.info(f'Work dir: {auto_generated_dir}')
os.chdir(hydra.utils.get_original_cwd())
wandb_run = init_wandb(auto_generated_dir, config)
args_train = T... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.