'num_layers': 1,
'learning_rate': 0.001,
'mode_train': True,
'sent_max_size': 228,
'gen_length': 20,
'temperature': 0.5,
'keep_rate': 0.66,
'input': ['GOT', 'PTB'][1],
'vocab_drop': 3,
'gpu': 0
}
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = params['gpu']
import tensorflow as tf
# for back compatibility
params_c = Parameters()
params_c.batch_size = params['batch_size']
params_c.num_epochs = params['num_epochs']
params_c.embed_size = params['embed_size']
params_c.learning_rate = params['learning_rate']
params_c.pre_trained_embed = False
params_c.beam_search = False
params_c.vocab_drop = params['vocab_drop']
params_c.embed_size = params['embed_size']
def online_inference(sess,
data_dict,
sample,
seq,
in_state=None,
help='batch size (default: 10)')
parser.add_argument('--num-sample', type=int, default=5, metavar='NS',
help='num sample (default: 5)')
parser.add_argument('--use-cuda', type=bool, default=True, metavar='CUDA',
help='use cuda (default: True)')
parser.add_argument('--train-data', default='', metavar='TD',
help='load custom training dataset (default: '')')
args = parser.parse_args()
batch_loader = BatchLoader(path = '',
custom_index = False,
train_data_name=args.train_data)
params = Parameters(batch_loader.max_word_len,
batch_loader.max_seq_len,
batch_loader.words_vocab_size,
batch_loader.chars_vocab_size)
neg_loss = NEG_loss(params.word_vocab_size, params.word_embed_size)
if args.use_cuda:
neg_loss = neg_loss.cuda()
# NEG_loss is defined over two embedding matrixes with shape of [params.word_vocab_size, params.word_embed_size]
optimizer = SGD(neg_loss.parameters(), 0.1)
for iteration in range(args.num_iterations):
input_idx, target_idx = batch_loader.next_embedding_seq(args.batch_size)
input = Variable(t.from_numpy(input_idx).long())
target = Variable(t.from_numpy(target_idx).long())
'''
data_files = [path + 'train.txt', path + 'test.txt']
idx_files = [path + 'words_vocab.pkl', path + 'characters_vocab.pkl']
tensor_files = [[
path + 'train_word_tensor.npy', path + 'valid_word_tensor.npy'
],
[
path + 'train_character_tensor.npy',
path + 'valid_character_tensor.npy'
]]
batch_loader = BatchLoader(data_files, idx_files, tensor_files, path)
parameters = Parameters(batch_loader.max_word_len,
batch_loader.max_seq_len,
batch_loader.words_vocab_size,
batch_loader.chars_vocab_size, path)
''' =================== Doing the same for encoder-2 ===============================================
'''
data_files = [path + 'super/train_2.txt', path + 'super/test_2.txt']
idx_files = [
path + 'super/words_vocab_2.pkl', path + 'super/characters_vocab_2.pkl'
]
tensor_files = [[
path + 'super/train_word_tensor_2.npy',
path + 'super/valid_word_tensor_2.npy'
],
[
path + 'super/train_character_tensor_2.npy',
from utils.evaluation import evaluate_model
from utils.sampler import WarpSampler
from utils.checkpoint import save_model
from utils import utils
warnings.filterwarnings("ignore", category=DeprecationWarning)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
if __name__ == '__main__':
args = parse_args()
print('Loading dataset...', end="")
args.device = device
args.date_time = datetime.datetime.now()
dataset = EmbedDataset(args)
params = Parameters(args, dataset)
print("\rDataset Statistics:")
print(f" Users: {params.num_user} | Lists: {params.num_list} | Items:{params.num_item}")
print(f" Train: {params.num_train_instances} | Valid: {params.num_valid_instances} | Test: {params.num_test_instances}")
print(f" Density: {100 * params.num_train_instances / (params.num_list * params.num_item):.4f} %")
print("="*60)
args.args_str = params.get_args_to_string()
t1 = time()
models = Models(params, device=device)
model = models.get_model()
model.to(device)
save_model_path = os.path.join("./saved_models", params.dataset + ".pth.tar")
criterion_li = torch.nn.BCELoss()
optimizer_gnn = torch.optim.Adam(model.parameters(), lr=params.lr)
help="Indices to words dictionary")
parser.add_argument('--gpu',
default='',
help="Specify GPU number if use GPU")
parser.add_argument(
'--c_v_generator',
default=None,
help="If use cluster vectors, specify tensorflow api model"
"For more information look README")
parser.add_argument('--gen_method',
default='greedy',
help='greedy, beam_search or sample')
parser.add_argument('--params_path',
default=None,
help="specify params pickle file")
parser.add_argument('--beam_size',
default=2,
help="If using beam_search, specify beam_size")
args = parser.parse_args()
# CUDA settings
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
# parameter of the model
params = Parameters()
generator = Generator(checkpoint_path=args.checkpoint,
params_path=args.params_path,
vocab_path=args.vocab_path,
gen_method=args.gen_method)
caption = generator.generate_caption(args.img_path, args.beam_size)
print(caption[0]['caption'])
metavar='CUDA',
help='use cuda (default: True)')
parser.add_argument('--learning-rate',
type=float,
default=5e-5,
metavar='LR',
help='learning rate (default: 5e-5)')
parser.add_argument('--use-trained',
type=bool,
default=False,
metavar='UT',
help='load pretrained model (default: False)')
args = parser.parse_args()
batch_loader = BatchLoader('')
parameters = Parameters(batch_loader.max_word_len,
batch_loader.max_seq_len, batch_loader.vocab_size)
rgan = RGAN(parameters)
if args.use_trained:
rgan.load_state_dict(t.load('trained_RGAN'))
if args.use_cuda:
rgan = rgan.cuda()
g_optimizer = Adam(rgan.generator.parameters(), args.learning_rate)
d_optimizer = Adam(rgan.discriminator.parameters(), args.learning_rate)
for iteration in range(args.num_iterations):
for _ in range(5):
'''Dicriminator forward-loss-backward-update'''
z, true_data = batch_loader.input_data(args.batch_size,
args.use_cuda, parameters)
help='dropout (default: 0.12)')
parser.add_argument('--aux',
type=float,
default=0.4,
metavar='DR',
help='aux loss coef (default: 0.4)')
parser.add_argument('--use-trained',
type=bool,
default=False,
metavar='UT',
help='load pretrained model (default: False)')
args = parser.parse_args()
batch_loader = BatchLoader()
parameters = Parameters(batch_loader.vocab_size)
vae = VAE(parameters.vocab_size, parameters.embed_size,
parameters.latent_size, parameters.decoder_rnn_size,
parameters.decoder_rnn_num_layers)
if args.use_trained:
vae.load_state_dict(t.load('trained_VAE'))
if args.use_cuda:
vae = vae.cuda()
optimizer = Adam(vae.parameters(), args.learning_rate)
for iteration in range(args.num_iterations):
'''Train step'''
input, decoder_input, target = batch_loader.next_batch(
args.batch_size, 'train', args.use_cuda)