code stringlengths 17 6.64M |
|---|
def accuracy(output, target, topk=(1,)):
'Computes the precision@k for the specified values of k'
with torch.no_grad():
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)).expa... |
def test_imagenet_zero(fc_file_pred, has_train=1):
with open(classids_file_retrain) as fp:
classids = json.load(fp)
with open(word2vec_file, 'rb') as fp:
word2vec_feat = pkl.load(fp)
testlist = []
testlabels = []
with open(vallist_folder) as fp:
for line in fp:
... |
def download(vid_file):
with open(vid_file) as fp:
vid_list = [line.strip() for line in fp]
url_list = 'http://www.image-net.org/download/synset?wnid='
url_key = ('&username=%s&accesskey=%s&release=latest&src=stanford' % (args.user, args.key))
testfile = urllib.URLopener()
for i in range(l... |
def make_image_list(list_file, image_dir, name, offset=1000):
with open(list_file) as fp:
wnid_list = [line.strip() for line in fp]
save_file = os.path.join(data_dir, 'list', ('img-%s.txt' % name))
wr_fp = open(save_file, 'w')
for (i, wnid) in enumerate(wnid_list):
img_list = glob.glob... |
def rm_empty(vid_file):
with open(vid_file) as fp:
vid_list = [line.strip() for line in fp]
cnt = 0
for i in range(len(vid_list)):
save_dir = os.path.join(scratch_dir, vid_list[i])
jpg_list = glob.glob((save_dir + '/*.JPEG'))
if (len(jpg_list) < 10):
print(vid_l... |
def down_sample(list_file, image_dir, size=256):
with open(list_file) as fp:
index_list = [line.split()[0] for line in fp]
for (i, index) in enumerate(index_list):
img_file = os.path.join(image_dir, index)
if (not os.path.exists(img_file)):
print('not exist:', img_file)
... |
def downsample_image(img_file, target_size):
img = cv2.imread(img_file)
if (img is None):
return img
im_shape = img.shape
im_size_min = np.min(im_shape[0:2])
im_scale = (float(target_size) / float(im_size_min))
im_scale = min(1, im_scale)
img = cv2.resize(img, None, None, fx=im_sca... |
def parse_arg():
parser = argparse.ArgumentParser(description='')
parser.add_argument('--hop', type=str, default='2', help='choice of test difficulties: 2,3,all')
parser.add_argument('--save_dir', type=str, default=None, help='path to save images')
parser.add_argument('--user', type=str, help='your us... |
def my_make_dataset(dir, class_to_idx, extensions):
cached_fn = (('cached_' + dir.replace('/', '_').strip('_')) + '.pth')
if os.path.isfile(cached_fn):
print(('Load from cached file list: ' + cached_fn))
return torch.load(cached_fn)
images = []
dir = os.path.expanduser(dir)
for tar... |
class MyDatasetFolder(DatasetFolder):
def __init__(self, root, loader, extensions, transform=None, target_transform=None):
(classes, class_to_idx) = find_classes(root)
samples = my_make_dataset(root, class_to_idx, extensions)
if (len(samples) == 0):
raise RuntimeError(((('Foun... |
class MyImageFolder(MyDatasetFolder):
def __init__(self, root, transform=None, target_transform=None, loader=default_loader):
super(MyImageFolder, self).__init__(root, loader, IMG_EXTENSIONS, transform=transform, target_transform=target_transform)
self.imgs = self.samples
def __getitem__(sel... |
def main():
global args, best_prec1
args = parser.parse_args()
args.distributed = (args.world_size > 1)
if args.distributed:
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size)
if args.pretrained:
print("=> using pre-trained mod... |
def train(train_loader, model, criterion, optimizer, epoch):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
model.train()
end = time.time()
for (i, (input, target, paths)) in enumerate(train_loader):
da... |
def validate(val_loader, model, criterion):
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
model.eval()
with torch.no_grad():
end = time.time()
for (i, (input, target, paths)) in enumerate(val_loader):
target = target... |
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, 'model_best.pth.tar')
|
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 10 every 30 epochs'
lr = (args.lr * (0.1 ** (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'
with torch.no_grad():
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)).expa... |
def embed_text_file(text_file, word_vectors, get_vector, save_file):
with open(text_file) as fp:
text_list = json.load(fp)
all_feats = []
has = 0
cnt_missed = 0
missed_list = []
for i in range(len(text_list)):
class_name = text_list[i].lower()
if ((i % 500) == 0):
... |
def get_embedding(entity_str, word_vectors, get_vector):
try:
feat = get_vector(word_vectors, entity_str)
return feat
except:
feat = np.zeros(feat_len)
str_set = filter(None, re.split('[ \\-_]+', entity_str))
cnt_word = 0
for i in range(len(str_set)):
temp_str = str... |
def get_glove_dict(txt_dir):
print('load glove word embedding')
txt_file = os.path.join(txt_dir, 'glove.6B.300d.txt')
word_dict = {}
with open(txt_file) as fp:
for line in fp:
feat = np.zeros(feat_len)
words = line.split()
assert ((len(words) - 1) == feat_le... |
def glove_google(word_vectors, word):
return word_vectors[word]
|
def fasttext(word_vectors, word):
return word_vectors.get_word_vector(word)
|
def get_vector(word_vectors, word):
if (word in word_vectors.stoi):
return word_vectors[word].numpy()
else:
raise NotImplementedError
|
def parse_arg():
parser = argparse.ArgumentParser(description='word embeddign type')
parser.add_argument('--wv', type=str, default='glove', help='word embedding type: [glove, google, fasttext]')
parser.add_argument('--path', type=str, default='', help='path to pretrained word embedding model')
args = ... |
def test(image_file, fc, feat_dir):
(index_list, label_list) = ([], [])
with open(image_file) as fp:
for line in fp:
(index, l) = line.split()
index_list.append(index.split('.')[0])
label_list.append(int(l))
top_retrv = [1, 5]
hit_count = np.zeros(len(top_re... |
def get_imdb(name):
'Get an imdb (image database) by name.'
if (name not in __sets):
raise KeyError('Unknown dataset: {}'.format(name))
return __sets[name]()
|
def list_imdbs():
'List all registered imdbs.'
return list(__sets.keys())
|
def generate_anchors_pre(height, width, feat_stride, anchor_scales=(8, 16, 32), anchor_ratios=(0.5, 1, 2)):
" A wrapper function to generate anchors given different scales\n Also return the number of anchors in variable 'length'\n "
anchors = generate_anchors(ratios=np.array(anchor_ratios), scales=np.arra... |
def get_output_dir(imdb, weights_filename):
'Return the directory where experimental artifacts are placed.\n If the directory does not exist, it is created.\n\n A canonical path is built using the name from an imdb and a network\n (if not None).\n '
outdir = osp.abspath(osp.join(__C.ROOT_DIR, 'output', __... |
def get_output_tb_dir(imdb, weights_filename):
'Return the directory where tensorflow summaries are placed.\n If the directory does not exist, it is created.\n\n A canonical path is built using the name from an imdb and a network\n (if not None).\n '
outdir = osp.abspath(osp.join(__C.ROOT_DIR, 'tensorboar... |
def _merge_a_into_b(a, b):
'Merge config dictionary a into config dictionary b, clobbering the\n options in b whenever they are also specified in a.\n '
if (type(a) is not edict):
return
for (k, v) in a.items():
if (k not in b):
raise KeyError('{} is not a valid config key'.f... |
def cfg_from_file(filename):
'Load a config file and merge it into the default options.'
import yaml
with open(filename, 'r') as f:
yaml_cfg = edict(yaml.load(f))
_merge_a_into_b(yaml_cfg, __C)
|
def cfg_from_list(cfg_list):
'Set config keys via list (e.g., from command line).'
from ast import literal_eval
assert ((len(cfg_list) % 2) == 0)
for (k, v) in zip(cfg_list[0::2], cfg_list[1::2]):
key_list = k.split('.')
d = __C
for subkey in key_list[:(- 1)]:
asser... |
def scale_lr(optimizer, scale):
'Scale the learning rate of the optimizer'
for param_group in optimizer.param_groups:
param_group['lr'] *= scale
|
class SolverWrapper(object):
'\n A wrapper class for the training process\n '
def __init__(self, network, imdb, roidb, valroidb, output_dir, tbdir, pretrained_model=None):
self.net = network
self.imdb = imdb
self.roidb = roidb
self.valroidb = valroidb
self.output_d... |
def get_training_roidb(imdb):
'Returns a roidb (Region of Interest database) for use in training.'
if cfg.TRAIN.USE_FLIPPED:
print('Appending horizontally-flipped training examples...')
imdb.append_flipped_images()
print('done')
print('Preparing training data...')
rdl_roidb.pre... |
def filter_roidb(roidb):
'Remove roidb entries that have no usable RoIs.'
def is_valid(entry):
overlaps = entry['max_overlaps']
fg_inds = np.where((overlaps >= cfg.TRAIN.FG_THRESH))[0]
bg_inds = np.where(((overlaps < cfg.TRAIN.BG_THRESH_HI) & (overlaps >= cfg.TRAIN.BG_THRESH_LO)))[0]
... |
def train_net(network, imdb, roidb, valroidb, output_dir, tb_dir, pretrained_model=None, max_iters=40000):
'Train a Faster R-CNN network.'
roidb = filter_roidb(roidb)
valroidb = filter_roidb(valroidb)
sw = SolverWrapper(network, imdb, roidb, valroidb, output_dir, tb_dir, pretrained_model=pretrained_mo... |
def mobilenet_v1_base(final_endpoint='Conv2d_13_pointwise', min_depth=8, depth_multiplier=1.0, conv_defs=None, output_stride=None):
"Mobilenet v1.\n\n Constructs a Mobilenet v1 network from inputs to the given final endpoint.\n\n Args:\n inputs: a tensor of shape [batch_size, height, width, channels]... |
class mobilenetv1(Network):
def __init__(self):
Network.__init__(self)
self._feat_stride = [16]
self._feat_compress = [(1.0 / float(self._feat_stride[0]))]
self._depth_multiplier = cfg.MOBILENET.DEPTH_MULTIPLIER
self._net_conv_channels = 512
self._fc7_channels = 10... |
class ResNet(torchvision.models.resnet.ResNet):
def __init__(self, block, layers, num_classes=1000):
self.inplanes = 64
super(ResNet, self).__init__(block, layers, num_classes)
for i in range(2, 4):
getattr(self, ('layer%d' % i))[0].conv1.stride = (2, 2)
getattr(se... |
def resnet18(pretrained=False):
'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])
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
return model
|
def resnet34(pretrained=False):
'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])
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet34']))
return model
|
def resnet50(pretrained=False):
'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])
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
return model
|
def resnet101(pretrained=False):
'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])
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
return model
|
def resnet152(pretrained=False):
'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])
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet152']))
return model
|
class resnetv1(Network):
def __init__(self, num_layers=50):
Network.__init__(self)
self._feat_stride = [16]
self._feat_compress = [(1.0 / float(self._feat_stride[0]))]
self._num_layers = num_layers
self._net_conv_channels = 1024
self._fc7_channels = 2048
def _... |
class vgg16(Network):
def __init__(self):
Network.__init__(self)
self._feat_stride = [16]
self._feat_compress = [(1.0 / float(self._feat_stride[0]))]
self._net_conv_channels = 512
self._fc7_channels = 4096
def _init_head_tail(self):
self.vgg = models.vgg16()
... |
def prepare_roidb(imdb):
"Enrich the imdb's roidb by adding some derived quantities that\n are useful for training. This function precomputes the maximum\n overlap, taken over ground-truth boxes, between each ROI and\n each ground-truth box. The class with maximum overlap is also\n recorded.\n "
roidb = ... |
class Timer(object):
'A simple timer.'
def __init__(self):
self._total_time = {}
self._calls = {}
self._start_time = {}
self._diff = {}
self._average_time = {}
def tic(self, name='default'):
if torch.cuda.is_available():
torch.cuda.synchronize(... |
def add_path(path):
if (path not in sys.path):
sys.path.insert(0, path)
|
def parse_args():
'\n Parse input arguments\n '
parser = argparse.ArgumentParser(description='Re-evaluate results')
parser.add_argument('output_dir', nargs=1, help='results directory', type=str)
parser.add_argument('--imdb', dest='imdb_name', help='dataset to re-evaluate', default='voc_2007_test', t... |
def from_dets(imdb_name, output_dir, args):
imdb = get_imdb(imdb_name)
imdb.competition_mode(args.comp_mode)
imdb.config['matlab_eval'] = args.matlab_eval
with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f:
dets = pickle.load(f)
if args.apply_nms:
print('Applying NMS ... |
def parse_args():
'\n Parse input arguments\n '
parser = argparse.ArgumentParser(description='Test a Fast R-CNN network')
parser.add_argument('--cfg', dest='cfg_file', help='optional config file', default=None, type=str)
parser.add_argument('--model', dest='model', help='model to test', default=None... |
def parse_args():
'\n Parse input arguments\n '
parser = argparse.ArgumentParser(description='Train a Fast R-CNN network')
parser.add_argument('--cfg', dest='cfg_file', help='optional config file', default=None, type=str)
parser.add_argument('--weight', dest='weight', help='initialize with pretraine... |
def combined_roidb(imdb_names):
'\n Combine multiple roidbs\n '
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print('Loaded dataset `{:s}` for training'.format(imdb.name))
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print('Set proposal method: {:s}'.format(cfg... |
def complex_flatten(real, imag):
real = tf.keras.layers.Flatten()(real)
imag = tf.keras.layers.Flatten()(imag)
return (real, imag)
|
def CReLU(real, imag):
real = tf.keras.layers.ReLU()(real)
imag = tf.keras.layers.ReLU()(imag)
return (real, imag)
|
def zReLU(real, imag):
real = tf.keras.layers.ReLU()(real)
imag = tf.keras.layers.ReLU()(imag)
real_flag = tf.cast(tf.cast(real, tf.bool), tf.float32)
imag_flag = tf.cast(tf.cast(imag, tf.bool), tf.float32)
flag = (real_flag * imag_flag)
real = tf.math.multiply(real, flag)
imag = tf.math.m... |
def modReLU(real, imag):
norm = tf.abs(tf.complex(real, imag))
bias = tf.Variable(np.zeros([norm.get_shape()[(- 1)]]), trainable=True, dtype=tf.float32)
relu = tf.nn.relu((norm + bias))
real = tf.math.multiply(((relu / norm) + 100000.0), real)
imag = tf.math.multiply(((relu / norm) + 100000.0), im... |
def CLeaky_ReLU(real, imag):
real = tf.nn.leaky_relu(real)
imag = tf.nn.leaky_relu(imag)
return (real, imag)
|
def complex_tanh(real, imag):
real = tf.nn.tanh(real)
imag = tf.nn.tanh(imag)
return (real, imag)
|
def complex_softmax(real, imag):
magnitude = tf.abs(tf.complex(real, imag))
magnitude = tf.keras.layers.Softmax()(magnitude)
return magnitude
|
def update_params(lr, epoch):
for p in net.parameters():
if (not hasattr(p, 'buf')):
p.buf = torch.zeros(p.size()).cuda(device_id)
d_p = p.grad.data
d_p.add_(weight_decay, p.data)
buf_new = (((1 - args.alpha) * p.buf) - (lr * d_p))
if (((epoch % 50) + 1) > 45):
... |
def adjust_learning_rate(epoch, batch_idx):
rcounter = ((epoch * num_batch) + batch_idx)
cos_inner = (np.pi * (rcounter % (T // M)))
cos_inner /= (T // M)
cos_out = (np.cos(cos_inner) + 1)
lr = ((0.5 * cos_out) * lr_0)
return lr
|
def train(epoch):
print(('\nEpoch: %d' % epoch))
net.train()
train_loss = 0
correct = 0
total = 0
for (batch_idx, (inputs, targets)) in enumerate(trainloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targets.cuda(device_id))
net.zero_grad()
... |
def test(epoch):
global best_acc
net.eval()
test_loss = 0
correct = 0
total = 0
with torch.no_grad():
for (batch_idx, (inputs, targets)) in enumerate(testloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targets.cuda(device_id))
... |
def noise_loss(lr, alpha):
noise_loss = 0.0
noise_std = (((2 / lr) * alpha) ** 0.5)
for var in net.parameters():
means = torch.zeros(var.size()).cuda(device_id)
noise_loss += torch.sum((var * torch.normal(means, std=noise_std).cuda(device_id)))
return noise_loss
|
def adjust_learning_rate(optimizer, epoch, batch_idx):
rcounter = ((epoch * num_batch) + batch_idx)
cos_inner = (np.pi * (rcounter % (T // M)))
cos_inner /= (T // M)
cos_out = (np.cos(cos_inner) + 1)
lr = ((0.5 * cos_out) * lr_0)
for param_group in optimizer.param_groups:
param_group['... |
def train(epoch):
print(('\nEpoch: %d' % epoch))
net.train()
train_loss = 0
correct = 0
total = 0
for (batch_idx, (inputs, targets)) in enumerate(trainloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targets.cuda(device_id))
optimizer.zero_grad()
... |
def test(epoch):
global best_acc
net.eval()
test_loss = 0
correct = 0
total = 0
with torch.no_grad():
for (batch_idx, (inputs, targets)) in enumerate(testloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targets.cuda(device_id))
... |
def get_accuracy(truth, pred):
assert (len(truth) == len(pred))
right = 0
for i in range(len(truth)):
if (truth[i] == pred[i]):
right += 1.0
return (right / len(truth))
|
def test():
global best_acc
net.eval()
test_loss = 0
correct = 0
total = 0
pred_list = []
truth_res = []
with torch.no_grad():
for (batch_idx, (inputs, targets)) in enumerate(testloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targ... |
def update_params(lr, epoch):
for p in net.parameters():
if (not hasattr(p, 'buf')):
p.buf = torch.zeros(p.size()).cuda(device_id)
d_p = p.grad.data
d_p.add_(weight_decay, p.data)
buf_new = (((1 - args.alpha) * p.buf) - (lr * d_p))
if (((epoch % 50) + 1) > 45):
... |
def adjust_learning_rate(epoch, batch_idx):
rcounter = ((epoch * num_batch) + batch_idx)
cos_inner = (np.pi * (rcounter % (T // M)))
cos_inner /= (T // M)
cos_out = (np.cos(cos_inner) + 1)
lr = ((0.5 * cos_out) * lr_0)
return lr
|
def train(epoch):
print(('\nEpoch: %d' % epoch))
net.train()
train_loss = 0
correct = 0
total = 0
for (batch_idx, (inputs, targets)) in enumerate(trainloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targets.cuda(device_id))
net.zero_grad()
... |
def test(epoch):
global best_acc
net.eval()
test_loss = 0
correct = 0
total = 0
with torch.no_grad():
for (batch_idx, (inputs, targets)) in enumerate(testloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targets.cuda(device_id))
... |
def noise_loss(lr, alpha):
noise_loss = 0.0
noise_std = (((2 / lr) * alpha) ** 0.5)
for var in net.parameters():
means = torch.zeros(var.size()).cuda(device_id)
noise_loss += torch.sum((var * torch.normal(means, std=noise_std).cuda(device_id)))
return noise_loss
|
def adjust_learning_rate(optimizer, epoch, batch_idx):
rcounter = ((epoch * num_batch) + batch_idx)
cos_inner = (np.pi * (rcounter % (T // M)))
cos_inner /= (T // M)
cos_out = (np.cos(cos_inner) + 1)
lr = ((0.5 * cos_out) * lr_0)
for param_group in optimizer.param_groups:
param_group['... |
def train(epoch):
print(('\nEpoch: %d' % epoch))
net.train()
train_loss = 0
correct = 0
total = 0
for (batch_idx, (inputs, targets)) in enumerate(trainloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targets.cuda(device_id))
optimizer.zero_grad()
... |
def test(epoch):
global best_acc
net.eval()
test_loss = 0
correct = 0
total = 0
with torch.no_grad():
for (batch_idx, (inputs, targets)) in enumerate(testloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targets.cuda(device_id))
... |
def get_accuracy(truth, pred):
assert (len(truth) == len(pred))
right = 0
for i in range(len(truth)):
if (truth[i] == pred[i]):
right += 1.0
return (right / len(truth))
|
def test():
global best_acc
net.eval()
test_loss = 0
correct = 0
total = 0
pred_list = []
truth_res = []
with torch.no_grad():
for (batch_idx, (inputs, targets)) in enumerate(testloader):
if use_cuda:
(inputs, targets) = (inputs.cuda(device_id), targ... |
def learning_rate(init, epoch):
optim_factor = 0
if (epoch > 160):
optim_factor = 3
elif (epoch > 120):
optim_factor = 2
elif (epoch > 60):
optim_factor = 1
return (init * math.pow(0.2, optim_factor))
|
def get_hms(seconds):
(m, s) = divmod(seconds, 60)
(h, m) = divmod(m, 60)
return (h, m, s)
|
def plot_result(data, title, range_limit, point=True, step=1, alpha=1.0):
bbox = [range_limit[0], range_limit[1], range_limit[0], range_limit[1]]
df = pd.DataFrame(data)
fig = plt.figure(figsize=[5, 5])
g = sns.JointGrid(x=0, y=1, data=df, xlim=range_limit, ylim=range_limit)
g.plot_joint(sns.kdepl... |
def gmm(x):
for i in range(num_mixtures):
d = st.multivariate_normal(u_mean[i], [[std, 0.0], [0.0, std]])
if (i == 0):
ans = (d.pdf(x) / num_mixtures)
else:
ans += (d.pdf(x) / num_mixtures)
return ans
|
def evaluate_bivariate(range, npoints):
'Evaluate (possibly unnormalized) pdf over a meshgrid.'
side = np.linspace(range[0], range[1], npoints)
(z1, z2) = np.meshgrid(side, side)
zv = np.hstack([z1.reshape((- 1), 1), z2.reshape((- 1), 1)])
return (z1, z2, zv)
|
class Bottleneck(nn.Module):
def __init__(self, in_planes, growth_rate):
super(Bottleneck, self).__init__()
self.bn1 = nn.BatchNorm2d(in_planes)
self.conv1 = nn.Conv2d(in_planes, (4 * growth_rate), kernel_size=1, bias=False)
self.bn2 = nn.BatchNorm2d((4 * growth_rate))
sel... |
class Transition(nn.Module):
def __init__(self, in_planes, out_planes):
super(Transition, self).__init__()
self.bn = nn.BatchNorm2d(in_planes)
self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=1, bias=False)
def forward(self, x):
out = self.conv(F.relu(self.bn(x)))
... |
class DenseNet(nn.Module):
def __init__(self, block, nblocks, growth_rate=12, reduction=0.5, num_classes=10):
super(DenseNet, self).__init__()
self.growth_rate = growth_rate
num_planes = (2 * growth_rate)
self.conv1 = nn.Conv2d(3, num_planes, kernel_size=3, padding=1, bias=False)
... |
def DenseNet121():
return DenseNet(Bottleneck, [6, 12, 24, 16], growth_rate=32)
|
def DenseNet169():
return DenseNet(Bottleneck, [6, 12, 32, 32], growth_rate=32)
|
def DenseNet201():
return DenseNet(Bottleneck, [6, 12, 48, 32], growth_rate=32)
|
def DenseNet161():
return DenseNet(Bottleneck, [6, 12, 36, 24], growth_rate=48)
|
def densenet_cifar():
return DenseNet(Bottleneck, [6, 12, 24, 16], growth_rate=12)
|
def test_densenet():
net = densenet_cifar()
x = torch.randn(1, 3, 32, 32)
y = net(Variable(x))
print(y)
|
class Inception(nn.Module):
def __init__(self, in_planes, n1x1, n3x3red, n3x3, n5x5red, n5x5, pool_planes):
super(Inception, self).__init__()
self.b1 = nn.Sequential(nn.Conv2d(in_planes, n1x1, kernel_size=1), nn.BatchNorm2d(n1x1), nn.ReLU(True))
self.b2 = nn.Sequential(nn.Conv2d(in_planes... |
class GoogLeNet(nn.Module):
def __init__(self):
super(GoogLeNet, self).__init__()
self.pre_layers = nn.Sequential(nn.Conv2d(3, 192, kernel_size=3, padding=1), nn.BatchNorm2d(192), nn.ReLU(True))
self.a3 = Inception(192, 64, 96, 128, 16, 32, 32)
self.b3 = Inception(256, 128, 128, 1... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.