code stringlengths 17 6.64M |
|---|
def build_vocab(imgs, params):
count_thr = params['word_count_threshold']
counts = {}
for img in imgs:
for sent in img['sentences']:
for w in sent['tokens']:
counts[w] = (counts.get(w, 0) + 1)
cw = sorted([(count, w) for (w, count) in counts.items()], reverse=True)
... |
def encode_captions(imgs, params, wtoi):
' \n encode all captions into one large array, which will be 1-indexed.\n also produces label_start_ix and label_end_ix which store 1-indexed \n and inclusive (Lua-style) pointers to the first and last caption for\n each image in the dataset.\n '
max_len... |
def main(params):
imgs = json.load(open(params['input_json'], 'r'))
imgs = imgs['images']
seed(123)
vocab = build_vocab(imgs, params)
itow = {(i + 1): w for (i, w) in enumerate(vocab)}
wtoi = {w: (i + 1) for (i, w) in enumerate(vocab)}
(L, label_start_ix, label_end_ix, label_length) = enco... |
def get_doc_freq(refs, params):
tmp = CiderScorer(df_mode='corpus')
for ref in refs:
tmp.cook_append(None, ref)
tmp.compute_doc_freq()
return (tmp.document_frequency, len(tmp.crefs))
|
def build_dict(imgs, wtoi, params):
wtoi['<eos>'] = 0
count_imgs = 0
refs_words = []
refs_idxs = []
for img in imgs:
if ((params['split'] == img['split']) or ((params['split'] == 'train') and (img['split'] == 'restval')) or (params['split'] == 'all')):
ref_words = []
... |
def main(params):
imgs = json.load(open(params['input_json'], 'r'))
dict_json = json.load(open(params['dict_json'], 'r'))
itow = dict_json['ix_to_word']
wtoi = {w: i for (i, w) in itow.items()}
if ('bpe' in dict_json):
import tempfile
import codecs
codes_f = tempfile.NamedT... |
def main(params):
imgs = json.load(open(params['input_json'][0], 'r'))['images']
out = {'info': {'description': 'This is stable 1.0 version of the 2014 MS COCO dataset.', 'url': 'http://mscoco.org', 'version': '1.0', 'year': 2014, 'contributor': 'Microsoft COCO group', 'date_created': '2015-01-27 09:11:52.357... |
def test_folder():
x = pickle_load(open('log_trans/infos_trans.pkl', 'rb'))
dataset = CaptionDataset(x['opt'])
ds = torch.utils.data.Subset(dataset, dataset.split_ix['train'])
ds[0]
|
def test_lmdb():
x = pickle_load(open('log_trans/infos_trans.pkl', 'rb'))
x['opt'].input_att_dir = 'data/vilbert_att.lmdb'
dataset = CaptionDataset(x['opt'])
ds = torch.utils.data.Subset(dataset, dataset.split_ix['train'])
ds[0]
|
def add_summary_value(writer, key, value, iteration):
if writer:
writer.add_scalar(key, value, iteration)
|
def train(opt):
loader = DataLoader(opt)
opt.vocab_size = loader.vocab_size
opt.seq_length = loader.seq_length
infos = {'iter': 0, 'epoch': 0, 'loader_state_dict': None, 'vocab': loader.get_vocab()}
if ((opt.start_from is not None) and os.path.isfile(os.path.join(opt.start_from, (('infos_' + opt.i... |
class Dataset(torch.utils.data.Dataset):
def __init__(self, treated_patient_list, control_patient_list, diag_code_vocab=None, med_code_vocab=None):
self.treated_patient_list = treated_patient_list
self.control_patient_list = control_patient_list
self.diagnoses_visits = []
self.med... |
class LSTMModel(torch.nn.Module):
def __init__(self, diag_vocab_size, med_vocab_size, diag_embedding_size, med_embedding_size, diag_hidden_size, med_hidden_size, hidden_size, end_index, pad_index, bidirectional=True):
super().__init__()
self.pad_index = pad_index
self.end_index = end_inde... |
class CodeVocab(object):
END_CODE = '<end>'
PAD_CODE = '<pad>'
UNK_CODE = '<unk>'
def __init__(self):
super().__init__()
special_codes = [CodeVocab.END_CODE, CodeVocab.PAD_CODE, CodeVocab.UNK_CODE]
self.special_codes = special_codes
self.code2id = {}
self.id2co... |
def get_patient_cohort(root_file):
patient_1stDX_date = {}
patient_start_date = {}
for dir in ['CAD2012', 'CAD2013-2016']:
file = ((root_file + dir) + '/Cohort.csv')
with open(file, 'r') as f:
next(f)
for row in f:
row = row.split(',')
... |
def exclude(cad_prescription_taken_by_patient, patient_1stDX_date, patient_start_date, interval, followup, baseline):
cad_prescription_taken_by_patient_exclude = defaultdict(dict)
cad_patient_take_prescription_exclude = defaultdict(dict)
for (drug, taken_by_patient) in cad_prescription_taken_by_patient.it... |
def criteria_1_is_valid(index_date, DX):
return ((index_date - DX).days > 0)
|
def criteria_2_is_valid(dates, interval, followup, dates_days):
if ((dates[(- 1)] - dates[0]).days <= (followup - 89)):
return False
for i in range(1, len(dates)):
sup_day = dates_days.get(dates[(i - 1)])
if (((dates[i] - dates[(i - 1)]).days - sup_day) > interval):
return ... |
def criteria_3_is_valid(index_date, start_date, baseline):
return ((index_date - start_date).days >= baseline)
|
def user_cohort_extractor(cad_prescription_taken_by_patient, n_patients, n_prescriptions, time_interval):
cad_prescription_taken_by_patient_small = defaultdict(dict)
print('number of drugs: {}'.format(len(cad_prescription_taken_by_patient)), flush=True)
for (drug, patient_take_times) in cad_prescription_t... |
def minimal_criteria_is_valid(patient_take_times, n_patients, time_interval, n_prescriptions):
if (len(patient_take_times) < n_patients):
return False
count = 0
for (patient, take_times) in patient_take_times.items():
if drug_time_interval_is_valid(take_times, n_prescriptions, time_interva... |
def drug_time_interval_is_valid(take_times, n_prescription, time_interval):
count = 0
dates = [datetime.strptime(pair[0], '%m/%d/%Y') for pair in take_times if (pair[0] and pair[1])]
dates = sorted(dates)
for i in range(1, len(dates)):
if ((dates[i] - dates[(i - 1)]).days >= time_interval):
... |
def my_dump(obj, file_name):
print('dumping...', flush=True)
pickle.dump(obj, open(file_name, 'wb'))
print('dumped...', flush=True)
|
def my_load(file_name):
print('loading...', flush=True)
return pickle.load(open(file_name, 'rb'))
|
def get_user_dx(indir, patient_list, icd9_to_css, icd10_to_css):
user_dx = defaultdict(dict)
inpatient_dir = os.path.join(indir, 'inpatient')
inpatient_files = os.listdir(inpatient_dir)
outpatient_dir = os.path.join(indir, 'outpatient')
outpatient_files = os.listdir(outpatient_dir)
files = ([o... |
def get_css_code_for_icd(icd_codes, icd_to_css):
css_codes = []
for icd_code in icd_codes:
if (not pd.isnull(icd_code)):
for i in range(len(icd_code), (- 1), (- 1)):
if (icd_code[:i] in icd_to_css):
css_codes.append(icd_to_css.get(icd_code[:i]))
... |
def pre_user_cohort_dx(user_dx, cad_prescription_taken_by_patient, min_patients):
user_cohort_dx = AutoVivification()
for (drug, taken_by_patient) in tqdm(cad_prescription_taken_by_patient.items()):
if (len(taken_by_patient.keys()) >= min_patients):
for (patient, taken_times) in taken_by_p... |
class AutoVivification(dict):
"Implementation of perl's autovivification feature."
def __getitem__(self, item):
try:
return dict.__getitem__(self, item)
except KeyError:
value = self[item] = type(self)()
return value
|
def get_user_cohort_dx(indir, cad_prescription_taken_by_patient, icd9_to_css, icd10_to_css, min_patient, patient_list):
user_dx = get_user_dx(indir, patient_list, icd9_to_css, icd10_to_css)
return pre_user_cohort_dx(user_dx, cad_prescription_taken_by_patient, min_patient)
|
def pre_user_cohort_rx(cad_prescription_taken_by_patient, cad_patient_take_prescription, min_patients):
cad_user_cohort_rx = defaultdict(dict)
for (drug, taken_by_patient) in tqdm(cad_prescription_taken_by_patient.items()):
if (len(taken_by_patient.keys()) >= min_patients):
for (patient, t... |
def get_prescription_taken_times(index_date, dates, dates_2_days):
cnt = 0
for date in dates:
if (((index_date - date).days - dates_2_days[date]) > 0):
cnt += 1
else:
return cnt
return cnt
|
def drug_is_taken_in_baseline(index_date, dates):
for date in dates:
if ((index_date - date).days > 0):
return True
return False
|
def pre_user_cohort_rx_v2(cad_prescription_taken_by_patient, cad_patient_take_prescription, min_patients):
cad_user_cohort_rx = AutoVivification()
for (drug, taken_by_patient) in tqdm(cad_prescription_taken_by_patient.items()):
if (len(taken_by_patient.keys()) >= min_patients):
for (patien... |
def drug_is_taken_in_baseline_v2(index_date, dates):
res = []
for date in dates:
if ((index_date - date).days > 0):
res.append(date)
if (len(res) > 0):
return res
return False
|
class AutoVivification(dict):
"Implementation of perl's autovivification feature."
def __getitem__(self, item):
try:
return dict.__getitem__(self, item)
except KeyError:
value = self[item] = type(self)()
return value
|
def pre_user_cohort_demo(indir, patient_list):
cad_user_cohort_demo = {}
file = '{}/demo.csv'.format(indir)
with open(file, 'r') as f:
next(f)
for row in f:
row = row.split(',')
(id, db, sex) = (row[0], row[1], row[2])
if (id in patient_list):
... |
def get_user_cohort_demo(indir, patient_list):
return pre_user_cohort_demo(indir, patient_list)
|
def parse_args():
parser = argparse.ArgumentParser(description='process parameters')
parser.add_argument('--input_data_dir', default='../data/synthetic/drug', help='input data directory')
parser.add_argument('--output_data_dir', default='pickles/cad_prescription_taken_by_patient.pkl', help='output data di... |
def ndc2rxing():
mapping = np.loadtxt(fname='../data/NDC_complete_mapping.csv', delimiter=',', dtype='str', skiprows=1, usecols=(1, 2))
ndc2rx_mapping = {ndc: rx for (rx, ndc) in mapping}
return ndc2rx_mapping
|
def pre_drug_table(args):
cad_prescription_taken_by_patient = defaultdict(dict)
ndc2rx_mapping = ndc2rxing()
files = os.listdir(args.input_data_dir)
for file in files:
print('dir: {}\tfile: {}'.format(args.input_data_dir, file), flush=True)
df = os.path.join(args.input_data_dir, file)
... |
def drug_time_interval_is_valid(take_times, n_prescription, time_interval):
count = 0
dates = [datetime.strptime(pair[0], '%m/%d/%Y') for pair in take_times if (pair[0] and pair[1])]
dates = sorted(dates)
for i in range(1, len(dates)):
if ((dates[i] - dates[(i - 1)]).days >= time_interval):
... |
def is_valid_outcome_range(dx, code_range):
for code in code_range:
if dx.startswith(code):
return True
return False
|
def pre_user_cohort_outcome(indir, patient_list, codes9, codes0):
cad_user_cohort_outcome = defaultdict(list)
inpatient_dir = os.path.join(indir, 'inpatient')
inpatient_files = os.listdir(inpatient_dir)
outpatient_dir = os.path.join(indir, 'outpatient')
outpatient_files = os.listdir(outpatient_dir... |
def parse_args():
parser = argparse.ArgumentParser(description='process parameters')
parser.add_argument('--min_patients', default=500, type=int, help='minimum number of patients for each cohort.')
parser.add_argument('--min_prescription', default=2, type=int, help='minimum times of prescriptions of each ... |
def get_patient_list(min_patient, cad_prescription_taken_by_patient):
patients_list = set()
for (drug, patients) in cad_prescription_taken_by_patient.items():
if (len(patients) >= min_patient):
for patient in patients:
patients_list.add(patient)
return patients_list
|
def main(args):
print('Loading prescription data...')
cad_prescription_taken_by_patient = pickle.load(open(os.path.join(args.pickles, 'cad_prescription_taken_by_patient.pkl'), 'rb'))
(patient_1stDX_date, patient_start_date) = get_patient_init_date(args.input_data, args.pickles)
icd9_to_css = pickle.lo... |
def pre_user_cohort_triplet(cad_prescription_taken_by_patient, cad_user_cohort_rx, cad_user_cohort_dx, save_cohort_outcome, cad_user_cohort_demo, out_file_root):
cohorts_size = dict()
for (drug, taken_by_patient) in tqdm(cad_user_cohort_rx.items()):
file_x = '{}/{}.pkl'.format(out_file_root, drug)
... |
def get_outcome_feature_vector(dates, index_date):
for date in dates:
if ((date > index_date) and ((date - index_date).days <= 730)):
return 1
return 0
|
def get_rx_feature_vector(taken_times, RX2id, size):
feature_vector = ([0] * size)
for rx in taken_times:
if (rx in RX2id):
id = RX2id.get(rx)
feature_vector[id] = 1
return feature_vector
|
def get_dx_feature_vector(dx, CCS2id, size):
feature_vector = ([0] * size)
not_find = set()
for code in dx:
for c in code:
if (c in CCS2id):
id = CCS2id.get(c)
feature_vector[id] = 1
return (feature_vector, not_find)
|
def get_demo_feature_vector(demo, index_date):
if (not demo):
return [0, 0]
(db, sex) = demo
index_date_y = index_date.year
age = (index_date_y - int(db))
sex_n = (int(sex) - 1)
return [age, sex_n]
|
def get_patient_init_date(indir, outdir):
patient_1stDX_date = {}
patient_start_date = {}
file = '{}/Cohort.csv'.format(indir)
with open(file, 'r') as f:
next(f)
for row in f:
row = row.split(',')
(enrolid, dx_date, start_date) = (row[0], row[1], row[2])
... |
class Dataset(InMemoryDataset):
def __init__(self, root, dataset, rating_file, sep, args, transform=None, pre_transform=None):
self.path = root
self.dataset = dataset
self.rating_file = rating_file
self.sep = sep
self.store_backup = True
self.args = args
su... |
class inner_GNN(MessagePassing):
def __init__(self, dim, hidden_layer):
super(inner_GNN, self).__init__(aggr='mean')
self.lin1 = nn.Linear(dim, hidden_layer)
self.lin2 = nn.Linear(hidden_layer, dim)
self.act = nn.ReLU()
self.drop = nn.Dropout(p=0.5)
def forward(self, ... |
class cross_GNN(MessagePassing):
def __init__(self, dim, hidden_layer):
super(cross_GNN, self).__init__(aggr='mean')
def forward(self, x, edge_index, edge_weight=None):
x = x.squeeze()
return self.propagate(edge_index, x=x, edge_weight=edge_weight)
def message(self, x_i, x_j, ed... |
class GMCF(nn.Module):
'\n GMCF main model\n '
def __init__(self, args, n_features, device):
super(GMCF, self).__init__()
self.n_features = n_features
self.dim = args.dim
self.hidden_layer = args.hidden_layer
self.device = device
self.batch_size = args.ba... |
def train(args, data_info, show_loss):
train_loader = data_info['train']
val_loader = data_info['val']
test_loader = data_info['test']
feature_num = data_info['feature_num']
(train_num, val_num, test_num) = data_info['data_num']
device = torch.device(('cuda' if torch.cuda.is_available() else '... |
def evaluate(model, data_loader, device):
model.eval()
predictions = []
labels = []
user_ids = []
edges_all = [0, 0]
with torch.no_grad():
for data in data_loader:
(_, user_id_index) = np.unique(data.batch.detach().cpu().numpy(), return_index=True)
user_id = dat... |
def cal_ndcg(predicts, labels, user_ids, k):
d = {'user': np.squeeze(user_ids), 'predict': np.squeeze(predicts), 'label': np.squeeze(labels)}
df = pd.DataFrame(d)
user_unique = df.user.unique()
ndcg = []
for user_id in user_unique:
user_srow = df.loc[(df['user'] == user_id)]
upred ... |
class InpaintingTrainDataset(Dataset):
def __init__(self, paths, n_references, mask_generator, transform_shared, transform_individual):
self.in_files = paths
self.n_references = n_references
self.mask_generator = mask_generator
self.transform_shared = transform_shared
self... |
def get_transforms(transform_variant, out_size, easy=False):
assert (transform_variant == 'distortions')
if (transform_variant == 'default'):
transform = A.Compose([A.RandomScale(scale_limit=0.2), A.PadIfNeeded(min_height=out_size, min_width=out_size), A.RandomCrop(height=out_size, width=out_size), A.... |
def make_default_train_dataset(root, filelist, kind='default', out_size=512, mask_gen_kwargs=None, transform_variant='default', mask_generator_kind='mixed', easy=False, **kwargs):
if (kind != 'default'):
raise ValueError(f'Dropped support for other datasets: {kind}')
LOGGER.info(f'Make train dataloade... |
def make_default_val_dataset(indir, kind='default', out_size=512, **kwargs):
if (kind != 'default'):
raise ValueError(f'Dropped support for other datasets: {kind}')
if (OmegaConf.is_list(indir) or isinstance(indir, (tuple, list))):
return ConcatDataset([make_default_val_dataset(idir, kind=kind... |
def load_image(fname, mode='RGB', return_orig=False):
img = np.array(Image.open(fname).convert(mode))
if (img.ndim == 3):
img = np.transpose(img, (2, 0, 1))
out_img = (img.astype('float32') / 255)
if return_orig:
return (out_img, img)
else:
return out_img
|
def ceil_modulo(x, mod):
if ((x % mod) == 0):
return x
return (((x // mod) + 1) * mod)
|
def pad_img_to_modulo(img, mod):
(channels, height, width) = img.shape
out_height = ceil_modulo(height, mod)
out_width = ceil_modulo(width, mod)
return np.pad(img, ((0, 0), (0, (out_height - height)), (0, (out_width - width))), mode='symmetric')
|
def pad_tensor_to_modulo(img, mod):
(batch_size, channels, height, width) = img.shape
out_height = ceil_modulo(height, mod)
out_width = ceil_modulo(width, mod)
return F.pad(img, pad=(0, (out_width - width), 0, (out_height - height)), mode='reflect')
|
def scale_image(img, factor, interpolation=cv2.INTER_AREA):
if (img.shape[0] == 1):
img = img[0]
else:
img = np.transpose(img, (1, 2, 0))
img = cv2.resize(img, dsize=None, fx=factor, fy=factor, interpolation=interpolation)
if (img.ndim == 2):
img = img[(None, ...)]
else:
... |
class InpaintingEvaluationDataset(Dataset):
def __init__(self, datadir, img_suffix='.jpg', pad_out_to_modulo=None, scale_factor=None):
self.datadir = datadir
self.mask_filenames = sorted(list(glob.glob(os.path.join(self.datadir, '**', '*mask*.png'), recursive=True)))
self.img_filenames = ... |
class PRNGMixin(object):
'Adds a prng property which is a numpy RandomState which gets\n reinitialized whenever the pid changes to avoid synchronized sampling\n behavior when used in conjunction with multiprocessing.'
@property
def prng(self):
currentpid = os.getpid()
if (getattr(se... |
class LamaPropagation(Dataset, PRNGMixin):
def __init__(self, **kwargs):
self.clean_prob = kwargs.pop('clean_prob', (1.0 / kwargs['n_references']))
for k in default_mask_config:
if (not (k in kwargs)):
kwargs[k] = default_mask_config[k]
self.base_data = make_de... |
class LamaGI(Dataset, PRNGMixin):
def __init__(self, **kwargs):
self.clean_prob = kwargs.pop('clean_prob', (1.0 / kwargs['n_references']))
for k in default_mask_config:
if (not (k in kwargs)):
kwargs[k] = default_mask_config[k]
self.base_data = make_default_tra... |
class LamaGIValidation(Dataset):
def __init__(self, filenames, n_references, pad_out_to_modulo=None, scale_factor=None):
self.n_references = n_references
with open(filenames, 'r') as f:
filenames = f.read().splitlines()
self.mask_filenames = [fname for fname in filenames if fn... |
class CorrBlock():
def __init__(self, fmap1, fmap2, num_levels=4, radius=4):
self.num_levels = num_levels
self.radius = radius
self.corr_pyramid = []
corr = CorrBlock.corr(fmap1, fmap2)
(batch, h1, w1, dim, h2, w2) = corr.shape
corr = corr.reshape(((batch * h1) * w... |
class CorrLayer(torch.autograd.Function):
@staticmethod
def forward(ctx, fmap1, fmap2, coords, r):
fmap1 = fmap1.contiguous()
fmap2 = fmap2.contiguous()
coords = coords.contiguous()
ctx.save_for_backward(fmap1, fmap2, coords)
ctx.r = r
(corr,) = correlation_cud... |
class AlternateCorrBlock():
def __init__(self, fmap1, fmap2, num_levels=4, radius=4):
self.num_levels = num_levels
self.radius = radius
self.pyramid = [(fmap1, fmap2)]
for i in range(self.num_levels):
fmap1 = F.avg_pool2d(fmap1, 2, stride=2)
fmap2 = F.avg_p... |
class ResidualBlock(nn.Module):
def __init__(self, in_planes, planes, norm_fn='group', stride=1):
super(ResidualBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, padding=1, stride=stride)
self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1)
... |
class BottleneckBlock(nn.Module):
def __init__(self, in_planes, planes, norm_fn='group', stride=1):
super(BottleneckBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, (planes // 4), kernel_size=1, padding=0)
self.conv2 = nn.Conv2d((planes // 4), (planes // 4), kernel_size=3, paddin... |
class BasicEncoder(nn.Module):
def __init__(self, output_dim=128, norm_fn='batch', dropout=0.0):
super(BasicEncoder, self).__init__()
self.norm_fn = norm_fn
if (self.norm_fn == 'group'):
self.norm1 = nn.GroupNorm(num_groups=8, num_channels=64)
elif (self.norm_fn == 'ba... |
class SmallEncoder(nn.Module):
def __init__(self, output_dim=128, norm_fn='batch', dropout=0.0):
super(SmallEncoder, self).__init__()
self.norm_fn = norm_fn
if (self.norm_fn == 'group'):
self.norm1 = nn.GroupNorm(num_groups=8, num_channels=32)
elif (self.norm_fn == 'ba... |
class RAFT(nn.Module):
def __init__(self, args):
super(RAFT, self).__init__()
self.args = args
if args.small:
self.hidden_dim = hdim = 96
self.context_dim = cdim = 64
args.corr_levels = 4
args.corr_radius = 3
else:
self.h... |
class FlowHead(nn.Module):
def __init__(self, input_dim=128, hidden_dim=256):
super(FlowHead, self).__init__()
self.conv1 = nn.Conv2d(input_dim, hidden_dim, 3, padding=1)
self.conv2 = nn.Conv2d(hidden_dim, 2, 3, padding=1)
self.relu = nn.ReLU(inplace=True)
def forward(self, x... |
class ConvGRU(nn.Module):
def __init__(self, hidden_dim=128, input_dim=(192 + 128)):
super(ConvGRU, self).__init__()
self.convz = nn.Conv2d((hidden_dim + input_dim), hidden_dim, 3, padding=1)
self.convr = nn.Conv2d((hidden_dim + input_dim), hidden_dim, 3, padding=1)
self.convq = n... |
class SepConvGRU(nn.Module):
def __init__(self, hidden_dim=128, input_dim=(192 + 128)):
super(SepConvGRU, self).__init__()
self.convz1 = nn.Conv2d((hidden_dim + input_dim), hidden_dim, (1, 5), padding=(0, 2))
self.convr1 = nn.Conv2d((hidden_dim + input_dim), hidden_dim, (1, 5), padding=(0... |
class SmallMotionEncoder(nn.Module):
def __init__(self, args):
super(SmallMotionEncoder, self).__init__()
cor_planes = (args.corr_levels * (((2 * args.corr_radius) + 1) ** 2))
self.convc1 = nn.Conv2d(cor_planes, 96, 1, padding=0)
self.convf1 = nn.Conv2d(2, 64, 7, padding=3)
... |
class BasicMotionEncoder(nn.Module):
def __init__(self, args):
super(BasicMotionEncoder, self).__init__()
cor_planes = (args.corr_levels * (((2 * args.corr_radius) + 1) ** 2))
self.convc1 = nn.Conv2d(cor_planes, 256, 1, padding=0)
self.convc2 = nn.Conv2d(256, 192, 3, padding=1)
... |
class SmallUpdateBlock(nn.Module):
def __init__(self, args, hidden_dim=96):
super(SmallUpdateBlock, self).__init__()
self.encoder = SmallMotionEncoder(args)
self.gru = ConvGRU(hidden_dim=hidden_dim, input_dim=(82 + 64))
self.flow_head = FlowHead(hidden_dim, hidden_dim=128)
de... |
class BasicUpdateBlock(nn.Module):
def __init__(self, args, hidden_dim=128, input_dim=128):
super(BasicUpdateBlock, self).__init__()
self.args = args
self.encoder = BasicMotionEncoder(args)
self.gru = SepConvGRU(hidden_dim=hidden_dim, input_dim=(128 + hidden_dim))
self.flo... |
def conv_bn(inp, oup, stride):
return nn.Sequential(nn.Conv2d(inp, oup, 3, stride, 1, bias=False), BatchNorm2d(oup), nn.ReLU6(inplace=True))
|
def conv_1x1_bn(inp, oup):
return nn.Sequential(nn.Conv2d(inp, oup, 1, 1, 0, bias=False), BatchNorm2d(oup), nn.ReLU6(inplace=True))
|
class InvertedResidual(nn.Module):
def __init__(self, inp, oup, stride, expand_ratio):
super(InvertedResidual, self).__init__()
self.stride = stride
assert (stride in [1, 2])
hidden_dim = round((inp * expand_ratio))
self.use_res_connect = ((self.stride == 1) and (inp == ou... |
class MobileNetV2(nn.Module):
def __init__(self, n_class=1000, input_size=224, width_mult=1.0):
super(MobileNetV2, self).__init__()
block = InvertedResidual
input_channel = 32
last_channel = 1280
interverted_residual_setting = [[1, 16, 1, 1], [6, 24, 2, 2], [6, 32, 3, 2], ... |
def mobilenetv2(pretrained=False, **kwargs):
'Constructs a MobileNet_V2 model.\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = MobileNetV2(n_class=1000, **kwargs)
if pretrained:
model.load_state_dict(load_url(model_urls['mobilenetv2']), stri... |
def conv3x3(in_planes, out_planes, stride=1):
'3x3 convolution with padding'
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
|
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = BatchNorm2d(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = c... |
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, plan... |
class ResNet(nn.Module):
def __init__(self, block, layers, num_classes=1000):
self.inplanes = 128
super(ResNet, self).__init__()
self.conv1 = conv3x3(3, 64, stride=2)
self.bn1 = BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=True)
self.conv2 = conv3x3(64, 64)
... |
def resnet50(pretrained=False, **kwargs):
'Constructs a ResNet-50 model.\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n '
model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
if pretrained:
model.load_state_dict(load_url(model_urls['resnet50']), strict... |
def resnet18(pretrained=False, **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], **kwargs)
if pretrained:
model.load_state_dict(load_url(model_urls['resnet18']))
retu... |
def _sum_ft(tensor):
'sum over the first and last dimention'
return tensor.sum(dim=0).sum(dim=(- 1))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.