repo stringlengths 1 99 | file stringlengths 13 215 | code stringlengths 12 59.2M | file_length int64 12 59.2M | avg_line_length float64 3.82 1.48M | max_line_length int64 12 2.51M | extension_type stringclasses 1
value |
|---|---|---|---|---|---|---|
MAMS-for-ABSA | MAMS-for-ABSA-master/src/module/attention/mlp_attention.py | import torch
from torch import nn
from torch.nn import init
from src.module.attention.attention import Attention
class MlpAttention(Attention):
def __init__(self, query_size, key_size, out_size=100, dropout=0):
super(MlpAttention, self).__init__(dropout)
self.query_projection = nn.Linear(query_siz... | 1,092 | 44.541667 | 112 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/src/module/attention/no_query_attention.py | import torch
from torch import nn
from torch.nn import init
class NoQueryAttention(nn.Module):
def __init__(self, query_size, attention):
super(NoQueryAttention, self).__init__()
self.query_size = query_size
self.query = nn.Parameter(torch.Tensor(1, query_size))
init.xavier_uniform... | 566 | 32.352941 | 62 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/src/module/utils/squash.py | import torch
def squash(x, dim=-1):
squared = torch.sum(x * x, dim=dim, keepdim=True)
scale = torch.sqrt(squared) / (1.0 + squared)
return scale * x | 161 | 26 | 53 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/src/module/utils/loss.py | import torch
from torch import nn
import torch.nn.functional as F
class CapsuleLoss(nn.Module):
def __init__(self, smooth=0.1, lamda=0.6):
super(CapsuleLoss, self).__init__()
self.smooth = smooth
self.lamda = lamda
def forward(self, input, target):
one_hot = torch.zeros_like(i... | 2,309 | 38.152542 | 96 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/train/test.py | import torch
import os
from train import make_aspect_term_model, make_aspect_category_model
from train.make_data import make_term_test_data, make_category_test_data
from train.eval import eval
def test(config):
mode = config['mode']
if mode == 'term':
model = make_aspect_term_model.make_model(config)
... | 819 | 38.047619 | 118 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/train/make_aspect_term_model.py | import torch
from torch import nn
import numpy as np
import os
import yaml
from pytorch_pretrained_bert import BertModel
from src.aspect_term_model.recurrent_capsnet import RecurrentCapsuleNetwork
from src.aspect_term_model.bert_capsnet import BertCapsuleNetwork
def make_model(config):
model_type = config['aspect_... | 2,462 | 38.725806 | 83 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/train/make_data.py | import os
from torch.utils.data import DataLoader
from data_process.dataset import ABSADataset
input_list = {
'recurrent_capsnet': ['context', 'aspect'],
'bert_capsnet': ['bert_token', 'bert_segment']
}
def make_term_data(config):
base_path = config['base_path']
train_path = os.path.join(base_path, 'p... | 3,771 | 34.252336 | 93 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/train/make_optimizer.py | from torch import optim
import adabound
def make_optimizer(config, model):
mode = config['mode']
config = config['aspect_' + mode + '_model'][config['aspect_' + mode + '_model']['type']]
lr = config['learning_rate']
weight_decay = config['weight_decay']
opt = {
'sgd': optim.SGD,
'ad... | 831 | 35.173913 | 127 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/train/eval.py | import torch
def eval(model, data_loader, criterion=None):
total_samples = 0
correct_samples = 0
total_loss = 0
model.eval()
with torch.no_grad():
for data in data_loader:
input0, input1, label = data
input0, input1, label = input0.cuda(), input1.cuda(), label.cuda()... | 829 | 35.086957 | 81 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/train/make_aspect_category_model.py | import torch
from torch import nn
import numpy as np
import os
import yaml
from pytorch_pretrained_bert import BertModel
from src.aspect_category_model.recurrent_capsnet import RecurrentCapsuleNetwork
from src.aspect_category_model.bert_capsnet import BertCapsuleNetwork
def make_model(config):
model_type = config[... | 2,631 | 40.125 | 89 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/train/train.py | import torch
from torch import nn
from torch import optim
from train import make_aspect_term_model, make_aspect_category_model
from train.make_data import make_term_data, make_category_data
from train.make_optimizer import make_optimizer
from train.eval import eval
import os
import time
import pickle
from src.module.ut... | 3,271 | 42.052632 | 108 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/data_process/utils.py | import os
import numpy as np
import random
from xml.etree.ElementTree import parse
from pytorch_pretrained_bert import BertModel, BertTokenizer
from data_process.vocab import Vocab
from src.module.utils.constants import UNK, PAD_INDEX, ASPECT_INDEX
import spacy
import re
import json
url = re.compile('(<url>.*</url>)')... | 10,092 | 36.520446 | 132 | py |
MAMS-for-ABSA | MAMS-for-ABSA-master/data_process/dataset.py | import torch
from torch.utils.data import Dataset
import numpy as np
class ABSADataset(Dataset):
def __init__(self, path, input_list):
super(ABSADataset, self).__init__()
data = np.load(path)
self.data = {}
for key, value in data.items():
self.data[key] = torch.tensor(v... | 702 | 28.291667 | 56 | py |
OpenFWI | OpenFWI-main/pytorch_ssim.py | # From https://github.com/Po-Hsun-Su/pytorch-ssim/blob/master/pytorch_ssim/__init__.py
import torch
import torch.nn.functional as F
from torch.autograd import Variable
import numpy as np
from math import exp
def gaussian(window_size, sigma):
gauss = torch.Tensor([exp(-(x - window_size//2)**2/float(2*sigma**2)) fo... | 2,722 | 35.306667 | 104 | py |
OpenFWI | OpenFWI-main/test.py | # © 2022. Triad National Security, LLC. All rights reserved.
# This program was produced under U.S. Government contract 89233218CNA000001 for Los Alamos
# National Laboratory (LANL), which is operated by Triad National Security, LLC for the U.S.
# Department of Energy/National Nuclear Security Administration. All ri... | 10,383 | 42.814346 | 156 | py |
OpenFWI | OpenFWI-main/gan_train.py | # © 2022. Triad National Security, LLC. All rights reserved.
# This program was produced under U.S. Government contract 89233218CNA000001 for Los Alamos
# National Laboratory (LANL), which is operated by Triad National Security, LLC for the U.S.
# Department of Energy/National Nuclear Security Administration. All ri... | 16,662 | 43.553476 | 128 | py |
OpenFWI | OpenFWI-main/network.py | # © 2022. Triad National Security, LLC. All rights reserved.
# This program was produced under U.S. Government contract 89233218CNA000001 for Los Alamos
# National Laboratory (LANL), which is operated by Triad National Security, LLC for the U.S.
# Department of Energy/National Nuclear Security Administration. All ri... | 14,861 | 45.15528 | 167 | py |
OpenFWI | OpenFWI-main/vis.py | import os
import torch
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import ListedColormap
# Load colormap for velocity map visualization
rainbow_cmap = ListedColormap(np.load('rainbow256.npy'))
def plot_velocity(output, target, path, vmin=None, vmax... | 4,324 | 38.318182 | 89 | py |
OpenFWI | OpenFWI-main/utils.py | # © 2022. Triad National Security, LLC. All rights reserved.
# This program was produced under U.S. Government contract 89233218CNA000001 for Los Alamos
# National Laboratory (LANL), which is operated by Triad National Security, LLC for the U.S.
# Department of Energy/National Nuclear Security Administration. All ri... | 17,006 | 34.804211 | 105 | py |
OpenFWI | OpenFWI-main/dataset.py | # © 2022. Triad National Security, LLC. All rights reserved.
# This program was produced under U.S. Government contract 89233218CNA000001 for Los Alamos
# National Laboratory (LANL), which is operated by Triad National Security, LLC for the U.S.
# Department of Energy/National Nuclear Security Administration. All ri... | 3,920 | 37.441176 | 129 | py |
OpenFWI | OpenFWI-main/scheduler.py | # © 2022. Triad National Security, LLC. All rights reserved.
# This program was produced under U.S. Government contract 89233218CNA000001 for Los Alamos
# National Laboratory (LANL), which is operated by Triad National Security, LLC for the U.S.
# Department of Energy/National Nuclear Security Administration. All ri... | 2,380 | 35.075758 | 105 | py |
OpenFWI | OpenFWI-main/train.py | # © 2022. Triad National Security, LLC. All rights reserved.
# This program was produced under U.S. Government contract 89233218CNA000001 for Los Alamos
# National Laboratory (LANL), which is operated by Triad National Security, LLC for the U.S.
# Department of Energy/National Nuclear Security Administration. All ri... | 14,469 | 41.558824 | 122 | py |
OpenFWI | OpenFWI-main/transforms.py | # © 2022. Triad National Security, LLC. All rights reserved.
# This program was produced under U.S. Government contract 89233218CNA000001 for Los Alamos
# National Laboratory (LANL), which is operated by Triad National Security, LLC for the U.S.
# Department of Energy/National Nuclear Security Administration. All ri... | 8,236 | 29.394834 | 105 | py |
mmvae-public | mmvae-public/src/main.py | import argparse
import datetime
import sys
import json
from collections import defaultdict
from pathlib import Path
from tempfile import mkdtemp
import numpy as np
import torch
from torch import optim
import models
import objectives
from utils import Logger, Timer, save_model, save_vars, unpack_data
parser = argpars... | 6,968 | 40.482143 | 93 | py |
mmvae-public | mmvae-public/src/vis.py | # visualisation related functions
import matplotlib.colors as colors
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import torch
from matplotlib.lines import Line2D
from umap import UMAP
def custom_cmap(n):
"""Create customised colormap for scattered latent plot of n... | 2,938 | 39.260274 | 97 | py |
mmvae-public | mmvae-public/src/utils.py | import math
import os
import shutil
import sys
import time
import torch
import torch.distributions as dist
import torch.nn.functional as F
from datasets import CUBImageFt
# Classes
class Constants(object):
eta = 1e-6
log2 = math.log(2)
log2pi = math.log(2 * math.pi)
logceilc = 88 # largest cuda v s... | 6,857 | 32.950495 | 110 | py |
mmvae-public | mmvae-public/src/objectives.py | # objectives of choice
import torch
from numpy import prod
from utils import log_mean_exp, is_multidata, kl_divergence
# helper to vectorise computation
def compute_microbatch_split(x, K):
""" Checks if batch needs to be broken down further to fit in memory. """
B = x[0].size(0) if is_multidata(x) else x.siz... | 9,267 | 40.375 | 95 | py |
mmvae-public | mmvae-public/src/datasets.py | import io
import json
import os
import pickle
from collections import Counter, OrderedDict
from collections import defaultdict
import numpy as np
import torch
import torch.nn as nn
from nltk.tokenize import sent_tokenize, word_tokenize
from torch.utils.data import Dataset
from torchvision import transforms, models, da... | 8,431 | 32.19685 | 101 | py |
mmvae-public | mmvae-public/src/report/analyse_cub.py | """Calculate cross and joint coherence of language and image generation on CUB dataset using CCA."""
import argparse
import os
import sys
import torch
import torch.nn.functional as F
# relative import hack (sorry)
import inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
pa... | 5,427 | 36.694444 | 101 | py |
mmvae-public | mmvae-public/src/report/analyse_ms.py | """Calculate cross and joint coherence of trained model on MNIST-SVHN dataset.
Train and evaluate a linear model for latent space digit classification."""
import argparse
import os
import sys
import torch
import torch.nn as nn
import torch.optim as optim
# relative import hacks (sorry)
import inspect
currentdir = os... | 9,192 | 36.831276 | 113 | py |
mmvae-public | mmvae-public/src/report/helper.py | import json
import os
import pickle
from collections import Counter, OrderedDict
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from gensim.models import FastText
from nltk.tokenize import sent_tokenize, word_tokenize
from scipy.linalg import eig
from skimage.filters import thres... | 7,712 | 32.977974 | 110 | py |
mmvae-public | mmvae-public/src/report/calculate_likelihoods.py | """Calculate data marginal likelihood p(x) evaluated on the trained generative model."""
import os
import sys
import argparse
import numpy as np
import torch
from torchvision.utils import save_image
# relative import hacks (sorry)
import inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.cur... | 7,240 | 38.785714 | 116 | py |
mmvae-public | mmvae-public/src/models/vae_svhn.py | # SVHN model specification
import torch
import torch.distributions as dist
import torch.nn as nn
import torch.nn.functional as F
from numpy import sqrt
from torch.utils.data import DataLoader
from torchvision import transforms, datasets
from torchvision.utils import save_image, make_grid
from utils import Constants
f... | 5,053 | 37 | 101 | py |
mmvae-public | mmvae-public/src/models/mmvae_cub_images_sentences.py | # cub multi-modal model specification
import matplotlib.pyplot as plt
import torch.distributions as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
from numpy import sqrt, prod
from torch.utils.data import DataLoader
from torchnet.dataset import TensorDataset, ResampleDataset
from tor... | 6,015 | 42.912409 | 119 | py |
mmvae-public | mmvae-public/src/models/vae.py | # Base VAE class definition
import torch
import torch.nn as nn
from utils import get_mean, kl_divergence
from vis import embed_umap, tensors_to_df
class VAE(nn.Module):
def __init__(self, prior_dist, likelihood_dist, post_dist, enc, dec, params):
super(VAE, self).__init__()
self.pz = prior_dist
... | 2,674 | 32.024691 | 89 | py |
mmvae-public | mmvae-public/src/models/vae_cub_image.py | # CUB Image model specification
import torch
import torch.distributions as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
from numpy import sqrt
from torchvision import datasets, transforms
from torchvision.utils import make_grid, save_image
from utils import Constants
from vis imp... | 5,350 | 37.221429 | 91 | py |
mmvae-public | mmvae-public/src/models/vae_mnist.py | # MNIST model specification
import torch
import torch.distributions as dist
import torch.nn as nn
import torch.nn.functional as F
from numpy import prod, sqrt
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torchvision.utils import save_image, make_grid
from utils import Cons... | 4,623 | 37.857143 | 101 | py |
mmvae-public | mmvae-public/src/models/vae_cub_sent_ft.py | # Sentence model specification - CUB image feature version
import json
import os
import numpy as np
import torch
import torch.distributions as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
from torch.utils.data import DataLoader
from datasets import CUBSentences
from utils import ... | 8,185 | 40.135678 | 103 | py |
mmvae-public | mmvae-public/src/models/mmvae.py | # Base MMVAE class definition
from itertools import combinations
import torch
import torch.nn as nn
from utils import get_mean, kl_divergence
from vis import embed_umap, tensors_to_df
class MMVAE(nn.Module):
def __init__(self, prior_dist, params, *vaes):
super(MMVAE, self).__init__()
self.pz = ... | 3,238 | 37.105882 | 92 | py |
mmvae-public | mmvae-public/src/models/vae_cub_sent.py | # Sentence model specification - real CUB image version
import os
import json
import numpy as np
import torch
import torch.distributions as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
from torch.utils.data import DataLoader
from datasets import CUBSentences
from utils import Con... | 8,186 | 39.935 | 103 | py |
mmvae-public | mmvae-public/src/models/mmvae_cub_images_sentences_ft.py | # cub multi-modal model specification
import matplotlib.pyplot as plt
import torch.distributions as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
from numpy import sqrt, prod
from torch.utils.data import DataLoader
from torchnet.dataset import TensorDataset, ResampleDataset
from tor... | 6,432 | 44.302817 | 119 | py |
mmvae-public | mmvae-public/src/models/vae_cub_image_ft.py | # CUB Image feature model specification
import torch
import torch.distributions as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
from numpy import sqrt
from torchvision.utils import make_grid, save_image
from datasets import CUBImageFt
from utils import Constants, NN_lookup
from v... | 5,311 | 38.348148 | 100 | py |
mmvae-public | mmvae-public/src/models/mmvae_mnist_svhn.py | # MNIST-SVHN multi-modal model specification
import os
import torch
import torch.distributions as dist
import torch.nn as nn
import torch.nn.functional as F
from numpy import sqrt, prod
from torch.utils.data import DataLoader
from torchnet.dataset import TensorDataset, ResampleDataset
from torchvision.utils import sav... | 4,479 | 45.185567 | 101 | py |
mmvae-public | mmvae-public/bin/make-mnist-svhn-idx.py | import torch
from torchvision import datasets, transforms
def rand_match_on_idx(l1, idx1, l2, idx2, max_d=10000, dm=10):
"""
l*: sorted labels
idx*: indices of sorted labels in original list
"""
_idx1, _idx2 = [], []
for l in l1.unique(): # assuming both have same idxs
l_idx1, l_idx2 =... | 2,087 | 44.391304 | 90 | py |
MinkLoc3D | MinkLoc3D-master/training/train.py | # Author: Jacek Komorowski
# Warsaw University of Technology
import argparse
import torch
from training.trainer import do_train
from misc.utils import MinkLocParams
from datasets.dataset_utils import make_dataloaders
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Train Minkowski Net em... | 1,341 | 37.342857 | 120 | py |
MinkLoc3D | MinkLoc3D-master/training/trainer.py | # Author: Jacek Komorowski
# Warsaw University of Technology
# Train on Oxford dataset (from PointNetVLAD paper) using BatchHard hard negative mining.
import os
from datetime import datetime
import numpy as np
import torch
import pickle
import tqdm
import pathlib
from torch.utils.tensorboard import SummaryWriter
fr... | 10,845 | 39.17037 | 139 | py |
MinkLoc3D | MinkLoc3D-master/eval/evaluate.py | # Author: Jacek Komorowski
# Warsaw University of Technology
# Evaluation code adapted from PointNetVlad code: https://github.com/mikacuy/pointnetvlad
from sklearn.neighbors import KDTree
import numpy as np
import pickle
import os
import argparse
import torch
import tqdm
import MinkowskiEngine as ME
import random
fr... | 7,883 | 36.542857 | 120 | py |
MinkLoc3D | MinkLoc3D-master/models/minkloc.py | # Author: Jacek Komorowski
# Warsaw University of Technology
import torch
import MinkowskiEngine as ME
from models.minkfpn import MinkFPN
from models.netvlad import MinkNetVladWrapper
import layers.pooling as pooling
class MinkLoc(torch.nn.Module):
def __init__(self, model, in_channels, feature_size, output_dim... | 3,242 | 50.47619 | 141 | py |
MinkLoc3D | MinkLoc3D-master/models/resnet.py | # Copyright (c) Chris Choy (chrischoy@ai.stanford.edu).
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of
# this software and associated documentation files (the "Software"), to deal in
# the Software without restriction, including without limitation the rights to
# use, copy, modify, ... | 5,315 | 31.814815 | 87 | py |
MinkLoc3D | MinkLoc3D-master/models/minkfpn.py | # Author: Jacek Komorowski
# Warsaw University of Technology
import torch.nn as nn
import MinkowskiEngine as ME
from MinkowskiEngine.modules.resnet_block import BasicBlock
from models.resnet import ResNetBase
class MinkFPN(ResNetBase):
# Feature Pyramid Network (FPN) architecture implementation using Minkowski R... | 4,364 | 44.947368 | 125 | py |
MinkLoc3D | MinkLoc3D-master/models/loss.py | # Author: Jacek Komorowski
# Warsaw University of Technology
import numpy as np
import torch
from pytorch_metric_learning import losses, miners, reducers
from pytorch_metric_learning.distances import LpDistance
def make_loss(params):
if params.loss == 'BatchHardTripletMarginLoss':
# BatchHard mining with... | 6,696 | 49.353383 | 118 | py |
MinkLoc3D | MinkLoc3D-master/models/netvlad.py | # Code taken from PointNetVLAD Pytorch implementation: https://github.com/cattaneod/PointNetVlad-Pytorch
# Adapted by Jacek Komorowski
import torch
import torch.nn as nn
import torch.utils.data
import torch.nn.functional as F
import math
# NOTE: The toolbox can only pool lists of features of the same length. It was s... | 5,287 | 38.17037 | 118 | py |
MinkLoc3D | MinkLoc3D-master/datasets/dataset_utils.py | # Author: Jacek Komorowski
# Warsaw University of Technology
import numpy as np
import torch
from torch.utils.data import DataLoader
import MinkowskiEngine as ME
from datasets.oxford import OxfordDataset, TrainTransform, TrainSetTransform
from datasets.samplers import BatchSampler
from misc.utils import MinkLocParams... | 4,547 | 44.48 | 125 | py |
MinkLoc3D | MinkLoc3D-master/datasets/oxford.py | # Author: Jacek Komorowski
# Warsaw University of Technology
# Dataset wrapper for Oxford laser scans dataset from PointNetVLAD project
# For information on dataset see: https://github.com/mikacuy/pointnetvlad
import os
import pickle
import numpy as np
import math
from scipy.linalg import expm, norm
import random
imp... | 10,148 | 33.40339 | 115 | py |
MinkLoc3D | MinkLoc3D-master/datasets/samplers.py | # Author: Jacek Komorowski
# Warsaw University of Technology
import random
import copy
from torch.utils.data import Sampler
from datasets.oxford import OxfordDataset
class ListDict(object):
def __init__(self, items=None):
if items is not None:
self.items = copy.deepcopy(items)
s... | 5,532 | 38.805755 | 114 | py |
MinkLoc3D | MinkLoc3D-master/layers/pooling.py | # Code taken from: https://github.com/filipradenovic/cnnimageretrieval-pytorch
# and ported to MinkowskiEngine by Jacek Komorowski
import torch
import torch.nn as nn
import MinkowskiEngine as ME
class MAC(nn.Module):
def __init__(self):
super().__init__()
self.f = ME.MinkowskiGlobalMaxPooling()
... | 1,280 | 30.243902 | 84 | py |
MRE-ISE | MRE-ISE-main/run.py | import argparse
import logging
import sys
sys.path.append("..")
import torch
import numpy as np
import random
from torchvision import transforms
from torch.utils.data import DataLoader
from cores.gene.model import MRE
from transformers import CLIPProcessor, CLIPModel
from transformers import CLIPConfig
from processor... | 9,056 | 52.276471 | 187 | py |
MRE-ISE | MRE-ISE-main/VSG/RelTR_parser/visual_scene_graph.py | import os
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as T
from PIL import Image
import requests
import matplotlib.pyplot as plt
import json
import pickle
import ast
from tqdm import tqdm
from transformers import CLIPProcessor, CLIPModel
import cv2
from models.back... | 12,857 | 45.086022 | 341 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/models/eval_rels.py |
from dataloaders.visual_genome import VGDataLoader, VG
import numpy as np
import torch
from config import ModelConfig
from lib.pytorch_misc import optimistic_restore
from lib.evaluation.sg_eval import BasicSceneGraphEvaluator
from tqdm import tqdm
from config import BOX_SCALE, IM_SCALE
import dill as pkl
import os
c... | 4,353 | 37.530973 | 89 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/models/train_detector.py | """
Training script 4 Detection
"""
from dataloaders.mscoco import CocoDetection, CocoDataLoader
from dataloaders.visual_genome import VGDataLoader, VG
from lib.object_detector import ObjectDetector
import numpy as np
from torch import optim
import torch
import pandas as pd
import time
import os
from config import Mode... | 9,155 | 40.808219 | 115 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/models/eval_rel_count.py | """
Baseline model that works by simply iterating through the training set to make a dictionary.
Also, caches this (we can use this for training).
The model is quite simple, so we don't use the base train/test code
"""
from dataloaders.visual_genome import VGDataLoader, VG
from lib.object_detector import ObjectDetec... | 9,552 | 36.758893 | 116 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/models/_visualize.py | """
Visualization script. I used this to create the figures in the paper.
WARNING: I haven't tested this in a while. It's possible that some later features I added break things here, but hopefully there should be easy fixes. I'm uploading this in the off chance it might help someone. If you get it to work, let me know... | 9,693 | 36.867188 | 280 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/models/train_rels.py | """
Training script for scene graph detection. Integrated with my faster rcnn setup
"""
from dataloaders.visual_genome import VGDataLoader, VG
import numpy as np
from torch import optim
import torch
import pandas as pd
import time
import os
from config import ModelConfig, BOX_SCALE, IM_SCALE
from torch.nn import func... | 8,782 | 41.225962 | 130 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/dataloaders/visual_genome.py | """
File that involves dataloaders for the Visual Genome example_dataset.
"""
import json
import os
import h5py
import numpy as np
import torch
from PIL import Image
from torch.utils.data import Dataset
from torchvision.transforms import Resize, Compose, ToTensor, Normalize
from dataloaders.blob import Blob
from lib.... | 16,373 | 37.527059 | 129 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/dataloaders/blob.py | """
Data blob, hopefully to make collating less painful and MGPU training possible
"""
from lib.fpn.anchor_targets import anchor_target_layer
import numpy as np
import torch
from torch.autograd import Variable
class Blob(object):
def __init__(self, mode='det', is_train=False, num_gpus=1, primary_gpu=0, batch_size... | 9,073 | 38.281385 | 118 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/dataloaders/mscoco.py | from config import COCO_PATH, IM_SCALE, BOX_SCALE
import os
from torch.utils.data import Dataset
from pycocotools.coco import COCO
from PIL import Image
from lib.fpn.anchor_targets import anchor_target_layer
from torchvision.transforms import Resize, Compose, ToTensor, Normalize
from dataloaders.image_transforms import... | 6,783 | 34.518325 | 125 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/rel_model_stanford.py | """
Let's get the relationships yo
"""
import torch
import torch.nn as nn
import torch.nn.parallel
from torch.autograd import Variable
from torch.nn import functional as F
from lib.surgery import filter_dets
from lib.fpn.proposal_assignments.rel_assignments import rel_assignments
from lib.pytorch_misc import arange
fr... | 9,332 | 44.305825 | 109 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/pytorch_misc.py | """
Miscellaneous functions that might be useful for pytorch
"""
import h5py
import numpy as np
import torch
from torch.autograd import Variable
import os
import dill as pkl
from itertools import tee
from torch import nn
def optimistic_restore(network, state_dict):
mismatch = False
own_state = network.state_d... | 14,457 | 30.430435 | 110 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/get_dataset_counts.py | """
Get counts of all of the examples in the example_dataset. Used for creating the baseline
dictionary model
"""
import numpy as np
from dataloaders.visual_genome import VG
from lib.fpn.box_intersections_cpu.bbox import bbox_overlaps
from lib.pytorch_misc import nonintersecting_2d_inds
def get_counts(train_data=VG(... | 2,293 | 31.309859 | 109 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/resnet.py | import torch.nn as nn
import math
import torch.utils.model_zoo as model_zoo
from torchvision.models.resnet import model_urls, conv3x3, BasicBlock
from torchvision.models.vgg import vgg16
from config import BATCHNORM_MOMENTUM
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, strid... | 4,805 | 31.693878 | 86 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/rel_model.py | """
Let's get the relationships yo
"""
import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
from torch.autograd import Variable
from torch.nn import functional as F
from torch.nn.utils.rnn import PackedSequence
from lib.resnet import resnet_l4
from config import BATCHNORM_MOMENTUM
from lib.fp... | 23,579 | 41.032086 | 136 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/word_vectors.py | """
Adapted from PyTorch's text library.
"""
import array
import os
import zipfile
import six
import torch
from six.moves.urllib.request import urlretrieve
from tqdm import tqdm
from config import DATA_PATH
import sys
def obj_edge_vectors(names, wv_type='glove.6B', wv_dir=DATA_PATH, wv_dim=300):
wv_dict, wv_arr... | 4,711 | 34.428571 | 96 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/object_detector.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.parallel
from torch.autograd import Variable
from torch.nn import functional as F
from config import ANCHOR_SIZE, ANCHOR_RATIOS, ANCHOR_SCALES
from lib.fpn.generate_anchors import generate_anchors
from lib.fpn.box_utils import bbox_preds, center_siz... | 25,429 | 39.11041 | 119 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/get_union_boxes.py | """
credits to https://github.com/ruotianluo/pytorch-faster-rcnn/blob/master/lib/nets/network.py#L91
"""
import torch
from torch.autograd import Variable
from torch.nn import functional as F
from lib.fpn.roi_align.functions.roi_align import RoIAlignFunction
from lib.draw_rectangles.draw_rectangles import draw_union_bo... | 3,235 | 39.45 | 114 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/sparse_targets.py | from lib.word_vectors import obj_edge_vectors
import torch.nn as nn
import torch
from torch.autograd import Variable
import numpy as np
from config import DATA_PATH
import os
from lib.get_dataset_counts import get_counts
class FrequencyBias(nn.Module):
"""
The goal of this is to provide a simplified way of co... | 1,718 | 31.433962 | 87 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/surgery.py | # create predictions from the other stuff
"""
Go from proposals + scores to relationships.
pred-cls: No bbox regression, obj dist is exactly known
sg-cls : No bbox regression
sg-det : Bbox regression
in all cases we'll return:
boxes, objs, rels, pred_scores
"""
import numpy as np
import torch
from lib.pytorch_misc ... | 2,059 | 33.333333 | 100 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/evaluation/sg_eval.py | """
Adapted from Danfei Xu. In particular, slow code was removed
"""
import numpy as np
from functools import reduce
from lib.pytorch_misc import intersect_2d, argsort_desc
from lib.fpn.box_intersections_cpu.bbox import bbox_overlaps
from config import MODES
np.set_printoptions(precision=3)
class BasicSceneGraphEvalua... | 11,883 | 40.698246 | 111 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/evaluation/sg_eval_all_rel_cates.py | """
Adapted from Danfei Xu. In particular, slow code was removed
"""
import numpy as np
from functools import reduce
from lib.pytorch_misc import intersect_2d, argsort_desc
from lib.fpn.box_intersections_cpu.bbox import bbox_overlaps
from config import MODES
import sys
np.set_printoptions(precision=3)
class BasicScene... | 14,355 | 39.439437 | 135 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/lstm/decoder_rnn.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
from torch.nn.utils.rnn import PackedSequence
from typing import Optional, Tuple
from lib.fpn.box_utils import nms_overlaps
from lib.word_vectors import obj_edge_vectors
from .highway_lstm_cuda.alternating_highway_ls... | 12,192 | 47.384921 | 109 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/lstm/highway_lstm_cuda/alternating_highway_lstm.py | from typing import Tuple
from overrides import overrides
import torch
from torch.autograd import Function, Variable
from torch.nn import Parameter
from torch.nn.utils.rnn import PackedSequence, pad_packed_sequence, pack_padded_sequence
import itertools
from ._ext import highway_lstm_layer
def block_orthogonal(tensor... | 15,176 | 48.924342 | 109 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/lstm/highway_lstm_cuda/build.py | # pylint: disable=invalid-name
import os
import torch
from torch.utils.ffi import create_extension
if not torch.cuda.is_available():
raise Exception('HighwayLSTM can only be compiled with CUDA')
sources = ['src/highway_lstm_cuda.c']
headers = ['src/highway_lstm_cuda.h']
defines = [('WITH_CUDA', None)]
with_cuda =... | 798 | 25.633333 | 75 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/lstm/highway_lstm_cuda/_ext/highway_lstm_layer/__init__.py |
from torch.utils.ffi import _wrap_function
from ._highway_lstm_layer import lib as _lib, ffi as _ffi
__all__ = []
def _import_symbols(locals):
for symbol in dir(_lib):
fn = getattr(_lib, symbol)
locals[symbol] = _wrap_function(fn, _ffi)
__all__.append(symbol)
_import_symbols(locals())
| 317 | 23.461538 | 57 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/box_utils.py | import torch
import numpy as np
from torch.nn import functional as F
from lib.fpn.box_intersections_cpu.bbox import bbox_overlaps as bbox_overlaps_np
from lib.fpn.box_intersections_cpu.bbox import bbox_intersections as bbox_intersections_np
def bbox_loss(prior_boxes, deltas, gt_boxes, eps=1e-4, scale_before=1):
"... | 5,965 | 37.24359 | 98 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/proposal_assignments/proposal_assignments_rel.py | # --------------------------------------------------------
# Goal: assign ROIs to targets
# --------------------------------------------------------
import numpy as np
import numpy.random as npr
from config import BG_THRESH_HI, BG_THRESH_LO, FG_FRACTION_REL, ROIS_PER_IMG_REL, REL_FG_FRACTION, \
RELS_PER_IMG
from ... | 9,678 | 41.451754 | 150 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/proposal_assignments/proposal_assignments_gtbox.py | from lib.pytorch_misc import enumerate_by_image, gather_nd, random_choose
from lib.fpn.box_utils import bbox_preds, center_size, bbox_overlaps
import torch
from lib.pytorch_misc import diagonal_inds, to_variable
from config import RELS_PER_IMG, REL_FG_FRACTION
@to_variable
def proposal_assignments_gtbox(rois, gt_boxe... | 3,434 | 38.034091 | 97 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/proposal_assignments/rel_assignments.py | # --------------------------------------------------------
# Goal: assign ROIs to targets
# --------------------------------------------------------
import numpy as np
import numpy.random as npr
from config import BG_THRESH_HI, BG_THRESH_LO, REL_FG_FRACTION, RELS_PER_IMG_REFINE
from lib.fpn.box_utils import bbox_over... | 6,381 | 42.712329 | 98 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/proposal_assignments/proposal_assignments_det.py |
import numpy as np
import numpy.random as npr
from config import BG_THRESH_HI, BG_THRESH_LO, FG_FRACTION, ROIS_PER_IMG
from lib.fpn.box_utils import bbox_overlaps
from lib.pytorch_misc import to_variable
import torch
#############################################################
# The following is only for object dete... | 4,477 | 36.949153 | 98 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/proposal_assignments/proposal_assignments_postnms.py | # --------------------------------------------------------
# Goal: assign ROIs to targets
# --------------------------------------------------------
import numpy as np
import numpy.random as npr
from .proposal_assignments_rel import _sel_rels
from lib.fpn.box_utils import bbox_overlaps
from lib.pytorch_misc import to... | 5,420 | 39.455224 | 100 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/roi_align/build.py | import os
import torch
from torch.utils.ffi import create_extension
# Might have to export PATH=/usr/local/cuda-8.0/bin${PATH:+:${PATH}}
# sources = ['src/roi_align.c']
# headers = ['src/roi_align.h']
sources = []
headers = []
defines = []
with_cuda = False
if torch.cuda.is_available():
print('Including CUDA code... | 901 | 23.378378 | 75 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/roi_align/functions/roi_align.py | """
performs ROI aligning
"""
import torch
from torch.autograd import Function
from .._ext import roi_align
class RoIAlignFunction(Function):
def __init__(self, aligned_height, aligned_width, spatial_scale):
self.aligned_width = int(aligned_width)
self.aligned_height = int(aligned_height)
... | 2,455 | 31.746667 | 79 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/roi_align/modules/roi_align.py | from torch.nn.modules.module import Module
from torch.nn.functional import avg_pool2d, max_pool2d
from ..functions.roi_align import RoIAlignFunction
class RoIAlign(Module):
def __init__(self, aligned_height, aligned_width, spatial_scale):
super(RoIAlign, self).__init__()
self.aligned_width = int(... | 1,672 | 37.906977 | 74 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/roi_align/_ext/roi_align/__init__.py |
from torch.utils.ffi import _wrap_function
from ._roi_align import lib as _lib, ffi as _ffi
__all__ = []
def _import_symbols(locals):
for symbol in dir(_lib):
fn = getattr(_lib, symbol)
locals[symbol] = _wrap_function(fn, _ffi)
__all__.append(symbol)
_import_symbols(locals())
| 308 | 22.769231 | 49 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/nms/build.py | import os
import torch
from torch.utils.ffi import create_extension
# Might have to export PATH=/usr/local/cuda-8.0/bin${PATH:+:${PATH}}
sources = []
headers = []
defines = []
with_cuda = False
if torch.cuda.is_available():
print('Including CUDA code.')
sources += ['src/nms_cuda.c']
headers += ['src/nms_c... | 814 | 21.638889 | 75 | py |
MRE-ISE | MRE-ISE-main/VSG/VG_parser/lib/fpn/nms/functions/nms.py | # Le code for doing NMS
import torch
import numpy as np
from .._ext import nms
def apply_nms(scores, boxes, pre_nms_topn=12000, post_nms_topn=2000, boxes_per_im=None,
nms_thresh=0.7):
"""
Note - this function is non-differentiable so everything is assumed to be a tensor, not
a variable.
... | 1,312 | 27.543478 | 98 | py |
MRE-ISE | MRE-ISE-main/processor/create_bow.py | import numpy as np
import os
from sklearn.cluster import KMeans
from PIL import Image
import cv2
import pickle
from transformers import CLIPModel, CLIPProcessor
import torch
import json
from tqdm import tqdm
from sklearn.feature_extraction.text import CountVectorizer
from nltk.corpus import stopwords as stop_words
from... | 9,510 | 38.962185 | 113 | py |
MRE-ISE | MRE-ISE-main/processor/dataset.py | import pickle
import random
import os
import numpy as np
import torch
import json
import ast
from PIL import Image
from torch.utils.data import Dataset, DataLoader
from transformers import BertTokenizer
from torchvision import transforms
from transformers import CLIPTokenizer
from torch_geometric.utils import to_dense... | 12,476 | 42.024138 | 120 | py |
MRE-ISE | MRE-ISE-main/cores/lamo/decoding_network.py | import torch
from torch import nn
from torch.nn import functional as F
from cores.lamo.inference_network import CombinedInferenceNetwork, ContextualInferenceNetwork
class DecoderNetwork(nn.Module):
def __init__(self, text_input_size, visual_input_size, bert_size, infnet, n_components=10, model_type='prodLDA',
... | 7,129 | 39.977011 | 125 | py |
MRE-ISE | MRE-ISE-main/cores/lamo/ctm.py | import datetime
import multiprocessing as mp
import os
import warnings
from collections import defaultdict
import matplotlib.pyplot as plt
import numpy as np
import torch
import wordcloud
from scipy.special import softmax
from torch import optim
from torch.optim.lr_scheduler import ReduceLROnPlateau
from torch.utils.da... | 30,164 | 41.545839 | 167 | py |
MRE-ISE | MRE-ISE-main/cores/lamo/early_stopping.py | import numpy as np
import torch
class EarlyStopping:
"""Early stops the training if validation loss doesn't improve after a given patience.
Source code: https://github.com/Bjarten/early-stopping-pytorch """
def __init__(self, patience=7, verbose=False, delta=0, path='checkpoint.pt', trace_func=print):
... | 2,353 | 36.967742 | 121 | py |
MRE-ISE | MRE-ISE-main/cores/lamo/inference_network.py | from collections import OrderedDict
from torch import nn
import torch
class ContextualInferenceNetwork(nn.Module):
"""Inference Network."""
def __init__(self, text_input_size, visual_input_size, bert_size, output_size, hidden_sizes,
activation='softplus', dropout=0.2, label_size=0):
... | 5,742 | 37.033113 | 103 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.