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 |
|---|---|---|---|---|---|---|
CANTM | CANTM-main/GateMIcateLib/models/bertSimple.py | from transformers import BertModel
from .miscLayer import BERT_Embedding, CLSAW_TopicModel_Base, WVHidden
import os
import torch.nn.functional as F
import torch
import torch.nn as nn
class BERT_Simple(CLSAW_TopicModel_Base):
def __init__(self, config, **kwargs):
super().__init__(config=config)
self.bert_embedding = BERT_Embedding(config)
bert_dim = self.bert_embedding.bert_dim
self.hidden_dim = bert_dim
self.hidden2 = WVHidden(self.hidden_dim, self.z_dim)
self.layer_output = torch.nn.Linear(self.z_dim, self.n_classes)
#self.layer_output = torch.nn.Linear(bert_dim, self.n_classes)
def forward(self, x, mask=None, pre_embd=False):
if pre_embd:
bert_rep = x
else:
bert_rep = self.bert_embedding(x, mask)
bert_rep = bert_rep[0]
bert_rep = bert_rep[:,0]
#hidden = self.hidden1(bert_rep)
hidden = bert_rep
hidden = self.hidden2(hidden)
out = self.layer_output(hidden)
y = {
'y_hat':out
}
return y
| 1,100 | 25.853659 | 71 | py |
CANTM | CANTM-main/GateMIcateLib/models/bertPure.py | from transformers import BertModel
from .miscLayer import BERT_Embedding, CLSAW_TopicModel_Base, WVHidden
import os
import torch.nn.functional as F
import torch
import torch.nn as nn
class BERT_Simple(CLSAW_TopicModel_Base):
def __init__(self, config, **kwargs):
super().__init__(config=config)
self.bert_embedding = BERT_Embedding(config)
bert_dim = self.bert_embedding.bert_dim
self.hidden_dim = bert_dim
#self.hidden2 = WVHidden(self.hidden_dim, self.z_dim)
#self.layer_output = torch.nn.Linear(self.z_dim, self.n_classes)
self.layer_output = torch.nn.Linear(bert_dim, self.n_classes)
def forward(self, x, mask=None, pre_embd=False):
if pre_embd:
bert_rep = x
else:
bert_rep = self.bert_embedding(x, mask)
bert_rep = bert_rep[0]
bert_rep = bert_rep[:,0]
#hidden = self.hidden1(bert_rep)
hidden = bert_rep
#hidden = self.hidden2(hidden)
out = self.layer_output(hidden)
y = {
'y_hat':out
}
return y
| 1,102 | 25.902439 | 72 | py |
CANTM | CANTM-main/GateMIcateLib/models/NVDM.py | import torch
from torch import nn
from torch.nn import init
from torch.nn import functional as F
import math
from .miscLayer import BERT_Embedding, WVHidden, WVClassifier, Identity, Topics, kld, CLSAW_TopicModel_Base
class NVDM(CLSAW_TopicModel_Base):
def __init__(self, config, vocab_dim=None):
super().__init__(config=config)
default_config = {}
self.bert_embedding = BERT_Embedding(config)
bert_dim = self.bert_embedding.bert_dim
if self.banlance_loss:
self.banlance_lambda = float(math.ceil(vocab_dim/self.n_classes))
else:
self.banlance_lambda = 1
#self.wv_hidden = WVHidden(bert_dim, self.hidden_dim)
self.hidden_dim = bert_dim
##############M1###########################################
self.mu_z1 = nn.Linear(self.hidden_dim, self.z_dim)
self.log_sigma_z1 = nn.Linear(self.hidden_dim, self.z_dim)
self.x_only_topics = Topics(self.z_dim, vocab_dim)
#self.xy_classifier = WVClassifier(self.z_dim, self.n_classes)
#self.class_criterion = nn.CrossEntropyLoss()
#############M2############################################
#self.hidden_y_dim = self.hidden_dim + self.n_classes
#self.z_y_dim = self.z_dim + self.n_classes
#self.x_y_hidden = WVHidden(self.hidden_y_dim, self.hidden_dim)
#self.z_y_hidden = WVHidden(self.z_y_dim, self.ntopics)
#self.mu_z2 = nn.Linear(self.hidden_dim, self.z_dim)
#self.log_sigma_z2 = nn.Linear(self.hidden_dim, self.z_dim)
#self.xy_topics = Topics(self.ntopics, vocab_dim)
#self.z2y_classifier = WVClassifier(self.ntopics, self.n_classes)
############################################################
self.h_to_z = Identity()
#self.class_topics = Topics(self.n_classes, vocab_dim)
self.reset_parameters()
def forward(self,x, mask=None, n_samples=1, bow=None, train=False, true_y=None, pre_embd=False, true_y_ids=None):
#print(true_y.shape)
if pre_embd:
bert_rep = x
else:
bert_rep = self.bert_embedding(x, mask)
bert_rep = bert_rep[0]
atted = bert_rep[:,0]
#hidden = self.wv_hidden(atted)
hidden = atted
mu_z1 = self.mu_z1(hidden)
log_sigma_z1 = self.log_sigma_z1(hidden)
kldz1 = kld(mu_z1, log_sigma_z1)
rec_loss_z1 = 0
classifier_loss = 0
kldz2 = 0
rec_loss_z2 = 0
log_y_hat_rec_loss = 0
class_topic_rec_loss = 0
for i in range(n_samples):
z1 = torch.zeros_like(mu_z1).normal_() * torch.exp(log_sigma_z1) + mu_z1
z1 = self.h_to_z(z1)
log_probz_1 = self.x_only_topics(z1)
rec_loss_z1 = rec_loss_z1-(log_probz_1 * bow).sum(dim=-1)
rec_loss_z1 = rec_loss_z1/n_samples
elbo_z1 = kldz1 + rec_loss_z1
total_loss = elbo_z1.sum()
y_hat_logis = torch.zeros(x.shape[0], self.n_classes)
elbo_z2 = torch.zeros_like(elbo_z1)
classifier_loss = torch.tensor(0)
y = {
'loss': total_loss,
'elbo_xy': elbo_z2,
'rec_loss': rec_loss_z2,
'kld': kldz2,
'cls_loss': classifier_loss,
'class_topic_loss': class_topic_rec_loss,
'y_hat': y_hat_logis,
'elbo_x': elbo_z1
}
return y, None
def reset_parameters(self):
init.zeros_(self.log_sigma_z1.weight)
init.zeros_(self.log_sigma_z1.bias)
def get_topics(self):
return self.x_only_topics.get_topics()
def get_class_topics(self):
return self.x_only_topics.get_topics()
def get_x_only_topics(self):
return self.x_only_topics.get_topics()
| 3,804 | 31.801724 | 117 | py |
CANTM | CANTM-main/GateMIcateLib/models/NVDM_ori.py | import torch
from torch import nn
from torch.nn import init
from torch.nn import functional as F
import math
from .miscLayer import BERT_Embedding, WVHidden, WVClassifier, Identity, Topics, kld, CLSAW_TopicModel_Base
class ORINVDM(CLSAW_TopicModel_Base):
def __init__(self, config, vocab_dim=None):
super().__init__(config=config)
default_config = {}
self.hidden_layer = nn.Linear(vocab_dim, 500)
##############M1###########################################
self.mu_z1 = nn.Linear(500, self.z_dim)
self.log_sigma_z1 = nn.Linear(500, self.z_dim)
self.x_only_topics = Topics(self.z_dim, vocab_dim)
self.h_to_z = Identity()
self.reset_parameters()
def forward(self,x, mask=None, n_samples=1, bow=None, train=False, true_y=None, pre_embd=False, true_y_ids=None):
#print(true_y.shape)
hidden = F.tanh(self.hidden_layer(bow))
mu_z1 = self.mu_z1(hidden)
log_sigma_z1 = self.log_sigma_z1(hidden)
kldz1 = kld(mu_z1, log_sigma_z1)
rec_loss_z1 = 0
classifier_loss = 0
kldz2 = 0
rec_loss_z2 = 0
log_y_hat_rec_loss = 0
class_topic_rec_loss = 0
for i in range(n_samples):
z1 = torch.zeros_like(mu_z1).normal_() * torch.exp(log_sigma_z1) + mu_z1
z1 = self.h_to_z(z1)
log_probz_1 = self.x_only_topics(z1)
rec_loss_z1 = rec_loss_z1-(log_probz_1 * bow).sum(dim=-1)
rec_loss_z1 = rec_loss_z1/n_samples
elbo_z1 = kldz1 + rec_loss_z1
total_loss = elbo_z1.sum()
y_hat_logis = torch.zeros(x.shape[0], self.n_classes)
elbo_z2 = torch.zeros_like(elbo_z1)
classifier_loss = torch.tensor(0)
y = {
'loss': total_loss,
'elbo_xy': elbo_z2,
'rec_loss': rec_loss_z2,
'kld': kldz2,
'cls_loss': classifier_loss,
'class_topic_loss': class_topic_rec_loss,
'y_hat': y_hat_logis,
'elbo_x': elbo_z1
}
return y, None
def reset_parameters(self):
init.zeros_(self.log_sigma_z1.weight)
init.zeros_(self.log_sigma_z1.bias)
def get_topics(self):
return self.x_only_topics.get_topics()
def get_class_topics(self):
return self.x_only_topics.get_topics()
def get_x_only_topics(self):
return self.x_only_topics.get_topics()
| 2,445 | 28.46988 | 117 | py |
CANTM | CANTM-main/GateMIcateLib/readers/ReaderBase.py | import random
import math
import json
import torch
class CLSReaderBase:
def __init__(self, postProcessor=None, shuffle=False, config=None):
self.label_count_dict = {}
self.label_weights_list = None
self._readConfigs(config)
self.shuffle = shuffle
self.postProcessor = postProcessor
self.goPoseprocessor = True
def _readConfigs(self, config):
self.target_labels = None
if config:
if 'TARGET' in config:
self.target_labels = config['TARGET'].get('labels')
print(self.target_labels)
def __iter__(self):
if self.shuffle:
random.shuffle(self.all_ids)
self._reset_iter()
return self
def __next__(self):
#print(self.all_ids)
if self.current_sample_idx < len(self.all_ids):
current_sample = self._readNextSample()
self.current_sample_idx += 1
return current_sample
else:
self._reset_iter()
raise StopIteration
def _readNextSample(self):
current_id = self.all_ids[self.current_sample_idx]
#print(current_id)
self.current_sample_dict_id = current_id
current_sample = self.data_dict[current_id]
if self.postProcessor and self.goPoseprocessor:
current_sample = self.postProcessor.postProcess(current_sample)
return current_sample
def preCalculateEmbed(self, embd_net, embd_field, dataType=torch.long, device='cuda:0'):
for sample, _ in self:
x_embd = sample[embd_field]
input_tensor = torch.tensor([x_embd], dtype=torch.long, device=device)
with torch.no_grad():
embd = embd_net(input_tensor)
self.data_dict[self.current_sample_dict_id]['embd'] = embd[0].tolist()
self.postProcessor.embd_ready = True
#pass
def __len__(self):
return len(self.all_ids)
def _reset_iter(self):
if self.shuffle:
random.shuffle(self.all_ids)
self.current_sample_idx = 0
#print(self.all_ids)
self.current_sample_dict_id = self.all_ids[self.current_sample_idx]
def count_samples(self):
self.goPoseprocessor = False
self.label_count_dict = {}
self.label_count_list = [0]*len(self.postProcessor.labelsFields)
for item in self:
#print(item)
annotation = item['selected_label']
annotation_idx = self.postProcessor.labelsFields.index(annotation)
self.label_count_list[annotation_idx] += 1
if annotation not in self.label_count_dict:
self.label_count_dict[annotation] = 0
self.label_count_dict[annotation] += 1
print(self.label_count_dict)
print(self.label_count_list)
self.goPoseprocessor = True
def cal_sample_weights(self):
self.count_samples()
self.label_weights_list = []
max_count = max(self.label_count_list)
for i in range(len(self.label_count_list)):
current_count = self.label_count_list[i]
num_samples = math.ceil(max_count/current_count)
self.label_weights_list.append(num_samples)
print(self.label_weights_list)
| 3,290 | 31.584158 | 92 | py |
CANTM | CANTM-main/GateMIcateLib/readers/WVmisInfoReader.py | import random
import math
import json
import torch
from .ReaderBase import CLSReaderBase
class WVmisInfoDataIter(CLSReaderBase):
def __init__(self, merged_json, label_field='category', **kwargs):
super().__init__(**kwargs)
self.label_field = label_field
self._initReader(merged_json)
self._reset_iter()
def _initReader(self, merged_json):
with open(merged_json, 'r') as f_json:
merged_data = json.load(f_json)
self.all_ids = []
self.data_dict = {}
numberid = 0
for item in merged_data:
select = True
annotation = item[self.label_field]
if self.target_labels:
if annotation not in self.target_labels:
#self.all_ids.append(item['unique_wv_id'])
#self.data_dict[item['unique_wv_id']] = item
select = False
if select:
try:
self.all_ids.append(item['unique_wv_id'])
self.data_dict[item['unique_wv_id']] = item
except:
self.all_ids.append(str(numberid))
self.data_dict[str(numberid)] = item
numberid += 1
| 1,266 | 29.902439 | 70 | py |
CANTM | CANTM-main/GateMIcateLib/readers/tsvBinaryFolderReader.py | import random
import math
import json
import torch
import glob
import os
from .ReaderBase import CLSReaderBase
class TsvBinaryFolderReader(CLSReaderBase):
def __init__(self, input_dir, pos_folder='positive', neg_folder='negative', text_filed=1, id_field=0, **kwargs):
super().__init__(**kwargs)
self.text_filed = text_filed
self.id_field = id_field
pos_dir = os.path.join(input_dir, pos_folder)
neg_dir = os.path.join(input_dir, neg_folder)
self._initReader(pos_dir, neg_dir)
self._reset_iter()
def _initReader(self, pos_dir, neg_dir):
self.all_ids = []
self.data_dict = {}
self.global_ids = 0
all_pos_file_list = glob.glob(pos_dir+'/*.tsv')
self._readDir(all_pos_file_list, 'pos')
all_neg_file_list = glob.glob(neg_dir+'/*.tsv')
self._readDir(all_neg_file_list, 'neg')
def _readDir(self, file_list, label):
for each_file in file_list:
self._readFile(each_file, label)
def _readFile(self, current_file, label):
current_text_id = str(self.global_ids)
with open(current_file, 'r') as fin:
for line in fin:
lineTok = line.split('\t')
#print(self.id_field)
if self.id_field != None:
#print('ssssssssssssss')
current_text_id = lineTok[self.id_field]
raw_text = lineTok[self.text_filed]
#print(current_text_id)
if current_text_id not in self.data_dict:
self.data_dict[current_text_id] = {}
self.data_dict[current_text_id]['text'] = raw_text
self.data_dict[current_text_id]['selected_label'] = label
self.all_ids.append(current_text_id)
else:
self.data_dict[current_text_id]['text'] += '\n'+raw_text
self.global_ids += 1
| 1,959 | 34.636364 | 117 | py |
CANTM | CANTM-main/GateMIcateLib/readers/aclImdbReader.py | import random
import math
import json
import torch
import glob
import os
from .ReaderBase import CLSReaderBase
class ACLimdbReader(CLSReaderBase):
def __init__(self, input_dir, **kwargs):
super().__init__(**kwargs)
pos_dir = os.path.join(input_dir,'pos')
neg_dir = os.path.join(input_dir,'neg')
self._initReader(pos_dir, neg_dir)
self._reset_iter()
def _initReader(self, pos_dir, neg_dir):
self.all_ids = []
self.data_dict = {}
self.global_ids = 0
all_pos_file_list = glob.glob(pos_dir+'/*.txt')
self._readDir(all_pos_file_list, 'pos')
all_neg_file_list = glob.glob(neg_dir+'/*.txt')
self._readDir(all_neg_file_list, 'neg')
def _readDir(self, file_list, label):
for each_file in file_list:
self._readFile(each_file, label)
def _readFile(self, current_file, label):
current_text_id = str(self.global_ids)
with open(current_file, 'r') as fin:
all_text = fin.readlines()
raw_text = ' '.join(all_text)
self.data_dict[current_text_id] = {}
self.data_dict[current_text_id]['text'] = raw_text
self.data_dict[current_text_id]['selected_label'] = label
self.all_ids.append(current_text_id)
self.global_ids += 1
| 1,338 | 29.431818 | 69 | py |
coderec_programming_states | coderec_programming_states-main/action_prediction/generate_features.py | from requests import session
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import json
import copy
import json
from tqdm import tqdm
import pickle
import logging
from tree_sitter import Language, Parser
logging.basicConfig(level=logging.INFO)
import argparse
import math
from get_code_label import get_prompt_label, parse_code
import torch
from transformers import AutoTokenizer, AutoModel
from datasets import Dataset, Features
from transformers import AutoModelForSequenceClassification
import os
from transformers import AutoTokenizer, AutoModelForMaskedLM
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--path', help='Path to extended logs frame', required=True) # change to True
parser.add_argument('-c', '--cudadevice', help='cuda device id', default=0, required=True, type=int)
parser.add_argument('-b', '--batchsize', help='batch size', default=1000, required=True, type=int)
parser.add_argument('-o', '--output', help='Output path of .pkl file', required=True) # change to True
parser.add_argument('-e', '--embedding', help='Whether to get embeddings for suggestion and prompt', required=True, type=int)
parser.add_argument('-m', '--maxusers', help='max users', default=100, required=True, type=int)
parser.add_argument('-a', '--onlyacceptreject', help='only get features for accept reject events (1 if yes 0 ow)', default=0, required=False, type=int)
def get_embedding_list(list_of_strs, batch_size=16):
def tokenize_function_embedding(examples):
prompt_token = tokenizer(examples['text'], return_tensors="pt", padding="max_length", truncation=True )['input_ids']
encoded_tokens = model(prompt_token.to(device)).pooler_output.detach().cpu().numpy()
dict = {'encoded_tokens': encoded_tokens}
return dict# overall_tokens
#a = df_observations[0][0].CurrentPrompt.to_numpy()
dataset = Dataset.from_dict({"text": list_of_strs })
ds_train_tokenized = dataset.map(tokenize_function_embedding, batched= True, batch_size=batch_size)
embeddings = [ds_train_tokenized[i]['encoded_tokens'] for i in range(len(ds_train_tokenized))]
return embeddings
def text_features(list_of_strs):
list_of_features = []
for str in list_of_strs:
numb_of_words = len(str.split())
# if includes #
includes_hash = '#' in str
# includes 'print'
includes_print = 'print' in str
# includes '='
includes_equal = '=' in str or '<=' in str or '>=' in str or '==' in str or '!=' in str
# includes 'for'
includes_for = 'for' in str
# includes 'while'
includes_while = 'while' in str
# includes 'if'
includes_if = 'if' in str
# includes 'else'
includes_else = 'else' in str
# includes 'def'
includes_def = 'def' in str
# includes 'class'
includes_class = 'class' in str
# includes 'import'
includes_import = 'import' in str
# includes 'from'
includes_from = 'from' in str
# includes 'return'
includes_return = 'return' in str
# includes 'try'
includes_try = 'try' in str
# includes 'except'
includes_except = 'except' in str
# includes 'raise'
includes_raise = 'raise' in str
# includes 'pass'
includes_pass = 'pass' in str
# includes 'continue'
includes_continue = 'continue' in str
# includes 'break'
includes_break = 'break' in str
# includes 'assert'
includes_assert = 'assert' in str
# includes '''
includes_quotes = '\'''' in str
# concatenate all
features = [numb_of_words, includes_quotes, includes_hash, includes_print, includes_equal, includes_for, includes_while, includes_if, includes_else, includes_def, includes_class, includes_import, includes_from, includes_return, includes_try, includes_except, includes_raise, includes_pass, includes_continue, includes_break, includes_assert]
list_of_features.append(features)
return list_of_features
def get_features(input_path, cudadevice, batchsize, include_embedding, output_path, maxusers, onlyAcceptReject):
# load pickle file
df_observations = pickle.load(open(input_path, 'rb'))
global device, tokenizer, model
device = torch.device('cuda:'+str(cudadevice) if torch.cuda.is_available() else 'cpu')
if include_embedding:
tokenizer = AutoTokenizer.from_pretrained("huggingface/CodeBERTa-small-v1")
model = AutoModel.from_pretrained("huggingface/CodeBERTa-small-v1").to(device)
include_editpercentage = True
include_timeinstate = True
include_codelabels = True
include_codeembeddings = include_embedding
include_measurements = True
include_userID = True
include_textfeatures = True
max_users = min(maxusers, len(df_observations))
df_observations_features = []
label_to_enum = {'codeinit': 0, 'function def': 1, 'test_assert': 2, 'import': 3,
'control flow': 4, 'print': 5, 'error handling': 6, 'assignment': 7, 'comment': 8,
'binary_operator': 9, 'comparison': 10, 'expression': 11, 'docstring':12, 'other': 13}
user_counter = 0
feature_dict = {'Measurements: compCharLen, confidence, documentLength, numLines, numTokens, promptCharLen, promptEndPos, quantile': 0,
'edit percentage': 1, 'time_in_state': 2, 'session_features':3, 'suggestion_label':4, 'prompt_label':5,
'suggestion_embedding':6, 'prompt_embedding':7, 'suggestion_text_features':8, 'prompt_text_features':9, 'statename':10}
for session in tqdm(df_observations):
df_features = []
logging.info(f'user {user_counter/len(df_observations)*100:.3f} \n \n' )
if user_counter >= max_users:
break
user_counter += 1
if len(session) == 0:
continue
session_features = []
prev_row = [0] * 8
# get prompt embedding
indices_to_keep = []
for i in range(len(session)):
row = session.iloc[i]
indices_to_keep.append(i)
suggs_text = session.CurrentSuggestion.to_numpy()[indices_to_keep]
prompts_text = session.CurrentPrompt.to_numpy()[indices_to_keep]
# for each prompt only keep last 3 lines
# split based on \n
prompts_text = [prompt.split('\n') for prompt in prompts_text]
prompts_text = [prompt[-3:] for prompt in prompts_text]
# join back together
prompts_text = ['\n'.join(prompt) for prompt in prompts_text]
if include_codeembeddings:
sugg_embedding = get_embedding_list(suggs_text)
prompt_embedding = get_embedding_list(prompts_text)
sugg_text_features = text_features(suggs_text)
prompt_text_features = text_features(prompts_text)
for i, index in enumerate(indices_to_keep):
observation = []
row = session.iloc[index]
row_og = session.iloc[index]
last_shown = copy.deepcopy(index)
found_shown = False
while not found_shown and last_shown >0:
last_shown -= 1
if session.iloc[last_shown]['StateName'] == 'Shown' or session.iloc[last_shown]['StateName'] == 'Replay':
found_shown = True
if not found_shown:
last_shown = max(0, index-1)
if row_og['StateName'] != 'Accepted' and row_og['StateName'] != 'Rejected':
continue
row = session.iloc[last_shown]
try:
# for Accepts and Rejects
measurement_features = [row['Measurements']['compCharLen'],
row['Measurements']['confidence'],
row['Measurements']['documentLength'],
row['Measurements']['numLines'],
row['Measurements']['numTokens'],
row['Measurements']['promptCharLen'],
row['Measurements']['promptEndPos'],
row['Measurements']['quantile'],
row['Measurements']['meanAlternativeLogProb'],
row['Measurements']['meanLogProb']]
prev_row = measurement_features
except:
# for shown or browsing
try:
measurement_features = [row['Measurements']['compCharLen'],
prev_row[1],
row['Measurements']['documentLength'],
row['Measurements']['numLines'],
row['Measurements']['numTokens'],
row['Measurements']['promptCharLen'],
row['Measurements']['promptEndPos'],
prev_row[7],
row['Measurements']['meanAlternativeLogProb'],
row['Measurements']['meanLogProb']]
except:
measurement_features = prev_row
current_suggestion = row['CurrentSuggestion']
# get embedding, get code feature
# CurrentPrompt
current_prompt = row['CurrentPrompt']
# get last 5 lines of the prompt
prompt_lines = current_prompt.split('\n')
prompt_lines_last5 = prompt_lines[-1:]
prompt_lines_last5_str = '\n'.join(prompt_lines_last5)
lenght_sug = len(current_suggestion)
lenght_prompt = len(current_prompt)
lenght_sug_words = len(current_suggestion.split(' '))
lenght_prompt_words = len(current_prompt.split(' '))
new_measurements = [lenght_sug, lenght_prompt, lenght_sug_words, lenght_prompt_words, index]
#measurement_features.extend(new_measurements)
new_measurements.extend(measurement_features)
edit_distance = row['EditPercentage']
# CurrentSuggestion
current_suggestion = row['CurrentSuggestion']
# get embedding, get code feature
# CurrentPrompt
current_prompt = row['CurrentPrompt']
# get last 5 lines of the prompt
prompt_lines = current_prompt.split('\n')
prompt_lines_last5 = prompt_lines[-1:]
prompt_lines_last5_str = '\n'.join(prompt_lines_last5)
time_spent_in_state = row['TimeSpentInState']
if include_measurements:
observation.append(new_measurements)
if include_editpercentage:
observation.append(edit_distance)
if include_timeinstate:
observation.append([time_spent_in_state])
observation.append([index, index/len(session), len(session)])
if include_codelabels:
sugg_label = get_prompt_label(current_suggestion)
sugg_label_enc = np.zeros(14)
sugg_label_enc[label_to_enum[sugg_label]] = 1
prompt_label = get_prompt_label(prompt_lines[-1]) # label last line
prompt_label_enc = np.zeros(14)
prompt_label_enc[label_to_enum[prompt_label]] = 1
observation.append(sugg_label_enc)
observation.append(prompt_label_enc)
if include_codeembeddings:
observation.append(sugg_embedding[i])
observation.append(prompt_embedding[i])
else:
observation.append(np.zeros(1))
observation.append(np.zeros(1))
if include_textfeatures:
observation.append(np.array(sugg_text_features[i]))
observation.append(np.array(prompt_text_features[i]))
# add label
observation.append(row_og['StateName'])
# make observation into numeric np array
observation = np.array(observation)#, dtype=np.float32)
session_features.append(observation)
df_observations_features.append(np.array(session_features))
pickle.dump([df_observations_features, feature_dict, ], open(output_path, 'wb'))
pickle.dump([df_observations_features, feature_dict, ], open(output_path, 'wb'))
def main():
args = parser.parse_args()
logging.info(args)
if args.embedding not in [0,1]:
raise ValueError('embedding argument must be 0 or 1')
get_features(args.path, args.cudadevice, args.batchsize, args.embedding, args.output, args.maxusers, args.onlyacceptreject)
if __name__ == '__main__':
main()
# call this script with
# python3 get_features.py --path ../data/observations.csv --cudadevice 0 --batchsize 32 --embedding True --output ../data/features.pkl --maxusers 100 | 13,075 | 41.732026 | 349 | py |
coderec_programming_states | coderec_programming_states-main/action_prediction/action_prediction_xgb.py |
from requests import session
import matplotlib.pyplot as plt
import pandas as pd
import json
import copy
import numpy as np, scipy.stats as st
import json
from tqdm import tqdm
import pickle
import logging
import argparse
import math
from xgboost import XGBClassifier
# logistic regression
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
from sklearn.metrics import f1_score
from itertools import chain
import xgboost as xg
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
logging.basicConfig(level=logging.INFO)
from sklearn import preprocessing
# two local imports
from action_prediction_prep import get_features_labels
from action_prediction_prep import process_data
import matplotlib
# plot calibration of Copilot confidences with XGBoost predictions
from re import S
from scipy.stats.stats import pearsonr
from sklearn.calibration import calibration_curve
from sklearn.metrics import roc_auc_score
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--path', help='Path to features array', required=True) # change to True
parser.add_argument('-c', '--usegpu', help='to use gpu (0 or 1)', default=0, required=True, type=int)
parser.add_argument('-s', '--splitbyusers', help='split by users or session (1 or 0)', default=0, required=True, type=int)
parser.add_argument('-o', '--output', help='output path folder', required=True)
parser.add_argument('-t', '--testpercentage', help='test percentage', default = 0.2, type =float)
parser.add_argument('-v', '--valpercentage', help='val percentage', default =0.1, type=float)
def main():
args = parser.parse_args()
path = args.path
use_gpu = args.usegpu
splitbyusers = args.splitbyusers
output_path = args.output
test_percentage = args.testpercentage
val_percentage = args.valpercentage
REMOVE_S_AND_R = True # remove shown and replay
features_to_keep = np.array([0,4,5,6,7,8,9])
label_index = np.array([10])
feature_dict = {'Measurements: compCharLen, confidence, documentLength, numLines, numTokens, promptCharLen, promptEndPos, quantile': 0,
'edit percentage': 1, 'time_in_state': 2, 'session_features':3, 'suggestion_label':4, 'prompt_label':5,
'suggestion_embedding':6, 'prompt_embedding':7, 'suggestion_text_features':8, 'prompt_text_features':9, 'statename':10}
df_observations_features, df_observations_labels = get_features_labels(path, features_to_keep, label_index, REMOVE_S_AND_R)
# split into train and test
SEQUENCE_MODE = False # keep session as a sequence or split it into events
SPLIT_BY_USER = bool(splitbyusers) # otherwise split by session uniformly
ADD_PREVIOUS_STATES = True
PREDICT_ACTION = True # Otherwise predict time in state
NORMALIZE_DATA = False # normalize data
test_percentage = args.testpercentage
val_percentage = args.valpercentage
previous_states_to_keep = 3
if not PREDICT_ACTION and SPLIT_BY_USER:
raise ValueError('Cannot predict time and split by user')
X_train, X_test, X_val, y_train, y_test, y_val = process_data(df_observations_features, df_observations_labels,
REMOVE_S_AND_R, SEQUENCE_MODE, SPLIT_BY_USER, ADD_PREVIOUS_STATES, PREDICT_ACTION, NORMALIZE_DATA,
test_percentage, val_percentage, previous_states_to_keep)
# train model
if PREDICT_ACTION:
if use_gpu:
model = XGBClassifier(tree_method='gpu_hist')
else:
model = XGBClassifier()
model.fit(X_train, y_train)
# predict
y_pred = model.predict(X_test)
# evaluate
print("Accuracy:", accuracy_score(y_test, y_pred))
accuracy = accuracy_score(y_test, y_pred)
confusion_matrix_act = confusion_matrix(y_test, y_pred)
classification_report_act = classification_report(y_test, y_pred)
print("Confusion Matrix:")
print(confusion_matrix(y_test, y_pred))
print("Classification Report:")
print(classification_report(y_test, y_pred))
y_pred_proba = model.predict_proba(X_test)
y_pred_proba = y_pred_proba[:,1]
print("AUC:", roc_auc_score(y_test, y_pred_proba))
auc = roc_auc_score(y_test, y_pred_proba)
pickle.dump([accuracy, confusion_matrix_act, classification_report_act, auc], open(output_path + '/action_prediction_results.pkl', 'wb'))
model.save_model(output_path+ "/model_trained.json")
# plot calibration curve
if PREDICT_ACTION:
y_pred_proba = model.predict_proba(X_test)[:,1]
fpr, tpr = calibration_curve(y_test, y_pred_proba, n_bins=10)
# Plot perfectly calibrated
plt.plot([0, 1], [0, 1], linestyle = '--', label = 'Ideally Calibrated')
# Plot model's calibration curve
plt.plot(tpr, fpr, marker = '.', label = 'XGBoost')
pickle.dump([tpr, fpr], open(output_path + '/xgb_calibration_curve.pkl', 'wb'))
leg = plt.legend(loc = 'upper left')
plt.xlabel('Average Predicted Probability in each bin')
plt.ylabel('Ratio of positives')
ax = plt.gca()
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
plt.savefig(output_path + '/calibration_curve.pdf',dpi=1000)
plt.clf()
if PREDICT_ACTION:
# print a curve where x axis is ration and y axis is accuracy
coverages = []
accuracies = []
aucs = []
for treshold in np.arange(0.01, 1, 0.01):
treshold_high = treshold
y_pred_proba = model.predict_proba(X_test)[:,1]
y_pred_proba = np.array([max(y_pred_proba[i], 1- y_pred_proba[i]) for i in range(len(y_pred_proba))])
y_pred = model.predict(X_test)
y_pred_high_confidence = y_pred[y_pred_proba > treshold_high]
y_pred_proba_high_confidence = y_pred_proba[y_pred_proba > treshold_high]
y_test_high_confidence = y_test[y_pred_proba > treshold_high]
coverages.append(len(y_pred_high_confidence)/len(y_pred))
accuracies.append(accuracy_score(y_test_high_confidence, y_pred_high_confidence))
# pickle data
pickle.dump([coverages, accuracies], open(output_path + '/xgb_coverage_accuracy.pkl', 'wb'))
plt.plot(coverages, accuracies)
plt.xlabel('Coverage (based on tresholding model confidence)')
plt.ylabel('Accuracy')
ax = plt.gca()
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
# more detailed y axis
plt.savefig(output_path + '/acc_vs_coverage.pdf',dpi=1000)
plt.clf()
# learning curve
if PREDICT_ACTION:
# empty 2 d array
training_izes = []
max_trials = 1
training_data_percentage = np.array([0.005,0.01,0.05,0.1,0.25,0.5,0.75,0.99])
accuracies = [[] for _ in range(max_trials)]
aucs = [[] for _ in range(max_trials)]
for trial in range(max_trials):
training_sizes = []
for split_percentage in training_data_percentage:
# split train data using sklearn
_, X_train_frac, _, y_train_frac = train_test_split(X_train, y_train, test_size=split_percentage)
# train model
if use_gpu:
model = XGBClassifier(tree_method='gpu_hist')
else:
model = XGBClassifier()
model.fit(X_train_frac, y_train_frac)
# predict
y_pred = model.predict(X_test)
# evaluate
accuracies[trial].append(accuracy_score(y_test, y_pred))
aucs[trial].append(roc_auc_score(y_test, model.predict_proba(X_test)[:,1]))
training_sizes.append(len(X_train_frac))
# plot with error bars and means
accuracies = np.array(accuracies)
aucs = np.array(aucs)
pickle.dump([training_data_percentage, accuracies], open(output_path + '/xgb_learning_curve.pkl', 'wb'))
plt.errorbar(training_data_percentage, [np.mean(accuracies[:,i]) for i in range(len(accuracies[0]))], yerr=[np.std(accuracies[:,i]) for i in range(len(accuracies[0]))])
plt.xlabel('Training Data Size')
plt.ylabel('Accuracy')
plt.plot(0, np.mean(y_test), 'o', label='base rate')
plt.legend()
plt.savefig(output_path + '/learning_curve.pdf',dpi=1000)
plt.clf()
main() | 8,716 | 41.940887 | 176 | py |
triple-descent-paper | triple-descent-paper-master/nn-numeric/main.py | import numpy as np
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import scipy
from collections import defaultdict
from utils import rot
from utils import get_data, hinge_regression, hinge_classification
from model import FullyConnected
import argparse
def train_and_test(model, tr_data, te_data, crit, task, opt, epochs, checkpoints):
tr_losses = []
te_losses = []
te_accs = []
for epoch in range(epochs):
epoch_loss = 0
for (x,y) in tr_data:
x, y = x.to(device), y.to(device)
opt.zero_grad()
out = model(x)
loss = crit(out, y)
loss.backward()
epoch_loss += loss.item()/len(tr_data)
opt.step()
if epoch in checkpoints:
tr_losses.append(epoch_loss)
te_loss, te_acc = test(model, te_data, crit, task)
te_losses.append(te_loss)
te_accs.append(te_acc)
return tr_losses, te_losses, te_accs
def test(model, te_data, crit, task):
with torch.no_grad():
for (x,y) in te_data:
x, y = x.to(device), y.to(device)
out = model(x)
test_loss = crit(out, y).item()
if task=='classification':
preds = out.max(1)[1]
test_acc = preds.eq(y).sum().float()/len(y)
test_acc = test_acc.item()
else:
test_acc = 0
break
return test_loss, test_acc
def test_ensemble(models, te_data, crit, task):
with torch.no_grad():
for (x,y) in te_data:
x, y = x.to(device), y.to(device)
outs = torch.stack([model(x) for model in models])
out = outs.mean(dim=0)
test_loss = crit(out, y).item()
if task=='classification':
preds = out.max(1)[1]
test_acc = preds.eq(y).sum().float()/len(y)
test_acc = test_acc.item()
else:
test_acc = 0
break
return test_loss, test_acc
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--name', default=None, type=str)
parser.add_argument('--num_seeds', default=1, type=int)
parser.add_argument('--no_cuda', default=False, type=bool)
parser.add_argument('--task', default='classification', type=str)
parser.add_argument('--dataset', default='random', type=str)
parser.add_argument('--loss_type', default='default', type=str)
parser.add_argument('--depth', default=1, type=int)
parser.add_argument('--teacher_width', default=100, type=int)
parser.add_argument('--teacher_depth', default=2, type=int)
parser.add_argument('--width', default=20, type=int)
parser.add_argument('--activation', default='relu', type=str)
parser.add_argument('--epochs', default=1000, type=int)
parser.add_argument('--d', default=2, type=int)
parser.add_argument('--n', default=100, type=int)
parser.add_argument('--n_test', default=1000, type=int)
parser.add_argument('--noise', default=0.1, type=float)
parser.add_argument('--test_noise', default=True, type=bool)
parser.add_argument('--n_classes', default=None, type=int)
parser.add_argument('--lr', default=0.01, type=float)
parser.add_argument('--mom', default=0.9, type=float)
parser.add_argument('--wd', default=0., type=float)
parser.add_argument('--bs', default=1000000, type=int)
args = parser.parse_args()
device = 'cuda' if torch.cuda.is_available() else 'cpu'
if args.no_cuda: device='cpu'
if not args.n_classes: args.n_classes = 1 if args.task=='regression' else 2
if not args.loss_type: args.loss_type = 'mse' if args.task=='regression' else 'nll'
if args.task=='classification':
if args.loss_type == 'linear_hinge':
crit = lambda x,y : hinge_classification(x,y, type='linear')
elif args.loss_type == 'quadratic_hinge':
crit = lambda x,y : hinge_classification(x,y, type='quadratic')
elif args.loss_type == 'nll':
crit = nn.CrossEntropyLoss()
else:
raise NotImplementedError
elif args.task=='regression':
if args.loss_type == 'linear_hinge':
crit = lambda x,y : hinge_regression(x,y, epsilon=args.epsilon, type='linear')
elif args.loss_type == 'quadratic_hinge':
crit = lambda x,y : hinge_regression(x,y, epsilon=args.epsilon, type='quadratic')
elif args.loss_type == 'mse':
crit = nn.MSELoss()
else:
raise NotImplementedError
else:
raise
torch.manual_seed(0)
with torch.no_grad():
teacher = FullyConnected(width=args.teacher_width, n_layers=args.teacher_depth, in_dim=args.d, out_dim=args.n_classes, activation=args.activation).to(device)
bs = min(args.bs, args.n)
n_batches = int(args.n/bs)
tr_data = get_data(args.dataset, args.task, n_batches, bs, args.d, args.noise, n_classes=args.n_classes, teacher=teacher)
test_noise = args.noise if args.test_noise else 0
te_data = get_data(args.dataset, args.task, 1, args.n_test, args.d, test_noise, n_classes=args.n_classes, teacher=teacher)
tr_losses = []
te_losses = []
te_accs = []
students = []
checkpoints = np.unique(np.logspace(0,np.log10(args.epochs),20).astype(int))
for seed in range(args.num_seeds):
torch.manual_seed(seed)
student = FullyConnected(width=args.width, n_layers=args.depth, in_dim=args.d, out_dim=args.n_classes, activation=args.activation).to(device)
opt = torch.optim.SGD(student.parameters(), lr=args.lr, momentum=args.mom, weight_decay=args.wd)
tr_loss_hist, te_loss_hist, te_acc_hist = train_and_test(student, tr_data, te_data, crit, args.task, opt, args.epochs, checkpoints)
tr_losses.append(tr_loss_hist)
te_losses.append(te_loss_hist)
te_accs.append(te_acc_hist)
students.append(student)
tr_losses, te_losses, te_accs = np.array(tr_losses), np.array(te_losses), np.array(te_accs)
tr_loss, te_loss, te_acc = np.mean(tr_losses, axis=0), np.mean(te_losses, axis=0), np.mean(te_accs, axis=0)
te_loss_ens, te_acc_ens = test_ensemble(students, te_data, crit, args.task)
dic = {'args':args, 'checkpoints':checkpoints,
'tr_loss':tr_loss, 'te_loss':te_loss, 'te_acc':te_acc,
'te_loss_ens':te_loss_ens, 'te_acc_ens':te_acc_ens}
print(dic)
torch.save(dic, args.name+'.pyT')
| 6,525 | 40.303797 | 165 | py |
triple-descent-paper | triple-descent-paper-master/nn-numeric/utils.py | # some useful functions
import os
import shutil
import math
import torch
import torchvision
from torch.utils.data import Dataset, DataLoader
import numpy as np
def hinge_regression(output, target, epsilon=.1, type='quadratic'):
power = 1 if type=='linear' else 2
delta = (output-target).abs()-epsilon
loss = torch.nn.functional.relu(delta)*delta.pow(power)
return loss.mean()
def hinge_classification(output,target,epsilon=.5, type='quadratic'):
power = 1 if type=='linear' else 2
output_size=output.size(1)
if output_size==1:
target = 2*target.double()-1
print(target,output)
return 0.5*(epsilon-output*target).mean()
delta = torch.zeros(output.size(0))
for i,(out,tar) in enumerate(zip(output,target)):
tar = int(tar)
delta[i] = epsilon + torch.cat((out[:tar],out[tar+1:])).max() - out[tar]
loss = 0.5 * torch.nn.functional.relu(delta).pow(power).mean()
return loss
def normalize(x):
mean = x.mean(dim=0, keepdim=True)
std = x.std(dim=0, keepdim=True)
std[std==0]=1
return (x-mean)/std
def get_data(dataset, task, n_batches, bs, d, noise, var=.5, n_classes=None, teacher=None, train=True):
n = n_batches*bs
if dataset=='random':
data = torch.randn(n, d)
else:
assert d**0.5 == int(d**0.5)
transforms = torchvision.transforms.Compose([
torchvision.transforms.Resize(int(d**0.5)),
torchvision.transforms.ToTensor()])
dataset = getattr(torchvision.datasets, dataset.upper())('~/data', train=train, download=True, transform=transforms)
data = normalize(torch.cat([dataset[mu][0] for mu in range(n)]).view(n,d))
data = data*d**0.5/data.norm(dim=-1,keepdim=True)
with torch.no_grad():
dataset = []
# Gaussian Mixture
# if task=='classification':
# for i in range(n_batches):
# vectors = torch.randn(n_classes, d)
# if n_classes==2:
# vectors[0] = torch.ones(d)
# vectors[1] = -torch.ones(d)
# labels = torch.randint(n_classes,(bs,))
# x = torch.ones(bs,d)
# y = torch.ones(bs)
# for j, label in enumerate(labels):
# x[j] = vectors[label] + var * torch.randn(d)
# y[j] = label if np.random.random()>noise else np.random.randint(n_classes)
# dataset.append((x,y.long()))
if task=='classification':
for i in range(n_batches):
x = data[i*bs:(i+1)*bs]
y = teacher(x).max(1)[1].squeeze()
for j in range(len(y)):
if np.random.random()<noise:
y[j]= np.random.randint(n_classes)
dataset.append((x,y.long()))
elif task=='regression':
for i in range(n_batches):
x = data[i*bs:(i+1)*bs]
y = teacher(x)+noise*torch.randn((bs,1))
dataset.append((x,y))
return dataset
def rot(x, th):
with torch.no_grad():
rotation = torch.eye(len(x))
rotation[:2,:2] = torch.Tensor([[np.cos(th),np.sin(th)],[-np.sin(th), np.cos(th)]])
return rotation @ x
def who_am_i():
import subprocess
whoami = subprocess.run(['whoami'], stdout=subprocess.PIPE)
whoami = whoami.stdout.decode('utf-8')
whoami = whoami.strip('\n')
return whoami
def copy_py(dst_folder):
# and copy all .py's into dst_folder
if not os.path.exists(dst_folder):
print("Folder doesn't exist!")
return
for f in os.listdir():
if f.endswith('.py'):
shutil.copy2(f, dst_folder)
class FastMNIST(torchvision.datasets.MNIST):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if torch.cuda.is_available():
self.device = torch.device('cuda')
else:
self.device = torch.device('cpu')
self.data = self.data.unsqueeze(1).float().div(255)
self.data = self.data.sub_(self.data.mean()).div_(self.data.std())
self.data, self.targets = self.data.to(self.device), self.targets.to(self.device)
def __getitem__(self, index):
img, target = self.data[index], self.targets[index]
return img, target, index
class FastFashionMNIST(torchvision.datasets.FashionMNIST):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if torch.cuda.is_available():
self.device = torch.device('cuda')
else:
self.device = torch.device('cpu')
self.data = self.data.unsqueeze(1).float().div(255)
self.data = self.data.sub_(self.data.mean()).div_(self.data.std())
self.data, self.targets = self.data.to(self.device), self.targets.to(self.device)
def __getitem__(self, index):
img, target = self.data[index], self.targets[index]
return img, target, index
class FastCIFAR10(torchvision.datasets.CIFAR10):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if torch.cuda.is_available():
self.device = torch.device('cuda')
else:
self.device = torch.device('cpu')
self.data = torch.from_numpy(self.data).float().div(255)
self.data = self.data.sub_(self.data.mean()).div_(self.data.std())
self.data, self.targets = self.data.to(self.device), torch.LongTensor(self.targets).to(self.device)
def __getitem__(self, index):
img, target = self.data[index], self.targets[index]
return img, target, index
def get_pca(tr_data, te_data, input_size, normalized = True):
device = tr_data.device
tr_data.data = tr_data.data.view(tr_data.data.size(0),-1)
te_data.data = te_data.data.view(te_data.data.size(0),-1)
x = tr_data.data.cpu()
# DATA IS ALREADY NORMALIZED
# m = x.mean(0).expand_as(x)
# u,s,v = torch.svd(torch.t(x-m))
u,s,v = torch.svd(torch.t(x))
if normalized:
tr_data.data = (tr_data.data) @ u[:, :input_size].to(device) / s[:input_size].to(device) ** 0.5
te_data.data = (te_data.data) @ u[:, :input_size].to(device) / s[:input_size].to(device) ** 0.5
else:
tr_data.data = (tr_data.data) @ u[:, :input_size].to(device).to(device) ** 0.5
te_data.data = (te_data.data) @ u[:, :input_size].to(device).to(device) ** 0.5
return tr_data, te_data
| 6,540 | 38.167665 | 124 | py |
triple-descent-paper | triple-descent-paper-master/nn-numeric/model.py | import torch
import torch.nn.functional as F
import torch.nn as nn
class MulConstant(nn.Module):
def __init__(self, constant=10):
super(MulConstant, self).__init__()
self.constant = constant
def forward(self, x):
return x * self.constant
def backward(self, g): # is this necessary?
return g * self.constant, None
class FullyConnected(nn.Module):
def __init__(self, sigma_0=1.4142135381698608, in_dim=28*28, width=512, n_layers=1, out_dim=10, bias=True, activation='relu', ntk_scaling=False):
super(FullyConnected, self).__init__()
self.in_dim = in_dim
self.width = width
self.n_layers = n_layers
self.bias = bias
self.out_dim = out_dim
if activation=='linear':
self.activation = nn.Identity()
if activation=='abs':
self.activation = nn.PReLU(init=-1)
self.activation.weight.requires_grad=False
if activation=='relu':
self.activation = nn.ReLU()
elif activation=='tanh':
self.activation = nn.Tanh()
self.layers = []
self.layers.append(nn.Linear(self.in_dim, self.width, bias=self.bias))
if ntk_scaling:
self.layers.append(MulConstant( 1 / (self.in_dim ** 0.5)))
self.layers.append(self.activation)
for i in range(self.n_layers-1):
self.layers.append(nn.Linear(self.width, self.width, bias=self.bias))
if ntk_scaling:
self.layers.append(MulConstant( 1 / (self.width ** 0.5)))
self.layers.append(self.activation)
self.layers.append(nn.Linear(self.width, self.out_dim, bias=self.bias),)
if ntk_scaling:
self.layers.append(MulConstant( 1 / (self.width ** 0.5)))
self.net = nn.Sequential(*self.layers)
# NTK initialization
if ntk_scaling:
with torch.no_grad():
for m in self.net.modules():
if isinstance(m, nn.Linear):
nn.init.normal_(m.weight, mean=0, std=sigma_0)
if m.bias is not None:
nn.init.constant_(m.bias, 0)
def forward(self, x):
x = self.net(x)
return x
| 2,314 | 34.615385 | 149 | py |
triple-descent-paper | triple-descent-paper-master/nn-numeric/run.py | import os
import time
import subprocess
import itertools
import collections
import argparse
import torch
import numpy as np
from utils import copy_py, who_am_i
def create_script(params):
script = '''#!/bin/bash
#SBATCH --gres=gpu:1
#SBATCH --mem=10GB
#SBATCH --nodes=1
#SBATCH --output={name}.out
#SBATCH --job-name={name}
#SBATCH --cpus-per-task=1
ulimit -n 64000
python main.py --name {name} --epochs {epochs} --noise {noise} --n {n} --width {width} --num_seeds {num_seeds} --lr {lr} --d {d} --test_noise {test_noise} --loss_type {loss_type} --n_classes 1 --task regression --no_cuda False --depth {depth} --wd {wd} --activation {activation} --dataset {dataset}
'''.format(**params)
with open('{}.sbatch'.format(params['name']), 'w') as f:
f.write(script)
# with open('{}.params'.format(params['name']), 'wb') as f:
# torch.save(params, f)
def send_script(file):
process = subprocess.Popen(['sbatch', file], stdout=subprocess.PIPE)
if __name__ == '__main__':
exp_dir = 'r.{}'.format(int(time.time()))
os.mkdir(exp_dir)
copy_py(exp_dir)
os.chdir(exp_dir)
widths = np.unique(np.logspace(0, 2.5, 20).astype(int))
ns = np.logspace(1,5,20).astype(int)
grid = collections.OrderedDict({
'width' : widths,
'n' : ns,
'depth': [1,2]
'wd' : [0., 0.05],
'activation' : ['tanh'],
'dataset' : ['random'],
'noise' : [0,0.5,5],
'lr' : [0.01],
'd' : [14*14],
'num_seeds' : [10],
'test_noise' : [False],
'loss_type' : ['mse'],
'epochs' : [1000],
})
def dict_product(d):
keys = d.keys()
for element in itertools.product(*d.values()):
yield dict(zip(keys, element))
for i, params in enumerate(dict_product(grid)):
torch.save(grid, 'params.pkl')
params['name'] = '{:06d}'.format(i)
create_script(params)
file_name = '{}.sbatch'.format(params['name'])
send_script(file_name)
| 2,016 | 27.814286 | 298 | py |
reco-gym | reco-gym-master/setup.py | import pathlib
from setuptools import setup, find_packages
# The directory containing this file
HERE = pathlib.Path(__file__).parent
# The text of the README file
README = (HERE / "README.md").read_text()
# This call to setup() does all the work
setup(
name="recogym",
version="0.1.2.4",
description="Open-AI gym reinforcement learning environment for recommendation",
long_description=README,
long_description_content_type="text/markdown",
url="https://github.com/criteo-research/reco-gym",
author="Criteo AI Lab",
license="Apache License",
classifiers=[
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.6",
],
packages=find_packages(exclude=("tests",)),
include_package_data=True,
install_requires=[
"absl-py",
"pandas",
"matplotlib",
"simplegeneric",
"gym",
"torch",
"tensorflow",
"numba",
"tqdm",
"datetime",
"jupyter",
"scipy",
"numpy",
"scikit-learn",
],
)
| 1,140 | 24.355556 | 84 | py |
reco-gym | reco-gym-master/leaderboard_entries/pytorch_CB_log.py | from recogym import build_agent_init
from recogym.agents import PyTorchMLRAgent, pytorch_mlr_args
pytorch_mlr_args['n_epochs'] = 30
pytorch_mlr_args['learning_rate'] = 0.01
pytorch_mlr_args['logIPS'] = True
agent = build_agent_init('PyTorchMLRAgent', PyTorchMLRAgent, {**pytorch_mlr_args})
| 292 | 31.555556 | 82 | py |
reco-gym | reco-gym-master/leaderboard_entries/pytorch_CB.py | from recogym import build_agent_init
from recogym.agents import PyTorchMLRAgent, pytorch_mlr_args
pytorch_mlr_args['n_epochs'] = 30
pytorch_mlr_args['learning_rate'] = 0.01
agent = build_agent_init('PyTorchMLRAgent', PyTorchMLRAgent, {**pytorch_mlr_args})
| 257 | 35.857143 | 82 | py |
reco-gym | reco-gym-master/leaderboard_entries/pytorch_likelihood.py | from recogym import build_agent_init
from recogym.agents import PyTorchMLRAgent, pytorch_mlr_args
pytorch_mlr_args['n_epochs'] = 30
pytorch_mlr_args['learning_rate'] = 0.01,
pytorch_mlr_args['ll_IPS'] = False,
pytorch_mlr_args['alpha'] = 1.0
agent = build_agent_init('PyTorchMLRAgent', PyTorchMLRAgent, {**pytorch_mlr_args})
| 326 | 35.333333 | 82 | py |
reco-gym | reco-gym-master/recogym/agents/pytorch_mlr.py | import numpy as np
#import tensorflow as tf
import torch
from torch.autograd import Variable
from torch.nn import functional as F
from scipy.special import expit
from recogym.agents import (
AbstractFeatureProvider,
Model,
ModelBasedAgent,
ViewsFeaturesProvider
)
from ..envs.configuration import Configuration
pytorch_mlr_args = {
'n_epochs': 30,
'learning_rate': 0.01,
'random_seed': np.random.randint(2 ** 31 - 1),
'logIPS': False,
'variance_penalisation_strength': .0,
'clip_weights': False,
'alpha': .0,
'll_IPS': True
}
from numba import jit
from tqdm import tqdm
@jit(nopython=True)
def act_linear_model(X, W, P):
return np.argmax(X.dot(W.T).reshape(P))
class PyTorchMLRModelBuilder(AbstractFeatureProvider):
def __init__(self, config):
super(PyTorchMLRModelBuilder, self).__init__(config)
def build(self):
class PyTorchMLRFeaturesProvider(ViewsFeaturesProvider):
"""
"""
def __init__(self, config):
super(PyTorchMLRFeaturesProvider, self).__init__(config)
def features(self, observation):
base_features = super().features(observation)
return base_features.reshape(1, self.config.num_products)
class PyTorchMLRModel(Model):
"""
"""
def __init__(self, config, model):
super(PyTorchMLRModel, self).__init__(config)
self.model = model
self.W = model.weight.detach().numpy()
def act(self, observation, features):
# OWN CODE
#X = features
#P = X.shape[1]
#X = Variable(torch.Tensor(X))
#action_probs = self.model(X).detach().numpy().ravel()
#action = np.argmax(action_probs)
#ps_all = np.zeros(P)
#ps_all[action] = 1.0
#/OWN CODE
# NUMBA CODE
P = features.shape[1]
X = features.astype(np.float32)
action = act_linear_model(X,self.W,P)
ps_all = np.zeros(P)
ps_all[action] = 1.0
#/NUMBA CODE
return {
**super().act(observation, features),
**{
'a': action,
'ps': 1.0,
'ps-a': ps_all,
},
}
class MultinomialLogisticRegressionModel(torch.nn.Module):
def __init__(self, input_dim, output_dim):
super(MultinomialLogisticRegressionModel, self).__init__()
# Generate weights - initialise randomly
self.weight = torch.nn.Parameter(torch.Tensor(output_dim, input_dim))
torch.nn.init.kaiming_uniform_(self.weight, a = np.sqrt(5))
# Experimental bias
self.bias = torch.nn.Parameter(torch.Tensor(1))
fan_in, _ = torch.nn.init._calculate_fan_in_and_fan_out(self.weight)
bound = 1 / np.sqrt(fan_in)
torch.nn.init.uniform_(self.bias, -bound, bound)
def forward(self, x):
# Compute linear transformation x.A.T
pred = F.linear(x, self.weight)
return pred
class BinomialLogisticRegressionModel(torch.nn.Module):
def __init__(self, multinomial_model):
super(BinomialLogisticRegressionModel, self).__init__()
# Weights learned through the multinomial model
self.weight = multinomial_model.weight
self.bias = multinomial_model.bias
def pairwise_dot(self, x, a):
# Not just .matmul - compute pairwise dotproduct for action/context pairs
return (x*a).sum(dim=1)
def forward(self, x, a):
# Compute linear transformation x.A.T
return torch.sigmoid(self.pairwise_dot(x, self.weight[a,:]) + self.bias) # Bias is experimental TODO
# Get data
features, actions, deltas, pss = self.train_data()
# Extract data properly
X = features
N = X.shape[0]
P = X.shape[1]
A = actions
y = deltas
# Generate model
multinomial_model = MultinomialLogisticRegressionModel(P, P)
binomial_model = BinomialLogisticRegressionModel(multinomial_model)
# Compute clipping constant as ratio between 90th and 10th percentile
# As recommended in POEM
M = np.inf
if type(self.config.clip_weights) != bool:
M = self.config.clip_weights
elif self.config.clip_weights:
M = np.percentile(pss[y != 0], 90) / np.percentile(pss[y != 0], 10)
if self.config.clip_weights:
print('Clipping with constant M:\t{0}'.format(M))
# Convert data to torch objects - only clicks for learning multinomial model
X1 = Variable(torch.Tensor(X[y != 0]))
A1 = Variable(torch.LongTensor(A[y != 0]))
w1 = torch.Tensor(pss[y != 0] ** -1)
N1 = X1.shape[0]
# Convert data to torch objects - all samples for learning binomial model
X = Variable(torch.Tensor(X))
A = Variable(torch.LongTensor(A))
w = torch.Tensor(pss ** -1)
y = Variable(torch.Tensor(y))
# Binary cross-entropy as objective for the binomial model
binary_cross_entropy = torch.nn.BCELoss(reduction = 'none')
# LBFGS for optimisation
optimiser = FullBatchLBFGS(multinomial_model.parameters())
def closure():
# Reset gradients
optimiser.zero_grad()
# Check whether we're using the multinomial model
if self.config.alpha < 1.0:
# Compute action predictions for clicks
p_a = multinomial_model(X1)
# Turn these into probabilities through softmax
p_a = F.softmax(p_a, dim = 1)
# Only keep probabilities for the actions that were taken
p_a = torch.gather(p_a, 1, A1.unsqueeze(1))
p_a = p_a.reshape(-1) # FIXME HOTFIX BY MARTIN
# (Clipped) IPS Estimate of the reward
reward = torch.clamp(p_a * w1, max = M)
# Logged version
log_reward = torch.log(torch.clamp(p_a, min = 1e-10)) * w1
# Compute the estimated reward
#reward = torch.clamp(torch.gather(F.softmax(prob_a, dim = 1), 1, A1.unsqueeze(1)) * w1, max = M)
# Log if necessary
#if self.config.logIPS:
# reward = torch.log(torch.clamp(reward, min = 1e-10))
# PyTorch likes to minimise - loss instead of reward
loss = -reward
log_loss = -log_reward
# If the variance regularisation strength is larger than zero
if self.config.variance_penalisation_strength:
# Compute the expectation of the IPS estimate
avg_weighted_loss = torch.mean(loss)
# Compute the variance of the IPS estimate
var = torch.sqrt(torch.sum((loss - avg_weighted_loss)**2) / (N1 - 1) / N1)
# Reweight with lambda and add to the loss
if self.config.logIPS:
loss = log_loss.mean() + self.config.variance_penalisation_strength * var
else:
loss = loss.mean() + self.config.variance_penalisation_strength * var
else:
# Compute the mean over all samples as the final loss
if self.config.logIPS:
loss = log_loss.mean()
else:
loss = loss.mean()
# Check whether we're using the binomial model
if .0 < self.config.alpha:
# Let it generate predictions
prob_c = binomial_model(X, A)
# Negative log-likelihood as loss here - TODO check whether IPS reweighting here makes sense
nll = binary_cross_entropy(prob_c, y)
if self.config.ll_IPS:
nll = nll * w
nll = nll.mean() #* rescaling_factor
# A bit ugly but most efficient - check explicitly for loss combination
if self.config.alpha == .0:
pass
elif self.config.alpha == 1.0:
loss = nll
else:
loss = (1.0 - self.config.alpha) * loss + self.config.alpha * nll
return loss
# Initial loss
last_obj = closure()
max_epoch = 200
tol = 1e-10 # Magic number
max_patience, patience = 20, 0
checkpoints = []
#for epoch in tqdm(range(self.config.n_epochs)):
for epoch in tqdm(range(max_epoch)):
# Optimisation step
obj, _, _, _, _, _, _, _ = optimiser.step({'closure': closure, 'current_loss': last_obj, 'max_ls': 20})
# Check for convergence
#if (last_obj - obj) < tol and epoch > 10:
# patience += 1
# if patience >= max_patience:
# print('Converged after {0} iterations. Final loss: {1}'.format(epoch, obj))
# break
# else:
# #print('Remaining patient at epoch {0}...'.format(epoch))
# pass
# Save last loss
last_obj = obj
if (epoch % 25) == 0:
checkpoints.append(last_obj)
#if epoch == (max_epoch - 1):
# print('Not converged after {0} iterations. Final loss: {1}'.format(max_epoch, last_obj))
print('Checkpoints: {0}\nFinal loss: {1}'.format(checkpoints, last_obj))
return (
PyTorchMLRFeaturesProvider(self.config),
PyTorchMLRModel(self.config, multinomial_model)
)
class PyTorchMLRAgent(ModelBasedAgent):
"""
PyTorch-based multinomial logistic regression Agent.
"""
def __init__(self, config = Configuration(pytorch_mlr_args)):
super(PyTorchMLRAgent, self).__init__(
config,
PyTorchMLRModelBuilder(config)
)
# GRACIOUSLY TAKEN FROM https://github.com/hjmshi/PyTorch-LBFGS
import torch
import numpy as np
import matplotlib.pyplot as plt
from functools import reduce
from copy import deepcopy
from torch.optim import Optimizer
#%% Helper Functions for L-BFGS
def is_legal(v):
"""
Checks that tensor is not NaN or Inf.
Inputs:
v (tensor): tensor to be checked
"""
legal = not torch.isnan(v).any() and not torch.isinf(v)
return legal
def polyinterp(points, x_min_bound=None, x_max_bound=None, plot=False):
"""
Gives the minimizer and minimum of the interpolating polynomial over given points
based on function and derivative information. Defaults to bisection if no critical
points are valid.
Based on polyinterp.m Matlab function in minFunc by Mark Schmidt with some slight
modifications.
Implemented by: Hao-Jun Michael Shi and Dheevatsa Mudigere
Last edited 12/6/18.
Inputs:
points (nparray): two-dimensional array with each point of form [x f g]
x_min_bound (float): minimum value that brackets minimum (default: minimum of points)
x_max_bound (float): maximum value that brackets minimum (default: maximum of points)
plot (bool): plot interpolating polynomial
Outputs:
x_sol (float): minimizer of interpolating polynomial
F_min (float): minimum of interpolating polynomial
Note:
. Set f or g to np.nan if they are unknown
"""
no_points = points.shape[0]
order = np.sum(1 - np.isnan(points[:,1:3]).astype('int')) - 1
x_min = np.min(points[:, 0])
x_max = np.max(points[:, 0])
# compute bounds of interpolation area
if(x_min_bound is None):
x_min_bound = x_min
if(x_max_bound is None):
x_max_bound = x_max
# explicit formula for quadratic interpolation
if no_points == 2 and order == 2 and plot is False:
# Solution to quadratic interpolation is given by:
# a = -(f1 - f2 - g1(x1 - x2))/(x1 - x2)^2
# x_min = x1 - g1/(2a)
# if x1 = 0, then is given by:
# x_min = - (g1*x2^2)/(2(f2 - f1 - g1*x2))
if(points[0, 0] == 0):
x_sol = -points[0, 2]*points[1, 0]**2/(2*(points[1, 1] - points[0, 1] - points[0, 2]*points[1, 0]))
else:
a = -(points[0, 1] - points[1, 1] - points[0, 2]*(points[0, 0] - points[1, 0]))/(points[0, 0] - points[1, 0])**2
x_sol = points[0, 0] - points[0, 2]/(2*a)
x_sol = np.minimum(np.maximum(x_min_bound, x_sol), x_max_bound)
# explicit formula for cubic interpolation
elif no_points == 2 and order == 3 and plot is False:
# Solution to cubic interpolation is given by:
# d1 = g1 + g2 - 3((f1 - f2)/(x1 - x2))
# d2 = sqrt(d1^2 - g1*g2)
# x_min = x2 - (x2 - x1)*((g2 + d2 - d1)/(g2 - g1 + 2*d2))
d1 = points[0, 2] + points[1, 2] - 3*((points[0, 1] - points[1, 1])/(points[0, 0] - points[1, 0]))
d2 = np.sqrt(d1**2 - points[0, 2]*points[1, 2])
if np.isreal(d2):
x_sol = points[1, 0] - (points[1, 0] - points[0, 0])*((points[1, 2] + d2 - d1)/(points[1, 2] - points[0, 2] + 2*d2))
x_sol = np.minimum(np.maximum(x_min_bound, x_sol), x_max_bound)
else:
x_sol = (x_max_bound + x_min_bound)/2
# solve linear system
else:
# define linear constraints
A = np.zeros((0, order+1))
b = np.zeros((0, 1))
# add linear constraints on function values
for i in range(no_points):
if not np.isnan(points[i, 1]):
constraint = np.zeros((1, order+1))
for j in range(order, -1, -1):
constraint[0, order - j] = points[i, 0]**j
A = np.append(A, constraint, 0)
b = np.append(b, points[i, 1])
# add linear constraints on gradient values
for i in range(no_points):
if not np.isnan(points[i, 2]):
constraint = np.zeros((1, order+1))
for j in range(order):
constraint[0, j] = (order-j)*points[i,0]**(order-j-1)
A = np.append(A, constraint, 0)
b = np.append(b, points[i, 2])
# check if system is solvable
if(A.shape[0] != A.shape[1] or np.linalg.matrix_rank(A) != A.shape[0]):
x_sol = (x_min_bound + x_max_bound)/2
f_min = np.Inf
else:
# solve linear system for interpolating polynomial
coeff = np.linalg.solve(A, b)
# compute critical points
dcoeff = np.zeros(order)
for i in range(len(coeff) - 1):
dcoeff[i] = coeff[i]*(order-i)
crit_pts = np.array([x_min_bound, x_max_bound])
crit_pts = np.append(crit_pts, points[:, 0])
if not np.isinf(dcoeff).any():
roots = np.roots(dcoeff)
crit_pts = np.append(crit_pts, roots)
# test critical points
f_min = np.Inf
x_sol = (x_min_bound + x_max_bound)/2 # defaults to bisection
for crit_pt in crit_pts:
if np.isreal(crit_pt) and crit_pt >= x_min_bound and crit_pt <= x_max_bound:
F_cp = np.polyval(coeff, crit_pt)
if np.isreal(F_cp) and F_cp < f_min:
x_sol = np.real(crit_pt)
f_min = np.real(F_cp)
if(plot):
plt.figure()
x = np.arange(x_min_bound, x_max_bound, (x_max_bound - x_min_bound)/10000)
f = np.polyval(coeff, x)
plt.plot(x, f)
plt.plot(x_sol, f_min, 'x')
return x_sol
#%% L-BFGS Optimizer
class LBFGS(Optimizer):
"""
Implements the L-BFGS algorithm. Compatible with multi-batch and full-overlap
L-BFGS implementations and (stochastic) Powell damping. Partly based on the
original L-BFGS implementation in PyTorch, Mark Schmidt's minFunc MATLAB code,
and Michael Overton's weak Wolfe line search MATLAB code.
Implemented by: Hao-Jun Michael Shi and Dheevatsa Mudigere
Last edited 12/6/18.
Warnings:
. Does not support per-parameter options and parameter groups.
. All parameters have to be on a single device.
Inputs:
lr (float): steplength or learning rate (default: 1)
history_size (int): update history size (default: 10)
line_search (str): designates line search to use (default: 'Wolfe')
Options:
'None': uses steplength designated in algorithm
'Armijo': uses Armijo backtracking line search
'Wolfe': uses Armijo-Wolfe bracketing line search
dtype: data type (default: torch.float)
debug (bool): debugging mode
References:
[1] Berahas, Albert S., Jorge Nocedal, and Martin Takác. "A Multi-Batch L-BFGS
Method for Machine Learning." Advances in Neural Information Processing
Systems. 2016.
[2] Bollapragada, Raghu, et al. "A Progressive Batching L-BFGS Method for Machine
Learning." International Conference on Machine Learning. 2018.
[3] Lewis, Adrian S., and Michael L. Overton. "Nonsmooth Optimization via Quasi-Newton
Methods." Mathematical Programming 141.1-2 (2013): 135-163.
[4] Liu, Dong C., and Jorge Nocedal. "On the Limited Memory BFGS Method for
Large Scale Optimization." Mathematical Programming 45.1-3 (1989): 503-528.
[5] Nocedal, Jorge. "Updating Quasi-Newton Matrices With Limited Storage."
Mathematics of Computation 35.151 (1980): 773-782.
[6] Nocedal, Jorge, and Stephen J. Wright. "Numerical Optimization." Springer New York,
2006.
[7] Schmidt, Mark. "minFunc: Unconstrained Differentiable Multivariate Optimization
in Matlab." Software available at http://www.cs.ubc.ca/~schmidtm/Software/minFunc.html
(2005).
[8] Schraudolph, Nicol N., Jin Yu, and Simon Günter. "A Stochastic Quasi-Newton
Method for Online Convex Optimization." Artificial Intelligence and Statistics.
2007.
[9] Wang, Xiao, et al. "Stochastic Quasi-Newton Methods for Nonconvex Stochastic
Optimization." SIAM Journal on Optimization 27.2 (2017): 927-956.
"""
def __init__(self, params, lr=1, history_size=10, line_search='Wolfe',
dtype=torch.float, debug=False):
# ensure inputs are valid
if not 0.0 <= lr:
raise ValueError("Invalid learning rate: {}".format(lr))
if not 0 <= history_size:
raise ValueError("Invalid history size: {}".format(history_size))
if line_search not in ['Armijo', 'Wolfe', 'None']:
raise ValueError("Invalid line search: {}".format(line_search))
defaults = dict(lr=lr, history_size=history_size, line_search=line_search,
dtype=dtype, debug=debug)
super(LBFGS, self).__init__(params, defaults)
if len(self.param_groups) != 1:
raise ValueError("L-BFGS doesn't support per-parameter options "
"(parameter groups)")
self._params = self.param_groups[0]['params']
self._numel_cache = None
state = self.state['global_state']
state.setdefault('n_iter', 0)
state.setdefault('curv_skips', 0)
state.setdefault('fail_skips', 0)
state.setdefault('H_diag',1)
state.setdefault('fail', True)
state['old_dirs'] = []
state['old_stps'] = []
def _numel(self):
if self._numel_cache is None:
self._numel_cache = reduce(lambda total, p: total + p.numel(), self._params, 0)
return self._numel_cache
def _gather_flat_grad(self):
views = []
for p in self._params:
if p.grad is None:
view = p.data.new(p.data.numel()).zero_()
elif p.grad.data.is_sparse:
view = p.grad.data.to_dense().view(-1)
else:
view = p.grad.data.view(-1)
views.append(view)
return torch.cat(views, 0)
def _add_update(self, step_size, update):
offset = 0
for p in self._params:
numel = p.numel()
# view as to avoid deprecated pointwise semantics
p.data.add_(step_size, update[offset:offset + numel].view_as(p.data))
offset += numel
assert offset == self._numel()
def _copy_params(self):
current_params = []
for param in self._params:
current_params.append(deepcopy(param.data))
return current_params
def _load_params(self, current_params):
i = 0
for param in self._params:
param.data[:] = current_params[i]
i += 1
def line_search(self, line_search):
"""
Switches line search option.
Inputs:
line_search (str): designates line search to use
Options:
'None': uses steplength designated in algorithm
'Armijo': uses Armijo backtracking line search
'Wolfe': uses Armijo-Wolfe bracketing line search
"""
group = self.param_groups[0]
group['line_search'] = line_search
return
def two_loop_recursion(self, vec):
"""
Performs two-loop recursion on given vector to obtain Hv.
Inputs:
vec (tensor): 1-D tensor to apply two-loop recursion to
Output:
r (tensor): matrix-vector product Hv
"""
group = self.param_groups[0]
history_size = group['history_size']
state = self.state['global_state']
old_dirs = state.get('old_dirs') # change in gradients
old_stps = state.get('old_stps') # change in iterates
H_diag = state.get('H_diag')
# compute the product of the inverse Hessian approximation and the gradient
num_old = len(old_dirs)
if 'rho' not in state:
state['rho'] = [None] * history_size
state['alpha'] = [None] * history_size
rho = state['rho']
alpha = state['alpha']
for i in range(num_old):
rho[i] = 1. / old_stps[i].dot(old_dirs[i])
q = vec
for i in range(num_old - 1, -1, -1):
alpha[i] = old_dirs[i].dot(q) * rho[i]
q.add_(-alpha[i], old_stps[i])
# multiply by initial Hessian
# r/d is the final direction
r = torch.mul(q, H_diag)
for i in range(num_old):
beta = old_stps[i].dot(r) * rho[i]
r.add_(alpha[i] - beta, old_dirs[i])
return r
def curvature_update(self, flat_grad, eps=1e-2, damping=False):
"""
Performs curvature update.
Inputs:
flat_grad (tensor): 1-D tensor of flattened gradient for computing
gradient difference with previously stored gradient
eps (float): constant for curvature pair rejection or damping (default: 1e-2)
damping (bool): flag for using Powell damping (default: False)
"""
assert len(self.param_groups) == 1
# load parameters
if(eps <= 0):
raise(ValueError('Invalid eps; must be positive.'))
group = self.param_groups[0]
history_size = group['history_size']
debug = group['debug']
# variables cached in state (for tracing)
state = self.state['global_state']
fail = state.get('fail')
# check if line search failed
if not fail:
d = state.get('d')
t = state.get('t')
old_dirs = state.get('old_dirs')
old_stps = state.get('old_stps')
H_diag = state.get('H_diag')
prev_flat_grad = state.get('prev_flat_grad')
Bs = state.get('Bs')
# compute y's
y = flat_grad.sub(prev_flat_grad)
s = d.mul(t)
sBs = s.dot(Bs)
ys = y.dot(s) # y*s
# update L-BFGS matrix
if ys > eps*sBs or damping == True:
# perform Powell damping
if damping == True and ys < eps*sBs:
if debug:
print('Applying Powell damping...')
theta = ((1-eps)*sBs)/(sBs - ys)
y = theta*y + (1-theta)*Bs
# updating memory
if len(old_dirs) == history_size:
# shift history by one (limited-memory)
old_dirs.pop(0)
old_stps.pop(0)
# store new direction/step
old_dirs.append(s)
old_stps.append(y)
# update scale of initial Hessian approximation
H_diag = ys / y.dot(y) # (y*y)
state['old_dirs'] = old_dirs
state['old_stps'] = old_stps
state['H_diag'] = H_diag
else:
# save skip
state['curv_skips'] += 1
if debug:
print('Curvature pair skipped due to failed criterion')
else:
# save skip
state['fail_skips'] += 1
if debug:
print('Line search failed; curvature pair update skipped')
return
def _step(self, p_k, g_Ok, g_Sk=None, options={}):
"""
Performs a single optimization step.
Inputs:
p_k (tensor): 1-D tensor specifying search direction
g_Ok (tensor): 1-D tensor of flattened gradient over overlap O_k used
for gradient differencing in curvature pair update
g_Sk (tensor): 1-D tensor of flattened gradient over full sample S_k
used for curvature pair damping or rejection criterion,
if None, will use g_Ok (default: None)
options (dict): contains options for performing line search
Options for Armijo backtracking line search:
'closure' (callable): reevaluates model and returns function value
'current_loss' (tensor): objective value at current iterate (default: F(x_k))
'gtd' (tensor): inner product g_Ok'd in line search (default: g_Ok'd)
'eta' (tensor): factor for decreasing steplength > 0 (default: 2)
'c1' (tensor): sufficient decrease constant in (0, 1) (default: 1e-4)
'max_ls' (int): maximum number of line search steps permitted (default: 10)
'interpolate' (bool): flag for using interpolation (default: True)
'inplace' (bool): flag for inplace operations (default: True)
'ls_debug' (bool): debugging mode for line search
Options for Wolfe line search:
'closure' (callable): reevaluates model and returns function value
'current_loss' (tensor): objective value at current iterate (default: F(x_k))
'gtd' (tensor): inner product g_Ok'd in line search (default: g_Ok'd)
'eta' (float): factor for extrapolation (default: 2)
'c1' (float): sufficient decrease constant in (0, 1) (default: 1e-4)
'c2' (float): curvature condition constant in (0, 1) (default: 0.9)
'max_ls' (int): maximum number of line search steps permitted (default: 10)
'interpolate' (bool): flag for using interpolation (default: True)
'inplace' (bool): flag for inplace operations (default: True)
'ls_debug' (bool): debugging mode for line search
Outputs (depends on line search):
. No line search:
t (float): steplength
. Armijo backtracking line search:
F_new (tensor): loss function at new iterate
t (tensor): final steplength
ls_step (int): number of backtracks
closure_eval (int): number of closure evaluations
desc_dir (bool): descent direction flag
True: p_k is descent direction with respect to the line search
function
False: p_k is not a descent direction with respect to the line
search function
fail (bool): failure flag
True: line search reached maximum number of iterations, failed
False: line search succeeded
. Wolfe line search:
F_new (tensor): loss function at new iterate
g_new (tensor): gradient at new iterate
t (float): final steplength
ls_step (int): number of backtracks
closure_eval (int): number of closure evaluations
grad_eval (int): number of gradient evaluations
desc_dir (bool): descent direction flag
True: p_k is descent direction with respect to the line search
function
False: p_k is not a descent direction with respect to the line
search function
fail (bool): failure flag
True: line search reached maximum number of iterations, failed
False: line search succeeded
Notes:
. If encountering line search failure in the deterministic setting, one
should try increasing the maximum number of line search steps max_ls.
"""
assert len(self.param_groups) == 1
# load parameter options
group = self.param_groups[0]
lr = group['lr']
line_search = group['line_search']
dtype = group['dtype']
debug = group['debug']
# variables cached in state (for tracing)
state = self.state['global_state']
d = state.get('d')
t = state.get('t')
prev_flat_grad = state.get('prev_flat_grad')
Bs = state.get('Bs')
# keep track of nb of iterations
state['n_iter'] += 1
# set search direction
d = p_k
# modify previous gradient
if prev_flat_grad is None:
prev_flat_grad = g_Ok.clone()
else:
prev_flat_grad.copy_(g_Ok)
# set initial step size
t = lr
# closure evaluation counter
closure_eval = 0
if g_Sk is None:
g_Sk = g_Ok.clone()
# perform Armijo backtracking line search
if(line_search == 'Armijo'):
# load options
if(options):
if('closure' not in options.keys()):
raise(ValueError('closure option not specified.'))
else:
closure = options['closure']
if('gtd' not in options.keys()):
gtd = g_Ok.dot(d)
else:
gtd = options['gtd']
if('current_loss' not in options.keys()):
F_k = closure()
closure_eval += 1
else:
F_k = options['current_loss']
if('eta' not in options.keys()):
eta = 2
elif(options['eta'] <= 0):
raise(ValueError('Invalid eta; must be positive.'))
else:
eta = options['eta']
if('c1' not in options.keys()):
c1 = 1e-4
elif(options['c1'] >= 1 or options['c1'] <= 0):
raise(ValueError('Invalid c1; must be strictly between 0 and 1.'))
else:
c1 = options['c1']
if('max_ls' not in options.keys()):
max_ls = 10
elif(options['max_ls'] <= 0):
raise(ValueError('Invalid max_ls; must be positive.'))
else:
max_ls = options['max_ls']
if('interpolate' not in options.keys()):
interpolate = True
else:
interpolate = options['interpolate']
if('inplace' not in options.keys()):
inplace = True
else:
inplace = options['inplace']
if('ls_debug' not in options.keys()):
ls_debug = False
else:
ls_debug = options['ls_debug']
else:
raise(ValueError('Options are not specified; need closure evaluating function.'))
# initialize values
if(interpolate):
if(torch.cuda.is_available()):
F_prev = torch.tensor(np.nan, dtype=dtype).cuda()
else:
F_prev = torch.tensor(np.nan, dtype=dtype)
ls_step = 0
t_prev = 0 # old steplength
fail = False # failure flag
# begin print for debug mode
if ls_debug:
print('==================================== Begin Armijo line search ===================================')
print('F(x): %.8e g*d: %.8e' %(F_k, gtd))
# check if search direction is descent direction
if gtd >= 0:
desc_dir = False
if debug:
print('Not a descent direction!')
else:
desc_dir = True
# store values if not in-place
if not inplace:
current_params = self._copy_params()
# update and evaluate at new point
self._add_update(t, d)
F_new = closure()
closure_eval += 1
# print info if debugging
if(ls_debug):
print('LS Step: %d t: %.8e F(x+td): %.8e F-c1*t*g*d: %.8e F(x): %.8e'
%(ls_step, t, F_new, F_k + c1*t*gtd, F_k))
# check Armijo condition
while F_new > F_k + c1*t*gtd or not is_legal(F_new):
# check if maximum number of iterations reached
if(ls_step >= max_ls):
if inplace:
self._add_update(-t, d)
else:
self._load_params(current_params)
t = 0
F_new = closure()
closure_eval += 1
fail = True
break
else:
# store current steplength
t_new = t
# compute new steplength
# if first step or not interpolating, then multiply by factor
if(ls_step == 0 or not interpolate or not is_legal(F_new)):
t = t/eta
# if second step, use function value at new point along with
# gradient and function at current iterate
elif(ls_step == 1 or not is_legal(F_prev)):
t = polyinterp(np.array([[0, F_k.item(), gtd.item()], [t_new, F_new.item(), np.nan]]))
# otherwise, use function values at new point, previous point,
# and gradient and function at current iterate
else:
t = polyinterp(np.array([[0, F_k.item(), gtd.item()], [t_new, F_new.item(), np.nan],
[t_prev, F_prev.item(), np.nan]]))
# if values are too extreme, adjust t
if(interpolate):
if(t < 1e-3*t_new):
t = 1e-3*t_new
elif(t > 0.6*t_new):
t = 0.6*t_new
# store old point
F_prev = F_new
t_prev = t_new
# update iterate and reevaluate
if inplace:
self._add_update(t-t_new, d)
else:
self._load_params(current_params)
self._add_update(t, d)
F_new = closure()
closure_eval += 1
ls_step += 1 # iterate
# print info if debugging
if(ls_debug):
print('LS Step: %d t: %.8e F(x+td): %.8e F-c1*t*g*d: %.8e F(x): %.8e'
%(ls_step, t, F_new, F_k + c1*t*gtd, F_k))
# store Bs
if Bs is None:
Bs = (g_Sk.mul(-t)).clone()
else:
Bs.copy_(g_Sk.mul(-t))
# print final steplength
if ls_debug:
print('Final Steplength:', t)
print('===================================== End Armijo line search ====================================')
state['d'] = d
state['prev_flat_grad'] = prev_flat_grad
state['t'] = t
state['Bs'] = Bs
state['fail'] = fail
return F_new, t, ls_step, closure_eval, desc_dir, fail
# perform weak Wolfe line search
elif(line_search == 'Wolfe'):
# load options
if(options):
if('closure' not in options.keys()):
raise(ValueError('closure option not specified.'))
else:
closure = options['closure']
if('current_loss' not in options.keys()):
F_k = closure()
closure_eval += 1
else:
F_k = options['current_loss']
if('gtd' not in options.keys()):
gtd = g_Ok.dot(d)
else:
gtd = options['gtd']
if('eta' not in options.keys()):
eta = 2
elif(options['eta'] <= 1):
raise(ValueError('Invalid eta; must be greater than 1.'))
else:
eta = options['eta']
if('c1' not in options.keys()):
c1 = 1e-4
elif(options['c1'] >= 1 or options['c1'] <= 0):
raise(ValueError('Invalid c1; must be strictly between 0 and 1.'))
else:
c1 = options['c1']
if('c2' not in options.keys()):
c2 = 0.9
elif(options['c2'] >= 1 or options['c2'] <= 0):
raise(ValueError('Invalid c2; must be strictly between 0 and 1.'))
elif(options['c2'] <= c1):
raise(ValueError('Invalid c2; must be strictly larger than c1.'))
else:
c2 = options['c2']
if('max_ls' not in options.keys()):
max_ls = 10
elif(options['max_ls'] <= 0):
raise(ValueError('Invalid max_ls; must be positive.'))
else:
max_ls = options['max_ls']
if('interpolate' not in options.keys()):
interpolate = True
else:
interpolate = options['interpolate']
if('inplace' not in options.keys()):
inplace = True
else:
inplace = options['inplace']
if('ls_debug' not in options.keys()):
ls_debug = False
else:
ls_debug = options['ls_debug']
else:
raise(ValueError('Options are not specified; need closure evaluating function.'))
# initialize counters
ls_step = 0
grad_eval = 0 # tracks gradient evaluations
t_prev = 0 # old steplength
# initialize bracketing variables and flag
alpha = 0
beta = float('Inf')
fail = False
# initialize values for line search
if(interpolate):
F_a = F_k
g_a = gtd
if(torch.cuda.is_available()):
F_b = torch.tensor(np.nan, dtype=dtype).cuda()
g_b = torch.tensor(np.nan, dtype=dtype).cuda()
else:
F_b = torch.tensor(np.nan, dtype=dtype)
g_b = torch.tensor(np.nan, dtype=dtype)
# begin print for debug mode
if ls_debug:
print('==================================== Begin Wolfe line search ====================================')
print('F(x): %.8e g*d: %.8e' %(F_k, gtd))
# check if search direction is descent direction
if gtd >= 0:
desc_dir = False
if debug:
print('Not a descent direction!')
else:
desc_dir = True
# store values if not in-place
if not inplace:
current_params = self._copy_params()
# update and evaluate at new point
self._add_update(t, d)
F_new = closure()
closure_eval += 1
# main loop
while True:
# check if maximum number of line search steps have been reached
if(ls_step >= max_ls):
if inplace:
self._add_update(-t, d)
else:
self._load_params(current_params)
t = 0
F_new = closure()
F_new.backward()
g_new = self._gather_flat_grad()
closure_eval += 1
grad_eval += 1
fail = True
break
# print info if debugging
if(ls_debug):
print('LS Step: %d t: %.8e alpha: %.8e beta: %.8e'
%(ls_step, t, alpha, beta))
print('Armijo: F(x+td): %.8e F-c1*t*g*d: %.8e F(x): %.8e'
%(F_new, F_k + c1*t*gtd, F_k))
# check Armijo condition
if(F_new > F_k + c1*t*gtd):
# set upper bound
beta = t
t_prev = t
# update interpolation quantities
if(interpolate):
F_b = F_new
if(torch.cuda.is_available()):
g_b = torch.tensor(np.nan, dtype=dtype).cuda()
else:
g_b = torch.tensor(np.nan, dtype=dtype)
else:
# compute gradient
F_new.backward()
g_new = self._gather_flat_grad()
grad_eval += 1
gtd_new = g_new.dot(d)
# print info if debugging
if(ls_debug):
print('Wolfe: g(x+td)*d: %.8e c2*g*d: %.8e gtd: %.8e'
%(gtd_new, c2*gtd, gtd))
# check curvature condition
if(gtd_new < c2*gtd):
# set lower bound
alpha = t
t_prev = t
# update interpolation quantities
if(interpolate):
F_a = F_new
g_a = gtd_new
else:
break
# compute new steplength
# if first step or not interpolating, then bisect or multiply by factor
if(not interpolate or not is_legal(F_b)):
if(beta == float('Inf')):
t = eta*t
else:
t = (alpha + beta)/2.0
# otherwise interpolate between a and b
else:
t = polyinterp(np.array([[alpha, F_a.item(), g_a.item()],[beta, F_b.item(), g_b.item()]]))
# if values are too extreme, adjust t
if(beta == float('Inf')):
if(t > 2*eta*t_prev):
t = 2*eta*t_prev
elif(t < eta*t_prev):
t = eta*t_prev
else:
if(t < alpha + 0.2*(beta - alpha)):
t = alpha + 0.2*(beta - alpha)
elif(t > (beta - alpha)/2.0):
t = (beta - alpha)/2.0
# if we obtain nonsensical value from interpolation
if(t <= 0):
t = (beta - alpha)/2.0
# update parameters
if inplace:
self._add_update(t - t_prev, d)
else:
self._load_params(current_params)
self._add_update(t, d)
# evaluate closure
F_new = closure()
closure_eval += 1
ls_step += 1
# store Bs
if Bs is None:
Bs = (g_Sk.mul(-t)).clone()
else:
Bs.copy_(g_Sk.mul(-t))
# print final steplength
if ls_debug:
print('Final Steplength:', t)
print('===================================== End Wolfe line search =====================================')
state['d'] = d
state['prev_flat_grad'] = prev_flat_grad
state['t'] = t
state['Bs'] = Bs
state['fail'] = fail
return F_new, g_new, t, ls_step, closure_eval, grad_eval, desc_dir, fail
else:
# perform update
self._add_update(t, d)
# store Bs
if Bs is None:
Bs = (g_Sk.mul(-t)).clone()
else:
Bs.copy_(g_Sk.mul(-t))
state['d'] = d
state['prev_flat_grad'] = prev_flat_grad
state['t'] = t
state['Bs'] = Bs
state['fail'] = False
return t
def step(self, p_k, g_Ok, g_Sk=None, options={}):
return self._step(p_k, g_Ok, g_Sk, options)
#%% Full-Batch (Deterministic) L-BFGS Optimizer (Wrapper)
class FullBatchLBFGS(LBFGS):
"""
Implements full-batch or deterministic L-BFGS algorithm. Compatible with
Powell damping. Can be used when evaluating a deterministic function and
gradient. Wraps the LBFGS optimizer. Performs the two-loop recursion,
updating, and curvature updating in a single step.
Implemented by: Hao-Jun Michael Shi and Dheevatsa Mudigere
Last edited 11/15/18.
Warnings:
. Does not support per-parameter options and parameter groups.
. All parameters have to be on a single device.
Inputs:
lr (float): steplength or learning rate (default: 1)
history_size (int): update history size (default: 10)
line_search (str): designates line search to use (default: 'Wolfe')
Options:
'None': uses steplength designated in algorithm
'Armijo': uses Armijo backtracking line search
'Wolfe': uses Armijo-Wolfe bracketing line search
dtype: data type (default: torch.float)
debug (bool): debugging mode
"""
def __init__(self, params, lr=1, history_size=10, line_search='Wolfe',
dtype=torch.float, debug=False):
super(FullBatchLBFGS, self).__init__(params, lr, history_size, line_search,
dtype, debug)
def step(self, options={}):
"""
Performs a single optimization step.
Inputs:
options (dict): contains options for performing line search
General Options:
'eps' (float): constant for curvature pair rejection or damping (default: 1e-2)
'damping' (bool): flag for using Powell damping (default: False)
Options for Armijo backtracking line search:
'closure' (callable): reevaluates model and returns function value
'current_loss' (tensor): objective value at current iterate (default: F(x_k))
'gtd' (tensor): inner product g_Ok'd in line search (default: g_Ok'd)
'eta' (tensor): factor for decreasing steplength > 0 (default: 2)
'c1' (tensor): sufficient decrease constant in (0, 1) (default: 1e-4)
'max_ls' (int): maximum number of line search steps permitted (default: 10)
'interpolate' (bool): flag for using interpolation (default: True)
'inplace' (bool): flag for inplace operations (default: True)
'ls_debug' (bool): debugging mode for line search
Options for Wolfe line search:
'closure' (callable): reevaluates model and returns function value
'current_loss' (tensor): objective value at current iterate (default: F(x_k))
'gtd' (tensor): inner product g_Ok'd in line search (default: g_Ok'd)
'eta' (float): factor for extrapolation (default: 2)
'c1' (float): sufficient decrease constant in (0, 1) (default: 1e-4)
'c2' (float): curvature condition constant in (0, 1) (default: 0.9)
'max_ls' (int): maximum number of line search steps permitted (default: 10)
'interpolate' (bool): flag for using interpolation (default: True)
'inplace' (bool): flag for inplace operations (default: True)
'ls_debug' (bool): debugging mode for line search
Outputs (depends on line search):
. No line search:
t (float): steplength
. Armijo backtracking line search:
F_new (tensor): loss function at new iterate
t (tensor): final steplength
ls_step (int): number of backtracks
closure_eval (int): number of closure evaluations
desc_dir (bool): descent direction flag
True: p_k is descent direction with respect to the line search
function
False: p_k is not a descent direction with respect to the line
search function
fail (bool): failure flag
True: line search reached maximum number of iterations, failed
False: line search succeeded
. Wolfe line search:
F_new (tensor): loss function at new iterate
g_new (tensor): gradient at new iterate
t (float): final steplength
ls_step (int): number of backtracks
closure_eval (int): number of closure evaluations
grad_eval (int): number of gradient evaluations
desc_dir (bool): descent direction flag
True: p_k is descent direction with respect to the line search
function
False: p_k is not a descent direction with respect to the line
search function
fail (bool): failure flag
True: line search reached maximum number of iterations, failed
False: line search succeeded
Notes:
. If encountering line search failure in the deterministic setting, one
should try increasing the maximum number of line search steps max_ls.
"""
# load options for damping and eps
if('damping' not in options.keys()):
damping = False
else:
damping = options['damping']
if('eps' not in options.keys()):
eps = 1e-2
else:
eps = options['eps']
# gather gradient
grad = self._gather_flat_grad()
# update curvature if after 1st iteration
state = self.state['global_state']
if(state['n_iter'] > 0):
self.curvature_update(grad, eps, damping)
# compute search direction
p = self.two_loop_recursion(-grad)
# take step
return self._step(p, grad, options=options)
| 52,651 | 38.030393 | 128 | py |
reco-gym | reco-gym-master/recogym/agents/organic_mf.py | import numpy as np
import torch
from ..envs.configuration import Configuration
from .abstract import Agent
# Default Arguments ----------------------------------------------------------
organic_mf_square_args = {
'num_products': 10,
'embed_dim': 5,
'mini_batch_size': 32,
'loss_function': torch.nn.CrossEntropyLoss(),
'optim_function': torch.optim.RMSprop,
'learning_rate': 0.01,
'with_ps_all': False,
}
# Model ----------------------------------------------------------------------
class OrganicMFSquare(torch.nn.Module, Agent):
"""
Organic Matrix Factorisation (Square)
The Agent that selects an Action from the model that performs
Organic Events matrix factorisation.
"""
def __init__(self, config = Configuration(organic_mf_square_args)):
torch.nn.Module.__init__(self)
Agent.__init__(self, config)
self.product_embedding = torch.nn.Embedding(
self.config.num_products, self.config.embed_dim
)
self.output_layer = torch.nn.Linear(
self.config.embed_dim, self.config.num_products
)
# Initializing optimizer type.
self.optimizer = self.config.optim_function(
self.parameters(), lr = self.config.learning_rate
)
self.last_product_viewed = None
self.curr_step = 0
self.train_data = []
self.action = None
def forward(self, product):
product = torch.Tensor([product])
a = self.product_embedding(product.long())
b = self.output_layer(a)
return b
def act(self, observation, reward, done):
with torch.no_grad():
if observation is not None and len(observation.current_sessions) > 0:
logits = self.forward(observation.current_sessions[-1]['v'])
# No exploration strategy, choose maximum logit.
self.action = logits.argmax().item()
if self.config.with_ps_all:
all_ps = np.zeros(self.config.num_products)
all_ps[self.action] = 1.0
else:
all_ps = ()
return {
**super().act(observation, reward, done),
**{
'a': self.action,
'ps': 1.0,
'ps-a': all_ps,
}
}
def update_weights(self):
"""Update weights of embedding matrices using mini batch of data"""
# Eliminate previous gradient.
self.optimizer.zero_grad()
for prods in self.train_data:
# Calculating logit of action and last product viewed.
# Loop over the number of products.
for i in range(len(prods) - 1):
logit = self.forward(prods[i]['v'])
# Converting label into Tensor.
label = torch.LongTensor([prods[i + 1]['v']])
# Calculating supervised loss.
loss = self.config.loss_function(logit, label)
loss.backward()
# Update weight parameters.
self.optimizer.step()
def train(self, observation, action, reward, done = False):
"""Method to deal with the """
# Increment step.
self.curr_step += 1
# Update weights of model once mini batch of data accumulated.
if self.curr_step % self.config.mini_batch_size == 0:
self.update_weights()
self.train_data = []
else:
if observation is not None:
data = observation.current_sessions
self.train_data.append(data)
| 3,630 | 30.034188 | 81 | py |
reco-gym | reco-gym-master/recogym/agents/nn_ips.py | import numpy as np
import torch
import torch.optim as optim
from numpy.random.mtrand import RandomState
from torch import nn
from .abstract import AbstractFeatureProvider, ViewsFeaturesProvider, Model, ModelBasedAgent
from ..envs.configuration import Configuration
nn_ips_args = {
'num_products': 10,
'number_of_flips': 1,
'random_seed': np.random.randint(2 ** 31 - 1),
# Select a Product randomly with the the probability predicted by Neural Network with IPS.
'select_randomly': False,
'M': 111,
'learning_rate': 0.01,
'num_epochs': 100,
'num_hidden': 20,
'lambda_val': 0.01,
'with_ps_all': False,
}
class IpsLoss(nn.Module):
"""
IPS Loss Function
"""
def __init__(self, config):
super(IpsLoss, self).__init__()
self.config = config
self.clipping = nn.Threshold(self.config.M, self.config.M)
def forward(self, hx, h0, deltas):
u = self.clipping(hx / h0) * deltas
return torch.mean(u) + self.config.lambda_val * torch.sqrt(torch.var(u) / deltas.shape[0])
class NeuralNet(nn.Module):
"""
Neural Network Model
This class implements a Neural Net model by using PyTorch.
"""
def __init__(self, config):
super(NeuralNet, self).__init__()
self.config = config
self.model = nn.Sequential(
nn.Linear(self.config.num_products, self.config.num_hidden),
nn.Sigmoid(),
nn.Linear(self.config.num_hidden, self.config.num_hidden),
nn.Sigmoid(),
nn.Linear(self.config.num_hidden, self.config.num_products),
nn.Softmax(dim = 1)
)
def forward(self, features):
return self.model.forward(features)
class NnIpsModelBuilder(AbstractFeatureProvider):
"""
Neural Net Inverse Propensity Score Model Builder
"""
def __init__(self, config):
super(NnIpsModelBuilder, self).__init__(config)
def build(self):
model = NeuralNet(self.config)
criterion = IpsLoss(self.config)
optimizer = optim.SGD(model.parameters(), lr = self.config.learning_rate)
features, actions, deltas, pss = self.train_data()
deltas = deltas[:, np.newaxis] * np.ones((1, self.config.num_products))
pss = pss[:, np.newaxis] * np.ones((1, self.config.num_products))
for epoch in range(self.config.num_epochs):
optimizer.zero_grad()
loss = criterion(
model(torch.Tensor(features)),
torch.Tensor(pss),
torch.Tensor(-1.0 * deltas)
)
loss.backward()
optimizer.step()
class TorchFeatureProvider(ViewsFeaturesProvider):
def __init__(self, config):
super(TorchFeatureProvider, self).__init__(config, is_sparse=True)
def features(self, observation):
base_features = super().features(observation).reshape(1, self.config.num_products)
return torch.Tensor(base_features)
class TorchModel(Model):
def __init__(self, config, model):
super(TorchModel, self).__init__(config)
self.model = model
if self.config.select_randomly:
self.rng = RandomState(self.config.random_seed)
def act(self, observation, features):
prob = self.model.forward(features)[0, :]
if self.config.select_randomly:
prob = prob.detach().numpy()
action = self.rng.choice(
np.array(self.config.num_products),
p = prob
)
if self.config.with_ps_all:
ps_all = prob
else:
ps_all = ()
else:
action = torch.argmax(prob).item()
if self.config.with_ps_all:
ps_all = np.zeros(self.config.num_products)
ps_all[action] = 1.0
else:
ps_all = ()
return {
**super().act(observation, features),
**{
'a': action,
'ps': prob[action].item(),
'ps-a': ps_all,
},
}
return (
TorchFeatureProvider(self.config),
TorchModel(self.config, model)
)
class NnIpsAgent(ModelBasedAgent):
"""
Neural Network Agent with IPS
"""
def __init__(self, config = Configuration(nn_ips_args)):
super(NnIpsAgent, self).__init__(
config,
NnIpsModelBuilder(config)
)
| 4,794 | 29.935484 | 98 | py |
reco-gym | reco-gym-master/recogym/agents/bandit_mf.py | import torch
import numpy as np
from torch import nn, optim, Tensor
from ..envs.configuration import Configuration
from .abstract import Agent
# Default Arguments.
bandit_mf_square_args = {
'num_products': 10,
'embed_dim': 5,
'mini_batch_size': 32,
'loss_function': nn.BCEWithLogitsLoss(),
'optim_function': optim.RMSprop,
'learning_rate': 0.01,
'with_ps_all': False,
}
# Model.
class BanditMFSquare(nn.Module, Agent):
def __init__(self, config = Configuration(bandit_mf_square_args)):
nn.Module.__init__(self)
Agent.__init__(self, config)
self.product_embedding = nn.Embedding(
self.config.num_products, self.config.embed_dim
)
self.user_embedding = nn.Embedding(
self.config.num_products, self.config.embed_dim
)
# Initializing optimizer type.
self.optimizer = self.config.optim_function(
self.parameters(), lr = self.config.learning_rate
)
self.last_product_viewed = None
self.curr_step = 0
self.train_data = ([], [], [])
self.all_products = np.arange(self.config.num_products)
def forward(self, products, users = None):
if users is None:
users = np.full(products.shape[0], self.last_product_viewed)
a = self.product_embedding(torch.LongTensor(products))
b = self.user_embedding(torch.LongTensor(users))
return torch.sum(a * b, dim = 1)
def get_logits(self):
"""Returns vector of product recommendation logits"""
return self.forward(self.all_products)
def update_lpv(self, observation):
"""Updates the last product viewed based on the observation"""
assert (observation is not None)
assert (observation.sessions() is not None)
if observation.sessions():
self.last_product_viewed = observation.sessions()[-1]['v']
def act(self, observation, reward, done):
with torch.no_grad():
# Update last product viewed.
self.update_lpv(observation)
# Get logits for all possible actions.
logits = self.get_logits()
# No exploration strategy, choose maximum logit.
action = logits.argmax().item()
if self.config.with_ps_all:
all_ps = np.zeros(self.config.num_products)
all_ps[action] = 1.0
else:
all_ps = ()
return {
**super().act(observation, reward, done),
**{
'a': action,
'ps': logits[action],
'ps-a': all_ps,
},
}
def update_weights(self):
"""Update weights of embedding matrices using mini batch of data"""
if len(self.train_data[0]) != 0:
# Eliminate previous gradient.
self.optimizer.zero_grad()
assert len(self.train_data[0]) == len(self.train_data[1])
assert len(self.train_data[0]) == len(self.train_data[2])
lpvs, actions, rewards = self.train_data
# Calculating logit of action and last product viewed.
logit = self.forward(np.array(actions), np.array(lpvs))
# Converting reward into Tensor.
reward = Tensor(np.array(rewards))
# Calculating supervised loss.
loss = self.config.loss_function(logit, reward)
loss.backward()
# Update weight parameters.
self.optimizer.step()
def train(self, observation, action, reward, done = False):
# Update last product viewed.
self.update_lpv(observation)
# Increment step.
self.curr_step += 1
# Update weights of model once mini batch of data accumulated.
if self.curr_step % self.config.mini_batch_size == 0:
self.update_weights()
self.train_data = ([], [], [])
else:
if action is not None and reward is not None:
self.train_data[0].append(self.last_product_viewed)
self.train_data[1].append(action['a'])
self.train_data[2].append(reward)
| 4,211 | 32.165354 | 75 | py |
reco-gym | reco-gym-master/recogym/agents/__init__.py |
from .abstract import (
Agent,
FeatureProvider,
AbstractFeatureProvider,
ViewsFeaturesProvider,
Model,
ModelBasedAgent
)
from .bayesian_poly_vb import BayesianAgentVB
from .bandit_mf import BanditMFSquare, bandit_mf_square_args
from .bandit_count import BanditCount, bandit_count_args
from .random_agent import RandomAgent, random_args
from .organic_count import OrganicCount, organic_count_args
from .organic_mf import OrganicMFSquare, organic_mf_square_args
from .logreg_ips import LogregMulticlassIpsAgent, logreg_multiclass_ips_args
from .nn_ips import NnIpsAgent, nn_ips_args
from .epsilon_greedy import EpsilonGreedy, epsilon_greedy_args
from .logreg_poly import LogregPolyAgent, logreg_poly_args
from .organic_user_count import OrganicUserEventCounterAgent, organic_user_count_args
from .pytorch_mlr import PyTorchMLRAgent, pytorch_mlr_args
| 878 | 31.555556 | 85 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/main.py | import numpy as np, os, time, random
from envs_repo.constructor import EnvConstructor
from models.constructor import ModelConstructor
from core.params import Parameters
import argparse, torch
from algos.erl_trainer import ERL_Trainer
parser = argparse.ArgumentParser()
####################### COMMANDLINE - ARGUMENTS ######################
parser.add_argument('--env', type=str, help='Env Name', default='Pendulum-v0')
parser.add_argument('--seed', type=int, help='Seed', default=991)
parser.add_argument('--savetag', type=str, help='#Tag to append to savefile', default='')
parser.add_argument('--gpu_id', type=int, help='#GPU ID ', default=0)
parser.add_argument('--total_steps', type=float, help='#Total steps in the env in millions ', default=2)
parser.add_argument('--buffer', type=float, help='Buffer size in million', default=1.0)
parser.add_argument('--frameskip', type=int, help='Frameskip', default=1)
parser.add_argument('--hidden_size', type=int, help='#Hidden Layer size', default=256)
parser.add_argument('--critic_lr', type=float, help='Critic learning rate?', default=3e-4)
parser.add_argument('--actor_lr', type=float, help='Actor learning rate?', default=1e-4)
parser.add_argument('--tau', type=float, help='Tau', default=1e-3)
parser.add_argument('--gamma', type=float, help='Discount Rate', default=0.99)
parser.add_argument('--alpha', type=float, help='Alpha for Entropy term ', default=0.1)
parser.add_argument('--batchsize', type=int, help='Seed', default=512)
parser.add_argument('--reward_scale', type=float, help='Reward Scaling Multiplier', default=1.0)
parser.add_argument('--learning_start', type=int, help='Frames to wait before learning starts', default=5000)
#ALGO SPECIFIC ARGS
parser.add_argument('--popsize', type=int, help='#Policies in the population', default=10)
parser.add_argument('--rollsize', type=int, help='#Policies in rollout size', default=5)
parser.add_argument('--gradperstep', type=float, help='#Gradient step per env step', default=1.0)
parser.add_argument('--num_test', type=int, help='#Test envs to average on', default=5)
#Figure out GPU to use [Default is 0]
os.environ['CUDA_VISIBLE_DEVICES']=str(vars(parser.parse_args())['gpu_id'])
####################### Construct ARGS Class to hold all parameters ######################
args = Parameters(parser)
#Set seeds
torch.manual_seed(args.seed); np.random.seed(args.seed); random.seed(args.seed)
################################## Find and Set MDP (environment constructor) ########################
env_constructor = EnvConstructor(args.env_name, args.frameskip)
####################### Actor, Critic and ValueFunction Model Constructor ######################
model_constructor = ModelConstructor(env_constructor.state_dim, env_constructor.action_dim, args.hidden_size)
ai = ERL_Trainer(args, model_constructor, env_constructor)
ai.train(args.total_steps)
| 2,890 | 50.625 | 110 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/core/utils.py |
from torch import nn
from torch.autograd import Variable
import random, pickle, copy, argparse
import numpy as np, torch, os
from torch import distributions
import torch.nn.functional as F
class Tracker(): #Tracker
def __init__(self, save_folder, vars_string, project_string):
self.vars_string = vars_string; self.project_string = project_string
self.foldername = save_folder
self.all_tracker = [[[],0.0,[]] for _ in vars_string] #[Id of var tracked][fitnesses, avg_fitness, csv_fitnesses]
self.counter = 0
self.conv_size = 1
if not os.path.exists(self.foldername):
os.makedirs(self.foldername)
def update(self, updates, generation):
"""Add a metric observed
Parameters:
updates (list): List of new scoresfor each tracked metric
generation (int): Current gen
Returns:
None
"""
self.counter += 1
for update, var in zip(updates, self.all_tracker):
if update == None: continue
var[0].append(update)
#Constrain size of convolution
for var in self.all_tracker:
if len(var[0]) > self.conv_size: var[0].pop(0)
#Update new average
for var in self.all_tracker:
if len(var[0]) == 0: continue
var[1] = sum(var[0])/float(len(var[0]))
if self.counter % 1 == 0: # Save to csv file
for i, var in enumerate(self.all_tracker):
if len(var[0]) == 0: continue
var[2].append(np.array([generation, var[1]]))
filename = self.foldername + self.vars_string[i] + self.project_string
np.savetxt(filename, np.array(var[2]), fmt='%.3f', delimiter=',')
def weights_init_(m, lin_gain=1.0, bias_gain=0.1):
if isinstance(m, nn.Linear):
torch.nn.init.xavier_uniform_(m.weight, gain=lin_gain)
torch.nn.init.constant_(m.bias, bias_gain)
def str2bool(v):
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.')
def hard_update(target, source):
"""Hard update (clone) from target network to source
Parameters:
target (object): A pytorch model
source (object): A pytorch model
Returns:
None
"""
for target_param, param in zip(target.parameters(), source.parameters()):
target_param.data.copy_(param.data)
def soft_update(target, source, tau):
"""Soft update from target network to source
Parameters:
target (object): A pytorch model
source (object): A pytorch model
tau (float): Tau parameter
Returns:
None
"""
for target_param, param in zip(target.parameters(), source.parameters()):
target_param.data.copy_(target_param.data * (1.0 - tau) + param.data * tau)
def to_numpy(var):
"""Tensor --> numpy
Parameters:
var (tensor): tensor
Returns:
var (ndarray): ndarray
"""
return var.data.numpy()
def to_tensor(ndarray, volatile=False, requires_grad=False):
"""numpy --> Variable
Parameters:
ndarray (ndarray): ndarray
volatile (bool): create a volatile tensor?
requires_grad (bool): tensor requires gradients?
Returns:
var (variable): variable
"""
if isinstance(ndarray, list): ndarray = np.array(ndarray)
return Variable(torch.from_numpy(ndarray).float(), volatile=volatile, requires_grad=requires_grad)
def pickle_obj(filename, object):
"""Pickle object
Parameters:
filename (str): folder to dump pickled object
object (object): object to pickle
Returns:
None
"""
handle = open(filename, "wb")
pickle.dump(object, handle)
def unpickle_obj(filename):
"""Unpickle object from disk
Parameters:
filename (str): file from which to load and unpickle object
Returns:
obj (object): unpickled object
"""
with open(filename, 'rb') as f:
return pickle.load(f)
def init_weights(m):
"""Initialize weights using kaiming uniform initialization in place
Parameters:
m (nn.module): Linear module from torch.nn
Returns:
None
"""
if type(m) == nn.Linear:
nn.init.kaiming_uniform_(m.weight)
m.bias.data.fill_(0.01)
def list_mean(l):
"""compute avergae from a list
Parameters:
l (list): list
Returns:
mean (float): mean
"""
if len(l) == 0: return None
else: return sum(l)/len(l)
def pprint(l):
"""Pretty print
Parameters:
l (list/float/None): object to print
Returns:
pretty print str
"""
if isinstance(l, list):
if len(l) == 0: return None
else:
if l == None: return None
else: return '%.2f'%l
def flatten(d):
"""Recursive method to flatten a dict -->list
Parameters:
d (dict): dict
Returns:
l (list)
"""
res = [] # Result list
if isinstance(d, dict):
for key, val in sorted(d.items()):
res.extend(flatten(val))
elif isinstance(d, list):
res = d
else:
res = [d]
return res
def reverse_flatten(d, l):
"""Recursive method to unflatten a list -->dict [Reverse of flatten] in place
Parameters:
d (dict): dict
l (list): l
Returns:
None
"""
if isinstance(d, dict):
for key, _ in sorted(d.items()):
#FLoat is immutable so
if isinstance(d[key], float):
d[key] = l[0]
l[:] = l[1:]
continue
reverse_flatten(d[key], l)
elif isinstance(d, list):
d[:] = l[0:len(d)]
l[:] = l[len(d):]
def load_all_models_dir(dir, model_template):
"""Load all models from a given directory onto a template
Parameters:
dir (str): directory
model_template (object): Class template to load the objects onto
Returns:
models (list): list of loaded objects
"""
list_files = os.listdir(dir)
print(list_files)
models = []
for i, fname in enumerate(list_files):
try:
model_template.load_state_dict(torch.load(dir + fname))
model_template.eval()
models.append(copy.deepcopy(model_template))
except:
print(fname, 'failed to load')
return models
| 6,665 | 23.780669 | 121 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/core/buffer.py |
import numpy as np
import random
import torch
from torch.multiprocessing import Manager
class Buffer():
"""Cyclic Buffer stores experience tuples from the rollouts
Parameters:
capacity (int): Maximum number of experiences to hold in cyclic buffer
"""
def __init__(self, capacity, buffer_gpu=False):
self.capacity = capacity; self.buffer_gpu = buffer_gpu; self.counter = 0
self.manager = Manager()
self.s = []; self.ns = []; self.a = []; self.r = []; self.done = []
def add(self, trajectory):
# Add ALL EXPERIENCE COLLECTED TO MEMORY concurrently
for exp in trajectory:
self.s.append(torch.Tensor(exp[0]))
self.ns.append(torch.Tensor(exp[1]))
self.a.append(torch.Tensor(exp[2]))
self.r.append(torch.Tensor(exp[3]))
self.done.append(torch.Tensor(exp[4]))
#Trim to make the buffer size < capacity
while self.__len__() > self.capacity:
self.s.pop(0); self.ns.pop(0); self.a.pop(0); self.r.pop(0); self.done.pop(0)
def __len__(self):
return len(self.s)
def sample(self, batch_size):
"""Sample a batch of experiences from memory with uniform probability
Parameters:
batch_size (int): Size of the batch to sample
Returns:
Experience (tuple): A tuple of (state, next_state, action, shaped_reward, done) each as a numpy array with shape (batch_size, :)
"""
ind = random.sample(range(len(self.s)), batch_size)
return torch.cat([self.s[i] for i in ind]),\
torch.cat([self.ns[i] for i in ind]),\
torch.cat([self.a[i] for i in ind]),\
torch.cat([self.r[i] for i in ind]),\
torch.cat([self.done[i] for i in ind])
| 1,624 | 27.017241 | 135 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/core/runner.py |
from core import utils as utils
import numpy as np
import torch
# Rollout evaluate an agent in a complete game
@torch.no_grad()
def rollout_worker(id, type, task_pipe, result_pipe, store_data, model_bucket, env_constructor):
env = env_constructor.make_env()
np.random.seed(id) ###make sure the random seeds across learners are different
###LOOP###
while True:
identifier = task_pipe.recv() # Wait until a signal is received to start rollout
if identifier == 'TERMINATE': exit(0) #Exit
# Get the requisite network
net = model_bucket[identifier]
fitness = 0.0
total_frame = 0
state = env.reset()
rollout_trajectory = []
state = utils.to_tensor(state)
while True: # unless done
if type == 'pg': action = net.noisy_action(state)
else: action = net.clean_action(state)
action = utils.to_numpy(action)
next_state, reward, done, info = env.step(action.flatten()) # Simulate one step in environment
next_state = utils.to_tensor(next_state)
fitness += reward
# If storing transitions
if store_data: #Skip for test set
rollout_trajectory.append([utils.to_numpy(state), utils.to_numpy(next_state),
np.float32(action), np.reshape(np.float32(np.array([reward])), (1, 1)),
np.reshape(np.float32(np.array([float(done)])), (1, 1))])
state = next_state
total_frame += 1
# DONE FLAG IS Received
if done:
break
# Send back id, fitness, total length and shaped fitness using the result pipe
result_pipe.send([identifier, fitness, total_frame, rollout_trajectory])
| 1,834 | 32.981481 | 111 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/core/params.py | import os
from torch.utils.tensorboard import SummaryWriter
class Parameters:
def __init__(self, parser):
"""Parameter class stores all parameters for policy gradient
Parameters:
None
Returns:
None
"""
#Env args
self.env_name = vars(parser.parse_args())['env']
self.frameskip = vars(parser.parse_args())['frameskip']
self.total_steps = int(vars(parser.parse_args())['total_steps'] * 1000000)
self.gradperstep = vars(parser.parse_args())['gradperstep']
self.savetag = vars(parser.parse_args())['savetag']
self.seed = vars(parser.parse_args())['seed']
self.batch_size = vars(parser.parse_args())['batchsize']
self.rollout_size = vars(parser.parse_args())['rollsize']
self.hidden_size = vars(parser.parse_args())['hidden_size']
self.critic_lr = vars(parser.parse_args())['critic_lr']
self.actor_lr = vars(parser.parse_args())['actor_lr']
self.tau = vars(parser.parse_args())['tau']
self.gamma = vars(parser.parse_args())['gamma']
self.reward_scaling = vars(parser.parse_args())['reward_scale']
self.buffer_size = int(vars(parser.parse_args())['buffer'] * 1000000)
self.learning_start = vars(parser.parse_args())['learning_start']
self.pop_size = vars(parser.parse_args())['popsize']
self.num_test = vars(parser.parse_args())['num_test']
self.test_frequency = 1
self.asynch_frac = 1.0 # Aynchronosity of NeuroEvolution
#Non-Args Params
self.elite_fraction = 0.2
self.crossover_prob = 0.15
self.mutation_prob = 0.90
self.extinction_prob = 0.005 # Probability of extinction event
self.extinction_magnituide = 0.5 # Probabilty of extinction for each genome, given an extinction event
self.weight_magnitude_limit = 10000000
self.mut_distribution = 1 # 1-Gaussian, 2-Laplace, 3-Uniform
self.alpha = vars(parser.parse_args())['alpha']
self.target_update_interval = 1
self.alpha_lr = 1e-3
#Save Results
self.savefolder = 'Results/Plots/'
if not os.path.exists(self.savefolder): os.makedirs(self.savefolder)
self.aux_folder = 'Results/Auxiliary/'
if not os.path.exists(self.aux_folder): os.makedirs(self.aux_folder)
self.savetag += str(self.env_name)
self.savetag += '_seed' + str(self.seed)
self.savetag += '_roll' + str(self.rollout_size)
self.savetag += '_pop' + str(self.pop_size)
self.savetag += '_alpha' + str(self.alpha)
self.writer = SummaryWriter(log_dir='Results/tensorboard/' + self.savetag)
| 2,717 | 36.75 | 111 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/models/discrete_models.py | import torch, random
import torch.nn as nn
from torch.distributions import Normal, RelaxedOneHotCategorical, Categorical
import torch.nn.functional as F
class CategoricalPolicy(nn.Module):
"""Critic model
Parameters:
args (object): Parameter class
"""
def __init__(self, state_dim, action_dim, hidden_size):
super(CategoricalPolicy, self).__init__()
self.action_dim = action_dim
######################## Q1 Head ##################
# Construct Hidden Layer 1 with state
self.f1 = nn.Linear(state_dim, hidden_size)
#self.q1ln1 = nn.LayerNorm(l1)
#Hidden Layer 2
self.f2 = nn.Linear(hidden_size, hidden_size)
#self.q1ln2 = nn.LayerNorm(l2)
#Value
self.val = nn.Linear(hidden_size, 1)
#Advantages
self.adv = nn.Linear(hidden_size, action_dim)
def clean_action(self, obs, return_only_action=True):
"""Method to forward propagate through the critic's graph
Parameters:
input (tensor): states
input (tensor): actions
Returns:
Q1 (tensor): Qval 1
Q2 (tensor): Qval 2
V (tensor): Value
"""
###### Feature ####
info = torch.relu(self.f1(obs))
info = torch.relu(self.f2(info))
val = self.val(info)
adv = self.adv(info)
logits = val + adv - adv.mean()
if return_only_action:
return logits.argmax(1)
return None, None, logits
def noisy_action(self, obs, return_only_action=True):
_, _, logits = self.clean_action(obs, return_only_action=False)
dist = Categorical(logits=logits)
action = dist.sample()
action = action
if return_only_action:
return action
return action, None, logits
class GumbelPolicy(nn.Module):
"""Critic model
Parameters:
args (object): Parameter class
"""
def __init__(self, state_dim, action_dim, hidden_size, epsilon_start, epsilon_end, epsilon_decay_frames):
super(GumbelPolicy, self).__init__()
self.action_dim = action_dim
######################## Q1 Head ##################
# Construct Hidden Layer 1 with state
self.f1 = nn.Linear(state_dim, hidden_size)
#self.q1ln1 = nn.LayerNorm(l1)
#Hidden Layer 2
self.f2 = nn.Linear(hidden_size, hidden_size)
#self.q1ln2 = nn.LayerNorm(l2)
#Value
self.val = nn.Linear(hidden_size, 1)
#Advantages
self.adv = nn.Linear(hidden_size, action_dim)
#Temperature
self.log_temp = torch.nn.Linear(hidden_size, 1)
self.LOG_TEMP_MAX = 2
self.LOG_TEMP_MIN = -10
def clean_action(self, obs, return_only_action=True):
"""Method to forward propagate through the critic's graph
Parameters:
input (tensor): states
input (tensor): actions
Returns:
Q1 (tensor): Qval 1
Q2 (tensor): Qval 2
V (tensor): Value
"""
###### Feature ####
info = torch.relu(self.f1(obs))
info = torch.relu(self.f2(info))
val = self.val(info)
adv = self.adv(info)
logits = val + adv - adv.mean()
if return_only_action:
return logits.argmax(1)
else:
log_temp = self.log_temp(info)
log_temp = torch.clamp(log_temp, min=self.LOG_TEMP_MIN, max=self.LOG_TEMP_MAX)
return logits.argmax(1), log_temp, logits
def noisy_action(self, obs, return_only_action=True):
_, log_temp, logits = self.clean_action(obs, return_only_action=False)
temp = log_temp.exp()
dist = RelaxedOneHotCategorical(temperature=temp, probs=F.softmax(logits, dim=1))
action = dist.rsample()
if return_only_action:
return action.argmax(1)
log_prob = dist.log_prob(action)
log_prob = torch.diagonal(log_prob, offset=0).unsqueeze(1)
return action.argmax(1), log_prob, logits
| 4,229 | 24.178571 | 109 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/models/constructor.py | import torch
class ModelConstructor:
def __init__(self, state_dim, action_dim, hidden_size, actor_seed=None, critic_seed=None):
"""
A general Environment Constructor
"""
self.state_dim = state_dim
self.action_dim = action_dim
self.hidden_size = hidden_size
self.actor_seed = actor_seed
self.critic_seed = critic_seed
def make_model(self, type, seed=False):
"""
Generate and return an model object
"""
if type == 'Gaussian_FF':
from models.continous_models import Gaussian_FF
model = Gaussian_FF(self.state_dim, self.action_dim, self.hidden_size)
if seed:
model.load_state_dict(torch.load(self.critic_seed))
print('Critic seeded from', self.critic_seed)
elif type == 'Tri_Head_Q':
from models.continous_models import Tri_Head_Q
model = Tri_Head_Q(self.state_dim, self.action_dim, self.hidden_size)
if seed:
model.load_state_dict(torch.load(self.critic_seed))
print('Critic seeded from', self.critic_seed)
elif type == 'GumbelPolicy':
from models.discrete_models import GumbelPolicy
model = GumbelPolicy(self.state_dim, self.action_dim, self.hidden_size)
elif type == 'CategoricalPolicy':
from models.discrete_models import CategoricalPolicy
model = CategoricalPolicy(self.state_dim, self.action_dim, self.hidden_size)
else:
AssertionError('Unknown model type')
return model
| 1,629 | 29.754717 | 94 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/models/continous_models.py |
import torch
import torch.nn as nn
from torch.distributions import Normal, RelaxedOneHotCategorical
from core.utils import weights_init_
import torch.nn.functional as F
def weights_init_(m, lin_gain=1.0, bias_gain=0.1):
if isinstance(m, nn.Linear):
torch.nn.init.xavier_uniform_(m.weight, gain=lin_gain)
torch.nn.init.constant_(m.bias, bias_gain)
class Gaussian_FF(nn.Module):
def __init__(self, num_inputs, num_actions, hidden_size):
super(Gaussian_FF, self).__init__()
self.num_actions = num_actions
#Shared FF
self.linear1 = nn.Linear(num_inputs, hidden_size)
self.linear2 = nn.Linear(hidden_size, hidden_size)
self.mean_linear = nn.Linear(hidden_size, num_actions)
self.log_std_linear = nn.Linear(hidden_size, num_actions)
# SAC SPECIFIC
self.LOG_SIG_MAX = 2
self.LOG_SIG_MIN = -20
self.epsilon = 1e-6
def clean_action(self, state, return_only_action=True):
x = F.relu(self.linear1(state))
x = F.relu(self.linear2(x))
mean = self.mean_linear(x)
if return_only_action: return torch.tanh(mean)
log_std = self.log_std_linear(x)
log_std = torch.clamp(log_std, min=self.LOG_SIG_MIN, max=self.LOG_SIG_MAX)
return mean, log_std
def noisy_action(self, state,return_only_action=True):
mean, log_std = self.clean_action(state, return_only_action=False)
std = log_std.exp()
normal = Normal(mean, std)
x_t = normal.rsample() # for reparameterization trick (mean + std * N(0,1))
action = torch.tanh(x_t)
if return_only_action:
return action
log_prob = normal.log_prob(x_t)
# Enforcing Action Bound
log_prob -= torch.log(1 - action.pow(2) + self.epsilon)
log_prob = log_prob.sum(1, keepdim=True)
return action, log_prob, None,None,torch.tanh(mean)
def get_norm_stats(self):
minimum = min([torch.min(param).item() for param in self.parameters()])
maximum = max([torch.max(param).item() for param in self.parameters()])
means = [torch.mean(torch.abs(param)).item() for param in self.parameters()]
mean = sum(means)/len(means)
return minimum, maximum, mean
class Tri_Head_Q(nn.Module):
def __init__(self, state_dim, action_dim, hidden_size):
super(Tri_Head_Q, self).__init__()
######################## Q1 Head ##################
# Construct Hidden Layer 1 with state
self.q1f1 = nn.Linear(state_dim + action_dim, hidden_size)
# Hidden Layer 2
self.q1f2 = nn.Linear(hidden_size, hidden_size)
# Out
self.q1out = nn.Linear(hidden_size, 1)
######################## Q2 Head ##################
# Construct Hidden Layer 1 with state
self.q2f1 = nn.Linear(state_dim + action_dim, hidden_size)
# Hidden Layer 2
self.q2f2 = nn.Linear(hidden_size, hidden_size)
# Out
self.q2out = nn.Linear(hidden_size, 1)
def forward(self, obs, action):
#Concatenate observation+action as critic state
state = torch.cat([obs, action], 1)
###### Q1 HEAD ####
q1 = F.relu(self.q1f1(state))
#q1 = self.q1ln1(q1)
q1 = F.relu(self.q1f2(q1))
#q1 = self.q1ln2(q1)
q1 = self.q1out(q1)
###### Q2 HEAD ####
q2 = F.relu(self.q2f1(state))
#q2 = self.q2ln1(q2)
q2 = F.relu(self.q2f2(q2))
#q2 = self.q2ln2(q2)
q2 = self.q2out(q2)
return q1, q2, None
| 3,612 | 26.792308 | 84 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/algos/sac.py | import os
import torch
import torch.nn.functional as F
from torch.optim import Adam
from core.utils import soft_update, hard_update
class SAC(object):
def __init__(self, args, model_constructor):
self.gamma = args.gamma
self.tau = args.tau
self.alpha = args.alpha
self.writer = args.writer
self.target_update_interval = args.target_update_interval
self.automatic_entropy_tuning = False
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.critic = model_constructor.make_model('Tri_Head_Q').to(device=self.device)
self.critic_optim = Adam(self.critic.parameters(), lr=args.critic_lr)
self.critic_target = model_constructor.make_model('Tri_Head_Q').to(device=self.device)
hard_update(self.critic_target, self.critic)
if self.automatic_entropy_tuning == True:
self.target_entropy = -torch.prod(torch.Tensor(1, args.action_dim)).cuda().item()
self.log_alpha = torch.zeros(1, requires_grad=True)
self.alpha_optim = Adam([self.log_alpha], lr=args.alpha_lr)
self.log_alpha.to(device=self.device)
self.actor = model_constructor.make_model('Gaussian_FF').to(device=self.device)
self.actor_optim = Adam(self.actor.parameters(), lr=args.actor_lr)
self.num_updates = 0
def update_parameters(self, state_batch, next_state_batch, action_batch, reward_batch, done_batch):
state_batch = state_batch.to(self.device)
next_state_batch=next_state_batch.to(self.device)
action_batch=action_batch.to(self.device)
reward_batch=reward_batch.to(self.device)
done_batch=done_batch.to(self.device)
with torch.no_grad():
next_state_action, next_state_log_pi,_,_,_= self.actor.noisy_action(next_state_batch, return_only_action=False)
qf1_next_target, qf2_next_target,_ = self.critic_target.forward(next_state_batch, next_state_action)
min_qf_next_target = torch.min(qf1_next_target, qf2_next_target) - self.alpha * next_state_log_pi
next_q_value = reward_batch + self.gamma * (min_qf_next_target) * (1 - done_batch)
self.writer.add_scalar('next_q', next_q_value.mean().item())
qf1, qf2,_ = self.critic.forward(state_batch, action_batch) # Two Q-functions to mitigate positive bias in the policy improvement step
qf1_loss = F.mse_loss(qf1, next_q_value) # JQ = 𝔼(st,at)~D[0.5(Q1(st,at) - r(st,at) - γ(𝔼st+1~p[V(st+1)]))^2]
qf2_loss = F.mse_loss(qf2, next_q_value) # JQ = 𝔼(st,at)~D[0.5(Q1(st,at) - r(st,at) - γ(𝔼st+1~p[V(st+1)]))^2]
self.writer.add_scalar('q_loss', (qf1_loss + qf2_loss).mean().item() / 2.0)
pi, log_pi, _,_,_ = self.actor.noisy_action(state_batch, return_only_action=False)
self.writer.add_scalar('log_pi', log_pi.mean().item())
qf1_pi, qf2_pi, _ = self.critic.forward(state_batch, pi)
min_qf_pi = torch.min(qf1_pi, qf2_pi)
self.writer.add_scalar('policy_q', min_qf_pi.mean().item())
policy_loss = ((self.alpha * log_pi) - min_qf_pi).mean() # Jπ = 𝔼st∼D,εt∼N[α * logπ(f(εt;st)|st) − Q(st,f(εt;st))]
self.writer.add_scalar('policy_loss', policy_loss.mean().item())
self.critic_optim.zero_grad()
qf1_loss.backward()
qf2_loss.backward()
self.critic_optim.step()
self.actor_optim.zero_grad()
policy_loss.backward()
self.actor_optim.step()
self.num_updates += 1
soft_update(self.critic_target, self.critic, self.tau)
| 3,599 | 43.444444 | 143 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/algos/erl_trainer.py |
import numpy as np, os, time, random, torch, sys
from algos.neuroevolution import SSNE
from core import utils
from core.runner import rollout_worker
from torch.multiprocessing import Process, Pipe, Manager
from core.buffer import Buffer
import torch
class ERL_Trainer:
def __init__(self, args, model_constructor, env_constructor):
self.args = args
self.policy_string = 'CategoricalPolicy' if env_constructor.is_discrete else 'Gaussian_FF'
self.manager = Manager()
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
#Evolution
self.evolver = SSNE(self.args)
#Initialize population
self.population = self.manager.list()
for _ in range(args.pop_size):
self.population.append(model_constructor.make_model(self.policy_string))
#Save best policy
self.best_policy = model_constructor.make_model(self.policy_string)
#PG Learner
if env_constructor.is_discrete:
from algos.ddqn import DDQN
self.learner = DDQN(args, model_constructor)
else:
from algos.sac import SAC
self.learner = SAC(args, model_constructor)
#Replay Buffer
self.replay_buffer = Buffer(args.buffer_size)
#Initialize Rollout Bucket
self.rollout_bucket = self.manager.list()
for _ in range(args.rollout_size):
self.rollout_bucket.append(model_constructor.make_model(self.policy_string))
############## MULTIPROCESSING TOOLS ###################
#Evolutionary population Rollout workers
self.evo_task_pipes = [Pipe() for _ in range(args.pop_size)]
self.evo_result_pipes = [Pipe() for _ in range(args.pop_size)]
self.evo_workers = [Process(target=rollout_worker, args=(id, 'evo', self.evo_task_pipes[id][1], self.evo_result_pipes[id][0], args.rollout_size > 0, self.population, env_constructor)) for id in range(args.pop_size)]
for worker in self.evo_workers: worker.start()
self.evo_flag = [True for _ in range(args.pop_size)]
#Learner rollout workers
self.task_pipes = [Pipe() for _ in range(args.rollout_size)]
self.result_pipes = [Pipe() for _ in range(args.rollout_size)]
self.workers = [Process(target=rollout_worker, args=(id, 'pg', self.task_pipes[id][1], self.result_pipes[id][0], True, self.rollout_bucket, env_constructor)) for id in range(args.rollout_size)]
for worker in self.workers: worker.start()
self.roll_flag = [True for _ in range(args.rollout_size)]
#Test bucket
self.test_bucket = self.manager.list()
self.test_bucket.append(model_constructor.make_model(self.policy_string))
# Test workers
self.test_task_pipes = [Pipe() for _ in range(args.num_test)]
self.test_result_pipes = [Pipe() for _ in range(args.num_test)]
self.test_workers = [Process(target=rollout_worker, args=(id, 'test', self.test_task_pipes[id][1], self.test_result_pipes[id][0], False, self.test_bucket, env_constructor)) for id in range(args.num_test)]
for worker in self.test_workers: worker.start()
self.test_flag = False
#Trackers
self.best_score = -float('inf'); self.gen_frames = 0; self.total_frames = 0; self.test_score = None; self.test_std = None
def forward_generation(self, gen, tracker):
gen_max = -float('inf')
#Start Evolution rollouts
if self.args.pop_size > 1:
for id, actor in enumerate(self.population):
self.evo_task_pipes[id][0].send(id)
#Sync all learners actor to cpu (rollout) actor and start their rollout
self.learner.actor.cpu()
for rollout_id in range(len(self.rollout_bucket)):
utils.hard_update(self.rollout_bucket[rollout_id], self.learner.actor)
self.task_pipes[rollout_id][0].send(0)
self.learner.actor.to(device=self.device)
#Start Test rollouts
if gen % self.args.test_frequency == 0:
self.test_flag = True
for pipe in self.test_task_pipes: pipe[0].send(0)
############# UPDATE PARAMS USING GRADIENT DESCENT ##########
if self.replay_buffer.__len__() > self.args.learning_start: ###BURN IN PERIOD
for _ in range(int(self.gen_frames * self.args.gradperstep)):
s, ns, a, r, done = self.replay_buffer.sample(self.args.batch_size)
self.learner.update_parameters(s, ns, a, r, done)
self.gen_frames = 0
########## JOIN ROLLOUTS FOR EVO POPULATION ############
all_fitness = []; all_eplens = []
if self.args.pop_size > 1:
for i in range(self.args.pop_size):
_, fitness, frames, trajectory = self.evo_result_pipes[i][1].recv()
all_fitness.append(fitness); all_eplens.append(frames)
self.gen_frames+= frames; self.total_frames += frames
self.replay_buffer.add(trajectory)
self.best_score = max(self.best_score, fitness)
gen_max = max(gen_max, fitness)
########## JOIN ROLLOUTS FOR LEARNER ROLLOUTS ############
rollout_fitness = []; rollout_eplens = []
if self.args.rollout_size > 0:
for i in range(self.args.rollout_size):
_, fitness, pg_frames, trajectory = self.result_pipes[i][1].recv()
self.replay_buffer.add(trajectory)
self.gen_frames += pg_frames; self.total_frames += pg_frames
self.best_score = max(self.best_score, fitness)
gen_max = max(gen_max, fitness)
rollout_fitness.append(fitness); rollout_eplens.append(pg_frames)
######################### END OF PARALLEL ROLLOUTS ################
############ FIGURE OUT THE CHAMP POLICY AND SYNC IT TO TEST #############
if self.args.pop_size > 1:
champ_index = all_fitness.index(max(all_fitness))
utils.hard_update(self.test_bucket[0], self.population[champ_index])
if max(all_fitness) > self.best_score:
self.best_score = max(all_fitness)
utils.hard_update(self.best_policy, self.population[champ_index])
torch.save(self.population[champ_index].state_dict(), self.args.aux_folder + '_best'+self.args.savetag)
print("Best policy saved with score", '%.2f'%max(all_fitness))
else: #If there is no population, champion is just the actor from policy gradient learner
utils.hard_update(self.test_bucket[0], self.rollout_bucket[0])
###### TEST SCORE ######
if self.test_flag:
self.test_flag = False
test_scores = []
for pipe in self.test_result_pipes: #Collect all results
_, fitness, _, _ = pipe[1].recv()
self.best_score = max(self.best_score, fitness)
gen_max = max(gen_max, fitness)
test_scores.append(fitness)
test_scores = np.array(test_scores)
test_mean = np.mean(test_scores); test_std = (np.std(test_scores))
tracker.update([test_mean], self.total_frames)
else:
test_mean, test_std = None, None
#NeuroEvolution's probabilistic selection and recombination step
if self.args.pop_size > 1:
self.evolver.epoch(gen, self.population, all_fitness, self.rollout_bucket)
#Compute the champion's eplen
champ_len = all_eplens[all_fitness.index(max(all_fitness))] if self.args.pop_size > 1 else rollout_eplens[rollout_fitness.index(max(rollout_fitness))]
return gen_max, champ_len, all_eplens, test_mean, test_std, rollout_fitness, rollout_eplens
def train(self, frame_limit):
# Define Tracker class to track scores
test_tracker = utils.Tracker(self.args.savefolder, ['score_' + self.args.savetag], '.csv') # Tracker class to log progress
time_start = time.time()
for gen in range(1, 1000000000): # Infinite generations
# Train one iteration
max_fitness, champ_len, all_eplens, test_mean, test_std, rollout_fitness, rollout_eplens = self.forward_generation(gen, test_tracker)
if test_mean: self.args.writer.add_scalar('test_score', test_mean, gen)
print('Gen/Frames:', gen,'/',self.total_frames,
' Gen_max_score:', '%.2f'%max_fitness,
' Champ_len', '%.2f'%champ_len, ' Test_score u/std', utils.pprint(test_mean), utils.pprint(test_std),
' Rollout_u/std:', utils.pprint(np.mean(np.array(rollout_fitness))), utils.pprint(np.std(np.array(rollout_fitness))),
' Rollout_mean_eplen:', utils.pprint(sum(rollout_eplens)/len(rollout_eplens)) if rollout_eplens else None)
if gen % 5 == 0:
print('Best_score_ever:''/','%.2f'%self.best_score, ' FPS:','%.2f'%(self.total_frames/(time.time()-time_start)), 'savetag', self.args.savetag)
print()
if self.total_frames > frame_limit:
break
###Kill all processes
try:
for p in self.task_pipes: p[0].send('TERMINATE')
for p in self.test_task_pipes: p[0].send('TERMINATE')
for p in self.evo_task_pipes: p[0].send('TERMINATE')
except:
None
| 8,262 | 38.347619 | 217 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/algos/neuroevolution.py | import random
import numpy as np
import math
import core.utils as utils
class SSNE:
def __init__(self, args):
self.gen = 0
self.args = args;
self.population_size = self.args.pop_size
self.writer = args.writer
#RL TRACKERS
self.rl_policy = None
self.selection_stats = {'elite': 0, 'selected': 0, 'discarded': 0, 'total': 0}
def selection_tournament(self, index_rank, num_offsprings, tournament_size):
"""Conduct tournament selection
Parameters:
index_rank (list): Ranking encoded as net_indexes
num_offsprings (int): Number of offsprings to generate
tournament_size (int): Size of tournament
Returns:
offsprings (list): List of offsprings returned as a list of net indices
"""
total_choices = len(index_rank)
offsprings = []
for i in range(num_offsprings):
winner = np.min(np.random.randint(total_choices, size=tournament_size))
offsprings.append(index_rank[winner])
offsprings = list(set(offsprings)) # Find unique offsprings
if len(offsprings) % 2 != 0: # Number of offsprings should be even
offsprings.append(index_rank[winner])
return offsprings
def list_argsort(self, seq):
"""Sort the list
Parameters:
seq (list): list
Returns:
sorted list
"""
return sorted(range(len(seq)), key=seq.__getitem__)
def regularize_weight(self, weight, mag):
"""Clamps on the weight magnitude (reguralizer)
Parameters:
weight (float): weight
mag (float): max/min value for weight
Returns:
weight (float): clamped weight
"""
if weight > mag: weight = mag
if weight < -mag: weight = -mag
return weight
def crossover_inplace(self, gene1, gene2):
"""Conduct one point crossover in place
Parameters:
gene1 (object): A pytorch model
gene2 (object): A pytorch model
Returns:
None
"""
keys1 = list(gene1.state_dict())
keys2 = list(gene2.state_dict())
for key in keys1:
if key not in keys2: continue
# References to the variable tensors
W1 = gene1.state_dict()[key]
W2 = gene2.state_dict()[key]
if len(W1.shape) == 2: #Weights no bias
num_variables = W1.shape[0]
# Crossover opertation [Indexed by row]
try: num_cross_overs = random.randint(0, int(num_variables * 0.3)) # Number of Cross overs
except: num_cross_overs = 1
for i in range(num_cross_overs):
receiver_choice = random.random() # Choose which gene to receive the perturbation
if receiver_choice < 0.5:
ind_cr = random.randint(0, W1.shape[0]-1) #
W1[ind_cr, :] = W2[ind_cr, :]
else:
ind_cr = random.randint(0, W1.shape[0]-1) #
W2[ind_cr, :] = W1[ind_cr, :]
elif len(W1.shape) == 1: #Bias or LayerNorm
if random.random() <0.8: continue #Crossover here with low frequency
num_variables = W1.shape[0]
# Crossover opertation [Indexed by row]
#num_cross_overs = random.randint(0, int(num_variables * 0.05)) # Crossover number
for i in range(1):
receiver_choice = random.random() # Choose which gene to receive the perturbation
if receiver_choice < 0.5:
ind_cr = random.randint(0, W1.shape[0]-1) #
W1[ind_cr] = W2[ind_cr]
else:
ind_cr = random.randint(0, W1.shape[0]-1) #
W2[ind_cr] = W1[ind_cr]
def mutate_inplace(self, gene):
"""Conduct mutation in place
Parameters:
gene (object): A pytorch model
Returns:
None
"""
mut_strength = 0.1
num_mutation_frac = 0.05
super_mut_strength = 10
super_mut_prob = 0.05
reset_prob = super_mut_prob + 0.02
num_params = len(list(gene.parameters()))
ssne_probabilities = np.random.uniform(0, 1, num_params) * 2
for i, param in enumerate(gene.parameters()): # Mutate each param
# References to the variable keys
W = param.data
if len(W.shape) == 2: # Weights, no bias
num_weights = W.shape[0] * W.shape[1]
ssne_prob = ssne_probabilities[i]
if random.random() < ssne_prob:
num_mutations = random.randint(0,
int(math.ceil(num_mutation_frac * num_weights))) # Number of mutation instances
for _ in range(num_mutations):
ind_dim1 = random.randint(0, W.shape[0]-1)
ind_dim2 = random.randint(0, W.shape[-1]-1)
random_num = random.random()
if random_num < super_mut_prob: # Super Mutation probability
W[ind_dim1, ind_dim2] += random.gauss(0, super_mut_strength * W[ind_dim1, ind_dim2])
elif random_num < reset_prob: # Reset probability
W[ind_dim1, ind_dim2] = random.gauss(0, 0.1)
else: # mutauion even normal
W[ind_dim1, ind_dim2] += random.gauss(0, mut_strength * W[ind_dim1, ind_dim2])
# Regularization hard limit
W[ind_dim1, ind_dim2] = self.regularize_weight(W[ind_dim1, ind_dim2],
self.args.weight_magnitude_limit)
elif len(W.shape) == 1: # Bias or layernorm
num_weights = W.shape[0]
ssne_prob = ssne_probabilities[i]*0.04 #Low probability of mutation here
if random.random() < ssne_prob:
num_mutations = random.randint(0,
int(math.ceil(num_mutation_frac * num_weights))) # Number of mutation instances
for _ in range(num_mutations):
ind_dim = random.randint(0, W.shape[0]-1)
random_num = random.random()
if random_num < super_mut_prob: # Super Mutation probability
W[ind_dim] += random.gauss(0, super_mut_strength * W[ind_dim])
elif random_num < reset_prob: # Reset probability
W[ind_dim] = random.gauss(0, 1)
else: # mutauion even normal
W[ind_dim] += random.gauss(0, mut_strength * W[ind_dim])
# Regularization hard limit
W[ind_dim] = self.regularize_weight(W[ind_dim], self.args.weight_magnitude_limit)
def reset_genome(self, gene):
"""Reset a model's weights in place
Parameters:
gene (object): A pytorch model
Returns:
None
"""
for param in (gene.parameters()):
param.data.copy_(param.data)
def epoch(self, gen, pop, fitness_evals, migration):
self.gen+= 1; num_elitists = int(self.args.elite_fraction * len(fitness_evals))
if num_elitists < 2: num_elitists = 2
# Entire epoch is handled with indices; Index rank nets by fitness evaluation (0 is the best after reversing)
index_rank = self.list_argsort(fitness_evals); index_rank.reverse()
elitist_index = index_rank[:num_elitists] # Elitist indexes safeguard
# Selection step
offsprings = self.selection_tournament(index_rank, num_offsprings=len(index_rank) - len(elitist_index) - len(migration), tournament_size=3)
#Figure out unselected candidates
unselects = []; new_elitists = []
for net_i in range(len(pop)):
if net_i in offsprings or net_i in elitist_index:
continue
else:
unselects.append(net_i)
random.shuffle(unselects)
#Migration Tracker
if self.rl_policy != None: # RL Transfer happened
self.selection_stats['total'] += 1.0
if self.rl_policy in elitist_index:
self.selection_stats['elite'] += 1.0
elif self.rl_policy in offsprings:
self.selection_stats['selected'] += 1.0
elif self.rl_policy in unselects:
self.selection_stats['discarded'] += 1.0
self.rl_policy = None
self.writer.add_scalar('elite_rate', self.selection_stats['elite']/self.selection_stats['total'], gen)
self.writer.add_scalar('selection_rate', (self.selection_stats['elite']+self.selection_stats['selected'])/self.selection_stats['total'], gen)
self.writer.add_scalar('discard_rate', self.selection_stats['discarded']/self.selection_stats['total'], gen)
#Inheritance step (sync learners to population) --> Migration
for policy in migration:
replacee = unselects.pop(0)
utils.hard_update(target=pop[replacee], source=policy)
self.rl_policy = replacee
# Elitism step, assigning elite candidates to some unselects
for i in elitist_index:
try: replacee = unselects.pop(0)
except: replacee = offsprings.pop(0)
new_elitists.append(replacee)
utils.hard_update(target=pop[replacee], source=pop[i])
# Crossover for unselected genes with 100 percent probability
if len(unselects) % 2 != 0: # Number of unselects left should be even
unselects.append(unselects[random.randint(0, len(unselects)-1)])
for i, j in zip(unselects[0::2], unselects[1::2]):
off_i = random.choice(new_elitists);
off_j = random.choice(offsprings)
utils.hard_update(target=pop[i], source=pop[off_i])
utils.hard_update(target=pop[j], source=pop[off_j])
self.crossover_inplace(pop[i], pop[j])
# Crossover for selected offsprings
for i, j in zip(offsprings[0::2], offsprings[1::2]):
if random.random() < self.args.crossover_prob:
self.crossover_inplace(pop[i], pop[j])
# Mutate all genes in the population except the new elitists
for net_i in range(len(pop)):
if net_i not in new_elitists: # Spare the new elitists
if random.random() < self.args.mutation_prob:
self.mutate_inplace(pop[net_i])
| 8,888 | 30.299296 | 144 | py |
Evolutionary-Reinforcement-Learning | Evolutionary-Reinforcement-Learning-master/algos/ddqn.py | import os, random
import torch
import torch.nn.functional as F
from torch.optim import Adam
from core.utils import soft_update, hard_update
class DDQN(object):
def __init__(self, args, model_constructor):
self.gamma = args.gamma
self.tau = args.tau
self.alpha = args.alpha
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.actor = model_constructor.make_model('CategoricalPolicy').to(device=self.device)
self.actor_optim = Adam(self.actor.parameters(), lr=args.actor_lr)
self.actor_target = model_constructor.make_model('CategoricalPolicy').to(device=self.device)
hard_update(self.actor_target, self.actor)
self.log_softmax = torch.nn.LogSoftmax(dim=1)
self.softmax = torch.nn.Softmax(dim=1)
self.num_updates = 0
def update_parameters(self, state_batch, next_state_batch, action_batch, reward_batch, done_batch):
state_batch = state_batch.to(self.device)
next_state_batch=next_state_batch.to(self.device)
action_batch=action_batch.to(self.device)
reward_batch=reward_batch.to(self.device)
done_batch=done_batch.to(self.device)
action_batch = action_batch.long().unsqueeze(1)
with torch.no_grad():
na = self.actor.clean_action(next_state_batch, return_only_action=True)
_, _, ns_logits = self.actor_target.noisy_action(next_state_batch, return_only_action=False)
next_entropy = -(F.softmax(ns_logits, dim=1) * F.log_softmax(ns_logits, dim=1)).mean(1).unsqueeze(1)
ns_logits = ns_logits.gather(1, na.unsqueeze(1))
next_target = ns_logits + self.alpha * next_entropy
next_q_value = reward_batch + (1-done_batch) * self.gamma * next_target
_, _, logits = self.actor.noisy_action(state_batch, return_only_action=False)
entropy = -(F.softmax(logits, dim=1) * F.log_softmax(logits, dim=1)).mean(1).unsqueeze(1)
q_val = logits.gather(1, action_batch)
q_loss = (next_q_value - q_val)**2
q_loss -= self.alpha*entropy
q_loss = q_loss.mean()
self.actor_optim.zero_grad()
q_loss.backward()
self.actor_optim.step()
self.num_updates += 1
soft_update(self.actor_target, self.actor, self.tau)
| 2,338 | 36.725806 | 112 | py |
MAX-Toxic-Comment-Classifier | MAX-Toxic-Comment-Classifier-master/core/bert_pytorch.py | #
# Copyright 2018-2019 IBM Corp. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import torch
from torch.nn import BCEWithLogitsLoss
from pytorch_pretrained_bert.modeling import BertPreTrainedModel, BertModel
import logging
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
level=logging.INFO)
logger = logging.getLogger(__name__)
class BertForMultiLabelSequenceClassification(BertPreTrainedModel):
"""BERT model for classification.
This module is composed of the BERT model with a linear layer on top of
the pooled output.
Params:
`config`: a BertConfig class instance with the configuration to build a new model.
`num_labels`: the number of classes for the classifier. Default = 2.
Inputs:
`input_ids`: a torch.LongTensor of shape [batch_size, sequence_length]
with the word token indices in the vocabulary(see the tokens preprocessing logic in the scripts
`extract_features.py`, `run_classifier.py` and `run_squad.py`)
`token_type_ids`: an optional torch.LongTensor of shape [batch_size, sequence_length] with the token
types indices selected in [0, 1]. Type 0 corresponds to a `sentence A` and type 1 corresponds to
a `sentence B` token (see BERT paper for more details).
`attention_mask`: an optional torch.LongTensor of shape [batch_size, sequence_length] with indices
selected in [0, 1]. It's a mask to be used if the input sequence length is smaller than the max
input sequence length in the current batch. It's the mask that we typically use for attention when
a batch has varying length sentences.
`labels`: labels for the classification output: torch.LongTensor of shape [batch_size]
with indices selected in [0, ..., num_labels].
Outputs:
if `labels` is not `None`:
Outputs the CrossEntropy classification loss of the output with the labels.
if `labels` is `None`:
Outputs the classification logits of shape [batch_size, num_labels].
Example usage:
```python
# Already been converted into WordPiece token ids
input_ids = torch.LongTensor([[31, 51, 99], [15, 5, 0]])
input_mask = torch.LongTensor([[1, 1, 1], [1, 1, 0]])
token_type_ids = torch.LongTensor([[0, 0, 1], [0, 1, 0]])
config = BertConfig(vocab_size_or_config_json_file=32000, hidden_size=768,
num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072)
num_labels = 2
model = BertForSequenceClassification(config, num_labels)
logits = model(input_ids, token_type_ids, input_mask)
```
"""
def __init__(self, config, num_labels=2):
super(BertForMultiLabelSequenceClassification, self).__init__(config)
self.num_labels = num_labels
self.bert = BertModel(config)
self.dropout = torch.nn.Dropout(config.hidden_dropout_prob)
self.classifier = torch.nn.Linear(config.hidden_size, num_labels)
self.apply(self.init_bert_weights)
def forward(self, input_ids, token_type_ids=None, attention_mask=None, labels=None):
_, pooled_output = self.bert(input_ids, token_type_ids, attention_mask, output_all_encoded_layers=False)
pooled_output = self.dropout(pooled_output)
logits = self.classifier(pooled_output)
if labels is not None:
loss_fct = BCEWithLogitsLoss()
loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1, self.num_labels))
return loss
else:
return logits
class InputExample(object):
"""A single training/test example for simple sequence classification."""
def __init__(self, guid, text_a, labels=None):
"""Constructs a InputExample.
Args:
guid: Unique id for the example.
text_a: string. The untokenized text of the first sequence. For single
sequence tasks, only this sequence must be specified.
text_b: (Optional) string. The untokenized text of the second sequence.
Only must be specified for sequence pair tasks.
labels: (Optional) [string]. The label of the example. This should be
specified for train and dev examples, but not for test examples.
"""
self.guid = guid
self.text_a = text_a
self.labels = labels
class InputFeatures(object):
"""A single set of features of data."""
def __init__(self, input_ids, input_mask, segment_ids, label_ids):
self.input_ids = input_ids
self.input_mask = input_mask
self.segment_ids = segment_ids
self.label_ids = label_ids
def convert_examples_to_features(examples, max_seq_length, tokenizer):
"""Loads a data file into a list of `InputBatch`s."""
features = []
for (ex_index, example) in enumerate(examples):
tokens_a = tokenizer.tokenize(str(example.text_a))
# Account for [CLS] and [SEP] with "- 2"
if len(tokens_a) > max_seq_length - 2:
tokens_a = tokens_a[:(max_seq_length - 2)]
# The convention in BERT is:
# (a) For sequence pairs:
# tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
# type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1
# (b) For single sequences:
# tokens: [CLS] the dog is hairy . [SEP]
# type_ids: 0 0 0 0 0 0 0
#
# Where "type_ids" are used to indicate whether this is the first
# sequence or the second sequence. The embedding vectors for `type=0` and
# `type=1` were learned during pre-training and are added to the wordpiece
# embedding vector (and position vector). This is not *strictly* necessary
# since the [SEP] token unambigiously separates the sequences, but it makes
# it easier for the model to learn the concept of sequences.
#
# For classification tasks, the first vector (corresponding to [CLS]) is
# used as as the "sentence vector". Note that this only makes sense because
# the entire model is fine-tuned.
tokens = ["[CLS]"] + tokens_a + ["[SEP]"]
segment_ids = [0] * len(tokens)
input_ids = tokenizer.convert_tokens_to_ids(tokens)
# The mask has 1 for real tokens and 0 for padding tokens. Only real
# tokens are attended to.
input_mask = [1] * len(input_ids)
# Zero-pad up to the sequence length.
padding = [0] * (max_seq_length - len(input_ids))
input_ids += padding
input_mask += padding
segment_ids += padding
if len(input_ids) != max_seq_length:
raise ValueError(f"input_ids has an invalid length {len(input_ids)}")
if len(input_mask) != max_seq_length:
raise ValueError(f"input_mask has an invalid length {len(input_mask)}")
if len(segment_ids) != max_seq_length:
raise ValueError(f"segment_ids has an invalid length {len(segment_ids)}")
labels_ids = []
for label in example.labels:
labels_ids.append(float(label))
if ex_index < 0:
logger.info("*** Example ***")
logger.info("guid: %s" % (example.guid))
logger.info("tokens: %s" % " ".join(
[str(x) for x in tokens]))
logger.info("input_ids: %s" % " ".join([str(x) for x in input_ids]))
logger.info("input_mask: %s" % " ".join([str(x) for x in input_mask]))
logger.info(
"segment_ids: %s" % " ".join([str(x) for x in segment_ids]))
logger.info("label: %s (id = %s)" % (example.labels, labels_ids))
features.append(
InputFeatures(input_ids=input_ids,
input_mask=input_mask,
segment_ids=segment_ids,
label_ids=labels_ids))
return features
| 8,564 | 43.378238 | 112 | py |
MAX-Toxic-Comment-Classifier | MAX-Toxic-Comment-Classifier-master/core/model.py | #
# Copyright 2018-2019 IBM Corp. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from maxfw.model import MAXModelWrapper
import logging
from config import DEFAULT_MODEL_PATH, LABEL_LIST, MODEL_META_DATA as model_meta
import torch
import time
import numpy as np
from pytorch_pretrained_bert.tokenization import BertTokenizer
from torch.utils.data import TensorDataset, DataLoader, SequentialSampler
from core.bert_pytorch import BertForMultiLabelSequenceClassification, InputExample, convert_examples_to_features
logger = logging.getLogger()
class ModelWrapper(MAXModelWrapper):
MODEL_META_DATA = model_meta
def __init__(self, path=DEFAULT_MODEL_PATH):
"""Instantiate the BERT model."""
logger.info('Loading model from: {}...'.format(path))
# Load the model
# 1. set the appropriate parameters
self.eval_batch_size = 64
self.max_seq_length = 256
self.do_lower_case = True
# 2. Initialize the PyTorch model
model_state_dict = torch.load(DEFAULT_MODEL_PATH+'pytorch_model.bin', map_location='cpu')
self.tokenizer = BertTokenizer.from_pretrained(DEFAULT_MODEL_PATH, do_lower_case=self.do_lower_case)
self.model = BertForMultiLabelSequenceClassification.from_pretrained(DEFAULT_MODEL_PATH,
num_labels=len(LABEL_LIST),
state_dict=model_state_dict)
self.device = torch.device("cpu")
self.model.to(self.device)
# 3. Set the layers to evaluation mode
self.model.eval()
logger.info('Loaded model')
def _pre_process(self, input):
# Record the time spent in the prediction functions
self.start_time = time.time()
# Converting the input to features
test_examples = [InputExample(guid=i, text_a=x, labels=[]) for i, x in enumerate(input)]
test_features = convert_examples_to_features(test_examples, self.max_seq_length, self.tokenizer)
all_input_ids = torch.tensor([f.input_ids for f in test_features], dtype=torch.long)
all_input_mask = torch.tensor([f.input_mask for f in test_features], dtype=torch.long)
all_segment_ids = torch.tensor([f.segment_ids for f in test_features], dtype=torch.long)
# Turn input examples into batches
test_data = TensorDataset(all_input_ids, all_input_mask, all_segment_ids)
test_sampler = SequentialSampler(test_data)
self.test_dataloader = DataLoader(test_data, sampler=test_sampler, batch_size=self.eval_batch_size)
return test_examples
def _post_process(self, result):
"""Convert the prediction output to the expected output."""
# Generate the output format for every input string
output = [{LABEL_LIST[0]: p[0],
LABEL_LIST[1]: p[1],
LABEL_LIST[2]: p[2],
LABEL_LIST[3]: p[3],
LABEL_LIST[4]: p[4],
LABEL_LIST[5]: p[5],
} for p in result]
return output
def _predict(self, test_examples):
"""Predict the class probabilities using the BERT model."""
logger.info("***** Running prediction *****")
logger.info(" Num examples = %d", len(test_examples))
logger.info(" Batch size = %d", self.eval_batch_size)
all_logits = None
for step, batch in enumerate(self.test_dataloader):
input_ids, input_mask, segment_ids = batch
input_ids = input_ids.to(self.device)
input_mask = input_mask.to(self.device)
segment_ids = segment_ids.to(self.device)
# Compute the logits
with torch.no_grad():
logits = self.model(input_ids, segment_ids, input_mask)
logits = logits.sigmoid()
# Save the logits
if all_logits is None:
all_logits = logits.detach().cpu().numpy()
else:
all_logits = np.concatenate((all_logits, logits.detach().cpu().numpy()), axis=0)
# Return the predictions
logger.info(f'Inference done for {len(test_examples)} examples in {time.time() - self.start_time} seconds.')
return all_logits
| 4,848 | 39.07438 | 116 | py |
Vita-CLIP | Vita-CLIP-main/training/VitaCLIP_text_encoder.py | import torch
import torch.nn as nn
import copy
from collections import OrderedDict
from typing import Union, List
from pkg_resources import packaging
from VitaCLIP_text_encoder_utils import SimpleTokenizer as _Tokenizer
class QuickGELU(nn.Module):
def forward(self, x: torch.Tensor):
return x * torch.sigmoid(1.702 * x)
class LayerNorm(nn.LayerNorm):
"""Subclass torch's LayerNorm to handle fp16."""
def forward(self, x: torch.Tensor):
orig_type = x.dtype
ret = super().forward(x.type(torch.float32))
return ret.type(orig_type)
def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[torch.IntTensor, torch.LongTensor]:
"""
Returns the tokenized representation of given input string(s)
Parameters
----------
texts : Union[str, List[str]]
An input string or a list of input strings to tokenize
context_length : int
The context length to use; all CLIP models use 77 as the context length
truncate: bool
Whether to truncate the text in case its encoding is longer than the context length
Returns
-------
A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length].
We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long.
"""
if isinstance(texts, str):
texts = [texts]
_tokenizer = _Tokenizer()
sot_token = _tokenizer.encoder["<|startoftext|>"]
eot_token = _tokenizer.encoder["<|endoftext|>"]
all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts]
if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"):
result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
else:
result = torch.zeros(len(all_tokens), context_length, dtype=torch.int)
for i, tokens in enumerate(all_tokens):
if len(tokens) > context_length:
if truncate:
tokens = tokens[:context_length]
tokens[-1] = eot_token
else:
raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}")
result[i, :len(tokens)] = torch.tensor(tokens)
return result
class ResidualAttentionBlock(nn.Module):
def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None):
super().__init__()
self.attn = nn.MultiheadAttention(d_model, n_head)
self.ln_1 = LayerNorm(d_model)
self.mlp = nn.Sequential(OrderedDict([
("c_fc", nn.Linear(d_model, d_model * 4)),
("gelu", QuickGELU()),
("c_proj", nn.Linear(d_model * 4, d_model))
]))
self.ln_2 = LayerNorm(d_model)
self.attn_mask = attn_mask
def attention(self, x: torch.Tensor):
self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None
return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
def forward(self, x: torch.Tensor):
x = x + self.attention(self.ln_1(x))
x = x + self.mlp(self.ln_2(x))
return x
class Transformer(nn.Module):
def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None):
super().__init__()
self.width = width
self.layers = layers
self.resblocks = nn.ModuleList([ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])
def forward(self, x: torch.Tensor, maple_prompts=None):
if maple_prompts:
num_prompts = maple_prompts[0].shape[0]
for i, blk in enumerate(self.resblocks):
if i == 0:
x = blk(x)
else:
prefix = x[:1, :, :]
suffix = x[1 + num_prompts:, :, :]
# Create/configure learnable tokens of this layer
textual_context = maple_prompts[i-1]
textual_context = textual_context.expand(x.shape[1], -1, -1).permute(1, 0, 2)
# Add the learnable tokens of this layer with the input, replaced by previous
# layer learnable tokens
x = torch.cat([prefix, textual_context, suffix], dim=0)
# then do forward pass from transformer
x = blk(x)
else:
for blk in self.resblocks:
x = blk(x)
return x
class CLIPTextEncoder(nn.Module):
def __init__(
self,
embed_dim: int = 512,
context_length: int = 77,
vocab_size: int = 49408,
transformer_width: int = 512,
transformer_heads: int = 8,
transformer_layers: int = 12,
):
super().__init__()
self.context_length = context_length
self.transformer = Transformer(
width=transformer_width,
layers=transformer_layers,
heads=transformer_heads,
attn_mask=self.build_attention_mask()
)
self.vocab_size = vocab_size
self.token_embedding = nn.Embedding(vocab_size, transformer_width)
self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width))
self.ln_final = LayerNorm(transformer_width)
self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim))
def build_attention_mask(self):
# lazily create causal attention mask, with full attention between the vision tokens
# pytorch uses additive attention mask; fill with -inf
mask = torch.empty(self.context_length, self.context_length)
mask.fill_(float("-inf"))
mask.triu_(1) # zero out the lower diagonal
return mask
def forward(self, prompts, tokenized_prompts, maple_prompts=None):
x = prompts + self.positional_embedding
x = x.permute(1, 0, 2) # NLD -> LND
if maple_prompts:
x = self.transformer(x, maple_prompts)
else:
x = self.transformer(x)
x = x.permute(1, 0, 2) # LND -> NLD
x = self.ln_final(x)
# x.shape = [batch_size, n_ctx, transformer.width]
# take features from the eot embedding (eot_token is the highest number in each sequence)
x = x[torch.arange(x.shape[0]), tokenized_prompts.argmax(dim=-1)] @ self.text_projection
return x
class TextPromptLearner(nn.Module):
def __init__(self, classnames, text_model, num_prompts, prompts_init='', CSC=False, ctx_pos='end'):
super().__init__()
_tokenizer = _Tokenizer()
n_cls = len(classnames)
n_ctx = num_prompts
ctx_init = prompts_init
ctx_dim = text_model.ln_final.weight.shape[0]
if ctx_init:
# use given words to initialize context vectors
ctx_init = ctx_init.replace("_", " ")
n_ctx = len(ctx_init.split(" "))
prompt = tokenize(ctx_init)
with torch.no_grad():
embedding = text_model.token_embedding(prompt)
ctx_vectors = embedding[0, 1 : 1 + n_ctx, :]
prompt_prefix = ctx_init
else:
# random initialization
if CSC:
print("Initializing class-specific contexts")
ctx_vectors = torch.empty(n_cls, n_ctx, ctx_dim)
else:
print("Initializing a generic context")
ctx_vectors = torch.empty(n_ctx, ctx_dim)
nn.init.normal_(ctx_vectors, std=0.02)
prompt_prefix = " ".join(["X"] * n_ctx)
print(f'Initial context: "{prompt_prefix}"')
print(f"Number of context words (tokens): {n_ctx}")
self.ctx = nn.Parameter(ctx_vectors) # to be optimized
classnames = [name.replace("_", " ") for name in classnames]
name_lens = [len(_tokenizer.encode(name)) for name in classnames]
prompts = [prompt_prefix + " " + name + "." for name in classnames]
tokenized_prompts = torch.cat([tokenize(p) for p in prompts])
# print(tokenized_prompts.shape)
with torch.no_grad():
embedding = text_model.token_embedding(tokenized_prompts)
# These token vectors will be saved when in save_model(),
# but they should be ignored in load_model() as we want to use
# those computed using the current class names
self.register_buffer("token_prefix", embedding[:, :1, :]) # SOS
self.register_buffer("token_suffix", embedding[:, 1 + n_ctx :, :]) # CLS, EOS
self.n_cls = n_cls
self.n_ctx = n_ctx
self.tokenized_prompts = tokenized_prompts # torch.Tensor
self.name_lens = name_lens
self.class_token_position = ctx_pos
def forward(self):
ctx = self.ctx
if ctx.dim() == 2:
ctx = ctx.unsqueeze(0).expand(self.n_cls, -1, -1)
prefix = self.token_prefix
suffix = self.token_suffix
if self.class_token_position == "end":
prompts = torch.cat(
[
prefix, # (n_cls, 1, dim)
ctx, # (n_cls, n_ctx, dim)
suffix, # (n_cls, *, dim)
],
dim=1,
)
elif self.class_token_position == "middle":
half_n_ctx = self.n_ctx // 2
prompts = []
for i in range(self.n_cls):
name_len = self.name_lens[i]
prefix_i = prefix[i : i + 1, :, :]
class_i = suffix[i : i + 1, :name_len, :]
suffix_i = suffix[i : i + 1, name_len:, :]
ctx_i_half1 = ctx[i : i + 1, :half_n_ctx, :]
ctx_i_half2 = ctx[i : i + 1, half_n_ctx:, :]
prompt = torch.cat(
[
prefix_i, # (1, 1, dim)
ctx_i_half1, # (1, n_ctx//2, dim)
class_i, # (1, name_len, dim)
ctx_i_half2, # (1, n_ctx//2, dim)
suffix_i, # (1, *, dim)
],
dim=1,
)
prompts.append(prompt)
prompts = torch.cat(prompts, dim=0)
elif self.class_token_position == "front":
prompts = []
for i in range(self.n_cls):
name_len = self.name_lens[i]
prefix_i = prefix[i : i + 1, :, :]
class_i = suffix[i : i + 1, :name_len, :]
suffix_i = suffix[i : i + 1, name_len:, :]
ctx_i = ctx[i : i + 1, :, :]
prompt = torch.cat(
[
prefix_i, # (1, 1, dim)
class_i, # (1, name_len, dim)
ctx_i, # (1, n_ctx, dim)
suffix_i, # (1, *, dim)
],
dim=1,
)
prompts.append(prompt)
prompts = torch.cat(prompts, dim=0)
else:
raise ValueError
return prompts
def _get_clones(module, N):
return nn.ModuleList([copy.deepcopy(module) for i in range(N)]) | 11,343 | 37.454237 | 137 | py |
Vita-CLIP | Vita-CLIP-main/training/checkpoint.py | #!/usr/bin/env python
import argparse
import os
import torch
import torch.distributed as dist
def setup_arg_parser(parser: argparse.ArgumentParser):
parser.add_argument('--checkpoint_dir', type=str,
help='checkpoint output path')
parser.add_argument('--auto_resume', action='store_true',
help='auto resume from the last checkpoint from checkpoint_dir')
parser.add_argument('--resume_path', type=str,
help='resume from manually specified checkpoint file, overriding auto_resume')
parser.add_argument('--pretrain', type=str,
help='path to pretrained weights. will NOT override auto_resume of resume_path, '
'load optimizer state or enforce strict matching of checkpoint and model weights.')
def _find_autoresume_path(args: argparse.Namespace):
print('Trying to auto resume from path:', args.checkpoint_dir)
if os.path.isdir(args.checkpoint_dir):
checkpoint_files = [x for x in os.listdir(args.checkpoint_dir) if x.startswith('checkpoint-') and x.endswith('.pth')]
checkpoint_iters = []
for x in checkpoint_files:
try:
x = x[len('checkpoint-'): -len('.pth')]
x = int(x)
except ValueError:
continue
checkpoint_iters.append(x)
else:
checkpoint_iters = []
if len(checkpoint_iters) == 0:
print('Did not find a valid checkpoint file.')
else:
checkpoint_iters.sort()
args.resume_path = os.path.join(args.checkpoint_dir, 'checkpoint-%d.pth' % checkpoint_iters[-1])
print(f'Found {len(checkpoint_iters)} checkpoint file(s).')
def resume_from_checkpoint(
model: torch.nn.Module,
optimizer: torch.optim.Optimizer,
lr_sched: torch.optim.lr_scheduler._LRScheduler,
loss_scaler: torch.cuda.amp.grad_scaler.GradScaler,
args: argparse.Namespace,
) -> int:
if args.pretrain is not None:
print(f'Loading pretrain model: {args.pretrain}')
ckpt = torch.load(args.pretrain, map_location='cpu')
print(model.load_state_dict(ckpt['model'], strict=False))
# returns resume_step on successful resume, or 0 otherwise.
if args.auto_resume and args.resume_path is None:
_find_autoresume_path(args)
if args.resume_path is None:
print('Not resuming from a checkpoint.')
return 0
else:
print(f'Resuming from checkpoint file {args.resume_path}')
ckpt = torch.load(args.resume_path, map_location='cpu')
model.load_state_dict(ckpt['model'], strict=True)
if 'optimizer' in ckpt:
optimizer.load_state_dict(ckpt['optimizer'])
lr_sched.load_state_dict(ckpt['lr_sched'])
loss_scaler.load_state_dict(ckpt['loss_scaler'])
return ckpt['next_step']
else:
print('Optimizer state is NOT found in checkpoint.')
return 0
def save_checkpoint(
model: torch.nn.Module,
optimizer: torch.optim.Optimizer,
lr_sched: torch.optim.lr_scheduler._LRScheduler,
loss_scaler: torch.cuda.amp.grad_scaler.GradScaler,
next_step: int,
args: argparse.Namespace,
):
if args.checkpoint_dir is None:
return
if not os.path.isdir(args.checkpoint_dir):
os.makedirs(args.checkpoint_dir)
to_save = {
'model': model.state_dict(),
'optimizer': optimizer.state_dict(),
'lr_sched': lr_sched.state_dict(),
'loss_scaler': loss_scaler.state_dict(),
'next_step': next_step,
}
torch.save(to_save, os.path.join(args.checkpoint_dir, f'checkpoint-{next_step}.pth'))
| 3,710 | 35.742574 | 125 | py |
Vita-CLIP | Vita-CLIP-main/training/VitaCLIP_vision_encoder.py | from typing import Tuple
import numpy as np
from einops import rearrange
import torch
import torch.nn as nn
import torch.nn.functional as F
from operator import mul
from functools import reduce
import math
from VitaCLIP_vision_encoder_utils import QuickGELU, LayerNorm, TransformerEncoderLayer, ImagePatchEmbed2D
class CLIPVisionEncoder(nn.Module):
def __init__(
self,
# data shape
input_size: Tuple[int, int] = (224, 224),
num_frames: int = 8,
# model def
feature_dim: int = 768,
patch_size: Tuple[int, int] = (16, 16),
num_heads: int = 12,
num_layers: int = 12,
mlp_factor: float = 4.0,
act: nn.Module = QuickGELU,
embed_dim: int = 512,
# use summary token
use_summary_token: bool = False,
# use local prompts
use_local_prompts: bool = False,
# use global prompts
use_global_prompts: bool = False,
num_global_prompts: int = 8,
):
super().__init__()
self.feature_dim = feature_dim
self.patch_embed = ImagePatchEmbed2D(img_size=input_size[0], patch_size=patch_size[0], in_chans=3, embed_dim=feature_dim)
self.num_patches = np.prod([x // y for x, y in zip(input_size, patch_size)]) + 1
self.cls_token = nn.Parameter(torch.zeros([feature_dim]))
self.pos_embed = nn.Parameter(torch.zeros([self.num_patches, feature_dim]))
self.time_embed = nn.Parameter(torch.zeros([num_frames, feature_dim]))
self.blocks = nn.ModuleList([
TransformerEncoderLayer(
in_feature_dim=feature_dim, qkv_dim=feature_dim, num_heads=num_heads,
mlp_factor=mlp_factor, act=act, use_summary_token=use_summary_token,
use_local_prompts=use_local_prompts, num_frames=num_frames, patch_size=patch_size
) for _ in range(num_layers)
])
self.ln_pre = LayerNorm(feature_dim)
self.ln_post = LayerNorm(feature_dim)
scale = feature_dim ** -0.5
self.proj = nn.Parameter(scale * torch.randn(feature_dim, embed_dim))
# global prompts
self.use_global_prompts = use_global_prompts
self.num_global_prompts = num_global_prompts
if self.use_global_prompts:
self.global_prompts = nn.Parameter(torch.zeros(num_layers, self.num_global_prompts, feature_dim))
self._initialize_global_prompts(patch_size, feature_dim)
self._initialize_weights()
def _initialize_weights(self):
nn.init.normal_(self.cls_token, std=0.02)
nn.init.normal_(self.pos_embed, std=0.02)
nn.init.normal_(self.time_embed, std=0.02)
def _initialize_global_prompts(self, patch_size, prompt_dim):
val = math.sqrt(6. / float(3 * reduce(mul, patch_size, 1) + prompt_dim))
# xavier_uniform initialization
nn.init.uniform_(self.global_prompts.data, -val, val)
def temporal_encoding(self, x, T, B):
## Time Embeddings
x = rearrange(x, '(b t) n m -> (b n) t m',b=B,t=T)
## Resizing time embeddings in case they don't match
if T != self.time_embed.size(0):
time_embed = self.time_embed.unsqueeze(0).transpose(1,2)
new_time_embed = F.interpolate(time_embed, size=(T), mode='nearest')
new_time_embed = new_time_embed.transpose(1, 2).squeeze(0)
x = x + new_time_embed
else:
x = x + self.time_embed
x = rearrange(x, '(b n) t m -> (b t) n m',b=B,t=T)
return x
def forward(self, x: torch.Tensor):
B, C, T, H, W = x.size()
x = x.permute(0, 2, 1, 3, 4).flatten(0, 1)
x = self.patch_embed(x)
x = torch.cat([self.cls_token.view(1, 1, -1).repeat(x.size(0), 1, 1), x], dim=1)
x = x + self.pos_embed
x = self.temporal_encoding(x, T, B)
x = self.ln_pre(x)
if self.use_global_prompts:
for i, blk in enumerate(self.blocks):
global_prompts = self.global_prompts[i].expand(B*T, -1, -1)
x = torch.cat((x[:, :1, :], global_prompts, x[:, 1:, :]), dim=1)
x = blk(x)
x = torch.cat((x[:, :1, :], x[:, self.num_global_prompts+1:, :]), dim=1)
else:
for blk in self.blocks:
x = blk(x)
cls_x = self.ln_post(x[:, 0, :])
cls_x = cls_x @ self.proj
cls_x = rearrange(cls_x, '(b t) e -> b t e', b=B,t=T).mean(dim=1)
return cls_x | 4,541 | 34.209302 | 129 | py |
Vita-CLIP | Vita-CLIP-main/training/VitaCLIP_model.py | #!/usr/bin/env python
from typing import Tuple
import numpy as np
import torch
import torch.nn as nn
from VitaCLIP_vision_encoder import CLIPVisionEncoder
from VitaCLIP_text_encoder import CLIPTextEncoder, TextPromptLearner
class VitaCLIP(nn.Module):
def __init__(
self,
# load weights
backbone_path: str = '',
# data shape
input_size: Tuple[int, int] = (224, 224),
num_frames: int = 16,
# model def
feature_dim: int = 768,
patch_size: Tuple[int, int] = (16, 16),
num_heads: int = 12,
num_layers: int = 12,
mlp_factor: float = 4.0,
embed_dim: int = 512,
# use summary token
use_summary_token: bool = False,
# use local prompts
use_local_prompts: bool = False,
# use global prompts
use_global_prompts: bool = False,
num_global_prompts: int = 8,
# use text prompt learning
use_text_prompt_learning: bool = False,
text_context_length: int = 77,
text_vocab_size: int = 49408,
text_transformer_width: int = 512,
text_transformer_heads: int = 8,
text_transformer_layers: int = 12,
text_num_prompts: int = 8,
text_prompt_pos: str = 'end',
text_prompt_init: str = '',
text_prompt_CSC: bool = False,
text_prompt_classes_path: str = '',
# zeroshot eval
zeroshot_evaluation: bool = False,
zeroshot_text_features_path: str = '',
):
super().__init__()
# frames and tubelet
self.num_frames = num_frames
# use summary token
self.use_summary_token = use_summary_token
# clip loss logit_scale
self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
# zeroshot text_features
self.zeroshot_evaluation = zeroshot_evaluation
if self.zeroshot_evaluation:
self.text_features = torch.load(zeroshot_text_features_path, map_location='cpu')
# visual model
self.visual = CLIPVisionEncoder(
# data shape
input_size=input_size,
num_frames=num_frames,
# model def
feature_dim=feature_dim,
patch_size=patch_size,
num_heads=num_heads,
num_layers=num_layers,
mlp_factor=mlp_factor,
embed_dim=embed_dim,
# use summary token
use_summary_token=use_summary_token,
# use local prompts
use_local_prompts=use_local_prompts,
# use global prompts
use_global_prompts=use_global_prompts,
num_global_prompts=num_global_prompts,
)
self.use_text_prompt_learning = use_text_prompt_learning
# text prompt learning
if self.use_text_prompt_learning:
self.textual = CLIPTextEncoder(
embed_dim=embed_dim,
context_length=text_context_length,
vocab_size=text_vocab_size,
transformer_width=text_transformer_width,
transformer_heads=text_transformer_heads,
transformer_layers=text_transformer_layers,
)
if backbone_path:
ckpt = torch.load(backbone_path)
self.load_state_dict(ckpt, strict=False)
if self.use_text_prompt_learning:
with open(text_prompt_classes_path, 'r') as f:
classes = f.read().strip().split('\n')
self.prompt_learner = TextPromptLearner(
classnames=classes,
text_model=self.textual,
num_prompts=text_num_prompts,
prompts_init=text_prompt_init,
CSC=text_prompt_CSC,
ctx_pos=text_prompt_pos
)
self.tokenized_prompts = self.prompt_learner.tokenized_prompts
# freeze encoders
self._freeze_visual_except_prompts_time_embed()
self._freeze_textual()
def _freeze_visual_except_prompts_time_embed(self):
for name, param in self.visual.named_parameters():
if 'summary' in name or 'local' in name or 'global' in name or 'time_embed' in name:
pass
else:
param.requires_grad = False
def _freeze_textual(self):
for name, param in self.textual.named_parameters():
param.requires_grad = False
def forward(self, x: torch.Tensor):
B, C, T, H, W = x.size()
# used in training
if self.use_text_prompt_learning:
# text side
prompts = self.prompt_learner()
tokenized_prompts = self.tokenized_prompts
text_features = self.textual(prompts, tokenized_prompts)
# vision side
video_features = self.visual(x)
# used in zeroshot evaluation
else:
# vision side
video_features = self.visual(x)
# text side
text_features = self.text_features.to(video_features.device)
# normalized features
video_features = video_features / video_features.norm(dim=-1, keepdim=True)
text_features = text_features / text_features.norm(dim=-1, keepdim=True)
# cosine similarity as logits
logit_scale = self.logit_scale.exp()
logits = logit_scale * video_features @ text_features.t()
return logits | 5,576 | 32.8 | 100 | py |
Vita-CLIP | Vita-CLIP-main/training/VitaCLIP_vision_encoder_utils.py | #!/usr/bin/env python
from collections import OrderedDict
from typing import Tuple
import torch
import torch.nn as nn
from operator import mul
from functools import reduce
import math
'''
QuickGELU and LayerNorm w/ fp16 from official CLIP repo
(https://github.com/openai/CLIP/blob/3b473b0e682c091a9e53623eebc1ca1657385717/clip/model.py)
'''
class QuickGELU(nn.Module):
def forward(self, x: torch.Tensor):
return x * torch.sigmoid(1.702 * x)
class LayerNorm(nn.LayerNorm):
"""Subclass torch's LayerNorm to handle fp16."""
def forward(self, x: torch.Tensor):
orig_type = x.dtype
ret = super().forward(x.type(torch.float32))
return ret.type(orig_type)
class Attention(nn.Module):
'''
A generalized attention module with more flexibility.
'''
def __init__(
self, q_in_dim: int, k_in_dim: int, v_in_dim: int,
qk_proj_dim: int, v_proj_dim: int, num_heads: int,
out_dim: int
):
super().__init__()
self.q_proj = nn.Linear(q_in_dim, qk_proj_dim)
self.k_proj = nn.Linear(k_in_dim, qk_proj_dim)
self.v_proj = nn.Linear(v_in_dim, v_proj_dim)
self.out_proj = nn.Linear(v_proj_dim, out_dim)
self.num_heads = num_heads
assert qk_proj_dim % num_heads == 0 and v_proj_dim % num_heads == 0
self._initialize_weights()
def _initialize_weights(self):
for m in (self.q_proj, self.k_proj, self.v_proj, self.out_proj):
nn.init.xavier_uniform_(m.weight)
nn.init.constant_(m.bias, 0.)
def forward(self, q: torch.Tensor, k: torch.Tensor, v: torch.Tensor):
assert q.ndim == 3 and k.ndim == 3 and v.ndim == 3
N = q.size(0); assert k.size(0) == N and v.size(0) == N
Lq, Lkv = q.size(1), k.size(1); assert v.size(1) == Lkv
q, k, v = self.q_proj(q), self.k_proj(k), self.v_proj(v)
H = self.num_heads
Cqk, Cv = q.size(-1) // H, v.size(-1) // H
q = q.view(N, Lq, H, Cqk)
k = k.view(N, Lkv, H, Cqk)
v = v.view(N, Lkv, H, Cv)
aff = torch.einsum('nqhc,nkhc->nqkh', q / (Cqk ** 0.5), k)
aff = aff.softmax(dim=-2)
mix = torch.einsum('nqlh,nlhc->nqhc', aff, v)
out = self.out_proj(mix.flatten(-2))
return out
class TransformerEncoderLayer(nn.Module):
def __init__(
self,
# attention def
in_feature_dim: int = 768,
qkv_dim: int = 768,
num_heads: int = 12,
mlp_factor: float = 4.0,
mlp_dropout: float = 0.0,
act: nn.Module = QuickGELU,
# use summary token
use_summary_token: bool = False,
# use local prompts
use_local_prompts: bool = False,
# model def
num_frames: int = 8,
patch_size: Tuple[int, int] = (16, 16),
):
super().__init__()
self.attn = Attention(
q_in_dim=in_feature_dim, k_in_dim=in_feature_dim, v_in_dim=in_feature_dim,
qk_proj_dim=qkv_dim, v_proj_dim=qkv_dim, num_heads=num_heads, out_dim=in_feature_dim
)
mlp_dim = round(mlp_factor * in_feature_dim)
self.mlp = nn.Sequential(OrderedDict([
('fc1', nn.Linear(in_feature_dim, mlp_dim)),
('act', act()),
('dropout', nn.Dropout(mlp_dropout)),
('fc2', nn.Linear(mlp_dim, in_feature_dim)),
]))
self.norm1 = LayerNorm(in_feature_dim)
self.norm2 = LayerNorm(in_feature_dim)
self.use_summary_token = use_summary_token
self.use_local_prompts = use_local_prompts
# for both summary token and local prompts we need the cls_proj layer and the num_frames
if self.use_summary_token or self.use_local_prompts:
self.cls_proj = nn.Linear(in_feature_dim, in_feature_dim)
self.num_frames = num_frames
# for summary token we need a layer norm and attention
if self.use_summary_token:
self.summary_ln = LayerNorm(in_feature_dim)
self.summary_attn_layer = Attention(
q_in_dim=in_feature_dim, k_in_dim=in_feature_dim, v_in_dim=in_feature_dim,
qk_proj_dim=qkv_dim, v_proj_dim=qkv_dim, num_heads=num_heads, out_dim=in_feature_dim
)
# for local prompts we init learnable tokens
if self.use_local_prompts:
self.local_prompts = nn.Parameter(torch.zeros(1, self.num_frames, in_feature_dim))
self._initialize_cls_prompts(patch_size, in_feature_dim)
self._initialize_weights()
def _initialize_weights(self):
for m in (self.mlp[0], self.mlp[-1]):
nn.init.xavier_uniform_(m.weight)
nn.init.normal_(m.bias, std=1e-6)
def _initialize_cls_prompts(self, patch_size, prompt_dim):
val = math.sqrt(6. / float(3 * reduce(mul, patch_size, 1) + prompt_dim))
# xavier_uniform initialization
nn.init.uniform_(self.local_prompts.data, -val, val)
def forward(self, x: torch.Tensor):
# get the cls tokens and apply fc
# which is required for both summaru token
# and local prompts
if self.use_summary_token or self.use_local_prompts:
BT, N, C = x.shape
T = self.num_frames
B = BT//T
cls_token = x[:, 0, :].view(B, T, C)
cls_token_proj = self.cls_proj(cls_token)
# then apply ln and attn if summary token being used
if self.use_summary_token:
summary_token_norm = self.summary_ln(cls_token_proj)
summary_token_attn = cls_token_proj + self.summary_attn_layer(summary_token_norm, summary_token_norm, summary_token_norm)
summary_token_attn_reshape = summary_token_attn.view(BT, 1, C)
x = torch.cat([x, summary_token_attn_reshape], dim=1)
# then if local prompts are being used
if self.use_local_prompts:
local_prompts = self.local_prompts.expand(B, -1, -1)
# If train time frames and
# test time frames are not equal
if T != self.num_frames:
token_multiplier = T//self.num_frames
local_prompts = local_prompts.repeat(1,token_multiplier,1)
# use additive conditioning
local_prompts = local_prompts + cls_token_proj
# repeat across frames
local_prompts = local_prompts.repeat_interleave(repeats=T, dim=0)
x = torch.cat((x[:, :1, :], local_prompts, x[:, 1:, :]), dim=1)
x_norm = self.norm1(x)
x = x + self.attn(x_norm, x_norm, x_norm)
# remove the tokens after self attention
if self.use_summary_token:
x = x[:, :-1, :]
if self.use_local_prompts:
x = torch.cat((x[:, :1, :], x[:, local_prompts.shape[1]+1:, :]), dim=1)
x = x + self.mlp(self.norm2(x))
return x
class ImagePatchEmbed2D(nn.Module):
""" Image to Patch Embedding
"""
def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
super().__init__()
num_patches = (img_size // patch_size) * (img_size // patch_size)
self.img_size = img_size
self.patch_size = patch_size
self.num_patches = num_patches
self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
def forward(self, x):
B, C, H, W = x.shape
x = self.proj(x).flatten(2).transpose(1, 2)
return x | 7,573 | 34.064815 | 133 | py |
Vita-CLIP | Vita-CLIP-main/training/train.py | #!/usr/bin/env python
import argparse
from datetime import datetime
import builtins
import torch
import torch.distributed as dist
import sys
sys.path.append('./')
import video_dataset
import checkpoint
from VitaCLIP_model import VitaCLIP
from collections import OrderedDict
def setup_print(is_master: bool):
"""
This function disables printing when not in master process
"""
builtin_print = builtins.print
def print(*args, **kwargs):
force = kwargs.pop('force', False)
if is_master or force:
now = datetime.now().time()
builtin_print('[{}] '.format(now), end='') # print with time stamp
builtin_print(*args, **kwargs)
builtins.print = print
def main():
# torch.autograd.set_detect_anomaly(True)
parser = argparse.ArgumentParser()
video_dataset.setup_arg_parser(parser)
checkpoint.setup_arg_parser(parser)
# train settings
parser.add_argument('--num_steps', type=int,
help='number of training steps')
parser.add_argument('--eval_only', action='store_true',
help='run evaluation only')
parser.add_argument('--save_freq', type=int, default=5000,
help='save a checkpoint every N steps')
parser.add_argument('--eval_freq', type=int, default=5000,
help='evaluate every N steps')
parser.add_argument('--print_freq', type=int, default=10,
help='print log message every N steps')
parser.add_argument('--lr', type=float, default=4e-4,
help='learning rate')
parser.add_argument('--weight_decay', type=float, default=0.05,
help='optimizer weight decay')
parser.add_argument('--batch_split', type=int, default=1,
help='optionally split the batch into smaller shards and forward/backward one shard '
'at a time to avoid out-of-memory error.')
# backbone and checkpoint paths
parser.add_argument('--backbone_path', type=str,
help='path to pretrained backbone weights', default='')
parser.add_argument('--checkpoint_path', type=str,
help='path to pretrained checkpoint weights', default=None)
# model params
parser.add_argument('--patch_size', type=int, default=16,
help='patch size of patch embedding')
parser.add_argument('--num_heads', type=int, default=12,
help='number of transformer heads')
parser.add_argument('--num_layers', type=int, default=12,
help='number of transformer layers')
parser.add_argument('--feature_dim', type=int, default=768,
help='transformer feature dimension')
parser.add_argument('--embed_dim', type=int, default=512,
help='clip projection embedding size')
parser.add_argument('--mlp_factor', type=float, default=4.0,
help='transformer mlp factor')
parser.add_argument('--cls_dropout', type=float, default=0.5,
help='dropout rate applied before the final classification linear projection')
# zeroshot evaluation
parser.add_argument('--zeroshot_evaluation', action='store_true', dest='zeroshot_evaluation',
help='set into zeroshot evaluation mode')
parser.add_argument('--zeroshot_text_features_path', type=str, default='./ucf101_text_features_B16/class-only.pth',
help='path to saved clip text features to be used for zeroshot evaluation')
#fp16
parser.add_argument('--use_fp16', action='store_true', dest='fp16',
help='disable fp16 during training or inference')
parser.set_defaults(fp16=False)
# use summary token attn
parser.add_argument('--use_summary_token', action='store_true', dest='use_summary_token',
help='use summary token')
# use local prompts
parser.add_argument('--use_local_prompts', action='store_true', dest='use_local_prompts',
help='use local (frame-level conditioned) prompts')
# use global prompts
parser.add_argument('--use_global_prompts', action='store_true', dest='use_global_prompts',
help='use global (video-level unconditioned) prompts')
parser.add_argument('--num_global_prompts', type=int, default=8,
help='number of global prompts')
# set defaults
parser.set_defaults(use_summary_token=False, use_local_prompts=False, use_global_prompts=False)
# text prompt learning
parser.add_argument('--use_text_prompt_learning', action='store_true', dest='use_text_prompt_learning',
help='use coop text prompt learning')
parser.add_argument('--text_context_length', type=int, default=77,
help='text model context length')
parser.add_argument('--text_vocab_size', type=int, default=49408,
help='text model vocab size')
parser.add_argument('--text_transformer_width', type=int, default=512,
help='text transformer width')
parser.add_argument('--text_transformer_heads', type=int, default=8,
help='text transformer heads')
parser.add_argument('--text_transformer_layers', type=int, default=12,
help='text transformer layers')
parser.add_argument('--text_num_prompts', type=int, default=16,
help='number of text prompts')
parser.add_argument('--text_prompt_pos', type=str, default='end',
help='postion of text prompt')
parser.add_argument('--text_prompt_init', type=str, default='',
help='initialization to be used for text prompt. Leave empty for random')
parser.add_argument('--use_text_prompt_CSC', action='store_true', dest='text_prompt_CSC',
help='use Class Specific Context in text prompt')
parser.add_argument('--text_prompt_classes_path', type=str, default='./classes/k400_classes.txt',
help='path of classnames txt file')
args = parser.parse_args()
dist.init_process_group('nccl')
setup_print(dist.get_rank() == 0)
cuda_device_id = dist.get_rank() % torch.cuda.device_count()
torch.cuda.set_device(cuda_device_id)
model = VitaCLIP(
# load weights
backbone_path=args.backbone_path,
# data shape
input_size=(args.spatial_size, args.spatial_size),
num_frames=args.num_frames,
# model def
feature_dim=args.feature_dim,
patch_size=(args.patch_size, args.patch_size),
num_heads=args.num_heads,
num_layers=args.num_layers,
mlp_factor=args.mlp_factor,
embed_dim=args.embed_dim,
# use summary token
use_summary_token=args.use_summary_token,
# use local prompts
use_local_prompts=args.use_local_prompts,
# use global prompts
use_global_prompts=args.use_global_prompts,
num_global_prompts=args.num_global_prompts,
# use text prompt learning
use_text_prompt_learning=args.use_text_prompt_learning,
text_context_length=args.text_context_length,
text_vocab_size=args.text_vocab_size,
text_transformer_width=args.text_transformer_width,
text_transformer_heads=args.text_transformer_heads,
text_transformer_layers=args.text_transformer_layers,
text_num_prompts=args.text_num_prompts,
text_prompt_pos=args.text_prompt_pos,
text_prompt_init=args.text_prompt_init,
text_prompt_CSC=args.text_prompt_CSC,
text_prompt_classes_path=args.text_prompt_classes_path,
# zeroshot eval
zeroshot_evaluation=args.zeroshot_evaluation,
zeroshot_text_features_path=args.zeroshot_text_features_path,
)
if args.checkpoint_path:
print('loading checkpoint')
ckpt = torch.load(args.checkpoint_path, map_location='cpu')
renamed_ckpt = OrderedDict((k[len("module."):], v) for k, v in ckpt['model'].items() if k.startswith("module."))
model.load_state_dict(renamed_ckpt, strict=True)
print(model)
print('----------------------------------------------------')
print('Trainable Parameters')
for name, param in model.named_parameters():
if param.requires_grad == True:
print(name)
print('----------------------------------------------------')
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[cuda_device_id], output_device=cuda_device_id,
)
optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)
lr_sched = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.num_steps)
loss_scaler = torch.cuda.amp.grad_scaler.GradScaler(enabled=args.fp16)
criterion = torch.nn.CrossEntropyLoss()
resume_step = checkpoint.resume_from_checkpoint(model, optimizer, lr_sched, loss_scaler, args)
val_loader = video_dataset.create_val_loader(args)
if args.eval_only:
print('Running in eval_only mode.')
model.eval()
evaluate(model, val_loader)
return
else:
assert args.train_list_path is not None, 'Train list path must be specified if not in eval_only mode.'
train_loader = video_dataset.create_train_loader(args, resume_step=resume_step)
assert len(train_loader) == args.num_steps - resume_step
batch_st, train_st = datetime.now(), datetime.now()
for i, (data, labels) in enumerate(train_loader, resume_step):
data, labels = data.cuda(), labels.cuda()
data_ed = datetime.now()
optimizer.zero_grad()
assert data.size(0) % args.batch_split == 0
split_size = data.size(0) // args.batch_split
hit1, hit5, loss_value = 0, 0, 0
for j in range(args.batch_split):
data_slice = data[split_size * j: split_size * (j + 1)]
labels_slice = labels[split_size * j: split_size * (j + 1)]
with torch.cuda.amp.autocast(args.fp16):
logits = model(data_slice)
loss = criterion(logits, labels_slice)
if labels.dtype == torch.long: # no mixup, can calculate accuracy
hit1 += (logits.topk(1, dim=1)[1] == labels_slice.view(-1, 1)).sum().item()
hit5 += (logits.topk(5, dim=1)[1] == labels_slice.view(-1, 1)).sum().item()
loss_value += loss.item() / args.batch_split
loss_scaler.scale(loss / args.batch_split).backward()
loss_scaler.step(optimizer)
loss_scaler.update()
lr_sched.step()
batch_ed = datetime.now()
if i % args.print_freq == 0:
sync_tensor = torch.Tensor([loss_value, hit1 / data.size(0), hit5 / data.size(0)]).cuda()
dist.all_reduce(sync_tensor)
sync_tensor = sync_tensor.cpu() / dist.get_world_size()
loss_value, acc1, acc5 = sync_tensor.tolist()
print(
f'batch_time: {(batch_ed - batch_st).total_seconds():.3f} '
f'data_time: {(data_ed - batch_st).total_seconds():.3f} '
f'ETA: {(batch_ed - train_st) / (i - resume_step + 1) * (args.num_steps - i - 1)} | '
f'lr: {optimizer.param_groups[0]["lr"]:.6f} '
f'loss: {loss_value:.6f}' + (
f' acc1: {acc1 * 100:.2f}% acc5: {acc5 * 100:.2f}%' if labels.dtype == torch.long else ''
)
)
if (i + 1) % args.eval_freq == 0:
print('Start model evaluation at step', i + 1)
model.eval()
evaluate(model, val_loader)
model.train()
if (i + 1) % args.save_freq == 0 and dist.get_rank() == 0:
checkpoint.save_checkpoint(model, optimizer, lr_sched, loss_scaler, i + 1, args)
batch_st = datetime.now()
def evaluate(model: torch.nn.Module, loader: torch.utils.data.DataLoader):
tot, hit1, hit5 = 0, 0, 0
eval_st = datetime.now()
for data, labels in loader:
data, labels = data.cuda(), labels.cuda()
assert data.size(0) == 1
if data.ndim == 6:
data = data[0] # now the first dimension is number of views
with torch.no_grad():
logits = model(data)
scores = logits.softmax(dim=-1).mean(dim=0)
tot += 1
hit1 += (scores.topk(1)[1] == labels).sum().item()
hit5 += (scores.topk(5)[1] == labels).sum().item()
if tot % 20 == 0:
print(f'[Evaluation] num_samples: {tot} '
f'ETA: {(datetime.now() - eval_st) / tot * (len(loader) - tot)} '
f'cumulative_acc1: {hit1 / tot * 100.:.2f}% '
f'cumulative_acc5: {hit5 / tot * 100.:.2f}%')
sync_tensor = torch.LongTensor([tot, hit1, hit5]).cuda()
dist.all_reduce(sync_tensor)
tot, hit1, hit5 = sync_tensor.cpu().tolist()
print(f'Accuracy on validation set: top1={hit1 / tot * 100:.2f}%, top5={hit5 / tot * 100:.2f}%')
if __name__ == '__main__': main()
| 13,336 | 42.161812 | 120 | py |
Vita-CLIP | Vita-CLIP-main/video_dataset/dataloader.py | #!/usr/bin/env python
import argparse
from typing import Dict
import torch
import torch.distributed as dist
from .dataset import VideoDataset, DummyDataset
def setup_arg_parser(parser: argparse.ArgumentParser):
parser.add_argument('--train_list_path', type=str,
help='path to training data list')
parser.add_argument('--val_list_path', type=str,
help='path to validation data list')
parser.add_argument('--train_data_root', type=str,
help='training samples root directory')
parser.add_argument('--val_data_root', type=str,
help='validation samples root directory')
parser.add_argument('--data_root', type=str, default='',
help='training and validation samples root directory, might be overrided by --train_data_root or --val_data_root')
parser.add_argument('--batch_size', type=int,
help='training batch size on a all GPUs')
parser.add_argument('--num_spatial_views', type=int, default=1,
help='number of spatial crops used for testing (total views = num_spatial_views * num_temporal_views)')
parser.add_argument('--num_temporal_views', type=int, default=3,
help='number of temporal crops used for testing (total views = num_spatial_views * num_temporal_views)')
parser.add_argument('--num_frames', type=int, default=8,
help='number of frames used for each view')
parser.add_argument('--sampling_rate', type=int, default=16,
help='temporal stride for frame sampling, only valid when tsn_sampling is not enabled')
parser.add_argument('--tsn_sampling', action='store_true',
help='enable TSN-style sampling (i.e. sample frames with dynamic stride to cover the whole video)')
parser.add_argument('--spatial_size', type=int, default=224,
help='frame height and width in pixels')
parser.add_argument('--mean', type=float, nargs='+',
help='pixel mean used to normalize the image.')
parser.add_argument('--std', type=float, nargs='+',
help='pixel std used to normalize the image')
parser.add_argument('--num_workers', type=int, default=10,
help='number of DataLoader worker threads')
parser.add_argument('--dummy_dataset', action='store_true',
help='use fake datasets that generate all 0 (use for speed test only)')
parser.add_argument('--auto_augment', type=str,
help='auto augment configuration')
parser.add_argument('--interpolation', type=str, default='bicubic',
help='interpolation mode')
parser.add_argument('--no_mirror', action='store_false', dest='mirror',
help='disable mirror for training (frequently used for the something-something dataset)')
parser.set_defaults(mirror=True)
def _parse_mean_and_std(args: argparse.Namespace) -> Dict[str, torch.Tensor]:
def parse_mean_or_std(arg, default_value):
if arg is None:
return torch.Tensor([default_value] * 3)
elif len(arg) == 1:
return torch.Tensor(arg * 3)
elif len(arg) == 3:
return torch.Tensor(arg)
else:
raise NotImplementedError()
return {
'mean': parse_mean_or_std(args.mean, 0.45),
'std': parse_mean_or_std(args.std, 0.225),
}
def create_train_dataset(args: argparse.Namespace) -> torch.utils.data.Dataset:
if args.dummy_dataset:
return DummyDataset(
list_path=args.train_list_path,
num_frames=args.num_frames,
num_views=1,
spatial_size=args.spatial_size,
)
return VideoDataset(
list_path=args.train_list_path,
data_root=args.train_data_root or args.data_root,
num_spatial_views=1, num_temporal_views=1, random_sample=True,
auto_augment=args.auto_augment,
interpolation=args.interpolation,
mirror=args.mirror,
num_frames=args.num_frames,
sampling_rate=-1 if args.tsn_sampling else args.sampling_rate,
spatial_size=args.spatial_size,
**_parse_mean_and_std(args),
)
def create_train_loader(args: argparse.Namespace, resume_step: int = 0) -> torch.utils.data.DataLoader:
dataset = create_train_dataset(args)
rank, world_size = (0, 1) if not dist.is_initialized() else (dist.get_rank(), dist.get_world_size())
assert args.batch_size % world_size == 0
batch_size_per_gpu = args.batch_size // world_size
# manually create a step-based sampler
sampler = []
while len(sampler) * len(dataset) < args.num_steps * args.batch_size:
g = torch.Generator()
g.manual_seed(len(sampler))
indices = torch.randperm(len(dataset), generator=g)
sampler.append(indices)
sampler = torch.cat(sampler, dim=0)[:args.num_steps * args.batch_size].view(args.num_steps, args.batch_size)
sampler = sampler[resume_step:, batch_size_per_gpu * rank: batch_size_per_gpu * (rank + 1)].flatten().tolist()
loader = torch.utils.data.DataLoader(
dataset, sampler=sampler, batch_size=batch_size_per_gpu,
num_workers=args.num_workers, pin_memory=False, drop_last=True,
)
return loader
def create_val_dataset(args: argparse.Namespace) -> torch.utils.data.Dataset:
if args.dummy_dataset:
return DummyDataset(
list_path=args.val_list_path,
num_frames=args.num_frames,
num_views=args.num_spatial_views * args.num_temporal_views,
spatial_size=args.spatial_size,
)
return VideoDataset(
list_path=args.val_list_path,
data_root=args.val_data_root or args.data_root,
num_spatial_views=args.num_spatial_views,
num_temporal_views=args.num_temporal_views,
random_sample=False,
num_frames=args.num_frames,
sampling_rate=-1 if args.tsn_sampling else args.sampling_rate,
spatial_size=args.spatial_size,
**_parse_mean_and_std(args),
)
def create_val_loader(args: argparse.Namespace) -> torch.utils.data.Dataset:
dataset = create_val_dataset(args)
rank, world_size = (0, 1) if not dist.is_initialized() else (dist.get_rank(), dist.get_world_size())
# sampler for distribued eval
sampler = list(range(rank, len(dataset), world_size))
loader = torch.utils.data.DataLoader(
dataset, sampler=sampler, batch_size=1,
num_workers=args.num_workers, pin_memory=False,
)
return loader
| 6,717 | 41.518987 | 138 | py |
Vita-CLIP | Vita-CLIP-main/video_dataset/transform.py | #!/usr/bin/env python3
# Originate from: https://github.com/facebookresearch/SlowFast/blob/fee19d699c49a81f33b890c5ff592bbb11aa5c54/slowfast/datasets/transform.py
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
import logging
import math
import numpy as np
# import cv2
import random
import torch
import torchvision as tv
import torchvision.transforms.functional as F
from PIL import Image, ImageFilter
from torchvision import transforms
from .rand_augment import rand_augment_transform
from .random_erasing import RandomErasing
_pil_interpolation_to_str = {
Image.NEAREST: "PIL.Image.NEAREST",
Image.BILINEAR: "PIL.Image.BILINEAR",
Image.BICUBIC: "PIL.Image.BICUBIC",
Image.LANCZOS: "PIL.Image.LANCZOS",
Image.HAMMING: "PIL.Image.HAMMING",
Image.BOX: "PIL.Image.BOX",
}
_RANDOM_INTERPOLATION = (Image.BILINEAR, Image.BICUBIC)
def _pil_interp(method):
if method == "bicubic":
return Image.BICUBIC
elif method == "lanczos":
return Image.LANCZOS
elif method == "hamming":
return Image.HAMMING
else:
return Image.BILINEAR
logger = logging.getLogger(__name__)
def random_short_side_scale_jitter(
images, min_size, max_size, boxes=None, inverse_uniform_sampling=False
):
"""
Perform a spatial short scale jittering on the given images and
corresponding boxes.
Args:
images (tensor): images to perform scale jitter. Dimension is
`num frames` x `channel` x `height` x `width`.
min_size (int): the minimal size to scale the frames.
max_size (int): the maximal size to scale the frames.
boxes (ndarray): optional. Corresponding boxes to images.
Dimension is `num boxes` x 4.
inverse_uniform_sampling (bool): if True, sample uniformly in
[1 / max_scale, 1 / min_scale] and take a reciprocal to get the
scale. If False, take a uniform sample from [min_scale, max_scale].
Returns:
(tensor): the scaled images with dimension of
`num frames` x `channel` x `new height` x `new width`.
(ndarray or None): the scaled boxes with dimension of
`num boxes` x 4.
"""
if inverse_uniform_sampling:
size = int(
round(1.0 / np.random.uniform(1.0 / max_size, 1.0 / min_size))
)
else:
size = int(round(np.random.uniform(min_size, max_size)))
height = images.shape[2]
width = images.shape[3]
if (width <= height and width == size) or (
height <= width and height == size
):
return images, boxes
new_width = size
new_height = size
if width < height:
new_height = int(math.floor((float(height) / width) * size))
if boxes is not None:
boxes = boxes * float(new_height) / height
else:
new_width = int(math.floor((float(width) / height) * size))
if boxes is not None:
boxes = boxes * float(new_width) / width
return (
torch.nn.functional.interpolate(
images,
size=(new_height, new_width),
mode="bilinear",
align_corners=False,
),
boxes,
)
def crop_boxes(boxes, x_offset, y_offset):
"""
Peform crop on the bounding boxes given the offsets.
Args:
boxes (ndarray or None): bounding boxes to peform crop. The dimension
is `num boxes` x 4.
x_offset (int): cropping offset in the x axis.
y_offset (int): cropping offset in the y axis.
Returns:
cropped_boxes (ndarray or None): the cropped boxes with dimension of
`num boxes` x 4.
"""
cropped_boxes = boxes.copy()
cropped_boxes[:, [0, 2]] = boxes[:, [0, 2]] - x_offset
cropped_boxes[:, [1, 3]] = boxes[:, [1, 3]] - y_offset
return cropped_boxes
def random_crop(images, size, boxes=None):
"""
Perform random spatial crop on the given images and corresponding boxes.
Args:
images (tensor): images to perform random crop. The dimension is
`num frames` x `channel` x `height` x `width`.
size (int): the size of height and width to crop on the image.
boxes (ndarray or None): optional. Corresponding boxes to images.
Dimension is `num boxes` x 4.
Returns:
cropped (tensor): cropped images with dimension of
`num frames` x `channel` x `size` x `size`.
cropped_boxes (ndarray or None): the cropped boxes with dimension of
`num boxes` x 4.
"""
if images.shape[2] == size and images.shape[3] == size:
return images, boxes
height = images.shape[2]
width = images.shape[3]
y_offset = 0
if height > size:
y_offset = int(np.random.randint(0, height - size))
x_offset = 0
if width > size:
x_offset = int(np.random.randint(0, width - size))
cropped = images[
:, :, y_offset : y_offset + size, x_offset : x_offset + size
]
cropped_boxes = (
crop_boxes(boxes, x_offset, y_offset) if boxes is not None else None
)
return cropped, cropped_boxes
def horizontal_flip(prob, images, boxes=None):
"""
Perform horizontal flip on the given images and corresponding boxes.
Args:
prob (float): probility to flip the images.
images (tensor): images to perform horizontal flip, the dimension is
`num frames` x `channel` x `height` x `width`.
boxes (ndarray or None): optional. Corresponding boxes to images.
Dimension is `num boxes` x 4.
Returns:
images (tensor): images with dimension of
`num frames` x `channel` x `height` x `width`.
flipped_boxes (ndarray or None): the flipped boxes with dimension of
`num boxes` x 4.
"""
if boxes is None:
flipped_boxes = None
else:
flipped_boxes = boxes.copy()
if np.random.uniform() < prob:
images = images.flip((-1))
if len(images.shape) == 3:
width = images.shape[2]
elif len(images.shape) == 4:
width = images.shape[3]
else:
raise NotImplementedError("Dimension does not supported")
if boxes is not None:
flipped_boxes[:, [0, 2]] = width - boxes[:, [2, 0]] - 1
return images, flipped_boxes
def uniform_crop(images, size, spatial_idx, boxes=None, scale_size=None):
"""
Perform uniform spatial sampling on the images and corresponding boxes.
Args:
images (tensor): images to perform uniform crop. The dimension is
`num frames` x `channel` x `height` x `width`.
size (int): size of height and weight to crop the images.
spatial_idx (int): 0, 1, or 2 for left, center, and right crop if width
is larger than height. Or 0, 1, or 2 for top, center, and bottom
crop if height is larger than width.
boxes (ndarray or None): optional. Corresponding boxes to images.
Dimension is `num boxes` x 4.
scale_size (int): optinal. If not None, resize the images to scale_size before
performing any crop.
Returns:
cropped (tensor): images with dimension of
`num frames` x `channel` x `size` x `size`.
cropped_boxes (ndarray or None): the cropped boxes with dimension of
`num boxes` x 4.
"""
assert spatial_idx in [0, 1, 2]
ndim = len(images.shape)
if ndim == 3:
images = images.unsqueeze(0)
height = images.shape[2]
width = images.shape[3]
if scale_size is not None:
if width <= height:
width, height = scale_size, int(height / width * scale_size)
else:
width, height = int(width / height * scale_size), scale_size
images = torch.nn.functional.interpolate(
images,
size=(height, width),
mode="bilinear",
align_corners=False,
)
y_offset = int(math.ceil((height - size) / 2))
x_offset = int(math.ceil((width - size) / 2))
if height > width:
if spatial_idx == 0:
y_offset = 0
elif spatial_idx == 2:
y_offset = height - size
else:
if spatial_idx == 0:
x_offset = 0
elif spatial_idx == 2:
x_offset = width - size
cropped = images[
:, :, y_offset : y_offset + size, x_offset : x_offset + size
]
cropped_boxes = (
crop_boxes(boxes, x_offset, y_offset) if boxes is not None else None
)
if ndim == 3:
cropped = cropped.squeeze(0)
return cropped, cropped_boxes
def clip_boxes_to_image(boxes, height, width):
"""
Clip an array of boxes to an image with the given height and width.
Args:
boxes (ndarray): bounding boxes to perform clipping.
Dimension is `num boxes` x 4.
height (int): given image height.
width (int): given image width.
Returns:
clipped_boxes (ndarray): the clipped boxes with dimension of
`num boxes` x 4.
"""
clipped_boxes = boxes.copy()
clipped_boxes[:, [0, 2]] = np.minimum(
width - 1.0, np.maximum(0.0, boxes[:, [0, 2]])
)
clipped_boxes[:, [1, 3]] = np.minimum(
height - 1.0, np.maximum(0.0, boxes[:, [1, 3]])
)
return clipped_boxes
def blend(images1, images2, alpha):
"""
Blend two images with a given weight alpha.
Args:
images1 (tensor): the first images to be blended, the dimension is
`num frames` x `channel` x `height` x `width`.
images2 (tensor): the second images to be blended, the dimension is
`num frames` x `channel` x `height` x `width`.
alpha (float): the blending weight.
Returns:
(tensor): blended images, the dimension is
`num frames` x `channel` x `height` x `width`.
"""
return images1 * alpha + images2 * (1 - alpha)
def grayscale(images):
"""
Get the grayscale for the input images. The channels of images should be
in order BGR.
Args:
images (tensor): the input images for getting grayscale. Dimension is
`num frames` x `channel` x `height` x `width`.
Returns:
img_gray (tensor): blended images, the dimension is
`num frames` x `channel` x `height` x `width`.
"""
# R -> 0.299, G -> 0.587, B -> 0.114.
img_gray = torch.tensor(images)
gray_channel = (
0.299 * images[:, 2] + 0.587 * images[:, 1] + 0.114 * images[:, 0]
)
img_gray[:, 0] = gray_channel
img_gray[:, 1] = gray_channel
img_gray[:, 2] = gray_channel
return img_gray
def color_jitter(images, img_brightness=0, img_contrast=0, img_saturation=0):
"""
Perfrom a color jittering on the input images. The channels of images
should be in order BGR.
Args:
images (tensor): images to perform color jitter. Dimension is
`num frames` x `channel` x `height` x `width`.
img_brightness (float): jitter ratio for brightness.
img_contrast (float): jitter ratio for contrast.
img_saturation (float): jitter ratio for saturation.
Returns:
images (tensor): the jittered images, the dimension is
`num frames` x `channel` x `height` x `width`.
"""
jitter = []
if img_brightness != 0:
jitter.append("brightness")
if img_contrast != 0:
jitter.append("contrast")
if img_saturation != 0:
jitter.append("saturation")
if len(jitter) > 0:
order = np.random.permutation(np.arange(len(jitter)))
for idx in range(0, len(jitter)):
if jitter[order[idx]] == "brightness":
images = brightness_jitter(img_brightness, images)
elif jitter[order[idx]] == "contrast":
images = contrast_jitter(img_contrast, images)
elif jitter[order[idx]] == "saturation":
images = saturation_jitter(img_saturation, images)
return images
def brightness_jitter(var, images):
"""
Perfrom brightness jittering on the input images. The channels of images
should be in order BGR.
Args:
var (float): jitter ratio for brightness.
images (tensor): images to perform color jitter. Dimension is
`num frames` x `channel` x `height` x `width`.
Returns:
images (tensor): the jittered images, the dimension is
`num frames` x `channel` x `height` x `width`.
"""
alpha = 1.0 + np.random.uniform(-var, var)
img_bright = torch.zeros(images.shape)
images = blend(images, img_bright, alpha)
return images
def contrast_jitter(var, images):
"""
Perfrom contrast jittering on the input images. The channels of images
should be in order BGR.
Args:
var (float): jitter ratio for contrast.
images (tensor): images to perform color jitter. Dimension is
`num frames` x `channel` x `height` x `width`.
Returns:
images (tensor): the jittered images, the dimension is
`num frames` x `channel` x `height` x `width`.
"""
alpha = 1.0 + np.random.uniform(-var, var)
img_gray = grayscale(images)
img_gray[:] = torch.mean(img_gray, dim=(1, 2, 3), keepdim=True)
images = blend(images, img_gray, alpha)
return images
def saturation_jitter(var, images):
"""
Perfrom saturation jittering on the input images. The channels of images
should be in order BGR.
Args:
var (float): jitter ratio for saturation.
images (tensor): images to perform color jitter. Dimension is
`num frames` x `channel` x `height` x `width`.
Returns:
images (tensor): the jittered images, the dimension is
`num frames` x `channel` x `height` x `width`.
"""
alpha = 1.0 + np.random.uniform(-var, var)
img_gray = grayscale(images)
images = blend(images, img_gray, alpha)
return images
def lighting_jitter(images, alphastd, eigval, eigvec):
"""
Perform AlexNet-style PCA jitter on the given images.
Args:
images (tensor): images to perform lighting jitter. Dimension is
`num frames` x `channel` x `height` x `width`.
alphastd (float): jitter ratio for PCA jitter.
eigval (list): eigenvalues for PCA jitter.
eigvec (list[list]): eigenvectors for PCA jitter.
Returns:
out_images (tensor): the jittered images, the dimension is
`num frames` x `channel` x `height` x `width`.
"""
if alphastd == 0:
return images
# generate alpha1, alpha2, alpha3.
alpha = np.random.normal(0, alphastd, size=(1, 3))
eig_vec = np.array(eigvec)
eig_val = np.reshape(eigval, (1, 3))
rgb = np.sum(
eig_vec * np.repeat(alpha, 3, axis=0) * np.repeat(eig_val, 3, axis=0),
axis=1,
)
out_images = torch.zeros_like(images)
if len(images.shape) == 3:
# C H W
channel_dim = 0
elif len(images.shape) == 4:
# T C H W
channel_dim = 1
else:
raise NotImplementedError(f"Unsupported dimension {len(images.shape)}")
for idx in range(images.shape[channel_dim]):
# C H W
if len(images.shape) == 3:
out_images[idx] = images[idx] + rgb[2 - idx]
# T C H W
elif len(images.shape) == 4:
out_images[:, idx] = images[:, idx] + rgb[2 - idx]
else:
raise NotImplementedError(
f"Unsupported dimension {len(images.shape)}"
)
return out_images
def color_normalization(images, mean, stddev):
"""
Perform color nomration on the given images.
Args:
images (tensor): images to perform color normalization. Dimension is
`num frames` x `channel` x `height` x `width`.
mean (list): mean values for normalization.
stddev (list): standard deviations for normalization.
Returns:
out_images (tensor): the noramlized images, the dimension is
`num frames` x `channel` x `height` x `width`.
"""
if len(images.shape) == 3:
assert (
len(mean) == images.shape[0]
), "channel mean not computed properly"
assert (
len(stddev) == images.shape[0]
), "channel stddev not computed properly"
elif len(images.shape) == 4:
assert (
len(mean) == images.shape[1]
), "channel mean not computed properly"
assert (
len(stddev) == images.shape[1]
), "channel stddev not computed properly"
else:
raise NotImplementedError(f"Unsupported dimension {len(images.shape)}")
out_images = torch.zeros_like(images)
for idx in range(len(mean)):
# C H W
if len(images.shape) == 3:
out_images[idx] = (images[idx] - mean[idx]) / stddev[idx]
elif len(images.shape) == 4:
out_images[:, idx] = (images[:, idx] - mean[idx]) / stddev[idx]
else:
raise NotImplementedError(
f"Unsupported dimension {len(images.shape)}"
)
return out_images
def _get_param_spatial_crop(
scale, ratio, height, width, num_repeat=10, log_scale=True, switch_hw=False
):
"""
Given scale, ratio, height and width, return sampled coordinates of the videos.
"""
for _ in range(num_repeat):
area = height * width
target_area = random.uniform(*scale) * area
if log_scale:
log_ratio = (math.log(ratio[0]), math.log(ratio[1]))
aspect_ratio = math.exp(random.uniform(*log_ratio))
else:
aspect_ratio = random.uniform(*ratio)
w = int(round(math.sqrt(target_area * aspect_ratio)))
h = int(round(math.sqrt(target_area / aspect_ratio)))
if np.random.uniform() < 0.5 and switch_hw:
w, h = h, w
if 0 < w <= width and 0 < h <= height:
i = random.randint(0, height - h)
j = random.randint(0, width - w)
return i, j, h, w
# Fallback to central crop
in_ratio = float(width) / float(height)
if in_ratio < min(ratio):
w = width
h = int(round(w / min(ratio)))
elif in_ratio > max(ratio):
h = height
w = int(round(h * max(ratio)))
else: # whole image
w = width
h = height
i = (height - h) // 2
j = (width - w) // 2
return i, j, h, w
def random_resized_crop(
images,
target_height,
target_width,
scale=(0.08, 1.0),
ratio=(3.0 / 4.0, 4.0 / 3.0),
):
"""
Crop the given images to random size and aspect ratio. A crop of random
size (default: of 0.08 to 1.0) of the original size and a random aspect
ratio (default: of 3/4 to 4/3) of the original aspect ratio is made. This
crop is finally resized to given size. This is popularly used to train the
Inception networks.
Args:
images: Images to perform resizing and cropping.
target_height: Desired height after cropping.
target_width: Desired width after cropping.
scale: Scale range of Inception-style area based random resizing.
ratio: Aspect ratio range of Inception-style area based random resizing.
"""
height = images.shape[2]
width = images.shape[3]
i, j, h, w = _get_param_spatial_crop(scale, ratio, height, width)
cropped = images[:, :, i : i + h, j : j + w]
return torch.nn.functional.interpolate(
cropped,
size=(target_height, target_width),
mode="bilinear",
align_corners=False,
)
def random_resized_crop_with_shift(
images,
target_height,
target_width,
scale=(0.8, 1.0),
ratio=(3.0 / 4.0, 4.0 / 3.0),
):
"""
This is similar to random_resized_crop. However, it samples two different
boxes (for cropping) for the first and last frame. It then linearly
interpolates the two boxes for other frames.
Args:
images: Images to perform resizing and cropping.
target_height: Desired height after cropping.
target_width: Desired width after cropping.
scale: Scale range of Inception-style area based random resizing.
ratio: Aspect ratio range of Inception-style area based random resizing.
"""
t = images.shape[1]
height = images.shape[2]
width = images.shape[3]
i, j, h, w = _get_param_spatial_crop(scale, ratio, height, width)
i_, j_, h_, w_ = _get_param_spatial_crop(scale, ratio, height, width)
i_s = [int(i) for i in torch.linspace(i, i_, steps=t).tolist()]
j_s = [int(i) for i in torch.linspace(j, j_, steps=t).tolist()]
h_s = [int(i) for i in torch.linspace(h, h_, steps=t).tolist()]
w_s = [int(i) for i in torch.linspace(w, w_, steps=t).tolist()]
out = torch.zeros((3, t, target_height, target_width))
for ind in range(t):
out[:, ind : ind + 1, :, :] = torch.nn.functional.interpolate(
images[
:,
ind : ind + 1,
i_s[ind] : i_s[ind] + h_s[ind],
j_s[ind] : j_s[ind] + w_s[ind],
],
size=(target_height, target_width),
mode="bilinear",
align_corners=False,
)
return out
def create_random_augment(
input_size,
auto_augment=None,
interpolation="bilinear",
):
"""
Get video randaug transform.
Args:
input_size: The size of the input video in tuple.
auto_augment: Parameters for randaug. An example:
"rand-m7-n4-mstd0.5-inc1" (m is the magnitude and n is the number
of operations to apply).
interpolation: Interpolation method.
"""
if isinstance(input_size, tuple):
img_size = input_size[-2:]
else:
img_size = input_size
if auto_augment:
assert isinstance(auto_augment, str)
if isinstance(img_size, tuple):
img_size_min = min(img_size)
else:
img_size_min = img_size
aa_params = {"translate_const": int(img_size_min * 0.45)}
if interpolation and interpolation != "random":
aa_params["interpolation"] = _pil_interp(interpolation)
if auto_augment.startswith("rand"):
return transforms.Compose(
[rand_augment_transform(auto_augment, aa_params)]
)
raise NotImplementedError
def random_sized_crop_img(
im,
size,
jitter_scale=(0.08, 1.0),
jitter_aspect=(3.0 / 4.0, 4.0 / 3.0),
max_iter=10,
):
"""
Performs Inception-style cropping (used for training).
"""
assert (
len(im.shape) == 3
), "Currently only support image for random_sized_crop"
h, w = im.shape[1:3]
i, j, h, w = _get_param_spatial_crop(
scale=jitter_scale,
ratio=jitter_aspect,
height=h,
width=w,
num_repeat=max_iter,
log_scale=False,
switch_hw=True,
)
cropped = im[:, i : i + h, j : j + w]
return torch.nn.functional.interpolate(
cropped.unsqueeze(0),
size=(size, size),
mode="bilinear",
align_corners=False,
).squeeze(0)
# The following code are modified based on timm lib, we will replace the following
# contents with dependency from PyTorchVideo.
# https://github.com/facebookresearch/pytorchvideo
class RandomResizedCropAndInterpolation:
"""Crop the given PIL Image to random size and aspect ratio with random interpolation.
A crop of random size (default: of 0.08 to 1.0) of the original size and a random
aspect ratio (default: of 3/4 to 4/3) of the original aspect ratio is made. This crop
is finally resized to given size.
This is popularly used to train the Inception networks.
Args:
size: expected output size of each edge
scale: range of size of the origin size cropped
ratio: range of aspect ratio of the origin aspect ratio cropped
interpolation: Default: PIL.Image.BILINEAR
"""
def __init__(
self,
size,
scale=(0.08, 1.0),
ratio=(3.0 / 4.0, 4.0 / 3.0),
interpolation="bilinear",
):
if isinstance(size, tuple):
self.size = size
else:
self.size = (size, size)
if (scale[0] > scale[1]) or (ratio[0] > ratio[1]):
print("range should be of kind (min, max)")
if interpolation == "random":
self.interpolation = _RANDOM_INTERPOLATION
else:
self.interpolation = _pil_interp(interpolation)
self.scale = scale
self.ratio = ratio
@staticmethod
def get_params(img, scale, ratio):
"""Get parameters for ``crop`` for a random sized crop.
Args:
img (PIL Image): Image to be cropped.
scale (tuple): range of size of the origin size cropped
ratio (tuple): range of aspect ratio of the origin aspect ratio cropped
Returns:
tuple: params (i, j, h, w) to be passed to ``crop`` for a random
sized crop.
"""
area = img.size[0] * img.size[1]
for _ in range(10):
target_area = random.uniform(*scale) * area
log_ratio = (math.log(ratio[0]), math.log(ratio[1]))
aspect_ratio = math.exp(random.uniform(*log_ratio))
w = int(round(math.sqrt(target_area * aspect_ratio)))
h = int(round(math.sqrt(target_area / aspect_ratio)))
if w <= img.size[0] and h <= img.size[1]:
i = random.randint(0, img.size[1] - h)
j = random.randint(0, img.size[0] - w)
return i, j, h, w
# Fallback to central crop
in_ratio = img.size[0] / img.size[1]
if in_ratio < min(ratio):
w = img.size[0]
h = int(round(w / min(ratio)))
elif in_ratio > max(ratio):
h = img.size[1]
w = int(round(h * max(ratio)))
else: # whole image
w = img.size[0]
h = img.size[1]
i = (img.size[1] - h) // 2
j = (img.size[0] - w) // 2
return i, j, h, w
def __call__(self, img):
"""
Args:
img (PIL Image): Image to be cropped and resized.
Returns:
PIL Image: Randomly cropped and resized image.
"""
i, j, h, w = self.get_params(img, self.scale, self.ratio)
if isinstance(self.interpolation, (tuple, list)):
interpolation = random.choice(self.interpolation)
else:
interpolation = self.interpolation
return F.resized_crop(img, i, j, h, w, self.size, interpolation)
def __repr__(self):
if isinstance(self.interpolation, (tuple, list)):
interpolate_str = " ".join(
[_pil_interpolation_to_str[x] for x in self.interpolation]
)
else:
interpolate_str = _pil_interpolation_to_str[self.interpolation]
format_string = self.__class__.__name__ + "(size={0}".format(self.size)
format_string += ", scale={0}".format(
tuple(round(s, 4) for s in self.scale)
)
format_string += ", ratio={0}".format(
tuple(round(r, 4) for r in self.ratio)
)
format_string += ", interpolation={0})".format(interpolate_str)
return format_string
| 27,344 | 33.18125 | 139 | py |
Vita-CLIP | Vita-CLIP-main/video_dataset/dataset.py | #!/usr/bin/env python
import os, sys
from typing import Optional
import av
import io
import numpy as np
import torch
from torchvision import transforms
from .transform import create_random_augment, random_resized_crop
class VideoDataset(torch.utils.data.Dataset):
def __init__(
self, list_path: str, data_root: str,
num_spatial_views: int, num_temporal_views: int, random_sample: bool,
num_frames: int, sampling_rate: int, spatial_size: int,
mean: torch.Tensor, std: torch.Tensor,
auto_augment: Optional[str] = None, interpolation: str = 'bicubic',
mirror: bool = False,
):
self.data_root = data_root
self.interpolation = interpolation
self.spatial_size = spatial_size
self.mean, self.std = mean, std
self.num_frames, self.sampling_rate = num_frames, sampling_rate
if random_sample:
assert num_spatial_views == 1 and num_temporal_views == 1
self.random_sample = True
self.mirror = mirror
self.auto_augment = auto_augment
else:
assert auto_augment is None and not mirror
self.random_sample = False
self.num_temporal_views = num_temporal_views
self.num_spatial_views = num_spatial_views
with open(list_path) as f:
self.data_list = f.read().splitlines()
def __len__(self):
return len(self.data_list)
def __getitem__(self, idx):
line = self.data_list[idx]
path, label = line.split(',')
path = os.path.join(self.data_root, path)
label = int(label)
container = av.open(path)
frames = {}
for frame in container.decode(video=0):
frames[frame.pts] = frame
container.close()
frames = [frames[k] for k in sorted(frames.keys())]
if self.random_sample:
frame_idx = self._random_sample_frame_idx(len(frames))
frames = [frames[x].to_rgb().to_ndarray() for x in frame_idx]
frames = torch.as_tensor(np.stack(frames)).float() / 255.
if self.auto_augment is not None:
aug_transform = create_random_augment(
input_size=(frames.size(1), frames.size(2)),
auto_augment=self.auto_augment,
interpolation=self.interpolation,
)
frames = frames.permute(0, 3, 1, 2) # T, C, H, W
frames = [transforms.ToPILImage()(frames[i]) for i in range(frames.size(0))]
frames = aug_transform(frames)
frames = torch.stack([transforms.ToTensor()(img) for img in frames])
frames = frames.permute(0, 2, 3, 1)
frames = (frames - self.mean) / self.std
frames = frames.permute(3, 0, 1, 2) # C, T, H, W
frames = random_resized_crop(
frames, self.spatial_size, self.spatial_size,
)
else:
frames = [x.to_rgb().to_ndarray() for x in frames]
frames = torch.as_tensor(np.stack(frames))
frames = frames.float() / 255.
frames = (frames - self.mean) / self.std
frames = frames.permute(3, 0, 1, 2) # C, T, H, W
if frames.size(-2) < frames.size(-1):
new_width = frames.size(-1) * self.spatial_size // frames.size(-2)
new_height = self.spatial_size
else:
new_height = frames.size(-2) * self.spatial_size // frames.size(-1)
new_width = self.spatial_size
frames = torch.nn.functional.interpolate(
frames, size=(new_height, new_width),
mode='bilinear', align_corners=False,
)
frames = self._generate_spatial_crops(frames)
frames = sum([self._generate_temporal_crops(x) for x in frames], [])
if len(frames) > 1:
frames = torch.stack(frames)
return frames, label
def _generate_temporal_crops(self, frames):
seg_len = (self.num_frames - 1) * self.sampling_rate + 1
if frames.size(1) < seg_len:
frames = torch.cat([frames, frames[:, -1:].repeat(1, seg_len - frames.size(1), 1, 1)], dim=1)
slide_len = frames.size(1) - seg_len
crops = []
for i in range(self.num_temporal_views):
if self.num_temporal_views == 1:
st = slide_len // 2
else:
st = round(slide_len / (self.num_temporal_views - 1) * i)
crops.append(frames[:, st: st + self.num_frames * self.sampling_rate: self.sampling_rate])
return crops
def _generate_spatial_crops(self, frames):
if self.num_spatial_views == 1:
assert min(frames.size(-2), frames.size(-1)) >= self.spatial_size
h_st = (frames.size(-2) - self.spatial_size) // 2
w_st = (frames.size(-1) - self.spatial_size) // 2
h_ed, w_ed = h_st + self.spatial_size, w_st + self.spatial_size
return [frames[:, :, h_st: h_ed, w_st: w_ed]]
elif self.num_spatial_views == 3:
assert min(frames.size(-2), frames.size(-1)) == self.spatial_size
crops = []
margin = max(frames.size(-2), frames.size(-1)) - self.spatial_size
for st in (0, margin // 2, margin):
ed = st + self.spatial_size
if frames.size(-2) > frames.size(-1):
crops.append(frames[:, :, st: ed, :])
else:
crops.append(frames[:, :, :, st: ed])
return crops
else:
raise NotImplementedError()
def _random_sample_frame_idx(self, len):
frame_indices = []
if self.sampling_rate < 0: # tsn sample
seg_size = (len - 1) / self.num_frames
for i in range(self.num_frames):
start, end = round(seg_size * i), round(seg_size * (i + 1))
frame_indices.append(np.random.randint(start, end + 1))
elif self.sampling_rate * (self.num_frames - 1) + 1 >= len:
for i in range(self.num_frames):
frame_indices.append(i * self.sampling_rate if i * self.sampling_rate < len else frame_indices[-1])
else:
start = np.random.randint(len - self.sampling_rate * (self.num_frames - 1))
frame_indices = list(range(start, start + self.sampling_rate * self.num_frames, self.sampling_rate))
return frame_indices
class DummyDataset(torch.utils.data.Dataset):
def __init__(self, list_path: str, num_frames: int, num_views: int, spatial_size: int):
with open(list_path) as f:
self.len = len(f.read().splitlines())
self.num_frames = num_frames
self.num_views = num_views
self.spatial_size = spatial_size
def __len__(self):
return self.len
def __getitem__(self, _):
shape = [3, self.num_frames, self.spatial_size, self.spatial_size]
if self.num_views != 1:
shape = [self.num_views] + shape
return torch.zeros(shape), 0
| 7,185 | 36.821053 | 115 | py |
Vita-CLIP | Vita-CLIP-main/video_dataset/random_erasing.py | #!/usr/bin/env python
# Originates from: https://github.com/facebookresearch/SlowFast/blob/fee19d699c49a81f33b890c5ff592bbb11aa5c54/slowfast/datasets/random_erasing.py
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
"""
This implementation is based on
https://github.com/rwightman/pytorch-image-models/blob/master/timm/data/random_erasing.py
pulished under an Apache License 2.0.
COMMENT FROM ORIGINAL:
Originally inspired by impl at https://github.com/zhunzhong07/Random-Erasing, Apache 2.0
Copyright Zhun Zhong & Liang Zheng
Hacked together by / Copyright 2020 Ross Wightman
"""
import math
import random
import torch
def _get_pixels(
per_pixel, rand_color, patch_size, dtype=torch.float32, device="cuda"
):
# NOTE I've seen CUDA illegal memory access errors being caused by the normal_()
# paths, flip the order so normal is run on CPU if this becomes a problem
# Issue has been fixed in master https://github.com/pytorch/pytorch/issues/19508
if per_pixel:
return torch.empty(patch_size, dtype=dtype, device=device).normal_()
elif rand_color:
return torch.empty(
(patch_size[0], 1, 1), dtype=dtype, device=device
).normal_()
else:
return torch.zeros((patch_size[0], 1, 1), dtype=dtype, device=device)
class RandomErasing:
"""Randomly selects a rectangle region in an image and erases its pixels.
'Random Erasing Data Augmentation' by Zhong et al.
See https://arxiv.org/pdf/1708.04896.pdf
This variant of RandomErasing is intended to be applied to either a batch
or single image tensor after it has been normalized by dataset mean and std.
Args:
probability: Probability that the Random Erasing operation will be performed.
min_area: Minimum percentage of erased area wrt input image area.
max_area: Maximum percentage of erased area wrt input image area.
min_aspect: Minimum aspect ratio of erased area.
mode: pixel color mode, one of 'const', 'rand', or 'pixel'
'const' - erase block is constant color of 0 for all channels
'rand' - erase block is same per-channel random (normal) color
'pixel' - erase block is per-pixel random (normal) color
max_count: maximum number of erasing blocks per image, area per box is scaled by count.
per-image count is randomly chosen between 1 and this value.
"""
def __init__(
self,
probability=0.5,
min_area=0.02,
max_area=1 / 3,
min_aspect=0.3,
max_aspect=None,
mode="const",
min_count=1,
max_count=None,
num_splits=0,
device="cuda",
cube=True,
):
self.probability = probability
self.min_area = min_area
self.max_area = max_area
max_aspect = max_aspect or 1 / min_aspect
self.log_aspect_ratio = (math.log(min_aspect), math.log(max_aspect))
self.min_count = min_count
self.max_count = max_count or min_count
self.num_splits = num_splits
mode = mode.lower()
self.rand_color = False
self.per_pixel = False
self.cube = cube
if mode == "rand":
self.rand_color = True # per block random normal
elif mode == "pixel":
self.per_pixel = True # per pixel random normal
else:
assert not mode or mode == "const"
self.device = device
def _erase(self, img, chan, img_h, img_w, dtype):
if random.random() > self.probability:
return
area = img_h * img_w
count = (
self.min_count
if self.min_count == self.max_count
else random.randint(self.min_count, self.max_count)
)
for _ in range(count):
for _ in range(10):
target_area = (
random.uniform(self.min_area, self.max_area) * area / count
)
aspect_ratio = math.exp(random.uniform(*self.log_aspect_ratio))
h = int(round(math.sqrt(target_area * aspect_ratio)))
w = int(round(math.sqrt(target_area / aspect_ratio)))
if w < img_w and h < img_h:
top = random.randint(0, img_h - h)
left = random.randint(0, img_w - w)
img[:, top : top + h, left : left + w] = _get_pixels(
self.per_pixel,
self.rand_color,
(chan, h, w),
dtype=dtype,
device=self.device,
)
break
def _erase_cube(
self,
img,
batch_start,
batch_size,
chan,
img_h,
img_w,
dtype,
):
if random.random() > self.probability:
return
area = img_h * img_w
count = (
self.min_count
if self.min_count == self.max_count
else random.randint(self.min_count, self.max_count)
)
for _ in range(count):
for _ in range(100):
target_area = (
random.uniform(self.min_area, self.max_area) * area / count
)
aspect_ratio = math.exp(random.uniform(*self.log_aspect_ratio))
h = int(round(math.sqrt(target_area * aspect_ratio)))
w = int(round(math.sqrt(target_area / aspect_ratio)))
if w < img_w and h < img_h:
top = random.randint(0, img_h - h)
left = random.randint(0, img_w - w)
for i in range(batch_start, batch_size):
img_instance = img[i]
img_instance[
:, top : top + h, left : left + w
] = _get_pixels(
self.per_pixel,
self.rand_color,
(chan, h, w),
dtype=dtype,
device=self.device,
)
break
def __call__(self, input):
if len(input.size()) == 3:
self._erase(input, *input.size(), input.dtype)
else:
batch_size, chan, img_h, img_w = input.size()
# skip first slice of batch if num_splits is set (for clean portion of samples)
batch_start = (
batch_size // self.num_splits if self.num_splits > 1 else 0
)
if self.cube:
self._erase_cube(
input,
batch_start,
batch_size,
chan,
img_h,
img_w,
input.dtype,
)
else:
for i in range(batch_start, batch_size):
self._erase(input[i], chan, img_h, img_w, input.dtype)
return input
| 7,056 | 37.353261 | 145 | py |
Vita-CLIP | Vita-CLIP-main/video_dataset/rand_augment.py | #!/usr/bin/env python
# Originates from: https://github.com/facebookresearch/SlowFast/blob/fee19d699c49a81f33b890c5ff592bbb11aa5c54/slowfast/datasets/rand_augment.py
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
"""
This implementation is based on
https://github.com/rwightman/pytorch-image-models/blob/master/timm/data/auto_augment.py
pulished under an Apache License 2.0.
COMMENT FROM ORIGINAL:
AutoAugment, RandAugment, and AugMix for PyTorch
This code implements the searched ImageNet policies with various tweaks and
improvements and does not include any of the search code. AA and RA
Implementation adapted from:
https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py
AugMix adapted from:
https://github.com/google-research/augmix
Papers:
AutoAugment: Learning Augmentation Policies from Data
https://arxiv.org/abs/1805.09501
Learning Data Augmentation Strategies for Object Detection
https://arxiv.org/abs/1906.11172
RandAugment: Practical automated data augmentation...
https://arxiv.org/abs/1909.13719
AugMix: A Simple Data Processing Method to Improve Robustness and
Uncertainty https://arxiv.org/abs/1912.02781
Hacked together by / Copyright 2020 Ross Wightman
"""
import math
import numpy as np
import random
import re
import PIL
from PIL import Image, ImageEnhance, ImageOps
_PIL_VER = tuple([int(x) for x in PIL.__version__.split(".")[:2]])
_FILL = (128, 128, 128)
# This signifies the max integer that the controller RNN could predict for the
# augmentation scheme.
_MAX_LEVEL = 10.0
_HPARAMS_DEFAULT = {
"translate_const": 250,
"img_mean": _FILL,
}
_RANDOM_INTERPOLATION = (Image.BILINEAR, Image.BICUBIC)
def _interpolation(kwargs):
interpolation = kwargs.pop("resample", Image.BILINEAR)
if isinstance(interpolation, (list, tuple)):
return random.choice(interpolation)
else:
return interpolation
def _check_args_tf(kwargs):
if "fillcolor" in kwargs and _PIL_VER < (5, 0):
kwargs.pop("fillcolor")
kwargs["resample"] = _interpolation(kwargs)
def shear_x(img, factor, **kwargs):
_check_args_tf(kwargs)
return img.transform(
img.size, Image.AFFINE, (1, factor, 0, 0, 1, 0), **kwargs
)
def shear_y(img, factor, **kwargs):
_check_args_tf(kwargs)
return img.transform(
img.size, Image.AFFINE, (1, 0, 0, factor, 1, 0), **kwargs
)
def translate_x_rel(img, pct, **kwargs):
pixels = pct * img.size[0]
_check_args_tf(kwargs)
return img.transform(
img.size, Image.AFFINE, (1, 0, pixels, 0, 1, 0), **kwargs
)
def translate_y_rel(img, pct, **kwargs):
pixels = pct * img.size[1]
_check_args_tf(kwargs)
return img.transform(
img.size, Image.AFFINE, (1, 0, 0, 0, 1, pixels), **kwargs
)
def translate_x_abs(img, pixels, **kwargs):
_check_args_tf(kwargs)
return img.transform(
img.size, Image.AFFINE, (1, 0, pixels, 0, 1, 0), **kwargs
)
def translate_y_abs(img, pixels, **kwargs):
_check_args_tf(kwargs)
return img.transform(
img.size, Image.AFFINE, (1, 0, 0, 0, 1, pixels), **kwargs
)
def rotate(img, degrees, **kwargs):
_check_args_tf(kwargs)
if _PIL_VER >= (5, 2):
return img.rotate(degrees, **kwargs)
elif _PIL_VER >= (5, 0):
w, h = img.size
post_trans = (0, 0)
rotn_center = (w / 2.0, h / 2.0)
angle = -math.radians(degrees)
matrix = [
round(math.cos(angle), 15),
round(math.sin(angle), 15),
0.0,
round(-math.sin(angle), 15),
round(math.cos(angle), 15),
0.0,
]
def transform(x, y, matrix):
(a, b, c, d, e, f) = matrix
return a * x + b * y + c, d * x + e * y + f
matrix[2], matrix[5] = transform(
-rotn_center[0] - post_trans[0],
-rotn_center[1] - post_trans[1],
matrix,
)
matrix[2] += rotn_center[0]
matrix[5] += rotn_center[1]
return img.transform(img.size, Image.AFFINE, matrix, **kwargs)
else:
return img.rotate(degrees, resample=kwargs["resample"])
def auto_contrast(img, **__):
return ImageOps.autocontrast(img)
def invert(img, **__):
return ImageOps.invert(img)
def equalize(img, **__):
return ImageOps.equalize(img)
def solarize(img, thresh, **__):
return ImageOps.solarize(img, thresh)
def solarize_add(img, add, thresh=128, **__):
lut = []
for i in range(256):
if i < thresh:
lut.append(min(255, i + add))
else:
lut.append(i)
if img.mode in ("L", "RGB"):
if img.mode == "RGB" and len(lut) == 256:
lut = lut + lut + lut
return img.point(lut)
else:
return img
def posterize(img, bits_to_keep, **__):
if bits_to_keep >= 8:
return img
return ImageOps.posterize(img, bits_to_keep)
def contrast(img, factor, **__):
return ImageEnhance.Contrast(img).enhance(factor)
def color(img, factor, **__):
return ImageEnhance.Color(img).enhance(factor)
def brightness(img, factor, **__):
return ImageEnhance.Brightness(img).enhance(factor)
def sharpness(img, factor, **__):
return ImageEnhance.Sharpness(img).enhance(factor)
def _randomly_negate(v):
"""With 50% prob, negate the value"""
return -v if random.random() > 0.5 else v
def _rotate_level_to_arg(level, _hparams):
# range [-30, 30]
level = (level / _MAX_LEVEL) * 30.0
level = _randomly_negate(level)
return (level,)
def _enhance_level_to_arg(level, _hparams):
# range [0.1, 1.9]
return ((level / _MAX_LEVEL) * 1.8 + 0.1,)
def _enhance_increasing_level_to_arg(level, _hparams):
# the 'no change' level is 1.0, moving away from that towards 0. or 2.0 increases the enhancement blend
# range [0.1, 1.9]
level = (level / _MAX_LEVEL) * 0.9
level = 1.0 + _randomly_negate(level)
return (level,)
def _shear_level_to_arg(level, _hparams):
# range [-0.3, 0.3]
level = (level / _MAX_LEVEL) * 0.3
level = _randomly_negate(level)
return (level,)
def _translate_abs_level_to_arg(level, hparams):
translate_const = hparams["translate_const"]
level = (level / _MAX_LEVEL) * float(translate_const)
level = _randomly_negate(level)
return (level,)
def _translate_rel_level_to_arg(level, hparams):
# default range [-0.45, 0.45]
translate_pct = hparams.get("translate_pct", 0.45)
level = (level / _MAX_LEVEL) * translate_pct
level = _randomly_negate(level)
return (level,)
def _posterize_level_to_arg(level, _hparams):
# As per Tensorflow TPU EfficientNet impl
# range [0, 4], 'keep 0 up to 4 MSB of original image'
# intensity/severity of augmentation decreases with level
return (int((level / _MAX_LEVEL) * 4),)
def _posterize_increasing_level_to_arg(level, hparams):
# As per Tensorflow models research and UDA impl
# range [4, 0], 'keep 4 down to 0 MSB of original image',
# intensity/severity of augmentation increases with level
return (4 - _posterize_level_to_arg(level, hparams)[0],)
def _posterize_original_level_to_arg(level, _hparams):
# As per original AutoAugment paper description
# range [4, 8], 'keep 4 up to 8 MSB of image'
# intensity/severity of augmentation decreases with level
return (int((level / _MAX_LEVEL) * 4) + 4,)
def _solarize_level_to_arg(level, _hparams):
# range [0, 256]
# intensity/severity of augmentation decreases with level
return (int((level / _MAX_LEVEL) * 256),)
def _solarize_increasing_level_to_arg(level, _hparams):
# range [0, 256]
# intensity/severity of augmentation increases with level
return (256 - _solarize_level_to_arg(level, _hparams)[0],)
def _solarize_add_level_to_arg(level, _hparams):
# range [0, 110]
return (int((level / _MAX_LEVEL) * 110),)
LEVEL_TO_ARG = {
"AutoContrast": None,
"Equalize": None,
"Invert": None,
"Rotate": _rotate_level_to_arg,
# There are several variations of the posterize level scaling in various Tensorflow/Google repositories/papers
"Posterize": _posterize_level_to_arg,
"PosterizeIncreasing": _posterize_increasing_level_to_arg,
"PosterizeOriginal": _posterize_original_level_to_arg,
"Solarize": _solarize_level_to_arg,
"SolarizeIncreasing": _solarize_increasing_level_to_arg,
"SolarizeAdd": _solarize_add_level_to_arg,
"Color": _enhance_level_to_arg,
"ColorIncreasing": _enhance_increasing_level_to_arg,
"Contrast": _enhance_level_to_arg,
"ContrastIncreasing": _enhance_increasing_level_to_arg,
"Brightness": _enhance_level_to_arg,
"BrightnessIncreasing": _enhance_increasing_level_to_arg,
"Sharpness": _enhance_level_to_arg,
"SharpnessIncreasing": _enhance_increasing_level_to_arg,
"ShearX": _shear_level_to_arg,
"ShearY": _shear_level_to_arg,
"TranslateX": _translate_abs_level_to_arg,
"TranslateY": _translate_abs_level_to_arg,
"TranslateXRel": _translate_rel_level_to_arg,
"TranslateYRel": _translate_rel_level_to_arg,
}
NAME_TO_OP = {
"AutoContrast": auto_contrast,
"Equalize": equalize,
"Invert": invert,
"Rotate": rotate,
"Posterize": posterize,
"PosterizeIncreasing": posterize,
"PosterizeOriginal": posterize,
"Solarize": solarize,
"SolarizeIncreasing": solarize,
"SolarizeAdd": solarize_add,
"Color": color,
"ColorIncreasing": color,
"Contrast": contrast,
"ContrastIncreasing": contrast,
"Brightness": brightness,
"BrightnessIncreasing": brightness,
"Sharpness": sharpness,
"SharpnessIncreasing": sharpness,
"ShearX": shear_x,
"ShearY": shear_y,
"TranslateX": translate_x_abs,
"TranslateY": translate_y_abs,
"TranslateXRel": translate_x_rel,
"TranslateYRel": translate_y_rel,
}
class AugmentOp:
"""
Apply for video.
"""
def __init__(self, name, prob=0.5, magnitude=10, hparams=None):
hparams = hparams or _HPARAMS_DEFAULT
self.aug_fn = NAME_TO_OP[name]
self.level_fn = LEVEL_TO_ARG[name]
self.prob = prob
self.magnitude = magnitude
self.hparams = hparams.copy()
self.kwargs = {
"fillcolor": hparams["img_mean"]
if "img_mean" in hparams
else _FILL,
"resample": hparams["interpolation"]
if "interpolation" in hparams
else _RANDOM_INTERPOLATION,
}
# If magnitude_std is > 0, we introduce some randomness
# in the usually fixed policy and sample magnitude from a normal distribution
# with mean `magnitude` and std-dev of `magnitude_std`.
# NOTE This is my own hack, being tested, not in papers or reference impls.
self.magnitude_std = self.hparams.get("magnitude_std", 0)
def __call__(self, img_list):
if self.prob < 1.0 and random.random() > self.prob:
return img_list
magnitude = self.magnitude
if self.magnitude_std and self.magnitude_std > 0:
magnitude = random.gauss(magnitude, self.magnitude_std)
magnitude = min(_MAX_LEVEL, max(0, magnitude)) # clip to valid range
level_args = (
self.level_fn(magnitude, self.hparams)
if self.level_fn is not None
else ()
)
if isinstance(img_list, list):
return [
self.aug_fn(img, *level_args, **self.kwargs) for img in img_list
]
else:
return self.aug_fn(img_list, *level_args, **self.kwargs)
_RAND_TRANSFORMS = [
"AutoContrast",
"Equalize",
"Invert",
"Rotate",
"Posterize",
"Solarize",
"SolarizeAdd",
"Color",
"Contrast",
"Brightness",
"Sharpness",
"ShearX",
"ShearY",
"TranslateXRel",
"TranslateYRel",
]
_RAND_INCREASING_TRANSFORMS = [
"AutoContrast",
"Equalize",
"Invert",
"Rotate",
"PosterizeIncreasing",
"SolarizeIncreasing",
"SolarizeAdd",
"ColorIncreasing",
"ContrastIncreasing",
"BrightnessIncreasing",
"SharpnessIncreasing",
"ShearX",
"ShearY",
"TranslateXRel",
"TranslateYRel",
]
# These experimental weights are based loosely on the relative improvements mentioned in paper.
# They may not result in increased performance, but could likely be tuned to so.
_RAND_CHOICE_WEIGHTS_0 = {
"Rotate": 0.3,
"ShearX": 0.2,
"ShearY": 0.2,
"TranslateXRel": 0.1,
"TranslateYRel": 0.1,
"Color": 0.025,
"Sharpness": 0.025,
"AutoContrast": 0.025,
"Solarize": 0.005,
"SolarizeAdd": 0.005,
"Contrast": 0.005,
"Brightness": 0.005,
"Equalize": 0.005,
"Posterize": 0,
"Invert": 0,
}
def _select_rand_weights(weight_idx=0, transforms=None):
transforms = transforms or _RAND_TRANSFORMS
assert weight_idx == 0 # only one set of weights currently
rand_weights = _RAND_CHOICE_WEIGHTS_0
probs = [rand_weights[k] for k in transforms]
probs /= np.sum(probs)
return probs
def rand_augment_ops(magnitude=10, hparams=None, transforms=None):
hparams = hparams or _HPARAMS_DEFAULT
transforms = transforms or _RAND_TRANSFORMS
return [
AugmentOp(name, prob=0.5, magnitude=magnitude, hparams=hparams)
for name in transforms
]
class RandAugment:
def __init__(self, ops, num_layers=2, choice_weights=None):
self.ops = ops
self.num_layers = num_layers
self.choice_weights = choice_weights
def __call__(self, img):
# no replacement when using weighted choice
ops = np.random.choice(
self.ops,
self.num_layers,
replace=self.choice_weights is None,
p=self.choice_weights,
)
for op in ops:
img = op(img)
return img
def rand_augment_transform(config_str, hparams):
"""
RandAugment: Practical automated data augmentation... - https://arxiv.org/abs/1909.13719
Create a RandAugment transform
:param config_str: String defining configuration of random augmentation. Consists of multiple sections separated by
dashes ('-'). The first section defines the specific variant of rand augment (currently only 'rand'). The remaining
sections, not order sepecific determine
'm' - integer magnitude of rand augment
'n' - integer num layers (number of transform ops selected per image)
'w' - integer probabiliy weight index (index of a set of weights to influence choice of op)
'mstd' - float std deviation of magnitude noise applied
'inc' - integer (bool), use augmentations that increase in severity with magnitude (default: 0)
Ex 'rand-m9-n3-mstd0.5' results in RandAugment with magnitude 9, num_layers 3, magnitude_std 0.5
'rand-mstd1-w0' results in magnitude_std 1.0, weights 0, default magnitude of 10 and num_layers 2
:param hparams: Other hparams (kwargs) for the RandAugmentation scheme
:return: A PyTorch compatible Transform
"""
magnitude = _MAX_LEVEL # default to _MAX_LEVEL for magnitude (currently 10)
num_layers = 2 # default to 2 ops per image
weight_idx = None # default to no probability weights for op choice
transforms = _RAND_TRANSFORMS
config = config_str.split("-")
assert config[0] == "rand"
config = config[1:]
for c in config:
cs = re.split(r"(\d.*)", c)
if len(cs) < 2:
continue
key, val = cs[:2]
if key == "mstd":
# noise param injected via hparams for now
hparams.setdefault("magnitude_std", float(val))
elif key == "inc":
if bool(val):
transforms = _RAND_INCREASING_TRANSFORMS
elif key == "m":
magnitude = int(val)
elif key == "n":
num_layers = int(val)
elif key == "w":
weight_idx = int(val)
else:
assert NotImplementedError
ra_ops = rand_augment_ops(
magnitude=magnitude, hparams=hparams, transforms=transforms
)
choice_weights = (
None if weight_idx is None else _select_rand_weights(weight_idx)
)
return RandAugment(ra_ops, num_layers, choice_weights=choice_weights)
| 16,366 | 29.478585 | 143 | py |
dstc9-SIMMC | dstc9-SIMMC-master/tools/simmc_dataset.py | import json
import pdb
import re
import string
import torch
from nltk.tokenize import WordPunctTokenizer
from torch.utils.data import Dataset
"""
The dialog intents have the shapes:
DA:<DIALOG_ACT>:<ACTIVITY>:<OBJECT> or DA:<DIALOG_ACT>:<ACTIVITY>:<OBJECT>.<attribute>
Examples:
DA:INFORM:GET:CLOTHING.embellishment
The <DIALOG_ACT> values are shared between fashion and furniture dataset. <ACTIVITY> values are dataset specific (see paper fig.3).
"""
DIALOG_ACT = {'ASK', 'CONFIRM', 'INFORM', 'PROMPT', 'REQUEST'}
ACTIVITY = {'ADD_TO_CART', 'CHECK', 'COMPARE', 'COUNT', 'DISPREFER', 'GET', 'PREFER', 'REFINE'}
class SIMMCDataset(Dataset):
"""Dataset wrapper for SIMMC Fashion
(list) self.ids[idx] = <dialogue_id>
(dict) self.id2dialog[<dialogue_id>].keys() = ['dialogue', 'dialogue_coref_map', 'dialogue_idx', 'domains', 'dialogue_task_id']
(dict) self.id2dialog[<dialogue_id>]['dialogue'][<dialogue_turn>].keys() = ['belief_state', 'domain', 'state_graph_0', 'state_graph_1', 'state_graph_2',
'system_transcript', 'system_transcript_annotated', 'system_turn_label',
'transcript', 'transcript_annotated', 'turn_idx', 'turn_label',
'visual_objects', 'raw_assistant_keystrokes']
(list) self.transcripts[idx] = 'dialogueid_turn' (e.g., '3094_3', '3094_0')
(dict) self.task_mapping[<task_id>].keys() = ['task_id', 'image_ids', 'focus_image', 'memory_images', 'database_images']
(dict) self.processed_turns[<dialogue_id>][turn] = {'transcript': <tokenized_transcript>, 'system_transcript': <tokenized_system_transcript>}
"""
def __init__(self, data_path, metadata_path, verbose=True):
"""Dataset constructor.
Args:
path (str): path to dataset json file
metadata_path (str): path to metadata json file
"""
data_fp = open(data_path)
raw_data = json.load(data_fp)
metadata_fp = open(metadata_path)
self.metadata = json.load(metadata_fp)
self.split = raw_data['split']
self.version = raw_data['version']
self.year = raw_data['year']
self.domain = raw_data['domain']
self.verbose = verbose
if self.verbose:
print('Creating dataset index ...')
self.create_index(raw_data)
if self.verbose:
print('Skipped dialogs: {}'.format(self.skipped_dialogs))
print(' ... index created')
def __len__(self):
return len(self.transcripts)
def __getitem__(self, index):
dial_id, turn = self.transcripts[index].split('_')
dial_id = int(dial_id)
turn = int(turn)
user_req = self.id2dialog[dial_id]['dialogue'][turn]['transcript']
wizard_resp = self.id2dialog[dial_id]['dialogue'][turn]['system_transcript']
# extract dialogue history
turn_str = '{} [SEP] {}'
history = [turn_str.format(self.id2dialog[dial_id]['dialogue'][t]['transcript'],
self.id2dialog[dial_id]['dialogue'][t]['transcript'])
for t in range(turn)]
# dispatch data across different dataset instantiation
if isinstance(self, SIMMCDatasetForActionPrediction,) or isinstance(self, SIMMCDatasetForResponseGeneration,):
focus_item = self.id2focus[dial_id][turn]
attributes = []
if self.id2act[dial_id][turn]['action_supervision'] is not None:
attributes = self.id2act[dial_id][turn]['action_supervision']['attributes']
return_tuple = (dial_id, turn, user_req, wizard_resp, history, focus_item, self.id2act[dial_id][turn]['action'], attributes)
if isinstance(self, SIMMCDatasetForResponseGeneration,):
return_tuple += (self.id2candidates[dial_id][turn]['retrieval_candidates'],)
return return_tuple
def extract_visual_context(self, dial_id):
task_id = self.id2dialog[dial_id]['dialogue_task_id']
init_focus = self.task_mapping[task_id]['focus_image']
focus_items = [init_focus]
for act_annotation in self.id2act[dial_id]:
#force object permanence
if act_annotation['action_supervision'] is None or 'focus' not in act_annotation['action_supervision']:
focus_items.append(focus_items[-1])
else:
focus_items.append(act_annotation['action_supervision']['focus'])
return focus_items
def create_index(self, raw_data):
self.ids = []
self.id2dialog = {}
self.transcripts = []
self.skipped_dialogs = set()
for dialog in raw_data['dialogue_data']:
if 'dialogue_task_id' in dialog:
self.ids.append(dialog['dialogue_idx'])
dialog_obj = {
'dialogue': dialog['dialogue'],
'dialogue_coref_map': dialog['dialogue_coref_map'],
'dialogue_idx': dialog['dialogue_idx'],
'domains': dialog['domains'],
'dialogue_task_id': dialog['dialogue_task_id']}
transcripts = ['{}_{}'.format(dialog['dialogue_idx'], turn) for turn, _ in enumerate(dialog['dialogue'])]
self.id2dialog[dialog['dialogue_idx']] = dialog_obj
self.transcripts.extend(transcripts)
else:
if self.verbose:
#print('id: {} ; is dialogue_task_id missing: {}'.format(dialog['dialogue_idx'], not 'dialogue_task_id' in dialog))
self.skipped_dialogs.add(dialog['dialogue_idx'])
self.task_mapping = {}
for task in raw_data['task_mapping']:
self.task_mapping[task['task_id']] = task
def getmetadata(self, obj_id):
"""Return metadata for the object with the specified id
Args:
obj_id (str): id of the object
Returns:
dict: returns a dict with the following shape
{'metadata':
{'availability': [],
'availableSizes': "['L', 'XXL']",
'brand': '212 Local',
'color': ['black'],
'customerRating': '2.06',
'embellishments': ['layered'],
'hemLength': ['knee_length'],
'pattern': [],
'price': '$269',
'size': [],
'skirtStyle': ['asymmetrical', 'fit_and_flare', 'loose'],
'type': 'skirt'
},
'url': 'GByeggJtfhLUq9UGAAAAAABqViN1btAUAAAB'
}
"""
return self.metadata[obj_id]
def __str__(self):
return '{}_{}_{}_v{}'.format(self.domain, self.split, self.year, self.version)
class SIMMCDatasetForResponseGeneration(SIMMCDataset):
# conversion from attribute and action annotations format to english string
_ATTRS = {'embellishment', 'skirtStyle', 'availableSizes', 'dressStyle', 'material', 'clothingStyle', 'jacketStyle',
'sleeveLength', 'soldBy', 'price', 'ageRange', 'hemLength', 'size', 'warmthRating', 'sweaterStyle',
'forGender', 'madeIn', 'info', 'customerRating', 'hemStyle', 'hasPart', 'pattern', 'clothingCategory',
'forOccasion', 'waistStyle', 'sleeveStyle', 'amountInStock', 'waterResistance', 'necklineStyle', 'skirtLength',
'color', 'brand', 'sequential'}
_ATTR2STR = {'skirtstyle': 'skirt style', 'availablesizes': 'available sizes', 'dressstyle': 'dress style', 'clothingstyle': 'clothing style',
'jacketstyle': 'jacket style', 'sleevelength': 'sleeve length', 'soldby': 'sold by', 'agerange': 'age range', 'hemlength': 'hem length',
'warmthrating': 'warmth rating', 'sweaterstyle': 'sweater style', 'forgender': 'for gender', 'madein': 'made in', 'customerrating': 'customer rating',
'hemstyle': 'hem style', 'haspart': 'has part', 'clothingcategory': 'clothing category', 'foroccasion': 'for occasion', 'waiststyle': 'waist style',
'sleevestyle': 'sleeve style', 'amountinstock': 'amount in stock', 'waterresistance': 'water resistance', 'necklinestyle': 'neckline style',
'skirtlength': 'skirt length'}
_ACT2STR = {'none': 'none', 'searchdatabase': 'search database', 'searchmemory': 'search memory', 'specifyinfo': 'specify info', 'addtocart': 'add to cart'}
#map attribute names to metadata fields
_ATTR2FIELD = {'embellishment': 'embellishments', 'skirtStyle': 'skirtStyle', 'availableSizes': 'availableSizes', 'dressStyle': 'dressStyle', 'jacketStyle': 'jacketStyle',
'sleeveLength': 'sleeveStyle', 'soldBy': 'brand', 'price': 'price', 'hemLength': 'hemLength', 'size': 'availableSizes', 'sweaterStyle': 'sweaterStyle',
'customerRating': 'customerRating', 'hemStyle': 'hemStyle', 'hasPart': 'embellishments', 'pattern': 'pattern', 'clothingCategory': 'type',
'waistStyle': 'waistStyle', 'sleeveStyle': 'sleeveStyle', 'necklineStyle': 'necklineStyle', 'skirtLength': 'skirtStyle', 'color': 'color', 'brand': 'brand'}
def __init__(self, data_path, metadata_path, actions_path, candidates_path, verbose=True):
super(SIMMCDatasetForResponseGeneration, self).__init__(data_path=data_path, metadata_path=metadata_path, verbose=verbose)
self.task = 'response_generation'
self.load_actions(actions_path)
self.load_candidates(candidates_path)
self.id2focus = {}
for id in self.ids:
#for response generation the context is shifted right (response based on the item chosen by the wizard)
self.id2focus[id] = self.extract_visual_context(id)[1:]
assert len(self.id2dialog[id]['dialogue']) == len(self.id2focus[id]), 'Focus items do not match dialogue {} length'.format(id)
self.processed_metadata = {}
self.process_metadata_items()
def process_metadata_items(self):
"""This method process the data inside metadata fields and make each field values a list
(avoiding mixing up single values and lists)
Args:
tokenizer ([type]): [description]
"""
for item_id, item in self.metadata.items():
assert item_id not in self.processed_metadata, 'Item {} presents twice'.format(item_id)
self.processed_metadata[item_id] = {}
for field, field_vals in item['metadata'].items():
curr_field = ''
# availability field is always empty
if field == 'availability' or field == 'url':
continue
values = field_vals
if field == 'availableSizes' and not isinstance(values, list,):
values = self.repair_size_list(values)
#field_tokens = tokenizer.tokenize(field)
field_tokens = re.split('_|\s', field)
for tok in field_tokens:
cleaned_tok = self._ATTR2STR[tok.lower()] if tok.lower() in self._ATTR2STR else tok.lower()
curr_field += cleaned_tok + ' '
curr_field = curr_field[:-1]
curr_val = ''
proc_values = []
if isinstance(values, list,):
for val in values:
curr_val = ''
#value_tokens = tokenizer.tokenize(val)
value_tokens = re.split('_|\s', val)
proc_values.append(' '.join(value_tokens))
else:
value_tokens = re.split('_|\s', values)
proc_values.append(' '.join(value_tokens))
#metadata JSON files contains different samples having hemLenght field twice.
# In this case just discard the one with no values.
if curr_field == 'hem length' and curr_field in self.processed_metadata[item_id]:
if not len(self.processed_metadata[item_id][curr_field]):
self.processed_metadata[item_id][curr_field] = proc_values
continue
assert curr_field not in self.processed_metadata[item_id], 'Field {} presents twice in item {}. Please remove one of them (preferably the empty one)'.format(curr_field, item_id)
self.processed_metadata[item_id][curr_field] = proc_values
def repair_size_list(self, str_val):
"""fixes availableSizes when it is a stringified list (e.g., "[' xl ', ' m ']"
Args:
str_val ([type]): [description]
"""
return [word for word in str_val[2:-2].split('\', \'')]
def __getitem__(self, index):
dial_id, turn, user_req, wizard_resp, history, focus, action, attributes, candidates_ids = super().__getitem__(index)
#convert actions and attributes to english strings
action = action.lower() if action.lower() not in self._ACT2STR else self._ACT2STR[action.lower()]
raw_fields = [attr if attr not in self._ATTR2FIELD else self._ATTR2FIELD[attr] for attr in attributes]
fields = [field.lower() if field.lower() not in self._ATTR2STR else self._ATTR2STR[field.lower()] for field in raw_fields]
item_attributes = []
if not len(fields):
item_attributes.append([])
for field in fields:
if field in self.processed_metadata[str(focus)] and len(self.processed_metadata[str(focus)][field]):
item_attributes.append(self.processed_metadata[str(focus)][field])
else:
item_attributes.append([])
retrieval_candidates = [self.candidates[candidate_id] for candidate_id in candidates_ids]
return dial_id, turn, user_req, wizard_resp, history, focus, action, item_attributes, retrieval_candidates
def __len__(self):
return super().__len__()
def __str__(self):
return '{}_subtask({})'.format(super().__str__(), self.task)
def load_candidates(self, candidates_path):
self.candidates = []
self.id2candidates = {}
with open(candidates_path) as fp:
raw_candidates = json.load(fp)
for candidate in raw_candidates['system_transcript_pool']:
self.candidates.append(candidate)
for candidates_per_dial in raw_candidates['retrieval_candidates']:
self.id2candidates[candidates_per_dial['dialogue_idx']] = candidates_per_dial['retrieval_candidates']
#check if all the candidate ids correspond to a valid candidate in the candidate pool
for (_, candidates_per_dial) in self.id2candidates.items():
for candidates_per_turn in candidates_per_dial:
for candidate_id in candidates_per_turn['retrieval_candidates']:
assert candidate_id < len(self.candidates), 'Candidate with id {} not present in candidate pool'.format(candidate_id)
def load_actions(self, actions_path):
self.id2act = {}
self.id2actfocus = {}
with open(actions_path) as fp:
raw_actions = json.load(fp)
for action in raw_actions:
if action['dialog_id'] in self.skipped_dialogs:
continue
assert len(action['actions']) == len(action['focus_images']), 'focus_images has different length than number of actions'
self.id2act[action['dialog_id']] = action['actions']
self.id2actfocus[action['dialog_id']] = action['focus_images']
#check if we have actions for all the turns
for dial_id in self.ids:
assert len(self.id2dialog[dial_id]['dialogue']) == len(self.id2act[dial_id]),\
'Actions number does not match dialogue turns in dialogue {}'.format(dial_id)
class SIMMCDatasetForActionPrediction(SIMMCDataset):
"""Dataset wrapper for SIMMC Fashion for api call prediction subtask
"""
_ACT2LABEL = {'None': 0,'SearchDatabase': 1, 'SearchMemory': 2, 'SpecifyInfo': 3, 'AddToCart': 4}
_LABEL2ACT = ['None','SearchDatabase', 'SearchMemory', 'SpecifyInfo', 'AddToCart']
"""
_ATTR2LABEL = {'embellishment': 0, 'skirtStyle': 1, 'availableSizes': 2, 'dressStyle': 3, 'material': 4, 'clothingStyle': 5, 'jacketStyle': 6,
'sleeveLength': 7, 'soldBy': 8, 'price': 9, 'ageRange': 10, 'hemLength': 11, 'size': 12, 'warmthRating': 13, 'sweaterStyle': 14,
'forGender': 15, 'madeIn': 16, 'info': 17, 'customerRating': 18, 'hemStyle': 19, 'hasPart': 20, 'pattern': 21, 'clothingCategory': 22,
'forOccasion': 23, 'waistStyle': 24, 'sleeveStyle': 25, 'amountInStock': 26, 'waterResistance': 27, 'necklineStyle': 28, 'skirtLength': 29,
'color': 30, 'brand': 31, 'sequential': 32}
_ATTRS = ['embellishment', 'skirtStyle', 'availableSizes', 'dressStyle', 'material', 'clothingStyle', 'jacketStyle',
'sleeveLength', 'soldBy', 'price', 'ageRange', 'hemLength', 'size', 'warmthRating', 'sweaterStyle',
'forGender', 'madeIn', 'info', 'customerRating', 'hemStyle', 'hasPart', 'pattern', 'clothingCategory',
'forOccasion', 'waistStyle', 'sleeveStyle', 'amountInStock', 'waterResistance', 'necklineStyle', 'skirtLength',
'color', 'brand', 'sequential']
"""
_ATTR2LABEL = {'embellishment': 0, 'availableSizes': 1, 'price': 2, 'info': 3, 'customerRating': 4,
'pattern': 5, 'color': 6, 'brand': 7, 'other': 8}
_ATTRS = ['embellishment', 'availableSizes', 'price', 'info', 'customerRating', 'pattern', 'color', 'brand', 'other']
def __init__(self, data_path, metadata_path, actions_path, verbose=True):
super(SIMMCDatasetForActionPrediction, self).__init__(data_path=data_path, metadata_path=metadata_path, verbose=verbose)
self.task = 'api_call_prediction'
self.load_actions(actions_path)
self.id2focus = {}
for id in self.ids:
#for action prediction do not use the item context after the last turn
self.id2focus[id] = self.extract_visual_context(id)[:-1]
assert len(self.id2dialog[id]['dialogue']) == len(self.id2focus[id]), 'Focus items do not match dialogue {} length'.format(id)
def __getitem__(self, index):
dial_id, turn, transcript, history, visual_context, action, attributes = super().__getitem__(index)
one_hot_attrs = [0]*(len(self._ATTR2LABEL))
for attr in attributes:
#assert attr in self._ATTR2LABEL, 'Unkown attribute \'{}\''.format(attr)
curr_attr = attr if attr in self._ATTR2LABEL else 'other'
#assert one_hot_attrs[self._ATTR2LABEL[curr_attr]] == 0, 'Attribute \'{}\' is present multiple times'.format(attr)
one_hot_attrs[self._ATTR2LABEL[curr_attr]] = 1
return dial_id, turn, transcript, history, visual_context, self._ACT2LABEL[action], one_hot_attrs
def __len__(self):
return super().__len__()
def __str__(self):
return '{}_subtask({})'.format(super().__str__(), self.task)
def load_actions(self, actions_path):
#TODO sort id2act based on 'turn_idx' field
self.id2act = {}
with open(actions_path) as fp:
raw_actions = json.load(fp)
for action in raw_actions:
if action['dialog_id'] in self.skipped_dialogs:
continue
self.id2act[action['dialog_id']] = action['actions']
#check if we have actions for all the turns
for dial_id in self.ids:
assert len(self.id2dialog[dial_id]['dialogue']) == len(self.id2act[dial_id]),\
'Actions number does not match dialogue turns in dialogue {}'.format(dial_id)
#compute frequency for actions
act_freq = [0]*len(self._LABEL2ACT)
freq_sum = 0
for dial_id in self.ids:
for act in self.id2act[dial_id]:
act_freq[self._ACT2LABEL[act['action']]] += 1
freq_sum += 1
self.act_support = {'per_class_frequency': act_freq, 'tot_samples': freq_sum}
#compute frequency for attributes
attr_freq = [0] * len(self._ATTRS)
freq_sum = 0
for dial_id in self.ids:
for act in self.id2act[dial_id]:
if act['action_supervision'] != None:
for attr in act['action_supervision']['attributes']:
if attr in self._ATTR2LABEL:
attr_freq[self._ATTR2LABEL[attr]] += 1
else:
attr_freq[self._ATTR2LABEL['other']] += 1
freq_sum += 1
self.attr_support = {'per_class_frequency': attr_freq, 'tot_samples': freq_sum}
"""
#print actions distribution
print('_______________________')
print('[ACTIONS DISTRIBUTION]:')
tot_samples = self.act_support['tot_samples']
for idx, freq in enumerate(self.act_support['per_class_frequency']):
print('{}: \t\t[{}%]: {}'.format(self._LABEL2ACT[idx], round(100*freq/tot_samples), freq))
print('Total support sum: {}'.format(tot_samples))
print('_______________________')
#print attributes distribution
print('[ATTRIBUTES DISTRIBUTION]:')
tot_samples = self.attr_support['tot_samples']
for idx, freq in enumerate(self.attr_support['per_class_frequency']):
print('{}: \t\t[{}%]: {}'.format(self._ATTRS[idx], round(100*freq/tot_samples), freq))
print('Total support sum: {}'.format(tot_samples))
print('_______________________')
pdb.set_trace()
"""
| 22,029 | 47.955556 | 193 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/preprocessing.py | import argparse
import datetime
import math
import os
import pdb
import random
import sys
import time
import numpy as np
import torch
from torch.utils.data import DataLoader
sys.path.append('.')
from config import special_toks
from tools.simmc_dataset import SIMMCDatasetForResponseGeneration
from transformers import BertTokenizer
class Collate():
ACT2STR = SIMMCDatasetForResponseGeneration._ACT2STR
UNK_WORDS = set()
def __init__(self, word2id, unk_token):
self.word2id = word2id
self.unk_token = unk_token
def metadata2ids(self, processed_metadata, word2id, unk_token):
unknown_words = set()
metadata_ids = {}
for item_id, item in processed_metadata.items():
metadata_ids[int(item_id)] = []
for field, values in item.items():
curr_field = []
for word in field.split():
if word not in word2id:
unknown_words.add(word)
curr_field.append(word2id[word] if word in word2id else unk_token)
curr_values = []
for value in values:
curr_value = []
for word in value.split():
if word not in word2id:
unknown_words.add(word)
curr_value.append(word2id[word] if word in word2id else unk_token)
curr_values.append(torch.tensor(curr_value))
if len(curr_values):
curr_values = torch.cat(curr_values)
else:
#insert none for field for which we do not have values
curr_values = torch.tensor([word2id['none']], dtype=torch.long)
metadata_ids[int(item_id)].append((torch.tensor(curr_field, dtype=torch.long), curr_values))
print('UNKNOWN METADATA WORDS: {}'.format(len(unknown_words)))
return metadata_ids
def collate_fn(self, batch):
dial_ids = [item[0] for item in batch]
turns = [item[1] for item in batch]
utterances = [item[2] for item in batch]
history = [item[3] for item in batch]
focus = [item[4] for item in batch]
actions = [item[5] for item in batch]
attributes = [item[6] for item in batch]
responses_pool = [item[7] for item in batch]
# words to ids for the current utterance
utterance_seq_ids = []
for utt in utterances:
curr_seq = []
for word in utt.split():
word_id = self.word2id[word] if word in self.word2id else self.word2id[self.unk_token]
if word not in self.word2id:
self.UNK_WORDS.add(word)
curr_seq.append(word_id)
utterance_seq_ids.append(curr_seq)
# words to ids for the history
history_seq_ids = []
for turn, item in zip(turns, history):
assert len(item) == turn, 'Number of turns does not match history length'
curr_turn_ids = []
for t in range(turn):
concat_sentences = item[t][0] + ' ' + item[t][1] #? separator token
curr_seq = []
for word in concat_sentences.split():
word_id = self.word2id[word] if word in self.word2id else self.word2id[self.unk_token]
if word not in self.word2id:
self.UNK_WORDS.add(word)
curr_seq.append(word_id)
curr_turn_ids.append(torch.tensor(curr_seq))
history_seq_ids.append(curr_turn_ids)
# convert response candidates to word ids
resp_ids = []
for resps in responses_pool:
curr_candidate = []
for resp in resps:
curr_seq = []
for word in resp.split():
word_id = self.word2id[word] if word in self.word2id else self.word2id[self.unk_token]
if word not in self.word2id:
self.UNK_WORDS.add(word)
curr_seq.append(word_id)
curr_candidate.append(torch.tensor(curr_seq, dtype=torch.long))
resp_ids.append(curr_candidate)
#convert actions and attributes to word ids
act_ids = []
for act in actions:
curr_seq = []
# todo collapse searchdatabase and searchmemory to one single action called search
act_tokens = act.split() if 'search' not in act else ['search']
for word in act_tokens:
word_id = self.word2id[word] if word in self.word2id else self.word2id[self.unk_token]
if word not in self.word2id:
self.UNK_WORDS.add(word)
curr_seq.append(word_id)
act_ids.append(torch.tensor(curr_seq, dtype=torch.long))
attr_ids = []
for attrs in attributes:
curr_attributes = []
for attr in attrs:
curr_seq = []
for word in attr.split():
word_id = self.word2id[word] if word in self.word2id else self.word2id[self.unk_token]
if word not in self.word2id:
self.UNK_WORDS.add(word)
curr_seq.append(word_id)
curr_attributes.append(torch.tensor(curr_seq, dtype=torch.long))
attr_ids.append(curr_attributes)
assert len(utterance_seq_ids) == 1, 'Only unitary batch sizes allowed'
assert len(utterance_seq_ids) == len(dial_ids), 'Batch sizes do not match'
assert len(utterance_seq_ids) == len(turns), 'Batch sizes do not match'
assert len(utterance_seq_ids) == len(history_seq_ids), 'Batch sizes do not match'
assert len(utterance_seq_ids) == len(resp_ids), 'Batch sizes do not match'
assert len(utterance_seq_ids) == len(attr_ids), 'Batch sizes do not match'
assert len(utterance_seq_ids) == len(focus)
batch_dict = {}
batch_dict['utterances'] = utterance_seq_ids
batch_dict['history'] = history_seq_ids
batch_dict['actions'] = act_ids
batch_dict['attributes'] = attr_ids
batch_dict['focus'] = focus[0] #only one focus per turn
return dial_ids, turns, batch_dict, resp_ids
class BertCollate():
def __init__(self, pretrained_model):
self.tokenizer = BertTokenizer.from_pretrained(pretrained_model)
self.tokenizer_vocab = self.tokenizer.vocab
self.bert2genid = {}
self.bert2genid[self.tokenizer.convert_tokens_to_ids('[PAD]')] = 0
self.bert2genid[self.tokenizer.convert_tokens_to_ids('[SEP]')] = 1
self.bert2genid[self.tokenizer.convert_tokens_to_ids('[UNK]')] = 2
self.avail_id = 3
self.id_occur = [1, 1, 1]
def add_tensor_ids_to_vocab(self, tensor_ids):
ids = [id for id in tensor_ids.view(-1).tolist()]
for id in ids:
# skip the [CLS]. Never in the generated output
if id == 101:
continue
if id not in self.bert2genid:
self.bert2genid[id] = self.avail_id
self.avail_id += 1
self.id_occur.append(1)
else:
self.id_occur[self.bert2genid[id]] += 1
def get_vocab_and_inv_frequencies(self):
#avoid frequency computation for padding
tot_sum = sum(self.id_occur[1:])
word_inv_freqs = [tot_sum/occur for occur in self.id_occur[1:]]
#insert 0 inverse frequency for padding
word_inv_freqs.insert(0, 0)
assert len(self.bert2genid) == len(word_inv_freqs)
return self.bert2genid, word_inv_freqs
def metadata2ids(self, processed_metadata):
"""Each item is represented by the plain string of all its attributes
'key1: val1, val2. key2: val1. ...'
"""
id2pos = {}
items_strings = []
for idx, (item_id, item) in enumerate(processed_metadata.items()):
id2pos[int(item_id)] = idx
curr_item_strings = []
for field, values in item.items():
if len(values):
curr_str = '{}: {}'.format(field, ', '.join(values))
else:
curr_str = '{}: {}'.format(field, 'none')
curr_item_strings.append(curr_str)
items_strings.append('. '.join(curr_item_strings))
items_tensors = self.tokenizer(items_strings, padding='longest', return_tensors='pt')
self.add_tensor_ids_to_vocab(items_tensors['input_ids'])
res_dict = {'id2pos': id2pos, 'items_tensors': items_tensors}
return res_dict
def collate_fn(self, batch):
dial_ids = [item[0] for item in batch]
turns = [item[1] for item in batch]
utterances = [item[2] for item in batch]
wizard_resp = [item[3] for item in batch]
history = [item[4] for item in batch]
focus = [item[5] for item in batch]
actions = [item[6] for item in batch]
attributes = [item[7][0] for item in batch]
retr_candidates = [item[8] for item in batch]
#each results has three keys: 'input_ids', 'token_type_ids', 'attention_mask'
utterances_tensors = self.tokenizer(utterances, padding='longest', return_tensors='pt')
self.add_tensor_ids_to_vocab(utterances_tensors['input_ids'])
responses_tensors = self.tokenizer(wizard_resp, padding='longest', return_tensors='pt')
self.add_tensor_ids_to_vocab(responses_tensors['input_ids'])
history_seq_ids = []
for turn, item in zip(turns, history):
assert len(item) == turn, 'Number of turns does not match history length'
if not len(item):
no_history = {'input_ids': torch.zeros(utterances_tensors['input_ids'].shape[1]),
'token_type_ids': torch.zeros(utterances_tensors['input_ids'].shape[1]),
'attention_mask': torch.zeros(utterances_tensors['input_ids'].shape[1])}
history_seq_ids.append(no_history)
continue
history_seq_ids.append(self.tokenizer(item, padding='longest', return_tensors='pt'))
actions_tensors = self.tokenizer(actions, padding='longest', return_tensors='pt')
all_candidates = [candidate for pool in retr_candidates for candidate in pool]
candidates_tensors = self.tokenizer(all_candidates, padding='longest', return_tensors='pt')
candidates_tensors = {'input_ids': candidates_tensors['input_ids'].view(len(dial_ids), 100, -1),
'token_type_ids': candidates_tensors['token_type_ids'].view(len(dial_ids), 100, -1),
'attention_mask': candidates_tensors['attention_mask'].view(len(dial_ids), 100, -1)}
assert utterances_tensors['input_ids'].shape[0] == len(dial_ids), 'Batch sizes do not match'
assert utterances_tensors['input_ids'].shape[0] == len(turns), 'Batch sizes do not match'
assert utterances_tensors['input_ids'].shape[0] == responses_tensors['input_ids'].shape[0], 'Batch sizes do not match'
assert utterances_tensors['input_ids'].shape[0] == len(history_seq_ids), 'Batch sizes do not match'
assert utterances_tensors['input_ids'].shape[0] == actions_tensors['input_ids'].shape[0], 'Batch sizes do not match'
assert utterances_tensors['input_ids'].shape[0] == len(attributes)
assert utterances_tensors['input_ids'].shape[0] == candidates_tensors['input_ids'].shape[0]
assert utterances_tensors['input_ids'].shape[0] == len(focus), 'Batch sizes do not match'
data_dict = {}
data_dict['utterances'] = utterances_tensors
data_dict['responses'] = responses_tensors
data_dict['history'] = history_seq_ids
data_dict['actions'] = actions_tensors
data_dict['attributes'] = attributes
data_dict['focus'] = focus
data_dict['candidates'] = candidates_tensors
return dial_ids, turns, data_dict
def save_data_on_file(loader, save_path):
dial_ids, turns, data_dict = iter(loader).next()
torch.save(
{
'dial_ids': dial_ids,
'turns': turns,
'data_dict': data_dict,
},
save_path
)
def preprocess(train_dataset, dev_dataset, test_dataset, args):
save_path = '{}/{}'
collate = BertCollate('bert-base-uncased')
metadata_ids = collate.metadata2ids(train_dataset.processed_metadata)
torch.save(metadata_ids, save_path.format(args.save_path, 'metadata_ids.dat'))
# prepare DataLoader
params = {'batch_size': len(train_dataset),
'shuffle': False,
'num_workers': 0}
assert params['batch_size'] == len(train_dataset) and not params['shuffle'], 'Keep batch size to max and shuffle to False to avoid problems during training'
trainloader = DataLoader(train_dataset, **params, collate_fn=collate.collate_fn)
devloader = DataLoader(dev_dataset, **params, collate_fn=collate.collate_fn)
testloader = DataLoader(test_dataset, **params, collate_fn=collate.collate_fn)
start_t = time.time()
save_data_on_file(loader=trainloader, save_path=save_path.format(args.save_path, 'train_response_retrieval_data.dat'))
#save vocab and inverse word frequencies only for training data
vocab, inv_freqs = collate.get_vocab_and_inv_frequencies()
torch.save({'vocab': vocab, 'inv_freqs': torch.tensor(inv_freqs)}, save_path.format(args.save_path, 'generative_vocab.dat'))
save_data_on_file(loader=devloader, save_path=save_path.format(args.save_path, 'dev_response_retrieval_data.dat'))
save_data_on_file(loader=testloader, save_path=save_path.format(args.save_path, 'devtest_response_retrieval_data.dat'))
#print('UNKNOWN DATASET WORDS: {}'.format(len(collate.UNK_WORDS)))
end_t = time.time()
h_count = (end_t-start_t) /60 /60
m_count = ((end_t-start_t)/60) % 60
s_count = (end_t-start_t) % 60
print('preprocessing time: {}h:{}m:{}s'.format(round(h_count), round(m_count), round(s_count)))
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
"--simmc_folder",
type=str,
required=True,
help="Path to simmc fashion dataset folder")
parser.add_argument(
"--actions_folder",
type=str,
required=True,
help="Path to simmc fashion actions folder")
parser.add_argument(
"--metadata",
type=str,
required=True,
help="Path to metadata JSON file")
parser.add_argument(
"--save_path",
type=str,
required=True,
help="Path to save processed files")
args = parser.parse_args()
dataset_path = '{}/fashion_{}_dials.json'
actions_path = '{}/fashion_{}_dials_api_calls.json'
candidates_path = '{}/fashion_{}_dials_retrieval_candidates.json'
train_dataset = SIMMCDatasetForResponseGeneration(data_path=dataset_path.format(args.simmc_folder, 'train'),
metadata_path=args.metadata,
actions_path=actions_path.format(args.actions_folder, 'train'),
candidates_path=candidates_path.format(args.simmc_folder, 'train'))
dev_dataset = SIMMCDatasetForResponseGeneration(data_path=dataset_path.format(args.simmc_folder, 'dev'),
metadata_path=args.metadata,
actions_path=actions_path.format(args.actions_folder, 'dev'),
candidates_path=candidates_path.format(args.simmc_folder, 'dev'))
test_dataset = SIMMCDatasetForResponseGeneration(data_path=dataset_path.format(args.simmc_folder, 'devtest'),
metadata_path=args.metadata,
actions_path=actions_path.format(args.actions_folder, 'devtest'),
candidates_path=candidates_path.format(args.simmc_folder, 'devtest'))
preprocess(train_dataset, dev_dataset, test_dataset, args)
| 16,410 | 42.762667 | 160 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/eval.py | import argparse
import json
import os
import pdb
import sys
import time
import string
import torch
from torch.utils.data import DataLoader
sys.path.append('.')
from config import special_toks, train_conf
from dataset import FastDataset
from models import BlindStatelessLSTM, MultiAttentiveTransformer
from tools.simmc_dataset import SIMMCDatasetForResponseGeneration
"""expected form for model output
[
{
"dialog_id": <dialog_id>,
"candidate_scores": [
<list of 100 scores for 100 candidates for round 1>
<list of 100 scores for 100 candidates for round 2>
...
]
}
...
]
"""
def instantiate_model(args, model_configurations, out_vocab, device):
if args.model == 'blindstateless':
return BlindStatelessLSTM(word_embeddings_path=args.embeddings,
pad_token=special_toks['pad_token'],
unk_token=special_toks['unk_token'],
seed=train_conf['seed'],
OOV_corrections=False,
freeze_embeddings=True)
elif args.model == 'matransformer':
return MultiAttentiveTransformer(**model_configurations,
seed=train_conf['seed'],
device=device,
out_vocab=out_vocab,
retrieval_eval=args.retrieval_eval,
gen_eval=args.gen_eval,
beam_size=args.beam_size,
mode='inference',
**special_toks,
)
else:
raise Exception('Model not present!')
def create_eval_dicts(dataset):
dataset.create_id2turns()
gen_eval_dict = {}
retr_eval_dict = {}
for dial_id, num_turns in dataset.id2turns.items():
gen_eval_dict[dial_id] = {'dialog_id': dial_id, 'predictions': []}
retr_eval_dict[dial_id] = {'dialog_id': dial_id, 'candidate_scores': []}
return gen_eval_dict, retr_eval_dict
def move_batch_to_device(batch, device):
for key in batch.keys():
if key == 'history':
raise Exception('Not implemented')
if key != 'attributes':
batch[key] = batch[key].to(device)
def visualize_result(utt_ids, item_ids, id2word, gen_ids=None):
item = [id2word[id.item()] for id in item_ids if id != 0]
words_request = [id2word[id.item()] for id in utt_ids if id != 0]
if gen_ids is not None:
words_resp = [id2word[id] for id in gen_ids]
#cleaned_req = clean_response(words_request)
#cleaned_resp = clean_response(words_resp)
print('USER: {}'.format(words_request))
if gen_ids is not None:
print('GEN: {}'.format(words_resp))
print('Item: {}'.format(item))
def eval(model, test_dataset, args, save_folder, device):
model.eval()
model.to(device)
#print('MODEL: {}'.format(model))
# prepare DataLoader
params = {'batch_size': 1,
'shuffle': False,
'num_workers': 0}
testloader = DataLoader(test_dataset, **params, collate_fn=model.collate_fn)
gen_eval_dict, retr_eval_dict = create_eval_dicts(test_dataset)
with torch.no_grad():
for curr_step, (dial_ids, turns, batch) in enumerate(testloader):
assert len(dial_ids) == 1, 'Only unitary batch size is allowed during testing'
dial_id = dial_ids[0]
turn = turns[0]
move_batch_to_device(batch, device)
res = model(**batch,
history=None,
actions=None)
if args.gen_eval:
gen_eval_dict[dial_id]['predictions'].append({'turn_id': turn, 'response': res['generation']['string']})
#visualize_result(batch['utterances'][0], batch['focus_items'][0], id2word, res['generation']['string'])
if args.retrieval_eval:
retr_eval_dict[dial_id]['candidate_scores'].append({'turn_id': turn, 'scores': res['retrieval'].squeeze(0).tolist()})
#todo here adjust candidates scores based on semantic attribute informations
if args.gen_eval:
gen_eval_list = []
for key in gen_eval_dict:
gen_eval_list.append(gen_eval_dict[key])
save_file = os.path.join(save_folder, 'eval_gen.json')
try:
with open(save_file, 'w+') as fp:
json.dump(gen_eval_list, fp)
print('generation results saved in {}'.format(save_file))
except:
print('Error in writing the resulting JSON')
if args.retrieval_eval:
retr_eval_list = []
for key in retr_eval_dict:
retr_eval_list.append(retr_eval_dict[key])
save_file = os.path.join(save_folder, 'eval_retr.json')
try:
with open(save_file, 'w+') as fp:
json.dump(retr_eval_list, fp)
print('retrieval results saved in {}'.format(save_file))
except:
print('Error in writing the resulting JSON')
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
"--model",
type=str,
choices=['blindstateless', 'blindstateful', 'matransformer'],
required=True,
help="Type of the model (options: 'blindstateless', 'blindstateful', 'matransformer')")
parser.add_argument(
"--model_path",
default=None,
type=str,
required=True,
help="Path to the weights of the model")
parser.add_argument(
"--model_conf",
default=None,
type=str,
required=True,
help="Path to the model configuration JSON file")
parser.add_argument(
"--vocabulary",
default=None,
type=str,
required=True,
help="Path to output vocabulary for the model")
parser.add_argument(
"--data",
default=None,
type=str,
required=True,
help="Path to test dataset json file")
parser.add_argument(
"--metadata_ids",
type=str,
required=True,
help="Path to metadata ids file")
parser.add_argument(
"--beam_size",
type=int,
required=True,
help="Size of the beam for the beam search at inference time")
parser.add_argument(
"--retrieval_eval",
action='store_true',
default=False,
required=False,
help="Flag to enable retrieval evaluation")
parser.add_argument(
"--gen_eval",
action='store_true',
default=False,
required=False,
help="Flag to enable generation evaluation")
parser.add_argument(
"--cuda",
default=None,
required=False,
type=int,
help="id of device to use")
start_t = time.time()
args = parser.parse_args()
test_dataset = FastDataset(dat_path=args.data,
metadata_ids_path= args.metadata_ids,
retrieval=args.retrieval_eval)
device = torch.device('cuda:{}'.format(args.cuda) if torch.cuda.is_available() and args.cuda is not None else "cpu")
print('EVAL DATASET: {}'.format(test_dataset))
# prepare model
with open(args.model_conf) as fp:
model_configurations = json.load(fp)
with open(args.vocabulary, 'rb') as fp:
bert2genid = torch.load(fp)
model = instantiate_model(args,
model_configurations=model_configurations,
out_vocab=bert2genid,
device=device)
model.load_state_dict(torch.load(args.model_path))
model_folder = '/'.join(args.model_path.split('/')[:-1])
print('model loaded from {}'.format(model_folder))
eval(model, test_dataset, args, save_folder=model_folder, device=device)
end_t = time.time()
m_count = ((end_t-start_t)/60) % 60
s_count = (end_t-start_t) % 60
print('evaluation time: {}m:{}s'.format(round(m_count), round(s_count)))
| 8,110 | 32.795833 | 133 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/train.py | import argparse
import datetime
import json
import math
import os
import pdb
import pickle
import random
import sys
import time
import numpy as np
import torch
from torch.utils.data import DataLoader
from config import model_conf, special_toks, train_conf
from dataset import FastDataset
from models import BlindStatelessLSTM, MultiAttentiveTransformer
from utilities import DataParallelV2, Logger, plotting_loss
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"]="0,2,3,4,5" # specify which GPU(s) to be used
torch.autograd.set_detect_anomaly(True)
torch.backends.cudnn.benchmark = True
torch.backends.cudnn.enabled = True
def instantiate_model(args, out_vocab, device):
"""
if args.model == 'blindstateless':
return BlindStatelessLSTM(word_embeddings_path=args.embeddings,
pad_token=special_toks['pad_token'],
unk_token=special_toks['unk_token'],
seed=train_conf['seed'],
OOV_corrections=False,
freeze_embeddings=True)
"""
if args.model == 'matransformer':
if args.from_checkpoint is not None:
with open(os.path.join(args.from_checkpoint, 'state_dict.pt'), 'rb') as fp:
state_dict = torch.load(fp)
with open(os.path.join(args.from_checkpoint, 'model_conf.json'), 'rb') as fp:
loaded_conf = json.load(fp)
loaded_conf.pop('dropout_prob')
model_conf.update(loaded_conf)
model = MultiAttentiveTransformer(**model_conf,
seed=train_conf['seed'],
device=device,
out_vocab=out_vocab,
**special_toks)
if args.from_checkpoint is not None:
model.load_state_dict(state_dict)
print('Model loaded from {}'.format(args.from_checkpoint))
return model
else:
raise Exception('Model not present!')
def plotting(epochs, losses_trend, checkpoint_dir=None):
epoch_list = np.arange(1, epochs+1)
losses = [(losses_trend['train'], 'blue', 'train'),
(losses_trend['dev'], 'red', 'validation')]
loss_path = os.path.join(checkpoint_dir, 'global_loss_plot') if checkpoint_dir is not None else None
plotting_loss(x_values=epoch_list, save_path=loss_path, functions=losses, plot_title='Global loss trend', x_label='epochs', y_label='loss')
def move_batch_to_device(batch, device):
for key in batch.keys():
if key == 'history':
raise Exception('Not implemented')
batch[key] = batch[key].to(device)
def visualize_output(request, responses, item, id2word, genid2word, vocab_logits, device):
shifted_targets = torch.cat((responses[:, 1:], torch.zeros((responses.shape[0], 1), dtype=torch.long).to(device)), dim=-1)
rand_idx = random.randint(0, shifted_targets.shape[0]-1)
eff_len = shifted_targets[rand_idx][shifted_targets[rand_idx] != 0].shape[0]
"""
inp = ' '.join([id2word[inp_id.item()] for inp_id in responses[rand_idx] if inp_id != vocab['[PAD]']])
print('input: {}'.format(inp))
"""
req = ' '.join([id2word[req_id.item()] for req_id in request[rand_idx] if req_id != 0])
print('user: {}'.format(req))
out = ' '.join([id2word[out_id.item()] for out_id in shifted_targets[rand_idx] if out_id !=0])
print('wizard: {}'.format(out))
item = ' '.join([id2word[item_id.item()] for item_id in item[rand_idx] if item_id !=0])
print('item: {}'.format(item))
gens = torch.argmax(torch.nn.functional.softmax(vocab_logits, dim=-1), dim=-1)
gen = ' '.join([genid2word[gen_id.item()] for gen_id in gens[:, :eff_len][rand_idx]])
print('generated: {}'.format(gen))
def forward_step(model, batch, generative_targets, response_criterion, device):
move_batch_to_device(batch, device)
generative_targets = generative_targets.to(device)
vocab_logits = model(**batch,
history=None,
actions=None,
attributes=None,
candidates=None,
candidates_mask=None,
candidates_token_type=None)
#keep the loss outside the forward: complex to compute the mean with a weighted loss
response_loss = response_criterion(vocab_logits.view(vocab_logits.shape[0]*vocab_logits.shape[1], -1),
generative_targets.view(vocab_logits.shape[0]*vocab_logits.shape[1]))
p = random.randint(0, 9)
if p > 8:
try:
vocab = model.vocab
id2word = model.id2word
genid2word = model.genid2word
except:
vocab = model.module.vocab
id2word = model.module.id2word
genid2word = model.module.genid2word
visualize_output(request=batch['utterances'], responses=batch['responses'], item=batch['focus'], id2word=id2word, genid2word=genid2word, vocab_logits=vocab_logits, device=device)
return response_loss
def train(train_dataset, dev_dataset, args, device):
# prepare checkpoint folder
if args.checkpoints:
curr_date = datetime.datetime.now().isoformat().split('.')[0]
checkpoint_dir = os.path.join(train_conf['ckpt_folder'], curr_date)
os.makedirs(checkpoint_dir, exist_ok=True)
# prepare logger to redirect both on file and stdout
sys.stdout = Logger(os.path.join(checkpoint_dir, 'train.log'))
sys.stderr = Logger(os.path.join(checkpoint_dir, 'err.log'))
print('device used: {}'.format(str(device)))
print('batch used: {}'.format(args.batch_size))
print('lr used: {}'.format(train_conf['lr']))
print('weight decay: {}'.format(train_conf['weight_decay']))
print('TRAINING DATASET: {}'.format(train_dataset))
print('VALIDATION DATASET: {}'.format(dev_dataset))
with open(args.generative_vocab, 'rb') as fp:
gen_vocab = dict(torch.load(fp))
bert2genid, inv_freqs = gen_vocab['vocab'], gen_vocab['inv_freqs']
if args.checkpoints:
torch.save(bert2genid, os.path.join(checkpoint_dir, 'bert2genid.pkl'))
print('GENERATIVE VOCABULARY SIZE: {}'.format(len(bert2genid)))
# prepare model
#response_criterion = torch.nn.CrossEntropyLoss(ignore_index=0, weight=inv_freqs/inv_freqs.sum()).to(device)
response_criterion = torch.nn.CrossEntropyLoss(ignore_index=0).to(device)
model = instantiate_model(args, out_vocab=bert2genid, device=device)
vocab = model.vocab
if args.checkpoints:
with open(os.path.join(checkpoint_dir, 'model_conf.json'), 'w+') as fp:
json.dump(model_conf, fp)
# work on multiple GPUs when available
if torch.cuda.device_count() > 1:
model = DataParallelV2(model)
model.to(device)
print('using {} GPU(s): {}'.format(torch.cuda.device_count(), os.environ["CUDA_VISIBLE_DEVICES"]))
print('MODEL NAME: {}'.format(args.model))
print('NETWORK: {}'.format(model))
# prepare DataLoader
params = {'batch_size': args.batch_size,
'shuffle': True,
'num_workers': 0,
'pin_memory': True}
collate_fn = model.collate_fn if torch.cuda.device_count() <= 1 else model.module.collate_fn
trainloader = DataLoader(train_dataset, **params, collate_fn=collate_fn)
devloader = DataLoader(dev_dataset, **params, collate_fn=collate_fn)
#prepare optimizer
#optimizer = torch.optim.Adam(params=model.parameters(), lr=train_conf['lr'])
optimizer = torch.optim.Adam(params=model.parameters(), lr=train_conf['lr'], weight_decay=train_conf['weight_decay'])
#scheduler1 = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones = list(range(500, 500*5, 100)), gamma = 0.1)
scheduler1 = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones = list(range(25, 100, 50)), gamma = 0.1)
scheduler2 = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=.1, patience=12, threshold=1e-3, cooldown=2, verbose=True)
#prepare containers for statistics
losses_trend = {'train': [],
'dev': []}
#candidates_pools_size = 100 if train_conf['distractors_sampling'] < 0 else train_conf['distractors_sampling'] + 1
#print('candidates\' pool size: {}'.format(candidates_pools_size))
#accumulation_steps = 8
best_loss = math.inf
global_step = 0
start_t = time.time()
for epoch in range(args.epochs):
ep_start = time.time()
model.train()
curr_epoch_losses = []
for batch_idx, (dial_ids, turns, batch, generative_targets) in enumerate(trainloader):
global_step += 1
step_start = time.time()
response_loss = forward_step(model,
batch=batch,
response_criterion=response_criterion,
generative_targets=generative_targets,
device=device)
optimizer.zero_grad()
#averaging losses from various GPUs by dividing by the batch size
response_loss.mean().backward()
#torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
optimizer.step()
step_end = time.time()
h_count = (step_end-step_start) /60 /60
m_count = ((step_end-step_start)/60) % 60
s_count = (step_end-step_start) % 60
print('step {}, loss: {}, time: {}h:{}m:{}s'.format(global_step, round(response_loss.mean().item(), 4), round(h_count), round(m_count), round(s_count)))
"""
if (batch_idx+1) % accumulation_steps == 0:
optimizer.step()
optimizer.zero_grad()
#torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
#step_end = time.time()
print('step {}, loss: {}'.format(global_step, round(response_loss.item()*accumulation_steps, 4)))
p = random.randint(0, 9)
if p > 8:
h_count = (step_end-step_start) /60 /60
m_count = ((step_end-step_start)/60) % 60
s_count = (step_end-step_start) % 60
print('step {}, loss: {}, time: {}h:{}m:{}s'.format(global_step, round(response_loss.mean().item(), 4), round(h_count), round(m_count), round(s_count)))
"""
#scheduler1.step()
#scheduler2.step(response_loss.item())
curr_epoch_losses.append(response_loss.mean().item())
losses_trend['train'].append(np.mean(curr_epoch_losses))
model.eval()
curr_epoch_losses = []
with torch.no_grad():
for curr_step, (dial_ids, turns, batch, generative_targets) in enumerate(devloader):
response_loss = forward_step(model,
batch=batch,
response_criterion=response_criterion,
generative_targets=generative_targets,
device=device)
curr_epoch_losses.append(response_loss.mean().item())
losses_trend['dev'].append(np.mean(curr_epoch_losses))
# save checkpoint if best model
if losses_trend['dev'][-1] < best_loss:
best_loss = losses_trend['dev'][-1]
if args.checkpoints:
try:
state_dict = model.cpu().module.state_dict()
except AttributeError:
state_dict = model.cpu().state_dict()
torch.save(state_dict, os.path.join(checkpoint_dir, 'state_dict.pt'))
#torch.save(model.cpu().state_dict(), os.path.join(checkpoint_dir, 'state_dict.pt'))
model.to(device)
ep_end = time.time()
ep_h_count = (ep_end-ep_start) /60 /60
ep_m_count = ((ep_end-ep_start)/60) % 60
ep_s_count = (ep_end-ep_start) % 60
time_str = '{}h:{}m:{}s'.format(round(ep_h_count), round(ep_m_count), round(ep_s_count))
print('EPOCH #{} :: train_loss = {:.4f} ; dev_loss = {:.4f} ; (lr={}); --time: {}'.format(epoch+1,
losses_trend['train'][-1],
losses_trend['dev'][-1],
optimizer.param_groups[0]['lr'],
time_str))
#TODO uncomment
#scheduler1.step()
scheduler2.step(losses_trend['dev'][-1])
end_t = time.time()
h_count = (end_t-start_t) /60 /60
m_count = ((end_t-start_t)/60) % 60
s_count = (end_t-start_t) % 60
print('training time: {}h:{}m:{}s'.format(round(h_count), round(m_count), round(s_count)))
if not args.checkpoints:
checkpoint_dir = None
plotting(epochs=args.epochs, losses_trend=losses_trend, checkpoint_dir=checkpoint_dir)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
"--model",
type=str,
choices=['blindstateless', 'blindstateful', 'matransformer'],
required=True,
help="Type of the model (options: 'blindstateless', 'blindstateful', 'matransformer')")
parser.add_argument(
"--data",
type=str,
required=True,
help="Path to preprocessed training data file .dat")
parser.add_argument(
"--eval",
type=str,
required=True,
help="Path to preprocessed eval data file .dat")
parser.add_argument(
"--metadata_ids",
type=str,
required=True,
help="Path to metadata ids file")
parser.add_argument(
"--generative_vocab",
type=str,
required=True,
help="Path to generative vocabulary file")
parser.add_argument(
"--batch_size",
required=True,
type=int,
help="Batch size")
parser.add_argument(
"--epochs",
required=True,
type=int,
help="Number of epochs")
parser.add_argument(
"--from_checkpoint",
type=str,
required=False,
default=None,
help="Path to checkpoint to load")
parser.add_argument(
"--checkpoints",
action='store_true',
default=False,
required=False,
help="Flag to enable checkpoint saving for best model, logs and plots")
parser.add_argument(
"--cuda",
action='store_true',
default=False,
required=False,
help="flag to use cuda")
args = parser.parse_args()
if not args.checkpoints:
print('************ NO CHECKPOINT SAVE !!! ************')
train_dataset = FastDataset(dat_path=args.data, metadata_ids_path= args.metadata_ids, distractors_sampling=train_conf['distractors_sampling'])
dev_dataset = FastDataset(dat_path=args.eval, metadata_ids_path= args.metadata_ids, distractors_sampling=train_conf['distractors_sampling']) #? sampling on eval
print('TRAIN DATA LEN: {}'.format(len(train_dataset)))
device = torch.device('cuda:0'.format(args.cuda) if torch.cuda.is_available() and args.cuda else 'cpu')
train(train_dataset, dev_dataset, args, device)
| 15,568 | 42.733146 | 186 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/dataset/processed_dataset.py | import pdb
import random
import numpy as np
import torch
from torch.utils.data import Dataset
torch.backends.cudnn.benchmark = True
torch.backends.cudnn.enabled = True
class FastDataset(Dataset):
"""Dataset with preprocessed data for response generation subtask
self.data.keys() = dict_keys(['dial_ids', 'turns', 'utterances', 'histories', 'actions',
'attributes', 'visual_contexts', 'seq_lengths', 'candidates'])
"""
def __init__(self, dat_path, metadata_ids_path, retrieval=False, distractors_sampling=-1):
super(FastDataset, self).__init__()
self.data = torch.load(dat_path)
self.retrieval = retrieval
if not retrieval:
self.data['data_dict'].pop('candidates', None)
self.data['data_dict'].pop('attributes', None)
self.metadata = torch.load(metadata_ids_path)
self.dataset_name = 'SIMMC'
self.task = 'response_retrieval'
self.distractors_sampling = distractors_sampling
def __getitem__(self, index):
"""
candidates = []
if self.retrieval and self.distractors_sampling >= 0:
samples = random.sample(range(1, 100), self.distractors_sampling)
# the first is always the ground truth
candidates.append(self.data['data_dict']['candidates'][index][0])
for sample in samples:
candidates.append(self.data['data_dict']['candidates'][index][sample])
assert len(candidates) == 1 + self.distractors_sampling, 'Invalid size of candidate list after sampling'
else:
candidates = self.data['data_dict']['candidates'][index]
"""
focus_id = self.data['data_dict']['focus'][index]
focus_pos = self.metadata['id2pos'][focus_id]
if self.data['turns'][index] != 0:
assert self.data['turns'][index] == self.data['data_dict']['history'][index]['input_ids'].shape[0], 'Number of turns and history length do not correpond'
ret_tuple = (self.data['dial_ids'][index],
self.data['turns'][index],
self.data['data_dict']['utterances']['input_ids'][index],
self.data['data_dict']['utterances']['attention_mask'][index],
self.data['data_dict']['utterances']['token_type_ids'][index],
self.data['data_dict']['responses']['input_ids'][index],
self.data['data_dict']['responses']['attention_mask'][index],
self.data['data_dict']['responses']['token_type_ids'][index],
self.data['data_dict']['attributes'][index],
#self.data['data_dict']['history'][index],
#self.data['data_dict']['actions'][index],
#self.data['data_dict']['attributes'][index],
self.metadata['items_tensors']['input_ids'][focus_pos],
self.metadata['items_tensors']['attention_mask'][focus_pos],
self.metadata['items_tensors']['token_type_ids'][focus_pos])
if self.retrieval:
ret_tuple += (self.data['data_dict']['candidates']['input_ids'][index],
self.data['data_dict']['candidates']['attention_mask'][index],
self.data['data_dict']['candidates']['token_type_ids'][index])
return ret_tuple
def create_id2turns(self):
"""used to create the eval dict during evaluation phase
"""
self.id2turns = {}
for dial_id in self.data['dial_ids']:
if dial_id in self.id2turns:
self.id2turns[dial_id] += 1
else:
self.id2turns[dial_id] = 1
def __len__(self):
#_DATA_PERC = 25
#frac = int(self.data['data_dict']['utterances']['input_ids'].shape[0] * (_DATA_PERC/100))
#return frac
return self.data['data_dict']['utterances']['input_ids'].shape[0]
def __str__(self):
return '{}_subtask({})'.format(self.dataset_name, self.task) | 4,071 | 43.26087 | 165 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/models/bert.py | import pdb
import torch
import torch.nn as nn
from transformers import BertConfig, BertModel
class BertEncoder(nn.Module):
def __init__(self, pretrained, freeze=False):
super(BertEncoder, self).__init__()
configuration = BertConfig()
self.bert = BertModel(config=configuration).from_pretrained(pretrained)
self.configuration = self.bert.config
if freeze:
for p in self.bert.parameters():
p.requires_grad = False
def forward(self, input, input_mask, input_token_type):
out_all, _ = self.bert(input_ids=input,
attention_mask=input_mask,
token_type_ids=input_token_type)
return out_all
| 728 | 29.375 | 79 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/models/embednets.py | import pdb
import numpy as np
import torch
import torch.nn as nn
from spellchecker import SpellChecker
class ItemEmbeddingNetwork(nn.Module):
"""Base class for word embedding layer initialization and weights loading
Args:
nn (torch.nn.Module): inherits from torch.nn.Module
"""
def __init__(self, item_embeddings_path, freeze=False):
super(ItemEmbeddingNetwork, self).__init__()
raw_data = np.load(item_embeddings_path, allow_pickle=True)
raw_data = dict(raw_data.item())
self.item2id = {}
for idx, item in enumerate(raw_data['item_ids']):
self.item2id[item] = idx
self.embedding_dim = raw_data['embedding_size']
fields_embeddings = np.stack([item_embs[0] for item_embs in raw_data['embeddings']])
values_embeddings = np.stack([item_embs[1] for item_embs in raw_data['embeddings']])
fields_embedding_weights = torch.tensor(fields_embeddings)
values_embedding_weights = torch.tensor(values_embeddings)
pdb.set_trace()
assert fields_embedding_weights.shape[0] == values_embedding_weights.shape[0], 'Number of fields and values embedding does not match'
assert fields_embedding_weights.shape[-1] == values_embedding_weights.shape[-1] and fields_embedding_weights.shape[-1] == self.embedding_dim,\
'Real embedding dimension does not match the declared one'
num_embeddings = fields_embedding_weights.shape[0]
self.fields_embedding_layer = nn.Embedding(num_embeddings, self.embedding_dim)
self.fields_embedding_layer.load_state_dict({'weight': fields_embedding_weights})
self.values_embedding_layer = nn.Embedding(num_embeddings, self.embedding_dim)
self.values_embedding_layer.load_state_dict({'weight': values_embedding_weights})
if freeze:
for p in self.fields_embedding_layer.parameters():
p.requires_grad = False
for p in self.values_embedding_layer.parameters():
p.requires_grad = False
def forward(self, fields_ids, values_ids):
return self.fields_embedding_layer(fields_ids), self.values_embedding_layer(values_ids)
class WordEmbeddingNetwork(nn.Module):
"""Base class for word embedding layer initialization and weights loading
Args:
nn (torch.nn.Module): inherits from torch.nn.Module
"""
def __init__(self, word_embeddings_path, word2id, pad_token, unk_token, OOV_corrections=False, freeze=False):
super(WordEmbeddingNetwork, self).__init__()
self.pad_token = pad_token
self.unk_token = unk_token
self.corrected_flag = OOV_corrections
self.word2id = word2id
self.embedding_file = word_embeddings_path.split('/')[-1]
self.load_embeddings_from_file(word_embeddings_path)
embedding_weights = self.get_embeddings_weights(OOV_corrections)
num_embeddings, self.embedding_dim = embedding_weights.shape
self.embedding_layer = nn.Embedding(num_embeddings, self.embedding_dim)
self.embedding_layer.load_state_dict({'weight': embedding_weights})
if freeze:
for p in self.embedding_layer.parameters():
p.requires_grad = False
def forward(self, batch):
return self.embedding_layer(batch)
def load_embeddings_from_file(self, embeddings_path):
self.glove = {}
with open(embeddings_path) as fp:
for l in fp:
line_tokens = l.split()
word = line_tokens[0]
if word in self.glove:
raise Exception('Repeated words in {} embeddings file'.format(embeddings_path))
vector = np.asarray(line_tokens[1:], "float32")
self.glove[word] = vector
self.embedding_size = vector.size
def get_embeddings_weights(self, OOV_corrections):
#if OOV_corrections:
# dataset_vocabulary = self.correct_spelling(dataset_vocabulary)
matrix_len = len(self.word2id)
weights_matrix = np.zeros((matrix_len, self.embedding_size))
# set pad and unknow ids
pad_id = self.word2id[self.pad_token]
unk_id = self.word2id[self.unk_token]
weights_matrix[pad_id] = np.zeros(shape=(self.embedding_size, ))
weights_matrix[unk_id] = np.random.normal(scale=0.6, size=(self.embedding_size, ))
for idx, word in enumerate(self.word2id):
if word in self.glove:
weights_matrix[idx] = self.glove[word]
return torch.tensor(weights_matrix, dtype=torch.float32)
def correct_spelling(self, dataset_vocabulary):
#todo fix: now dataset_vocabulary is a map, not a set (get the .keys())
oov = []
self.corrections = {}
checker = SpellChecker()
vocab_copy = copy.deepcopy(dataset_vocabulary)
for word in vocab_copy:
if word not in self.glove:
oov.append(word)
corrected_w = checker.correction(word)
if corrected_w in self.glove:
# the word with typos is assigned to the same id of the correspondant word after the correction
try:
self.word2id[word] = self.word2id[corrected_w] #TODO fix: word2id is still empty at this point
except:
pdb.set_trace()
self.corrections[word] = corrected_w
dataset_vocabulary.remove(word)
#print(oov)
#print(corrections.values())
return dataset_vocabulary
| 5,715 | 39.828571 | 150 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/models/old_encoder.py | import math
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
class SingleEncoder(nn.Module):
def __init__(self,
input_size,
hidden_size,
dropout_prob,
encoder_heads,
embedding_net):
super(SingleEncoder, self).__init__()
self.word_embeddings_layer = embedding_net
self.sentence_encoder = SentenceEncoder(emb_dim=input_size,
hidden_size=hidden_size,
bidirectional=True,
dropout_prob=dropout_prob)
self.memory_net = MemoryNet(in_features=hidden_size,
memory_hidden_size=hidden_size,
dropout_prob=dropout_prob)
#for h heads: d_k == d_v == emb_dim/h
self.triton_attention = Triton(in_features=hidden_size,
d_k=hidden_size//encoder_heads,
d_v=hidden_size//encoder_heads,
d_f=hidden_size//2,
n_heads=encoder_heads,
n_layers=1,
dropout_prob=dropout_prob)
self.layerNorm = nn.LayerNorm(hidden_size)
self.dropout = nn.Dropout(p=dropout_prob)
def forward(self, utterances, history, focus_items, seq_lengths=None):
# todo use attributes to enforce the user utterance?
# u_t shape [BATCH_SIZE x 2MEMORY_HIDDEN_SIZE], u_t_all shape [BATCH_SIZE x MAX_SEQ_LEN x 2MEMORY_HIDDEN_SIZE]
embedded_utt_tensor = self.word_embeddings_layer(utterances)
u_t, u_t_all = self.sentence_encoder(embedded_utt_tensor, seq_lengths)
#h_t shape h_t[<sample_in_batch>].shape = [N_TURNSx300] or [] if no history
embedded_hist_tensor = []
for history_sample in history:
if not len(history_sample):
embedded_hist_tensor.append([])
else:
embedded_hist_tensor.append(self.word_embeddings_layer(history_sample))
h_t = []
for h_embedding in embedded_hist_tensor:
if not len(h_embedding):
h_t.append([])
else:
h_t.append(self.sentence_encoder(h_embedding)[0])
#embedded_vis_tensor shape v_t[<sample_in_batch>][0/1].shape = [N_FIELDSx300]
#v_t shape [<sample_in_batch>]x300
#v_t_tilde contains contextual embedding for each item in the batch. Shape [Bx300]
v_t = self.encode_v_context(focus_items)
v_t_tilde = torch.stack([self.triton_attention(utt, v[0], v[1]) for utt, v in zip(u_t, v_t)])
# compute history context
h_t_tilde = []
for idx in range(u_t.shape[0]):
if not len(h_t[idx]):
h_t_tilde.append(u_t[idx])
else:
h_t_tilde.append(self.memory_net(u_t[idx], h_t[idx]))
h_t_tilde = torch.stack(h_t_tilde)
return u_t_all, v_t_tilde, h_t_tilde
def encode_v_context(self, focus_images):
v_batch = []
for keys, values in focus_images:
k_ht, _ = self.sentence_encoder(self.word_embeddings_layer(keys))
v_ht, _ = self.sentence_encoder(self.word_embeddings_layer(values))
v_batch.append([k_ht, v_ht])
return v_batch
def __str__(self):
return super().__str__()
class SentenceEncoder(nn.Module):
def __init__(self, emb_dim, hidden_size, dropout_prob, bidirectional=False):
super(SentenceEncoder, self).__init__()
self.encoder = nn.LSTM(emb_dim,
hidden_size,
batch_first=True,
bidirectional=bidirectional)
in_features = 2*hidden_size if bidirectional else hidden_size
self.mlp = nn.Linear(in_features=in_features, out_features=hidden_size)
self.dropout = nn.Dropout(p=dropout_prob)
self.layerNorm = nn.LayerNorm(hidden_size)
def forward(self, seq, seq_lengths=None):
if seq_lengths is not None:
# pack padded sequence
input_seq = pack_padded_sequence(seq, seq_lengths, batch_first=True) #seq_lengths.cpu().numpy()
else:
input_seq = seq
#to call every forward if DataParallel is used. Otherwise only once inside __init__()
self.encoder.flatten_parameters()
sentences_outs, (h_t, c_t) = self.encoder(input_seq)
#concat right and left hidden states of the last layer
bidirectional_h_t = torch.cat((h_t[-2], h_t[-1]), dim=-1)
if seq_lengths is not None:
# unpack padded sequence
sentences_outs, input_sizes = pad_packed_sequence(sentences_outs, batch_first=True)
mlp_out = self.mlp(bidirectional_h_t)
out = self.layerNorm(self.dropout(mlp_out))
return out, sentences_outs
class MemoryNet(nn.Module):
def __init__(self, in_features, memory_hidden_size, dropout_prob):
super(MemoryNet, self).__init__()
self.memory_hidden_size = memory_hidden_size
self.query_encoder = nn.Linear(in_features=in_features, out_features=memory_hidden_size)
self.memory_encoder = nn.Linear(in_features=in_features, out_features=memory_hidden_size)
self.dropout = nn.Dropout(p=dropout_prob)
self.layerNorm = nn.LayerNorm(memory_hidden_size)
def forward(self, input, context, device='cpu'):
query = self.query_encoder(input)
memory = self.memory_encoder(context) + self.get_positional_embeddings(context.shape[0], self.memory_hidden_size).to(context.device)
attn_logits = torch.matmul(query, torch.transpose(memory, 0, 1))/math.sqrt(self.memory_hidden_size)
attn_scores = F.softmax(attn_logits, -1)
weighted_memory = torch.sum(attn_scores[:, None] * memory, dim=0)
out = self.layerNorm(query + self.dropout(weighted_memory))
return out
def get_positional_embeddings(self, n_position, emb_dim):
"""Create positional embeddings (from "Attention Is All You Need", Vaswani et al. 2017)
Args:
n_position (int): number of elements in the sequence
emb_dim (int): size of embeddings
Returns:
toch.FloatTensor: a positional embedding with shape [N_POSITION x EMB_DIM]
"""
# keep dim 0 for padding token position encoding zero vector
position_enc = np.array([
[pos / np.power(10000, 2 * (k // 2) / emb_dim) for k in range(emb_dim)]
if pos != 0 else np.zeros(emb_dim) for pos in range(n_position)])
position_enc[1:, 0::2] = np.sin(position_enc[1:, 0::2]) # dim 2i
position_enc[1:, 1::2] = np.cos(position_enc[1:, 1::2]) # dim 2i+1
return torch.from_numpy(position_enc).type(torch.FloatTensor)
# Triton, trident? Not self attention! Triplet as input q, k, v belonging to different conceptual sets
class Triton(nn.Module):
def __init__(self, in_features, d_k, d_v, d_f, n_heads, n_layers, dropout_prob):
super(Triton, self).__init__()
assert n_layers >= 1, 'Not acceptable number of layers: {}'.format(n_layers)
self.n_layers = n_layers
#self.encoders = nn.ModuleList([TritonEncoder(emb_dim, d_k, d_v, n_heads) for _ in range(n_layers)])
#encoders = [TritonEncoder(emb_dim, d_k, d_v, d_f, n_heads) for _ in range(n_layers)]
#self.encoders = nn.Sequential(*encoders)
#todo change to allow multiple layers. Problem: sequential take only 1 input, so pack inputs to a tuple.
self.encoders = TritonEncoder(in_features, d_k, d_v, d_f, n_heads, dropout_prob)
def forward(self, ut, kt, vt):
out = self.encoders(ut, kt, vt)
return out
def __str__(self):
return super().__str__()
class TritonEncoder(nn.Module):
def __init__(self, in_features, d_k, d_v, d_f, n_heads, dropout_prob):
super(TritonEncoder, self).__init__()
self.multihead_attn = TritonMultiHeadCrossAttention(in_features, d_k, d_v, n_heads)
self.dropout = nn.Dropout(p=dropout_prob)
self.layerNorm = nn.LayerNorm(in_features)
self.fnn = nn.Sequential(nn.Linear(in_features=in_features, out_features=d_f),
nn.ReLU(),
nn.Linear(in_features=d_f, out_features=in_features))
def forward(self, u_t, k_t, v_t):
multihead_out = self.multihead_attn(u_t, k_t, v_t)
# residual connection is performed after the dropout and before normalization in (Vaswani et al.)
norm_out = self.layerNorm(self.dropout(multihead_out))
enc_out = self.fnn(norm_out)
out = self.layerNorm(self.dropout(multihead_out))
return out
def __str__(self):
return super().__str__()
class TritonMultiHeadCrossAttention(nn.Module):
def __init__(self, in_features, d_k, d_v, n_heads):
super(TritonMultiHeadCrossAttention, self).__init__()
self.n_heads = n_heads
self.attn_heads = nn.ModuleList([TritonCrossAttentionHead(in_features, d_k, d_v) for _ in range(n_heads)])
def forward(self, u_t, k_t, v_t):
attn_outs = []
heads_out = torch.cat([attn_head(u_t, k_t, v_t) for attn_head in self.attn_heads])
return heads_out
def __str__(self):
return super().__str__()
class TritonCrossAttentionHead(nn.Module):
def __init__(self, in_features, d_k, d_v):
super(TritonCrossAttentionHead, self).__init__()
self.d_k = d_k
self.d_v = d_v
self.Q = nn.Linear(in_features, d_k)
self.K = nn.Linear(in_features, d_k)
self.V = nn.Linear(in_features, d_v)
def forward(self, u_t, k_t, v_t):
query = self.Q(u_t)
key = self.K(k_t)
value = self.V(v_t)
attn_logits = torch.matmul(query, torch.transpose(key, 0, 1))/ math.sqrt(self.d_k)
attn_scores = F.softmax(attn_logits, -1)
out = torch.sum(attn_scores[:, None] * value, dim=0)
return out
def __str__(self):
return super().__str__()
| 10,368 | 36.981685 | 140 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/models/decoder.py | import math
import pdb
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
#the value with which to mask the attention
# DO NOT USE '-INF' BECAUSE IT WILL GENERATE NaN AFTER SOFTMAX FOR PADDING ROWS (filled with all 0's)
_MASKING_VALUE=-1e30
class Decoder(nn.Module):
def __init__(self,
d_model,
d_enc,
d_context,
d_k,
d_v,
d_f,
n_layers,
n_heads,
embedding_net,
input_vocab_size,
out_vocab_size,
dropout_prob):
super(Decoder, self).__init__()
self.d_model = d_model
self.input_vocab_size = input_vocab_size
self.out_vocab_size = out_vocab_size
self.n_layers = n_layers
self.embedding_layer = TransformerEmbedding(input_vocab_size, d_model)
#self.embedding_layer = embedding_net
self.decoder_layers = nn.ModuleList([
MultiAttentiveDecoder(d_model=d_model,
d_enc=d_enc,
d_context=d_context,
d_k=d_k,
d_v=d_v,
d_f=d_f,
n_heads=n_heads,
dropout_prob=dropout_prob)
for _ in range(n_layers)
])
self.out_layer = nn.Sequential(nn.Linear(d_model, d_model//2),
nn.ReLU(),
nn.Linear(d_model//2, d_model//4),
nn.ReLU(),
nn.Linear(d_model//4, self.out_vocab_size))
def forward(self,
input_batch,
encoder_out,
#history_context,
visual,
enc_mask,
visual_mask,
input_mask=None):
device = input_batch.device
if input_mask is None:
input_mask = torch.ones(input_batch.shape, dtype=torch.long).to(device)
assert input_batch.dim() == 2, 'Expected tensor with 2 dimensions but got {}'.format(input_batch.dim())
assert encoder_out.dim() == 3, 'Expected tensor with 2 dimensions but got {}'.format(encoder_out.dim())
assert input_mask.dim() == 2, 'Expected tensor with 2 dimensions but got {}'.format(input_mask.dim())
assert enc_mask.dim() == 2, 'Expected tensor with 2 dimensions but got {}'.format(enc_mask.dim())
assert input_batch.shape[0] == encoder_out.shape[0], 'Inconsistent batch size'
#assert input_batch.shape[0] == history_context.shape[0], 'Inconsistent batch size'
#assert input_batch.shape[0] == visual_context.shape[0], 'Inconsistent batch size'
assert input_batch.shape[0] == input_mask.shape[0], 'Inconsistent batch size'
assert input_batch.shape[0] == enc_mask.shape[0], 'Inconsistent batch size'
assert input_batch.shape == input_mask.shape, 'Inconsistent mask size, {} and {}'.format(input_batch.shape, input_mask.shape)
assert encoder_out.shape[:2] == enc_mask.shape, 'Inconsistent mask size, {} and {}'.format(encoder_out.shape[:2], enc_mask.shape)
assert input_batch.device == encoder_out.device, 'Different devices'
#assert input_batch.device == history_context.device, 'Different devices'
#assert input_batch.device == visual_context.device, 'Different devices'
assert input_batch.device == input_mask.device, 'Different devices'
assert input_batch.device == enc_mask.device, 'Different devices'
#input mask is the padding mask
#self attention mask is a mask resulting from the combination of attention and padding masks
#the attention mask is an upper triangular mask that avoid each word to attend to the future
#the padding mask instead is contains 0's for the entries containing padding in the correspondent sequence
#the resulting matrix avoids each word to attend to future and delete the attention between paddings
if input_mask is not None:
self_attn_mask = torch.tensor((np.triu(np.ones((input_batch.shape[0], input_batch.shape[1], input_batch.shape[1])), k=1) == 0), dtype=torch.long).to(device)
self_attn_mask &= input_mask[:, :, None]
else:
#this is used during inference, where the words are given one by one (future is not present)
self_attn_mask = torch.ones((input_batch.shape[0], input_batch.shape[1], input_batch.shape[1]))
#encoder attention mask avoid 2 things:
# the decoder to attend to encoder padding (to apply row wise)
# to use the decoder padding as query (to apply column wise)
enc_attn_mask = torch.zeros((input_mask.shape[0], input_mask.shape[1], enc_mask.shape[1])).to(device)
enc_attn_mask[:, :] = enc_mask[:, None, :]
enc_attn_mask = enc_attn_mask.transpose(1, 2)
enc_attn_mask[:, :] *= input_mask[:, None, :]
enc_attn_mask = enc_attn_mask.transpose(1, 2)
visual_attn_mask = torch.zeros((input_mask.shape[0], input_mask.shape[1], visual_mask.shape[1])).to(device)
visual_attn_mask[:, :] = visual_mask[:, None, :]
visual_attn_mask = visual_attn_mask.transpose(1, 2)
visual_attn_mask[:, :] *= input_mask[:, None, :]
visual_attn_mask = visual_attn_mask.transpose(1, 2)
x = self.embedding_layer(input_batch)
"""
x = torch.zeros((input_batch.shape[0], input_batch.shape[1], self.d_model), dtype=torch.float32).to(device)
#todo x[:, 0] = self.embedding_layer(self.start_id)
for i in range(input_batch.shape[-1]):
curr_embs = self.embedding_layer(input=input_batch[:, :i+1],
input_mask=self_attn_mask[:, i, :i+1],
input_token_type=torch.zeros(input_batch[:, :i+1].shape, dtype=torch.long).to(device))
x[:, i] = curr_embs[:, i]
"""
#todo from here
#pdb.set_trace()
for idx in range(len(self.decoder_layers)):
#pdb.set_trace()
x = self.decoder_layers[idx](input_embs=x,
enc_out=encoder_out,
#history_context=history_context,
visual=visual,
self_attn_mask=self_attn_mask,
enc_attn_mask=enc_attn_mask,
visual_attn_mask=visual_attn_mask)
#pdb.set_trace()
vocab_logits = self.out_layer(x)
return vocab_logits
"""
if self.training:
for _ in range(gt_sequences.shape[1]):
#curr_out, (curr_ht, curr_ct) = self.decoder_module(prev_out, (prev_ht, prev_ct))
#logits = self.out_layer(curr_out)
#todo save the logits (need to know the sentences lengths)
#pred_tok = torch.argmax(F.softmax(logits))
prev_out = gt_sequences['tok_embeddings'][:, 0]
#prev_ht = curr_ht
#prev_ct = curr_ct
#todo end tok at the end
return None
else:
#here beam search
pass
"""
def __str__(self):
return super().__str__()
class TransformerEmbedding(nn.Module):
def __init__(self, vocab_size, d_model, embedding_net=None):
super(TransformerEmbedding, self).__init__()
if embedding_net is not None:
assert embedding_net.embedding_dim == d_model, 'Embedding size of {} does not match d_model of {}'.format(embedding_net.embedding_dim, d_model)
self.embedding_net = embedding_net
else:
self.embedding_net = nn.Embedding(vocab_size, d_model)
self.d_model = d_model
self.positional_embeddings = self.init_positional(max_seq_len=512,
emb_dim=d_model)
def forward(self, input_seq):
assert input_seq.dim() == 2, 'Expected tensor with 2 dimensions but got {}'.format(input_seq.dim())
batch_size = input_seq.shape[0]
input_len = input_seq.shape[1]
device = input_seq.device
pos_emb = self.positional_embeddings[:input_len].to(device)
#enforce the embedding to prevent loose on information by multiplying it with a scalar
return self.embedding_net(input_seq)*math.sqrt(self.d_model) + pos_emb[None, :, :]
def init_positional(self, max_seq_len, emb_dim):
"""Create positional embeddings (from "Attention Is All You Need", Vaswani et al. 2017)
Args:
n_position (int): number of elements in the sequence
emb_dim (int): size of embeddings
Returns:
toch.FloatTensor: a positional embedding with shape [N_POSITION x EMB_DIM]
"""
# keep dim 0 for padding token position encoding zero vector
position_enc = np.array([
[pos / np.power(10000, 2 * (k // 2) / emb_dim) for k in range(emb_dim)]
if pos != 0 else np.zeros(emb_dim) for pos in range(max_seq_len)])
position_enc[1:, 0::2] = np.sin(position_enc[1:, 0::2]) # dim 2i
position_enc[1:, 1::2] = np.cos(position_enc[1:, 1::2]) # dim 2i+1
return torch.from_numpy(position_enc).type(torch.FloatTensor)
def __str__(self):
return super().__str__()
class MultiAttentiveDecoder(nn.Module):
def __init__(self,
d_model,
d_enc,
d_context,
d_k,
d_v,
d_f,
n_heads,
dropout_prob):
super(MultiAttentiveDecoder, self).__init__()
#multi head self attention
#encoder attention
#fusion layer
self.multi_head_self = MultiHeadSelfAttention(d_model=d_model, d_k=d_k, d_v=d_v, n_heads=n_heads, dropout_prob=dropout_prob)
self.multi_head_enc = MultiHeadEncoderAttention(d_model=d_model, d_enc=d_enc, d_k=d_k, d_v=d_v, n_heads=n_heads, dropout_prob=dropout_prob)
self.multi_head_item = MultiHeadEncoderAttention(d_model=d_model, d_enc=d_enc, d_k=d_k, d_v=d_v, n_heads=n_heads, dropout_prob=dropout_prob)
#self.fusion_module = FusionModule(d_model=d_model, d_context=d_context, dropout_prob=dropout_prob)
self.layerNorm = nn.LayerNorm(d_model)
self.dropout = nn.Dropout(p=dropout_prob)
self.fnn = nn.Sequential(nn.Linear(in_features=d_model, out_features=d_f),
nn.ReLU(),
nn.Dropout(p=dropout_prob),
nn.Linear(in_features=d_f, out_features=d_model))
def forward(self,
input_embs,
enc_out,
#history_context,
visual,
visual_attn_mask,
self_attn_mask,
enc_attn_mask):
#pdb.set_trace()
self_attn_out = self.multi_head_self(input_embs, self_attn_mask)
sub_out1 = self.layerNorm(input_embs + self.dropout(self_attn_out))
enc_attn_out = self.multi_head_enc(sub_out1, enc_out, enc_attn_mask)
sub_out2 = self.layerNorm(sub_out1 + self.dropout(enc_attn_out))
item_attn_out = self.multi_head_item(sub_out2, visual, visual_attn_mask)
sub_out3 = self.layerNorm(sub_out2 + self.dropout(item_attn_out))
#fusion_out = self.fusion_module(sub_out2, history_context, visual_context)
#sub_out3 = self.layerNorm(sub_out2 + self.dropout(fusion_out))
fnn_out = self.fnn(sub_out3) #todo change to subout3
sub_out4 = self.layerNorm(sub_out3 + self.dropout(fnn_out)) #todo change to subout3
return sub_out4
def __str__(self):
return super().__str__()
class FusionModule(nn.Module):
def __init__(self, d_model, d_context, dropout_prob):
super(FusionModule, self).__init__()
self.d_context = d_context
self.d_model = d_model
d_cat = d_model+d_context
self.h_stream = nn.Sequential(nn.Linear(in_features=d_cat, out_features=d_cat//2),
nn.Linear(in_features=d_cat//2, out_features=d_cat//4),
nn.ReLU(),
nn.Dropout(p=dropout_prob),
nn.Linear(in_features=d_cat//4, out_features=d_cat//2),
nn.Linear(in_features=d_cat//2, out_features=d_cat))
self.v_stream = nn.Sequential(nn.Linear(in_features=d_cat, out_features=d_cat//2),
nn.Linear(in_features=d_cat//2, out_features=d_cat//4),
nn.ReLU(),
nn.Dropout(p=dropout_prob),
nn.Linear(in_features=d_cat//4, out_features=d_cat//2),
nn.Linear(in_features=d_cat//2, out_features=d_cat))
self.fusion_stream = nn.Sequential(nn.Linear(in_features=2*d_cat, out_features=d_cat),
nn.ReLU(),
nn.Dropout(p=dropout_prob),
nn.Linear(in_features=d_cat, out_features=d_model))
def forward(self, decoder_batch, history_cntx, visual_cntx):
assert decoder_batch.dim() == 3, 'Expected 3 dimensions, got {}'.format(decoder_batch.dim())
assert history_cntx.shape[-1] == self.d_context, 'History dimension {} does not match d_context of {}'.format(history_cntx.shape[-1], self.d_context)
assert history_cntx.shape[-1] == visual_cntx.shape[-1], 'History and visual context sizes do not match'
h_in = torch.cat((decoder_batch, history_cntx.unsqueeze(1).expand(-1, decoder_batch.shape[1], -1)), dim=-1)
v_in = torch.cat((decoder_batch, visual_cntx.unsqueeze(1).expand(-1, decoder_batch.shape[1], -1)), dim=-1)
h_out = self.v_stream(h_in)
v_out = self.h_stream(v_in)
fuse_in = torch.cat((h_out, v_out), dim=-1)
fuse_out = self.fusion_stream(fuse_in)
return fuse_out
class MultiHeadSelfAttention(nn.Module):
def __init__(self, d_model, d_k, d_v, n_heads, dropout_prob):
super(MultiHeadSelfAttention, self).__init__()
self.n_heads = n_heads
self.attn_heads = nn.ModuleList([SelfAttention(d_model, d_k, d_v, dropout_prob) for _ in range(n_heads)])
def forward(self, input_batch, attn_mask):
return torch.cat([attn_head(input_batch, attn_mask) for attn_head in self.attn_heads], dim=-1)
def __str__(self):
return super().__str__()
class MultiHeadEncoderAttention(nn.Module):
def __init__(self, d_model, d_enc, d_k, d_v, n_heads, dropout_prob):
super(MultiHeadEncoderAttention, self).__init__()
self.n_heads = n_heads
self.attn_heads = nn.ModuleList([EncoderAttention(d_model, d_enc, d_k, d_v, dropout_prob) for _ in range(n_heads)])
def forward(self, decoder_batch, encoder_out, attn_mask):
return torch.cat([attn_head(decoder_batch, encoder_out, attn_mask) for attn_head in self.attn_heads], dim=-1)
def __str__(self):
return super().__str__()
class SelfAttention(nn.Module):
def __init__(self, d_model, d_k, d_v, dropout_prob):
super(SelfAttention, self).__init__()
self.d_k = d_k
self.d_v = d_v
self.Q = nn.Linear(d_model, d_k)
self.K = nn.Linear(d_model, d_k)
self.V = nn.Linear(d_model, d_v)
self.dropout = nn.Dropout(p=dropout_prob)
def forward(self, input_batch, attn_mask):
query = self.Q(input_batch)
key = self.K(input_batch)
value = self.V(input_batch)
attn_logits = torch.matmul(query, torch.transpose(key, -2, -1))/ math.sqrt(self.d_k)
#mask padding and future words with a great negative value.
# DO NOT USE '-INF' VALUES BECAUSE THEY WILL PRODUCE NaN VALUES AFTER SOFTMAX FOR PADDING WORDS
masked_attn_logits = attn_logits.masked_fill(attn_mask==0, value=_MASKING_VALUE)
attn_scores = F.softmax(masked_attn_logits, -1)
attn_scores = self.dropout(attn_scores)
out = torch.matmul(attn_scores, value)
return out
def __str__(self):
return super().__str__()
class EncoderAttention(nn.Module):
def __init__(self, d_model, d_enc, d_k, d_v, dropout_prob):
super(EncoderAttention, self).__init__()
self.d_k = d_k
self.d_v = d_v
self.Q = nn.Linear(d_model, d_k)
self.K = nn.Linear(d_enc, d_k)
self.V = nn.Linear(d_enc, d_v)
self.dropout = nn.Dropout(p=dropout_prob)
def forward(self, decoder_batch, encoder_out, attn_mask):
query = self.Q(decoder_batch)
key = self.K(encoder_out)
value = self.V(encoder_out)
attn_logits = torch.matmul(query, torch.transpose(key, -2, -1))/ math.sqrt(self.d_k)
#mask padding and future words with a great negative value.
# DO NOT USE '-INF' VALUES BECAUSE THEY WILL PRODUCE NaN VALUES AFTER SOFTMAX FOR PADDING WORDS
masked_attn_logits = attn_logits.masked_fill(attn_mask==0, value=_MASKING_VALUE)
attn_scores = F.softmax(masked_attn_logits, dim=-1)
attn_scores = self.dropout(attn_scores)
out = torch.matmul(attn_scores, value)
return out
def __str__(self):
return super().__str__() | 17,844 | 42.630807 | 168 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/models/matransformer.py | import math
import pdb
import numpy as np
import torch
import torch.nn.functional as F
from torch import nn
from .embednets import ItemEmbeddingNetwork, WordEmbeddingNetwork
from .decoder import Decoder
from .old_encoder import SingleEncoder
from .bert import BertEncoder
from transformers import BertTokenizer #todo remove
_MAX_INFER_LEN = 30
class MultiAttentiveTransformer(nn.Module):
def __init__(self,
pad_token,
start_token,
end_token,
unk_token, #? remove
seed,
dropout_prob,
n_decoders,
decoder_heads,
out_vocab,
freeze_bert=False,
beam_size=None,
retrieval_eval=False,
gen_eval=False,
mode='train',
device='cpu'):
torch.manual_seed(seed)
super(MultiAttentiveTransformer, self).__init__()
if mode == 'inference':
assert retrieval_eval is not None or gen_eval is not None, 'At least one among retrieval_eval and gen_eval must be activated during inference'
if gen_eval is not None:
assert beam_size is not None, 'Beam size need to be defined during generation inference'
self.mode = mode
self.beam_size = beam_size
self.retrieval_eval = retrieval_eval
self.gen_eval = gen_eval
self.bert2genid = out_vocab
#self.item_embeddings_layer = ItemEmbeddingNetwork(item_embeddings_path)
"""
self.word_embeddings_layer = WordEmbeddingNetwork(word_embeddings_path=word_embeddings_path,
word2id=word2id,
pad_token=pad_token,
unk_token=unk_token,
freeze=freeze_embeddings)
self.emb_dim = self.word_embeddings_layer.embedding_size
"""
self.bert = BertEncoder(pretrained='bert-base-uncased', freeze=freeze_bert)
self.tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
self.vocab = self.tokenizer.vocab
self.id2word = {id: word for word, id in self.vocab.items()}
self.genid2word = {gen_id: self.tokenizer.convert_ids_to_tokens(bert_id) for bert_id, gen_id in self.bert2genid.items()}
self.genid2bertid = {id: word for word, id in self.bert2genid.items()}
#start_id only presents in input
self.start_id = self.vocab[start_token]
#end_id only presents in output
self.end_id = self.bert2genid[self.vocab[end_token]]
#pad_id is the same between input and ouput
self.pad_id = self.vocab[pad_token]
self.unk_id = self.vocab[unk_token]
conf = self.bert.configuration
self.input_vocab_size = conf.vocab_size
self.output_vocab_size = len(out_vocab)
self.encoder_hidden_size = conf.hidden_size
"""
self.encoder = SingleEncoder(input_size=self.emb_dim,
hidden_size=hidden_size,
dropout_prob=dropout_prob,
encoder_heads=encoder_heads,
embedding_net=self.word_embeddings_layer)
"""
#for h heads: d_k == d_v == emb_dim/h
self.decoder = Decoder(d_model=self.encoder_hidden_size,
d_enc=self.encoder_hidden_size,
d_context=self.encoder_hidden_size,
d_k=self.encoder_hidden_size//decoder_heads,
d_v=self.encoder_hidden_size//decoder_heads,
d_f=self.encoder_hidden_size//2,
n_layers=n_decoders,
n_heads=decoder_heads,
embedding_net=self.bert,
input_vocab_size=self.input_vocab_size,
out_vocab_size=self.output_vocab_size,
dropout_prob=dropout_prob)
def forward(self,
utterances,
utterances_mask,
utterances_token_type,
responses,
responses_mask,
responses_token_type,
focus,
focus_mask,
focus_token_type,
history,
actions,
attributes,
candidates=None,
candidates_mask=None,
candidates_token_type=None,
candidates_targets=None,
seq_lengths=None):
"""The visual context is a list of visual contexts (a batch). Each visual context is, in turn, a list
of items. Each item is a list of (key, values) pairs, where key is a tensor containing the word ids
for the field name and values is a list of values where each value is a tensor of word ids.
type(visual_context[<sample_in_batch>][<item_n>][<field_n>]) -> tuple(tensor(key), [tensor(value)])
Args:
utterances ([type]): [description]
history ([type]): [description]
visual_context ([type]): [description]
seq_lengths ([type], optional): [description]. Defaults to None.
device (str, optional): [description]. Defaults to 'cpu'.
Returns:
[type]: [description]
"""
curr_device = utterances.device
if self.mode == 'inference':
assert utterances.shape[0] == 1, 'Only unitary batches allowed during inference'
#check batch size consistency (especially when using different gpus) and move list tensors to correct gpu
assert utterances.shape[0] == utterances_mask.shape[0], 'Inconstistent batch size'
assert utterances.shape[0] == utterances_token_type.shape[0], 'Inconstistent batch size'
assert utterances.shape[0] == responses.shape[0], 'Inconstistent batch size'
assert utterances.shape[0] == responses_mask.shape[0], 'Inconstistent batch size'
assert utterances.shape[0] == responses_token_type.shape[0], 'Inconstistent batch size'
assert utterances.shape[0] == focus.shape[0], 'Inconstistent batch size'
assert utterances.shape[0] == focus_mask.shape[0], 'Inconstistent batch size'
assert utterances.shape[0] == focus_token_type.shape[0], 'Inconstistent batch size'
if self.retrieval_eval:
assert candidates_targets is not None, 'Candidates have to be specified with retrieval_eval set to True'
assert attributes is not None, 'Attributes needed for semantic score computation'
u_t_all = self.bert(input=utterances,
input_mask=utterances_mask,
input_token_type=utterances_token_type)
v_t_tilde = self.bert(input=focus,
input_mask=focus_mask,
input_token_type=focus_token_type)
"""
u_t_all, v_t_tilde, h_t_tilde = self.encoder(utterances=utterances,
history=history,
focus_items=focus,
seq_lengths=seq_lengths)
"""
#decoding phase
if self.mode == 'train':
vocab_logits = self.decoder(input_batch=responses,
encoder_out=u_t_all,
#history_context=h_t_tilde,
visual=v_t_tilde,
input_mask=responses_mask,
enc_mask=utterances_mask,
visual_mask=focus_mask)
return vocab_logits
else:
infer_res = {}
if self.gen_eval:
#at inference time (NOT EVAL)
self.never_ending = 0
dec_args = {'encoder_out': u_t_all, 'enc_mask': utterances_mask, 'visual': v_t_tilde, 'visual_mask': focus_mask}
best_dict = self.beam_search(curr_seq=[self.start_id],
curr_score=0,
dec_args=dec_args,
best_dict={'seq': [], 'score': -float('inf')},
device=curr_device)
best_dict['string'] = self.tokenizer.decode([self.genid2bertid[id] for id in best_dict['seq']])
#print('Never-ending generated sequences: {}'.format(self.never_ending))
infer_res['generation'] = best_dict
if self.retrieval_eval:
#eval on retrieval task
#build a fake batch by expanding the tensors
vocab_logits = [
self.decoder(input_batch=pool,
encoder_out=u_t_all.expand(pool.shape[0], -1, -1),
#history_context=h_t_tilde.expand(pool.shape[0], -1),
visual=v_t_tilde.expand(pool.shape[0], -1, -1),
visual_mask=focus_mask.expand(pool.shape[0], -1),
input_mask=pool_mask,
enc_mask=utterances_mask.expand(pool.shape[0], -1))
for pool, pool_mask in zip(candidates, candidates_mask)
]
#candidates_scores shape: Bx100
candidates_scores = self.compute_candidates_scores(candidates_targets, vocab_logits, attributes)
infer_res['retrieval'] = candidates_scores
return infer_res
def beam_search(self, curr_seq, curr_score, dec_args, best_dict, device):
#pdb.set_trace()
if curr_seq[-1] == self.end_id or len(curr_seq) > _MAX_INFER_LEN:
assert len(curr_seq)-1 != 0, 'Division by 0 for generated sequence {}'.format(curr_seq)
#discard the start_id only. The probability of END token has to be taken into account instead.
norm_score = curr_score/(len(curr_seq)-1)
if norm_score > best_dict['score']:
best_dict['score'], best_dict['seq'] = curr_score, curr_seq[1:].copy() #delete the start_token
if len(curr_seq) > _MAX_INFER_LEN:
self.never_ending += 1
return best_dict
vocab_logits = self.decoder(input_batch=torch.tensor(curr_seq).unsqueeze(0).to(device), **dec_args).squeeze(0)
#take only the prediction for the last word
vocab_logits = vocab_logits[-1]
beam_ids = torch.argsort(vocab_logits, descending=True, dim=-1)[:self.beam_size].tolist()
lprobs = F.log_softmax(vocab_logits, dim=-1)
for curr_id in beam_ids:
curr_lprob = lprobs[curr_id].item()
best_dict = self.beam_search(curr_seq=curr_seq+[curr_id],
curr_score=curr_score+curr_lprob,
dec_args=dec_args,
best_dict=best_dict,
device=device)
return best_dict
def compute_candidates_scores(self, candidates_targets, vocab_logits, attributes):
"""The score of each candidate is the sum of the log-likelihood of each word, normalized by its length.
The score will be a negative value, longer sequences will be penalized without the normalization by length.
"""
scores = torch.zeros(candidates_targets.shape[:2])
for batch_idx, (pool_ids, pool_logits) in enumerate(zip(candidates_targets, vocab_logits)):
pool_lprobs = F.log_softmax(pool_logits, dim=-1)
for sentence_idx, (candidate_ids, candidate_lprobs) in enumerate(zip(pool_ids, pool_lprobs)):
curr_lprob = []
for candidate_word, words_probs in zip(candidate_ids, candidate_lprobs):
#until padding
if candidate_word.item() == self.pad_id:
break
curr_lprob.append(words_probs[candidate_word.item()].item())
scores[batch_idx, sentence_idx] = sum(curr_lprob)/len(curr_lprob)
#semantic score
candidate_string = self.tokenizer.decode([self.genid2bertid[id.item()] for id in candidate_ids])
semantic_score = [attr.lower() in candidate_string.lower() and len(attr) > 1 for attr in attributes]
if len(attributes):
scores[batch_idx, sentence_idx] += sum(semantic_score)/len(attributes)
return scores
def collate_fn(self, batch):
"""
This method prepares the batch for the LSTM: padding + preparation for pack_padded_sequence
Args:
batch (tuple): tuple of element returned by the Dataset.__getitem__()
Returns:
dial_ids (list): list of dialogue ids
turns (list): list of dialogue turn numbers
seq_tensor (torch.LongTensor): tensor with BxMAX_SEQ_LEN containing padded sequences of user transcript sorted by descending effective lengths
seq_lenghts: tensor with shape B containing the effective length of the correspondant transcript sequence
actions (torch.Longtensor): tensor with B shape containing target actions
attributes (torch.Longtensor): tensor with Bx33 shape containing attributes one-hot vectors, one for each sample.
"""
dial_ids = [item[0] for item in batch]
turns = [item[1] for item in batch]
utterances = torch.stack([item[2] for item in batch])
utterances_mask = torch.stack([item[3] for item in batch])
utterances_token_type = torch.stack([item[4] for item in batch])
responses = torch.stack([item[5] for item in batch])
responses_mask = torch.stack([item[6] for item in batch])
responses_token_type = torch.stack([item[7] for item in batch])
#history = [item[4] for item in batch]
#actions = torch.stack([item[5] for item in batch])
attributes = [item[8] for item in batch]
focus = torch.stack([item[9] for item in batch])
focus_mask = torch.stack([item[10] for item in batch])
focus_token_type = torch.stack([item[11] for item in batch])
if self.mode == 'train':
#creates target by shifting and converting id to output vocabulary
generative_targets = torch.cat((responses[:, 1:].clone().detach(), torch.zeros((responses.shape[0], 1), dtype=torch.long)), dim=-1)
for batch_idx, _ in enumerate(generative_targets):
for id_idx, curr_id in enumerate(generative_targets[batch_idx]):
if curr_id.item() == self.pad_id:
continue
if curr_id.item() not in self.bert2genid:
#dev test contains oov tokens
generative_targets[batch_idx][id_idx] = self.bert2genid[self.unk_id]
else:
generative_targets[batch_idx][id_idx] = self.bert2genid[curr_id.item()]
if self.mode == 'inference' and self.retrieval_eval:
candidates = torch.stack([item[12] for item in batch])
candidates_mask = torch.stack([item[13] for item in batch])
candidates_token_type = torch.stack([item[14] for item in batch])
candidates_targets = torch.cat((candidates[:, :, 1:].clone().detach(), torch.zeros((responses.shape[0], 100, 1), dtype=torch.long)), dim=-1)
for batch_idx, _ in enumerate(candidates_targets):
for pool_idx, curr_pool in enumerate(candidates_targets[batch_idx]):
for id_idx, curr_id in enumerate(candidates_targets[batch_idx][pool_idx]):
if curr_id.item() == self.pad_id:
continue
if curr_id.item() not in self.bert2genid:
candidates_targets[batch_idx][pool_idx][id_idx] = self.bert2genid[self.unk_id]
else:
candidates_targets[batch_idx][pool_idx][id_idx] = self.bert2genid[curr_id.item()]
assert utterances.shape[0] == len(dial_ids), 'Batch sizes do not match'
assert utterances.shape[0] == len(turns), 'Batch sizes do not match'
#assert len(utterances) == len(history), 'Batch sizes do not match'
#assert len(utterances) == len(actions), 'Batch sizes do not match'
#assert len(utterances) == len(attributes), 'Batch sizes do not match'
assert utterances.shape[0] == len(focus), 'Batch sizes do not match'
if self.mode == 'train':
assert responses.shape == generative_targets.shape, 'Batch sizes do not match'
if self.mode == 'inference' and self.retrieval_eval:
assert len(utterances) == candidates.shape[0], 'Batch sizes do not match'
batch_dict = {}
batch_dict['utterances'] = utterances
batch_dict['utterances_mask'] = utterances_mask
batch_dict['utterances_token_type'] = utterances_token_type
batch_dict['responses'] = responses
batch_dict['responses_mask'] = responses_mask
batch_dict['responses_token_type'] = responses_token_type
batch_dict['focus'] = focus
batch_dict['focus_mask'] = focus_mask
batch_dict['focus_token_type'] = focus_token_type
if self.retrieval_eval:
batch_dict['candidates'] = candidates
batch_dict['candidates_mask'] = candidates_mask
batch_dict['candidates_token_type'] = candidates_token_type
batch_dict['candidates_targets'] = candidates_targets
assert len(attributes) == 1, 'Batch size greater than 1 for attributes'
batch_dict['attributes'] = attributes[0]
ret_tuple = (dial_ids, turns, batch_dict)
if self.mode == 'train':
ret_tuple += (generative_targets,)
return ret_tuple
def __str__(self):
return super().__str__()
| 18,570 | 51.312676 | 155 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/models/blindstateless.py | import pdb
import numpy as np
import torch
import torch.nn.functional as F
from torch import nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
from .embednets import WordEmbeddingNetwork
class BlindStatelessLSTM(nn.Module):
"""Implementation of a blind and stateless LSTM for action prediction. It approximates the probability distribution:
P(a_t | U_t)
Where a_t is the action and U_t the user utterance.
Args:
torch (WordEmbeddingBasedNetwork): inherits from WordEmbeddingBasedNetwork
Attributes:
self.corrections (dict): Mapping from dataset word to its corrections (the corrections is included in the vocabulary)
"""
_HIDDEN_SIZE = 600
def __init__(self, word_embeddings_path, word2id, pad_token, unk_token,
seed, OOV_corrections=False, freeze_embeddings=False):
"""
Glove download: https://nlp.stanford.edu/projects/glove/
Args:
embedding_path ([type]): [description]
"""
torch.manual_seed(seed)
super(BlindStatelessLSTM, self).__init__()
self.hidden_size = self._HIDDEN_SIZE
self.word_embeddings_layer = WordEmbeddingNetwork(word_embeddings_path=word_embeddings_path,
word2id=word2id,
pad_token=pad_token,
unk_token=unk_token,
OOV_corrections=OOV_corrections,
freeze=freeze_embeddings)
self.lstm = nn.LSTM(self.word_embeddings_layer.embedding_dim, self.hidden_size, batch_first=True)
self.dropout = nn.Dropout(p=0.5)
self.matching_layer = nn.Linear(in_features=2*self.hidden_size, out_features=1)
def forward(self, utterances, candidates_pool, seq_lengths=None, device='cpu'):
"""Forward pass for BlindStatelessLSTM
Args:
batch (torch.LongTensor): Tensor containing the batch (shape=BxMAX_SEQ_LEN)
seq_lengths (torch.LongTensor, optional): Effective lengths (no pad) of each sequence in the batch. If given the pack_padded__sequence are used.
The shape is B. Defaults to None.
"""
embedded_seq_tensor = self.word_embeddings_layer(utterances)
if seq_lengths is not None:
# pack padded sequence
packed_input = pack_padded_sequence(embedded_seq_tensor, seq_lengths.cpu().numpy(), batch_first=True)
# h_t has shape NUM_DIRxBxHIDDEN_SIZE
out, (h_t, c_t) = self.lstm(packed_input)
"""unpack not needed. We don't use the output
if seq_lengths is not None:
# unpack padded sequence
output, input_sizes = pad_packed_sequence(out1, batch_first=True)
"""
utterance_hiddens = self.dropout(h_t.squeeze(0))
# tensors_pool has shape BATCH_SIZEx100xHIDDEN_SIZE
tensors_pool = self.encode_pool(candidates_pool, device)
# build pairs (utterance, candidate[i]) for computing similarity
assert utterance_hiddens.shape[0] == tensors_pool.shape[0], 'Problem with first dimension'
matching_pairs = []
for utterance, candidate in zip(utterance_hiddens, tensors_pool):
matching_pairs.append(torch.cat((utterance.expand(candidate.shape[0], -1), candidate), dim=-1))
matching_pairs = torch.stack(matching_pairs)
# matching_pairs has shape Bx100x2*HIDDEN_SIZE
matching_logits = []
for pair in matching_pairs:
matching_logits.append(self.matching_layer(pair))
matching_logits = torch.stack(matching_logits).squeeze(-1)
matching_scores = torch.sigmoid(matching_logits)
return matching_logits, matching_scores
def encode_pool(self, candidates_pool, device):
tensors_pool = []
for pool in candidates_pool:
curr_hiddens = []
for candidate in pool:
embeddings = self.word_embeddings_layer(candidate.to(device))
_, (h_t, _) = self.lstm(embeddings.unsqueeze(0))
curr_hiddens.append(h_t.squeeze(0).squeeze(0))
tensors_pool.append(torch.stack(curr_hiddens))
tensors_pool = torch.stack(tensors_pool)
return tensors_pool
def collate_fn(self, batch):
"""This method prepares the batch for the LSTM: padding + preparation for pack_padded_sequence
Args:
batch (tuple): tuple of element returned by the Dataset.__getitem__()
Returns:
dial_ids (list): list of dialogue ids
turns (list): list of dialogue turn numbers
seq_tensor (torch.LongTensor): tensor with BxMAX_SEQ_LEN containing padded sequences of user transcript sorted by descending effective lengths
seq_lenghts: tensor with shape B containing the effective length of the correspondant transcript sequence
actions (torch.Longtensor): tensor with B shape containing target actions
arguments (torch.Longtensor): tensor with Bx33 shape containing arguments one-hot vectors, one for each sample.
"""
dial_ids = [item[0] for item in batch]
turns = [item[1] for item in batch]
transcripts = [torch.tensor(item[2]) for item in batch]
responses_pool = [item[7] for item in batch]
assert len(transcripts) == len(dial_ids), 'Batch sizes do not match'
assert len(transcripts) == len(turns), 'Batch sizes do not match'
assert len(transcripts) == len(responses_pool), 'Batch sizes do not match'
# reorder the sequences from the longest one to the shortest one.
# keep the correspondance with the target
transcripts_lengths = torch.tensor(list(map(len, transcripts)), dtype=torch.long)
transcripts_tensor = torch.zeros((len(transcripts), transcripts_lengths.max()), dtype=torch.long)
for idx, (seq, seqlen) in enumerate(zip(transcripts, transcripts_lengths)):
transcripts_tensor[idx, :seqlen] = seq.clone().detach()
# sort instances by sequence length in descending order
transcripts_lengths, perm_idx = transcripts_lengths.sort(0, descending=True)
transcripts_tensor = transcripts_tensor[perm_idx]
sorted_dial_ids = []
sorted_dial_turns = []
sorted_responses = []
for idx in perm_idx:
sorted_dial_ids.append(dial_ids[idx])
sorted_dial_turns.append(turns[idx])
sorted_responses.append(responses_pool[idx])
batch_dict = {}
batch_dict['utterances'] = transcripts_tensor
batch_dict['seq_lengths'] = transcripts_lengths
# seq_lengths is used to create a pack_padded_sequence
return sorted_dial_ids, sorted_dial_turns, batch_dict, sorted_responses
def __str__(self):
return super().__str__()
| 7,099 | 42.82716 | 156 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_response_generation/utilities/dataparallelv2.py | from torch.nn.parallel._functions import Scatter
from torch.nn.parallel import DataParallel
import torch
import math
# This code was copied from torch.nn.parallel and adapted for DataParallel to chunk lists instead of duplicating them
# (this is really all this code is here for)
def scatter(inputs, target_gpus, dim=0):
r"""
Slices tensors into approximately equal chunks and
distributes them across given GPUs. Duplicates
references to objects that are not tensors.
"""
def scatter_map(obj):
if isinstance(obj, torch.Tensor):
return Scatter.apply(target_gpus, None, dim, obj)
if isinstance(obj, tuple) and len(obj) > 0:
return list(zip(*map(scatter_map, obj)))
if isinstance(obj, list) and len(obj) > 0:
#on the last gpu the torch scatter always put the remaining samples to fit the batch
# (e.g., batch=256, n_gpus=3 ==> chunks=[86, 86, 84])
size = math.ceil(len(obj)/len(target_gpus))
chunk = [obj[i * size:(i + 1) * size] for i in range(len(target_gpus)-1)]
diff = len(obj) - size*(len(target_gpus)-1)
chunk.append(obj[-diff:])
return chunk
if isinstance(obj, dict) and len(obj) > 0:
return list(map(type(obj), zip(*map(scatter_map, obj.items()))))
return [obj for targets in target_gpus]
# After scatter_map is called, a scatter_map cell will exist. This cell
# has a reference to the actual function scatter_map, which has references
# to a closure that has a reference to the scatter_map cell (because the
# fn is recursive). To avoid this reference cycle, we set the function to
# None, clearing the cell
try:
return scatter_map(inputs)
finally:
scatter_map = None
def scatter_kwargs(inputs, kwargs, target_gpus, dim=0):
r"""Scatter with support for kwargs dictionary"""
inputs = scatter(inputs, target_gpus, dim) if inputs else []
kwargs = scatter(kwargs, target_gpus, dim) if kwargs else []
if len(inputs) < len(kwargs):
inputs.extend([() for _ in range(len(kwargs) - len(inputs))])
elif len(kwargs) < len(inputs):
kwargs.extend([{} for _ in range(len(inputs) - len(kwargs))])
inputs = tuple(inputs)
kwargs = tuple(kwargs)
return inputs, kwargs
class DataParallelV2(DataParallel):
def scatter(self, inputs, kwargs, device_ids):
return scatter_kwargs(inputs, kwargs, device_ids, dim=self.dim) | 2,498 | 41.355932 | 117 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_action_prediction/preprocessing.py | import argparse
import datetime
import math
import os
import pdb
import random
import sys
import time
import numpy as np
import torch
from torch.utils.data import DataLoader
import sys
sys.path.append('.')
from config import TrainConfig
from tools.simmc_dataset import SIMMCDatasetForActionPrediction
class Collate():
def __init__(self, word2id, item2id, unk_token):
self.word2id = word2id
self.item2id = item2id
self.unk_token = unk_token
def collate_fn(self, batch):
dial_ids = [item[0] for item in batch]
turns = [item[1] for item in batch]
history = [item[3] for item in batch]
visual_context = [item[4] for item in batch]
actions = torch.tensor([item[5] for item in batch])
attributes = torch.tensor([item[6] for item in batch])
# words to ids for the current utterance
utterance_seq_ids = []
for item in batch:
curr_seq = []
for word in item[2].split():
word_id = self.word2id[word] if word in self.word2id else self.word2id[self.unk_token]
curr_seq.append(word_id)
utterance_seq_ids.append(curr_seq)
# words to ids for the history
history_seq_ids = []
for turn, item in zip(turns, history):
assert len(item) == turn, 'Number of turns does not match history length'
curr_turn_ids = []
for t in range(turn):
concat_sentences = item[t][0] + ' ' + item[t][1] #? separator token
curr_seq = []
for word in concat_sentences.split():
word_id = self.word2id[word] if word in self.word2id else self.word2id[self.unk_token]
curr_seq.append(word_id)
curr_turn_ids.append(torch.tensor(curr_seq))
history_seq_ids.append(curr_turn_ids)
# item to id for the visual context
visual_ids = {'focus': [], 'history': []}
for v in visual_context:
curr_focus = self.item2id[v['focus']]
curr_history = []
for vv in v['history']:
v_id = self.item2id[vv]
curr_history.append(torch.tensor(v_id))
visual_ids['focus'].append(torch.tensor(curr_focus))
if len(curr_history):
curr_history = torch.stack(curr_history)
visual_ids['history'].append(curr_history)
visual_ids['focus'] = torch.stack(visual_ids['focus'])
assert len(utterance_seq_ids) == 1, 'Only unitary batch sizes allowed'
assert len(utterance_seq_ids) == len(dial_ids), 'Batch sizes do not match'
assert len(utterance_seq_ids) == len(turns), 'Batch sizes do not match'
assert len(utterance_seq_ids) == len(history_seq_ids), 'Batch sizes do not match'
assert len(utterance_seq_ids) == actions.shape[0], 'Batch sizes do not match'
assert len(utterance_seq_ids) == attributes.shape[0], 'Batch sizes do not match'
assert len(utterance_seq_ids) == len(visual_ids['focus']), 'Batch sizes do not match'
assert len(utterance_seq_ids) == len(visual_ids['history']), 'Batch sizes do not match'
batch_dict = {}
batch_dict['utterances'] = utterance_seq_ids
batch_dict['history'] = history_seq_ids
batch_dict['visual_context'] = visual_ids
return dial_ids, turns, batch_dict, actions, attributes
def save_data_on_file(iterator, save_path):
dial_id_list = []
turn_list = []
utterance_list = []
history_list = []
actions_list = []
attributes_list = []
visual_context_list = {'focus': [], 'history': []}
for dial_ids, turns, batch, actions, attributes in iterator:
dial_id_list.append(dial_ids[0])
turn_list.append(turns[0])
utterance_list.append(batch['utterances'][0])
history_list.append(batch['history'][0])
actions_list.append(actions[0])
attributes_list.append(attributes[0])
visual_context_list['focus'].append(batch['visual_context']['focus'][0])
visual_context_list['history'].append(batch['visual_context']['history'][0])
torch.save(
{
'dial_ids': dial_id_list,
'turns': turn_list,
'utterances': utterance_list,
'histories': history_list,
'actions': torch.stack(actions_list),
'attributes': torch.stack(attributes_list),
'visual_contexts': visual_context_list,
'num_actions': len(SIMMCDatasetForActionPrediction._LABEL2ACT),
'num_attributes': len(SIMMCDatasetForActionPrediction._ATTRS),
'actions_support': iterator.dataset.act_support,
'attributes_support': iterator.dataset.attr_support
},
save_path
)
def preprocess(train_dataset, dev_dataset, test_dataset, args):
# prepare model's vocabulary
train_vocabulary = train_dataset.get_vocabulary()
dev_vocabulary = dev_dataset.get_vocabulary()
test_vocabulary = test_dataset.get_vocabulary()
vocabulary = train_vocabulary.union(dev_vocabulary)
vocabulary = vocabulary.union(test_vocabulary)
word2id = {}
word2id[TrainConfig._PAD_TOKEN] = 0
word2id[TrainConfig._UNK_TOKEN] = 1
for idx, word in enumerate(vocabulary):
word2id[word] = idx+2
np.save(os.path.join('/'.join(args.train_folder.split('/')[:-1]), 'vocabulary.npy'), word2id) #todo uncomment
print('VOCABULARY SIZE: {}'.format(len(vocabulary)))
raw_data = np.load(args.metadata_embeddings, allow_pickle=True)
raw_data = dict(raw_data.item())
item2id = {}
for idx, item in enumerate(raw_data['item_ids']):
item2id[item] = idx
collate = Collate(word2id=word2id, item2id=item2id, unk_token=TrainConfig._UNK_TOKEN)
# prepare DataLoader
params = {'batch_size': 1,
'shuffle': False,
'num_workers': 0}
trainloader = DataLoader(train_dataset, **params, collate_fn=collate.collate_fn)
devloader = DataLoader(dev_dataset, **params, collate_fn=collate.collate_fn)
testloader = DataLoader(test_dataset, **params, collate_fn=collate.collate_fn)
start_t = time.time()
save_path='{}/{}_action_prediction_data.dat'
save_data_on_file(iterator=trainloader, save_path=save_path.format(args.actions_folder, 'train'))
save_data_on_file(iterator=devloader, save_path=save_path.format(args.actions_folder, 'dev'))
save_data_on_file(iterator=testloader, save_path=save_path.format(args.actions_folder, 'devtest'))
end_t = time.time()
h_count = (end_t-start_t) /60 /60
m_count = ((end_t-start_t)/60) % 60
s_count = (end_t-start_t) % 60
print('preprocessing time: {}h:{}m:{}s'.format(round(h_count), round(m_count), round(s_count)))
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
"--simmc_folder",
type=str,
required=True,
help="Path to simmc fashion dataset folder")
parser.add_argument(
"--actions_folder",
type=str,
required=True,
help="Path to simmc fashion actions folder")
parser.add_argument(
"--embeddings",
type=str,
required=True,
help="Path to embeddings file")
parser.add_argument(
"--metadata_embeddings",
type=str,
required=True,
help="Path to metadata embeddings file")
parser.add_argument(
"--metadata",
type=str,
required=True,
help="Path to metadata JSON file")
args = parser.parse_args()
dataset_path = '{}/fashion_{}_dials.json'
actions_path = '{}/fashion_{}_dials_api_calls.json'
train_dataset = SIMMCDatasetForActionPrediction(data_path=dataset_path.format(args.simmc_folder, 'train'),
metadata_path=args.metadata,
actions_path=actions_path.format(args.actions_folder, 'train'))
dev_dataset = SIMMCDatasetForActionPrediction(data_path=dataset_path.format(args.simmc_folder, 'dev'),
metadata_path=args.metadata,
actions_path=actions_path.format(args.actions_folder, 'dev'))
test_dataset = SIMMCDatasetForActionPrediction(data_path=dataset_path.format(args.simmc_folder, 'devtest'),
metadata_path=args.metadata,
actions_path=actions_path.format(args.actions_folder, 'devtest'))
preprocess(train_dataset, dev_dataset, test_dataset, args)
| 8,706 | 38.220721 | 117 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_action_prediction/eval.py | import argparse
import json
import os
import pdb
import sys
import torch
from torch.utils.data import DataLoader
sys.path.append('.')
from config import TrainConfig
from dataset import FastDataset
from models import BlindStatefulLSTM, BlindStatelessLSTM, MMStatefulLSTM
from tools.simmc_dataset import SIMMCDatasetForActionPrediction
"""expected form for model output
[
{
"dialog_id": ...,
"predictions": [
{
"action": <predicted_action>,
"action_log_prob": {
<action_token>: <action_log_prob>,
...
},
"attributes": {
<attribute_label>: <attribute_val>,
...
}
}
]
}
]
Where <attribute_label> is "focus" or "attributes" (only "attributes" for fashion dataset).
"""
id2act = SIMMCDatasetForActionPrediction._LABEL2ACT
id2attrs = SIMMCDatasetForActionPrediction._ATTRS
def instantiate_model(args, num_actions, num_attrs, word2id):
if args.model == 'blindstateless':
return BlindStatelessLSTM(word_embeddings_path=args.embeddings,
word2id=word2id,
num_actions=num_actions,
num_attrs=num_attrs,
pad_token=TrainConfig._PAD_TOKEN,
unk_token=TrainConfig._UNK_TOKEN,
seed=TrainConfig._SEED,
OOV_corrections=False,
freeze_embeddings=True)
elif args.model == 'blindstateful':
return BlindStatefulLSTM(word_embeddings_path=args.embeddings,
word2id=word2id,
num_actions=num_actions,
num_attrs=num_attrs,
pad_token=TrainConfig._PAD_TOKEN,
unk_token=TrainConfig._UNK_TOKEN,
seed=TrainConfig._SEED,
OOV_corrections=False)
elif args.model == 'mmstateful':
return MMStatefulLSTM(word_embeddings_path=args.embeddings,
word2id=word2id,
item_embeddings_path=args.metadata_embeddings,
num_actions=num_actions,
num_attrs=num_attrs,
pad_token=TrainConfig._PAD_TOKEN,
unk_token=TrainConfig._UNK_TOKEN,
seed=TrainConfig._SEED,
OOV_corrections=False)
else:
raise Exception('Model not present!')
def create_eval_dict(dataset):
dataset.create_id2turns()
eval_dict = {}
for dial_id, num_turns in dataset.id2turns.items():
eval_dict[dial_id] = {'dialog_id': dial_id, 'predictions': [None] * num_turns}
return eval_dict
def eval(model, test_dataset, args, save_folder, device):
model.eval()
model.to(device)
print('MODEL: {}'.format(model))
# prepare DataLoader
params = {'batch_size': 1,
'shuffle': False,
'num_workers': 0}
testloader = DataLoader(test_dataset, **params, collate_fn=model.collate_fn)
eval_dict = create_eval_dict(test_dataset)
with torch.no_grad():
for curr_step, (dial_ids, turns, batch, actions, attributes) in enumerate(testloader):
assert len(dial_ids) == 1, 'Only unitary batch size is allowed during testing'
dial_id = dial_ids[0]
turn = turns[0]
batch['utterances'] = batch['utterances'].to(device)
actions = actions.to(device)
attributes = attributes.to(device)
actions_out, attributes_out, actions_probs, attributes_probs = model(**batch, device=device)
#get predicted action and arguments
actions_predictions = torch.argmax(actions_probs, dim=-1)
attributes_predictions = []
for batch_idx, t in enumerate(attributes_probs):
attributes_predictions.append([])
for pos, val in enumerate(t):
if val >= .5:
attributes_predictions[batch_idx].append(pos)
actions_predictions = actions_predictions[0].item()
attributes_predictions = attributes_predictions[0]
predicted_action = SIMMCDatasetForActionPrediction._LABEL2ACT[actions_predictions]
action_log_prob = {}
for idx, prob in enumerate(actions_probs[0]):
action_log_prob[SIMMCDatasetForActionPrediction._LABEL2ACT[idx]] = torch.log(prob).item()
attributes = {}
#for arg in args_predictions:
attributes['attributes'] = [SIMMCDatasetForActionPrediction._ATTRS[attr] for attr in attributes_predictions]
eval_dict[dial_id]['predictions'][turn] = {'action': predicted_action,
'action_log_prob': action_log_prob,
'attributes': attributes}
eval_list = []
for key in eval_dict:
eval_list.append(eval_dict[key])
save_file = os.path.join(save_folder, 'eval_out.json')
try:
with open(save_file, 'w+') as fp:
json.dump(eval_list, fp)
print('results saved in {}'.format(save_file))
except:
print('Error in writing the resulting JSON')
if __name__ == '__main__':
#TODO make "infer": dataset with unknown labels (modify the dataset class)
parser = argparse.ArgumentParser()
parser.add_argument(
"--model",
type=str,
choices=['blindstateless', 'blindstateful', 'mmstateful'],
required=True,
help="Type of the model (options: 'blindstateless', 'blindstateful', 'mmstateful')")
parser.add_argument(
"--model_path",
default=None,
type=str,
required=True,
help="Path to the weights of the model")
parser.add_argument(
"--vocabulary",
default=None,
type=str,
required=True,
help="Path to the vocabulary pickle file")
parser.add_argument(
"--data",
default=None,
type=str,
required=True,
help="Path to training dataset json file")
parser.add_argument(
"--embeddings",
default=None,
type=str,
required=True,
help="Path to embedding file")
parser.add_argument(
"--metadata_embeddings",
type=str,
required=True,
help="Path to metadata embeddings file")
parser.add_argument(
"--cuda",
default=None,
required=False,
type=int,
help="id of device to use")
args = parser.parse_args()
test_dataset = FastDataset(dat_path=args.data)
device = torch.device('cuda:{}'.format(args.cuda) if torch.cuda.is_available() and args.cuda is not None else "cpu")
eval_dict = create_eval_dict(test_dataset)
print('EVAL DATASET: {}'.format(test_dataset))
# prepare model
word2id = torch.load(args.vocabulary)
model = instantiate_model(args,
num_actions=len(SIMMCDatasetForActionPrediction._LABEL2ACT),
num_attrs=len(SIMMCDatasetForActionPrediction._ATTRS),
word2id=word2id)
model.load_state_dict(torch.load(args.model_path))
model_folder = '/'.join(args.model_path.split('/')[:-1])
print('model loaded from {}'.format(model_folder))
eval(model, test_dataset, args, save_folder=model_folder, device=device)
| 7,874 | 35.971831 | 120 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_action_prediction/train.py | import argparse
import datetime
import math
import os
import pdb
import random
import sys
import time
import numpy as np
import torch
from torch.utils.data import DataLoader
from config import TrainConfig
from models import BlindStatefulLSTM, BlindStatelessLSTM, MMStatefulLSTM
from utilities import Logger, plotting_loss
from dataset import FastDataset
#os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
#os.environ["CUDA_VISIBLE_DEVICES"]="0,5" # specify which GPU(s) to be used
def instantiate_model(args, num_actions, num_attrs, word2id):
if args.model == 'blindstateless':
return BlindStatelessLSTM(word_embeddings_path=args.embeddings,
word2id=word2id,
num_actions=num_actions,
num_attrs=num_attrs,
pad_token=TrainConfig._PAD_TOKEN,
unk_token=TrainConfig._UNK_TOKEN,
seed=TrainConfig._SEED,
OOV_corrections=False,
freeze_embeddings=True)
elif args.model == 'blindstateful':
return BlindStatefulLSTM(word_embeddings_path=args.embeddings,
word2id=word2id,
num_actions=num_actions,
num_attrs=num_attrs,
pad_token=TrainConfig._PAD_TOKEN,
unk_token=TrainConfig._UNK_TOKEN,
seed=TrainConfig._SEED,
OOV_corrections=False)
elif args.model == 'mmstateful':
return MMStatefulLSTM(word_embeddings_path=args.embeddings,
word2id=word2id,
item_embeddings_path=args.metadata_embeddings,
num_actions=num_actions,
num_attrs=num_attrs,
pad_token=TrainConfig._PAD_TOKEN,
unk_token=TrainConfig._UNK_TOKEN,
seed=TrainConfig._SEED,
OOV_corrections=False)
else:
raise Exception('Model not present!')
def plotting(epochs, losses_trend, checkpoint_dir):
epoch_list = np.arange(1, epochs+1)
losses = [(losses_trend['train']['global'], 'blue', 'train'),
(losses_trend['dev']['global'], 'red', 'validation')]
loss_path = os.path.join(checkpoint_dir, 'global_loss_plot')
plotting_loss(x_values=epoch_list, save_path=loss_path, functions=losses, plot_title='Global loss trend', x_label='epochs', y_label='loss')
losses = [(losses_trend['train']['actions'], 'green', 'train'),
(losses_trend['dev']['actions'], 'purple', 'validation')]
loss_path = os.path.join(checkpoint_dir, 'actions_loss_plot')
plotting_loss(x_values=epoch_list, save_path=loss_path, functions=losses, plot_title='Actions loss trend', x_label='epochs', y_label='loss')
losses = [(losses_trend['train']['attributes'], 'orange', 'train'),
(losses_trend['dev']['attributes'], 'black', 'validation')]
loss_path = os.path.join(checkpoint_dir, 'attributes_loss_plot')
plotting_loss(x_values=epoch_list, save_path=loss_path, functions=losses, plot_title='Arguments loss trend', x_label='epochs', y_label='loss')
def forward_step(model, batch, actions, attributes, actions_criterion, attributes_criterion, device):
batch['utterances'] = batch['utterances'].to(device)
actions_targets = actions.to(device)
attributes_targets = attributes.to(device)
"""
seq_lengths = seq_lengths.to(device)
"""
actions_logits, attributes_logits, actions_probs, attributes_probs = model(**batch, device=device)
actions_loss = actions_criterion(actions_logits, actions_targets)
attributes_targets = attributes_targets.type_as(actions_logits)
attributes_loss = attributes_criterion(attributes_logits, attributes_targets)
""" Not used
actions_predictions = torch.argmax(actions_probs, dim=-1)
attributes_predictions = []
for batch_idx, t in enumerate(attributes_probs):
attributes_predictions.append([])
for pos, val in enumerate(t):
if val >= .5:
attributes_predictions[batch_idx].append(pos)
"""
actions_predictions = None
attributes_predictions = None
return actions_loss, attributes_loss, actions_predictions, attributes_predictions
def train(train_dataset, dev_dataset, args, device):
# prepare checkpoint folder
curr_date = datetime.datetime.now().isoformat().split('.')[0]
checkpoint_dir = os.path.join(TrainConfig._CHECKPOINT_FOLDER, curr_date)
os.makedirs(checkpoint_dir, exist_ok=True)
# prepare logger to redirect both on file and stdout
sys.stdout = Logger(os.path.join(checkpoint_dir, 'train.log')) #todo uncomment before training
print('device used: {}'.format(str(device)))
print('batch used: {}'.format(args.batch_size))
print('lr used: {}'.format(TrainConfig._LEARNING_RATE))
print('weight decay: {}'.format(TrainConfig._WEIGHT_DECAY))
print('TRAINING DATASET: {}'.format(train_dataset))
print('VALIDATION DATASET: {}'.format(dev_dataset))
# prepare model's vocabulary
with open(args.vocabulary, 'rb') as fp:
vocabulary = np.load(fp, allow_pickle=True)
vocabulary = dict(vocabulary.item())
torch.save(vocabulary, os.path.join(checkpoint_dir, 'vocabulary.pkl'))
print('VOCABULARY SIZE: {}'.format(len(vocabulary)))
assert train_dataset.num_actions == dev_dataset.num_actions, 'Number of actions mismatch between train and dev dataset'
assert train_dataset.num_attributes == dev_dataset.num_attributes, 'Number of actions mismatch between train and dev dataset'
# prepare model
model = instantiate_model(args,
num_actions=train_dataset.num_actions,
num_attrs=train_dataset.num_attributes,
word2id=vocabulary)
model.to(device)
print('MODEL NAME: {}'.format(args.model))
print('NETWORK: {}'.format(model))
# prepare DataLoader
params = {'batch_size': args.batch_size,
'shuffle': True, #todo set to True
'num_workers': 0}
trainloader = DataLoader(train_dataset, **params, collate_fn=model.collate_fn)
devloader = DataLoader(dev_dataset, **params, collate_fn=model.collate_fn)
#prepare loss weights
act_per_class, act_tot_support = train_dataset.act_support['per_class_frequency'], train_dataset.act_support['tot_samples']
attr_per_class, attr_tot_support = train_dataset.attr_support['per_class_frequency'], train_dataset.attr_support['tot_samples']
#weights computed as negative_samples/positive_samples
ce_weights = torch.tensor([(act_tot_support-class_support)/class_support for class_support in act_per_class])
bce_weights = torch.tensor([(attr_tot_support-class_support)/class_support for class_support in attr_per_class])
#prepare losses and optimizer
actions_criterion = torch.nn.CrossEntropyLoss().to(device)
attributes_criterion = torch.nn.BCEWithLogitsLoss(pos_weight=bce_weights).to(device) #pos_weight=torch.tensor(10.)
optimizer = torch.optim.Adam(params=model.parameters(), lr=TrainConfig._LEARNING_RATE, weight_decay=TrainConfig._WEIGHT_DECAY)
scheduler1 = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones = list(range(10, args.epochs, 10)), gamma = 0.8)
scheduler2 = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=.5, patience=4, threshold=1e-2, cooldown=4, verbose=True)
#prepare containers for statistics
losses_trend = {'train': {'global':[], 'actions': [], 'attributes': []},
'dev': {'global':[], 'actions': [], 'attributes': []}}
best_loss = math.inf
start_t = time.time()
for epoch in range(args.epochs):
model.train()
curr_epoch_losses = {'global': [], 'actions': [], 'attributes': []}
for curr_step, (dial_ids, turns, batch, actions, attributes) in enumerate(trainloader):
actions_loss, attributes_loss, _, _ = forward_step(model,
batch=batch,
actions=actions,
attributes=attributes,
actions_criterion=actions_criterion,
attributes_criterion=attributes_criterion,
device=device)
#backward
optimizer.zero_grad()
loss = (actions_loss + attributes_loss)/2
loss.backward()
optimizer.step()
curr_epoch_losses['global'].append(loss.item())
curr_epoch_losses['actions'].append(actions_loss.item())
curr_epoch_losses['attributes'].append(attributes_loss.item())
losses_trend['train']['global'].append(np.mean(curr_epoch_losses['global']))
losses_trend['train']['actions'].append(np.mean(curr_epoch_losses['actions']))
losses_trend['train']['attributes'].append(np.mean(curr_epoch_losses['attributes']))
model.eval()
curr_epoch_losses = {'global': [], 'actions': [], 'attributes': []}
with torch.no_grad():
for curr_step, (dial_ids, turns, batch, actions, attributes) in enumerate(devloader):
actions_loss, attributes_loss, _, _ = forward_step(model,
batch=batch,
actions=actions,
attributes=attributes,
actions_criterion=actions_criterion,
attributes_criterion=attributes_criterion,
device=device)
loss = (actions_loss + attributes_loss)/2
curr_epoch_losses['global'].append(loss.item())
curr_epoch_losses['actions'].append(actions_loss.item())
curr_epoch_losses['attributes'].append(attributes_loss.item())
losses_trend['dev']['global'].append(np.mean(curr_epoch_losses['global']))
losses_trend['dev']['actions'].append(np.mean(curr_epoch_losses['actions']))
losses_trend['dev']['attributes'].append(np.mean(curr_epoch_losses['attributes']))
# save checkpoint if best model
if losses_trend['dev']['global'][-1] < best_loss:
best_loss = losses_trend['dev']['global'][-1]
torch.save(model.cpu().state_dict(),\
os.path.join(checkpoint_dir, 'state_dict.pt'))
model.to(device)
print('EPOCH #{} :: train_loss = {:.4f} ; dev_loss = {:.4f} [act_loss={:.4f}, attr_loss={:.4f}]; (lr={})'
.format(epoch+1, losses_trend['train']['global'][-1],
losses_trend['dev']['global'][-1],
losses_trend['dev']['actions'][-1],
losses_trend['dev']['attributes'][-1],
optimizer.param_groups[0]['lr']))
scheduler1.step()
scheduler2.step(losses_trend['dev']['global'][-1])
end_t = time.time()
h_count = (end_t-start_t) /60 /60
m_count = ((end_t-start_t)/60) % 60
s_count = (end_t-start_t) % 60
print('training time: {}h:{}m:{}s'.format(round(h_count), round(m_count), round(s_count)))
plotting(epochs=args.epochs, losses_trend=losses_trend, checkpoint_dir=checkpoint_dir)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
"--model",
type=str,
choices=['blindstateless', 'blindstateful', 'mmstateful'],
required=True,
help="Type of the model (options: 'blindstateless', 'blindstateful', 'mmstateful')")
parser.add_argument(
"--data",
type=str,
required=True,
help="Path to preprocessed training data file .dat")
parser.add_argument(
"--eval",
type=str,
required=True,
help="Path to preprocessed eval data file .dat")
parser.add_argument(
"--vocabulary",
type=str,
required=True,
help="Path to vocabulary file")
parser.add_argument(
"--embeddings",
type=str,
required=True,
help="Path to embeddings file")
parser.add_argument(
"--metadata_embeddings",
type=str,
required=True,
help="Path to metadata embeddings file")
parser.add_argument(
"--batch_size",
required=True,
type=int,
help="Batch size")
parser.add_argument(
"--epochs",
required=True,
type=int,
help="Number of epochs")
parser.add_argument(
"--cuda",
default=None,
required=False,
type=int,
help="id of device to use")
args = parser.parse_args()
train_dataset = FastDataset(dat_path=args.data)
dev_dataset = FastDataset(dat_path=args.eval)
device = torch.device('cuda:{}'.format(args.cuda) if torch.cuda.is_available() and args.cuda is not None else "cpu")
train(train_dataset, dev_dataset, args, device)
| 13,757 | 44.556291 | 146 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_action_prediction/dataset/processed_dataset.py | import numpy as np
import torch
from torch.utils.data import Dataset
import pdb
class FastDataset(Dataset):
"""Dataset with preprocessed data for response generation subtask
self.data.keys() = dict_keys(['dial_ids', 'turns', 'utterances', 'histories', 'actions',
'attributes', 'visual_contexts', 'seq_lengths', 'candidates'])
"""
def __init__(self, dat_path):
super(FastDataset, self).__init__()
self.data = torch.load(dat_path)
self.dataset_name = 'SIMMC'
self.task = 'action_prediction'
self.num_actions = self.data['num_actions']
self.num_attributes = self.data['num_attributes']
self.act_support = self.data['actions_support']
self.attr_support = self.data['attributes_support']
assert len(self.data['dial_ids']) == len(self.data['turns']), 'Inconsistent dataset'
assert len(self.data['dial_ids']) == len(self.data['utterances']), 'Inconsistent dataset'
assert len(self.data['dial_ids']) == len(self.data['histories']), 'Inconsistent dataset'
assert len(self.data['dial_ids']) == len(self.data['actions']), 'Inconsistent dataset'
assert len(self.data['dial_ids']) == len(self.data['attributes']), 'Inconsistent dataset'
assert len(self.data['dial_ids']) == len(self.data['visual_contexts']['focus']), 'Inconsistent dataset'
assert len(self.data['dial_ids']) == len(self.data['visual_contexts']['history']), 'Inconsistent dataset'
self.check_history_consistency()
def check_history_consistency(self):
for turns_num, history in zip(self.data['turns'], self.data['histories']):
assert turns_num == len(history), 'History length do not match number of turns'
def create_id2turns(self):
"""used to create the eval dict during evaluation phase
"""
self.id2turns = {}
for dial_id in self.data['dial_ids']:
if dial_id in self.id2turns:
self.id2turns[dial_id] += 1
else:
self.id2turns[dial_id] = 1
def __getitem__(self, index):
return self.data['dial_ids'][index], self.data['turns'][index], self.data['utterances'][index],\
self.data['histories'][index], self.data['actions'][index], self.data['attributes'][index],\
self.data['visual_contexts']['focus'][index], self.data['visual_contexts']['history'][index],
def __len__(self):
return len(self.data['utterances'])
def __str__(self):
return '{}_subtask({})'.format(self.dataset_name, self.task)
| 2,625 | 39.4 | 113 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_action_prediction/models/embednets.py | import pdb
import numpy as np
import torch
import torch.nn as nn
from spellchecker import SpellChecker
class ItemEmbeddingNetwork(nn.Module):
"""Base class for word embedding layer initialization and weights loading
Args:
nn (torch.nn.Module): inherits from torch.nn.Module
"""
def __init__(self, item_embeddings_path, freeze=False):
super(ItemEmbeddingNetwork, self).__init__()
raw_data = np.load(item_embeddings_path, allow_pickle=True)
raw_data = dict(raw_data.item())
self.item2id = {}
for idx, item in enumerate(raw_data['item_ids']):
self.item2id[item] = idx
self.embedding_dim = raw_data['embedding_size']
embeddings = np.stack(raw_data['embeddings'])
embedding_weights = torch.tensor(embeddings)
num_embeddings = embedding_weights.shape[0]
assert embedding_weights.shape[-1] == self.embedding_dim, 'Real embedding dimension does not match the declared one'
self.embedding_layer = nn.Embedding(num_embeddings, self.embedding_dim)
self.embedding_layer.load_state_dict({'weight': embedding_weights})
if freeze:
for p in self.embedding_layer.parameters():
p.requires_grad = False
def forward(self, input):
return self.embedding_layer(input)
class WordEmbeddingNetwork(nn.Module):
"""Base class for word embedding layer initialization and weights loading
Args:
nn (torch.nn.Module): inherits from torch.nn.Module
"""
def __init__(self, word_embeddings_path, word2id, pad_token, unk_token, OOV_corrections=False, freeze=False):
super(WordEmbeddingNetwork, self).__init__()
self.pad_token = pad_token
self.unk_token = unk_token
self.corrected_flag = OOV_corrections
self.word2id = word2id
self.embedding_file = word_embeddings_path.split('/')[-1]
self.load_embeddings_from_file(word_embeddings_path)
embedding_weights = self.get_embeddings_weights(OOV_corrections)
num_embeddings, self.embedding_dim = embedding_weights.shape
self.embedding_layer = nn.Embedding(num_embeddings, self.embedding_dim)
self.embedding_layer.load_state_dict({'weight': embedding_weights})
if freeze:
for p in self.embedding_layer.parameters():
p.requires_grad = False
def forward(self, input):
return self.embedding_layer(input)
def load_embeddings_from_file(self, embeddings_path):
self.glove = {}
with open(embeddings_path) as fp:
for l in fp:
line_tokens = l.split()
word = line_tokens[0]
if word in self.glove:
raise Exception('Repeated words in {} embeddings file'.format(embeddings_path))
vector = np.asarray(line_tokens[1:], "float32")
self.glove[word] = vector
self.embedding_size = vector.size
def get_embeddings_weights(self, OOV_corrections):
#if OOV_corrections:
# dataset_vocabulary = self.correct_spelling(dataset_vocabulary)
matrix_len = len(self.word2id)
weights_matrix = np.zeros((matrix_len, self.embedding_size))
# set pad and unknow ids
pad_id = self.word2id[self.pad_token]
unk_id = self.word2id[self.unk_token]
weights_matrix[pad_id] = np.zeros(shape=(self.embedding_size, ))
weights_matrix[unk_id] = np.random.normal(scale=0.6, size=(self.embedding_size, ))
for idx, word in enumerate(self.word2id):
if word in self.glove:
weights_matrix[idx] = self.glove[word]
return torch.tensor(weights_matrix, dtype=torch.float32)
def correct_spelling(self, dataset_vocabulary):
#todo fix: now dataset_vocabulary is a map, not a set (get the .keys())
oov = []
self.corrections = {}
checker = SpellChecker()
vocab_copy = copy.deepcopy(dataset_vocabulary)
for word in vocab_copy:
if word not in self.glove:
oov.append(word)
corrected_w = checker.correction(word)
if corrected_w in self.glove:
# the word with typos is assigned to the same id of the correspondant word after the correction
try:
self.word2id[word] = self.word2id[corrected_w] #TODO fix: word2id is still empty at this point
except:
pdb.set_trace()
self.corrections[word] = corrected_w
dataset_vocabulary.remove(word)
#print(oov)
#print(corrections.values())
return dataset_vocabulary
| 4,777 | 35.753846 | 124 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_action_prediction/models/blindstateless.py | import pdb
import numpy as np
import torch
import torch.nn.functional as F
from torch import nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
from .embednets import WordEmbeddingNetwork
class BlindStatelessLSTM(nn.Module):
"""Implementation of a blind and stateless LSTM for action prediction. It approximates the probability distribution:
P(a_t | U_t)
Where a_t is the action and U_t the user utterance.
Args:
torch (WordEmbeddingBasedNetwork): inherits from WordEmbeddingBasedNetwork
Attributes:
self.corrections (dict): Mapping from dataset word to its corrections (the corrections is included in the vocabulary)
"""
_HIDDEN_SIZE = 600
def __init__(self, word_embeddings_path, word2id, num_actions, num_attrs,
pad_token, unk_token, seed, OOV_corrections=False, freeze_embeddings=False):
"""
Glove download: https://nlp.stanford.edu/projects/glove/
Args:
embedding_path ([type]): [description]
"""
torch.manual_seed(seed)
super(BlindStatelessLSTM, self).__init__()
self.hidden_size = self._HIDDEN_SIZE
self.word_embeddings_layer = WordEmbeddingNetwork(word_embeddings_path=word_embeddings_path,
word2id=word2id,
pad_token=pad_token,
unk_token=unk_token,
OOV_corrections=OOV_corrections,
freeze=freeze_embeddings)
self.lstm = nn.LSTM(self.word_embeddings_layer.embedding_dim, self.hidden_size, batch_first=True)
self.dropout = nn.Dropout(p=0.5)
self.actions_linear = nn.Linear(in_features=self.hidden_size, out_features=num_actions)
self.attrs_linear = nn.Linear(in_features=self.hidden_size, out_features=num_attrs)
def forward(self, utterances, seq_lengths=None, device='cpu'):
"""Forward pass for BlindStatelessLSTM
Args:
batch (torch.LongTensor): Tensor containing the batch (shape=BxMAX_SEQ_LEN)
seq_lengths (torch.LongTensor, optional): Effective lengths (no pad) of each sequence in the batch. If given the pack_padded__sequence are used.
The shape is B. Defaults to None.
"""
embedded_seq_tensor = self.word_embeddings_layer(utterances)
if seq_lengths is not None:
# pack padded sequence
packed_input = pack_padded_sequence(embedded_seq_tensor, seq_lengths.cpu().numpy(), batch_first=True)
out1, (h_t, c_t) = self.lstm(packed_input)
"""unpack not needed. We don't use the output
if seq_lengths is not None:
# unpack padded sequence
output, input_sizes = pad_packed_sequence(out1, batch_first=True)
"""
h_t = self.dropout(h_t)
# h_t has shape NUM_DIRxBxHIDDEN_SIZE
actions_logits = self.actions_linear(h_t[0])
attrs_logits = self.attrs_linear(h_t[0])
#out2.shape = BxNUM_LABELS
actions_probs = F.softmax(actions_logits, dim=-1)
attrs_probs = torch.sigmoid(attrs_logits)
return actions_logits, attrs_logits, actions_probs, attrs_probs
def collate_fn(self, batch):
"""This method prepares the batch for the LSTM: padding + preparation for pack_padded_sequence
Args:
batch (tuple): tuple of element returned by the Dataset.__getitem__()
Returns:
dial_ids (list): list of dialogue ids
turns (list): list of dialogue turn numbers
seq_tensor (torch.LongTensor): tensor with BxMAX_SEQ_LEN containing padded sequences of user transcript sorted by descending effective lengths
seq_lenghts: tensor with shape B containing the effective length of the correspondant transcript sequence
actions (torch.Longtensor): tensor with B shape containing target actions
arguments (torch.Longtensor): tensor with Bx33 shape containing arguments one-hot vectors, one for each sample.
"""
dial_ids = [item[0] for item in batch]
turns = [item[1] for item in batch]
transcripts = [torch.tensor(item[2]) for item in batch]
actions = torch.tensor([item[4] for item in batch])
attributes = torch.stack([item[5] for item in batch])
assert len(transcripts) == len(dial_ids), 'Batch sizes do not match'
assert len(transcripts) == len(turns), 'Batch sizes do not match'
assert len(transcripts) == actions.shape[0], 'Batch sizes do not match'
assert len(transcripts) == attributes.shape[0], 'Batch sizes do not match'
# reorder the sequences from the longest one to the shortest one.
# keep the correspondance with the target
transcripts_lengths = torch.tensor(list(map(len, transcripts)), dtype=torch.long)
transcripts_tensor = torch.zeros((len(transcripts), transcripts_lengths.max()), dtype=torch.long)
for idx, (seq, seqlen) in enumerate(zip(transcripts, transcripts_lengths)):
transcripts_tensor[idx, :seqlen] = seq.clone().detach()
# sort instances by sequence length in descending order
transcripts_lengths, perm_idx = transcripts_lengths.sort(0, descending=True)
transcripts_tensor = transcripts_tensor[perm_idx]
actions = actions[perm_idx]
attributes = attributes[perm_idx]
sorted_dial_ids = []
sorted_dial_turns = []
for idx in perm_idx:
sorted_dial_ids.append(dial_ids[idx])
sorted_dial_turns.append(turns[idx])
batch_dict = {}
batch_dict['utterances'] = transcripts_tensor
batch_dict['seq_lengths'] = transcripts_lengths
# seq_lengths is used to create a pack_padded_sequence
return sorted_dial_ids, sorted_dial_turns, batch_dict, actions, attributes
def __str__(self):
return super().__str__()
| 6,218 | 42.795775 | 156 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_action_prediction/models/mmstateful.py | import pdb
import torch
import torch.nn.functional as F
from torch import nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
from .embednets import WordEmbeddingNetwork, ItemEmbeddingNetwork
import numpy as np
def get_positional_embeddings(n_position, emb_dim):
"""Create positional embeddings (from "Attention Is All You Need", Vaswani et al. 2017)
Args:
n_position (int): number of elements in the sequence
emb_dim (int): size of embeddings
Returns:
toch.FloatTensor: a positional embedding with shape [N_POSITION x EMB_DIM]
"""
# keep dim 0 for padding token position encoding zero vector
position_enc = np.array([
[pos / np.power(10000, 2 * (k // 2) / emb_dim) for k in range(emb_dim)]
if pos != 0 else np.zeros(emb_dim) for pos in range(n_position)])
position_enc[1:, 0::2] = np.sin(position_enc[1:, 0::2]) # dim 2i
position_enc[1:, 1::2] = np.cos(position_enc[1:, 1::2]) # dim 2i+1
return torch.from_numpy(position_enc).type(torch.FloatTensor)
class MMStatefulLSTM(nn.Module):
"""
Args:
nn ([type]): [description]
"""
_HIDDEN_SIZE = 300
def __init__(self, word_embeddings_path, word2id, item_embeddings_path,
num_actions, num_attrs, pad_token, unk_token,
seed, OOV_corrections):
torch.manual_seed(seed)
super(MMStatefulLSTM, self).__init__()
self.num_actions = num_actions
self.num_attrs = num_attrs
self.memory_hidden_size = self._HIDDEN_SIZE
# NETWORK
self.item_embeddings_layer = ItemEmbeddingNetwork(item_embeddings_path)
self.word_embeddings_layer = WordEmbeddingNetwork(word_embeddings_path=word_embeddings_path,
word2id=word2id,
pad_token=pad_token,
unk_token=unk_token)
self.utterance_encoder = nn.LSTM(self.word_embeddings_layer.embedding_dim,
self.memory_hidden_size,
batch_first=True,
bidirectional=True)
self.utterance_dropout = nn.Dropout(p=.5)
self.item_dim_reduction = nn.Linear(in_features=self.item_embeddings_layer.embedding_dim,
out_features=2*self.memory_hidden_size)
self.utterance_memory_attn = nn.Sequential(nn.Linear(4*self.memory_hidden_size, 4*self.memory_hidden_size),
nn.Tanh(),
nn.Dropout(p=.5),
nn.Linear(4*self.memory_hidden_size, 1),
nn.Dropout(p=.5)) #todo introduce layerNorm
self.linear_act_post_attn = nn.Sequential(nn.Linear(4*self.memory_hidden_size, 2*self.memory_hidden_size),
nn.Dropout(p=.5),
nn.ReLU())
self.linear_args_post_attn = nn.Sequential(nn.Linear(4*self.memory_hidden_size, 2*self.memory_hidden_size),
nn.Dropout(p=.5),
nn.ReLU())
self.multiturn_actions_outlayer = nn.Linear(in_features=2*self.memory_hidden_size, out_features=self.num_actions)
self.multiturn_args_outlayer = nn.Linear(in_features=2*self.memory_hidden_size, out_features=self.num_attrs)
self.singleturn_actions_outlayer = nn.Linear(in_features=4*self.memory_hidden_size, out_features=self.num_actions)
self.singleturn_args_outlayer = nn.Linear(in_features=4*self.memory_hidden_size, out_features=self.num_attrs)
def forward(self, utterances, history, visual_context, seq_lengths=None, device='cpu'):
# u_t shape [BATCH_SIZE x 2MEMORY_HIDDEN_SIZE]
u_t = self.encode_utterance(utterances, seq_lengths)
focus, focus_history = self.encode_visual(visual_context, device)
# u_t shape [BATCH_SIZE x 2MEMORY_HIDDEN_SIZE]
focus_t = self.item_dim_reduction(focus)
# separate single from multi-turn
single_turns = []
single_turns_v_focus = []
single_turns_pos = set()
multi_turns = []
multi_turns_v_focus = []
multi_turns_history = []
multi_turns_v_history = []
for dial_idx, history_item in enumerate(history):
if len(history_item) == 0:
single_turns_pos.add(dial_idx)
single_turns.append(u_t[dial_idx])
single_turns_v_focus.append(focus_t[dial_idx])
else:
multi_turns.append(u_t[dial_idx])
multi_turns_history.append(history[dial_idx])
multi_turns_v_focus.append(focus[dial_idx])
multi_turns_v_history.append(focus_history[dial_idx])
if len(single_turns):
# concat u_t with correspondent v_t
single_u_t = torch.stack(single_turns)
single_v_t = torch.stack(single_turns_v_focus)
#pos = list(single_turns_pos)
single_u_v_concat = torch.cat((single_u_t, single_v_t), dim=-1)
# compute output for single turn dialogues
act_out1 = self.singleturn_actions_outlayer(single_u_v_concat)
args_out1 = self.singleturn_args_outlayer(single_u_v_concat)
if len(multi_turns):
multi_u_t = torch.stack(multi_turns)
multi_v_t = torch.stack(multi_turns_v_focus)
multi_v_t = self.item_dim_reduction(multi_v_t)
# memory bank is a list of BATCH_SIZE tensors, each of them having shape N_TURNSx2MEMORY_HIDDEN_SIZE
lang_memory = self.encode_history(multi_turns_history, device)
assert len(multi_turns) == len(lang_memory), 'Wrong memory size'
#visual_memory = self.encode_visual_history(multi_turns_v_history, device) #todo visual memory
#assert len(multi_turns) == len(visual_memory), 'Wrong memory size'
# c_t shape [MULTI_TURNS_SET_SIZE x MEMORY_HIDDEN_SIZE]
c_t = self.attention_over_memory(multi_u_t, lang_memory)
mm_c_t = c_t * multi_v_t
#? Hadamard product between c_t and u_t? It is simply "tensor1 * tensor2"
ut_ct_concat = torch.cat((multi_u_t, mm_c_t), dim=-1)
c_t_tilde1 = self.linear_act_post_attn(ut_ct_concat)
ut_ct1_concat = torch.cat((multi_u_t, c_t_tilde1), dim=-1)
c_t_tilde2 = self.linear_args_post_attn(ut_ct1_concat)
act_out2 = self.multiturn_actions_outlayer(c_t_tilde1)
args_out2 = self.multiturn_args_outlayer(c_t_tilde2)
# recompose the output
act_out = []
args_out = []
pos1 = 0
pos2 = 0
for idx in range(utterances.shape[0]):
if idx in single_turns_pos:
act_out.append(act_out1[pos1])
args_out.append(args_out1[pos1])
pos1 += 1
else:
act_out.append(act_out2[pos2])
args_out.append(args_out2[pos2])
pos2 += 1
act_out = torch.stack(act_out)
args_out = torch.stack(args_out)
act_probs = F.softmax(act_out, dim=-1)
args_probs = torch.sigmoid(args_out)
return act_out, args_out, act_probs, args_probs
def encode_utterance(self, batch, seq_lengths):
embedded_seq_tensor = self.word_embeddings_layer(batch)
if seq_lengths is not None:
# pack padded sequence
packed_input = pack_padded_sequence(embedded_seq_tensor, seq_lengths.cpu().numpy(), batch_first=True)
out1, (h_t, c_t) = self.utterance_encoder(packed_input)
bidirectional_h_t = torch.cat((h_t[0], h_t[-1]), dim=-1)
bidirectional_h_t = self.utterance_dropout(bidirectional_h_t)
"""unpack not needed. We don't use the output
if seq_lengths is not None:
# unpack padded sequence
output, input_sizes = pad_packed_sequence(out1, batch_first=True)
"""
return bidirectional_h_t
def encode_visual(self, visual_context, device):
focus = self.item_embeddings_layer(visual_context['focus'].to(device))
history = []
for history_item in visual_context['history']:
if not len(history_item):
history.append([])
else:
history.append(self.item_embeddings_layer(history_item.to(device)))
return focus, history
def encode_history(self, history, device):
#todo turn embedding based on previous turns (hierarchical recurrent encoder - HRE)
encoded_batch_history = []
for dial in history:
hiddens = []
positional_embeddings = get_positional_embeddings(len(dial), 2*self.memory_hidden_size).to(device)
assert positional_embeddings.shape[0] == len(dial)
for turn, pos_emb in zip(dial, positional_embeddings):
emb = self.word_embeddings_layer(turn.unsqueeze(0).to(device))
# h_t.shape = [num_directions x 1 x HIDDEN_SIZE]
out, (h_t, c_t) = self.utterance_encoder(emb)
bidirectional_h_t = torch.cat((h_t[0], h_t[-1]), dim=-1)
pos_bidirectional_h_t = bidirectional_h_t+pos_emb
hiddens.append(pos_bidirectional_h_t.squeeze(0))
assert len(hiddens) > 0, 'Impossible to encode history for single turn instance'
encoded_batch_history.append(torch.stack(hiddens))
return encoded_batch_history
def encode_visual_history(self, history, device):
encoded_batch_history = []
for dial in history:
hiddens = []
for turn in dial:
m_t = self.item_dim_reduction(turn.unsqueeze(0).to(device))
hiddens.append(m_t.squeeze(0))
assert len(hiddens) > 0, 'Impossible to encode history for single turn instance'
encoded_batch_history.append(torch.stack(hiddens))
return encoded_batch_history
def attention_over_memory(self, u_t, memory_bank):
# input for attention layer consists of pairs (utterance_j, memory_j_i), for each j, i
attn_input_list = []
for dial_idx, dial_mem in enumerate(memory_bank):
num_turns = dial_mem.shape[0]
#utterance_mem_concat shape N_TURNS x (utterance_size + memory_size)
utterance_mem_concat = torch.cat((u_t[dial_idx].expand(num_turns, -1), dial_mem), dim=-1)
attn_input_list.append(utterance_mem_concat)
scores = []
for idx, input_tensor in enumerate(attn_input_list):
curr_out = self.utterance_memory_attn(input_tensor)
scores.append(curr_out)
attn_weights = []
for score in scores:
attn = F.softmax(score, dim=0)
attn_weights.append(attn)
assert len(attn_weights) == len(memory_bank), 'Memory size and attention weights do not match'
weighted_sum_list = []
for attn, mem in zip(attn_weights, memory_bank):
weighted_mem = attn * mem
weighted_sum = torch.sum(weighted_mem, dim=0)
weighted_sum_list.append(weighted_sum)
weighted_sum = torch.stack(weighted_sum_list)
return weighted_sum
def collate_fn(self, batch):
"""This method prepares the batch for the LSTM: padding + preparation for pack_padded_sequence
Args:
batch (tuple): tuple of element returned by the Dataset.__getitem__()
Returns:
dial_ids (list): list of dialogue ids
turns (list): list of dialogue turn numbers
seq_tensor (torch.LongTensor): tensor with BxMAX_SEQ_LEN containing padded sequences of user transcript sorted by descending effective lengths
seq_lenghts: tensor with shape B containing the effective length of the correspondant transcript sequence
actions (torch.Longtensor): tensor with B shape containing target actions
attributes (torch.Longtensor): tensor with Bx33 shape containing attributes one-hot vectors, one for each sample.
"""
dial_ids = [item[0] for item in batch]
turns = [item[1] for item in batch]
transcripts = [torch.tensor(item[2]) for item in batch]
history = [item[3] for item in batch]
actions = torch.tensor([item[4] for item in batch])
attributes = torch.stack([item[5] for item in batch])
visual_context = {'focus': [], 'history': []}
visual_context['focus'] = [item[6] for item in batch]
visual_context['history'] = [item[7] for item in batch]
assert len(transcripts) == len(dial_ids), 'Batch sizes do not match'
assert len(transcripts) == len(turns), 'Batch sizes do not match'
assert len(transcripts) == len(history), 'Batch sizes do not match'
assert len(transcripts) == actions.shape[0], 'Batch sizes do not match'
assert len(transcripts) == attributes.shape[0], 'Batch sizes do not match'
assert len(transcripts) == len(visual_context['focus']), 'Batch sizes do not match'
assert len(transcripts) == len(visual_context['history']), 'Batch sizes do not match'
# reorder the sequences from the longest one to the shortest one.
# keep the correspondance with the target
transcripts_lengths = torch.tensor(list(map(len, transcripts)), dtype=torch.long)
transcripts_tensor = torch.zeros((len(transcripts), transcripts_lengths.max()), dtype=torch.long)
for idx, (seq, seqlen) in enumerate(zip(transcripts, transcripts_lengths)):
transcripts_tensor[idx, :seqlen] = seq.clone().detach()
# sort instances by sequence length in descending order
transcripts_lengths, perm_idx = transcripts_lengths.sort(0, descending=True)
transcripts_tensor = transcripts_tensor[perm_idx]
actions = actions[perm_idx]
attributes = attributes[perm_idx]
sorted_dial_ids = []
sorted_dial_turns = []
sorted_dial_history = []
sorted_visual_context = {'focus': [], 'history':[]}
for idx in perm_idx:
sorted_dial_ids.append(dial_ids[idx])
sorted_dial_turns.append(turns[idx])
sorted_dial_history.append(history[idx])
sorted_visual_context['focus'].append(visual_context['focus'][idx])
sorted_visual_context['history'].append(visual_context['history'][idx])
sorted_visual_context['focus'] = torch.stack(sorted_visual_context['focus'])
batch_dict = {}
batch_dict['utterances'] = transcripts_tensor
batch_dict['history'] = sorted_dial_history
batch_dict['visual_context'] = sorted_visual_context
batch_dict['seq_lengths'] = transcripts_lengths
return sorted_dial_ids, sorted_dial_turns, batch_dict, actions, attributes
def __str__(self):
return super().__str__() | 15,354 | 45.814024 | 154 | py |
dstc9-SIMMC | dstc9-SIMMC-master/mm_action_prediction/models/blindstateful.py | import pdb
import torch
import torch.nn.functional as F
from torch import nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
from .embednets import WordEmbeddingNetwork
class BlindStatefulLSTM(nn.Module):
_HIDDEN_SIZE = 300
def __init__(self, word_embeddings_path, word2id, num_actions, num_attrs, pad_token, unk_token, seed, OOV_corrections):
torch.manual_seed(seed)
super(BlindStatefulLSTM, self).__init__()
self.num_actions = num_actions
self.num_attrs = num_attrs
self.memory_hidden_size = self._HIDDEN_SIZE
self.word_embeddings_layer = WordEmbeddingNetwork(word_embeddings_path=word_embeddings_path,
word2id=word2id,
pad_token=pad_token,
unk_token=unk_token)
self.utterance_encoder = nn.LSTM(self.word_embeddings_layer.embedding_dim,
self.memory_hidden_size,
batch_first=True,
bidirectional=True)
self.utterance_dropout = nn.Dropout(p=0.75)
self.utterance_normlayer = nn.LayerNorm([2*self.memory_hidden_size])
#todo recurrent attention?
#self.cross_history_attn = nn.Linear()
#! this is position agnostic (should not be good)
self.utterance_memory_attn = nn.Sequential(nn.Linear(4*self.memory_hidden_size, 4*self.memory_hidden_size),
nn.Tanh(),
nn.Dropout(p=0.75),
nn.Linear(4*self.memory_hidden_size, 1),
nn.Dropout(p=0.75)) #todo introduce layerNorm
self.linear_act_post_attn = nn.Sequential(nn.Linear(4*self.memory_hidden_size, 2*self.memory_hidden_size),
nn.Dropout(p=0.75),
nn.ReLU())
self.linear_attrs_post_attn = nn.Sequential(nn.Linear(4*self.memory_hidden_size, 2*self.memory_hidden_size),
nn.Dropout(p=0.75),
nn.ReLU(),)
self.multiturn_actions_outlayer = nn.Linear(in_features=2*self.memory_hidden_size, out_features=self.num_actions)
self.multiturn_attrs_outlayer = nn.Linear(in_features=2*self.memory_hidden_size, out_features=self.num_attrs)
self.singleturn_actions_outlayer = nn.Linear(in_features=2*self.memory_hidden_size, out_features=self.num_actions)
self.singleturn_attrs_outlayer = nn.Linear(in_features=2*self.memory_hidden_size, out_features=self.num_attrs)
def forward(self, utterances, history, seq_lengths=None, device='cpu'):
# u_t shape [BATCH_SIZE x 2MEMORY_HIDDEN_SIZE]
u_t = self.encode_utterance(utterances, seq_lengths)
# separate single from multi-turn
single_turns = []
single_turns_pos = set()
multi_turns = []
multi_turns_history = []
for dial_idx, history_item in enumerate(history):
if len(history_item) == 0:
single_turns_pos.add(dial_idx)
single_turns.append(u_t[dial_idx])
else:
multi_turns.append(u_t[dial_idx])
multi_turns_history.append(history[dial_idx])
if len(single_turns):
single_turns = torch.stack(single_turns)
# compute output for single turn dialogues
act_out1 = self.singleturn_actions_outlayer(single_turns)
attrs_out1 = self.singleturn_attrs_outlayer(single_turns)
if len(multi_turns):
multi_turns = torch.stack(multi_turns)
# memory bank is a list of BATCH_SIZE tensors, each of them having shape N_TURNSx2MEMORY_HIDDEN_SIZE
memory_bank = self.encode_history(multi_turns_history, device)
assert len(multi_turns) == len(memory_bank), 'Wrong memory size'
# c_t shape [MULTI_TURNS_SET_SIZE x MEMORY_HIDDEN_SIZE]
attentive_c_t = self.attention_over_memory(multi_turns, memory_bank)
#? Hadamard product between c_t and u_t? It is simply "tensor1 * tensor2"
ut_ct_concat = torch.cat((multi_turns, attentive_c_t), dim=-1)
c_t_tilde1 = self.linear_act_post_attn(ut_ct_concat)
ut_ct1_concat = torch.cat((multi_turns, c_t_tilde1), dim=-1)
c_t_tilde2 = self.linear_attrs_post_attn(ut_ct1_concat)
act_out2 = self.multiturn_actions_outlayer(c_t_tilde1)
attrs_out2 = self.multiturn_attrs_outlayer(c_t_tilde2)
# recompose the output
act_out = []
attrs_out = []
pos1 = 0
pos2 = 0
for idx in range(utterances.shape[0]):
if idx in single_turns_pos:
act_out.append(act_out1[pos1])
attrs_out.append(attrs_out1[pos1])
pos1 += 1
else:
act_out.append(act_out2[pos2])
attrs_out.append(attrs_out2[pos2])
pos2 += 1
act_out = torch.stack(act_out)
attrs_out = torch.stack(attrs_out)
act_probs = F.softmax(act_out, dim=-1)
attrs_probs = torch.sigmoid(attrs_out)
return act_out, attrs_out, act_probs, attrs_probs
def encode_history(self, history, device):
#todo turn embedding based on previous turns (hierarchical recurrent encoder - HRE)
encoded_batch_history = []
for dial in history:
hiddens = []
for turn in dial:
emb = self.word_embeddings_layer(turn.unsqueeze(0).to(device))
# h_t.shape = [num_directions x 1 x HIDDEN_SIZE]
out, (h_t, c_t) = self.utterance_encoder(emb)
bidirectional_h_t = torch.cat((h_t[0], h_t[-1]), dim=-1)
bidirectional_h_t = self.utterance_dropout(bidirectional_h_t)
bidirectional_h_t = self.utterance_normlayer(bidirectional_h_t)
hiddens.append(bidirectional_h_t.squeeze(0))
assert len(hiddens) > 0, 'Impossible to encode history for single turn instance'
encoded_batch_history.append(torch.stack(hiddens))
return encoded_batch_history
def encode_utterance(self, batch, seq_lengths):
embedded_seq_tensor = self.word_embeddings_layer(batch)
if seq_lengths is not None:
# pack padded sequence
packed_input = pack_padded_sequence(embedded_seq_tensor, seq_lengths.cpu().numpy(), batch_first=True)
out1, (h_t, c_t) = self.utterance_encoder(packed_input)
bidirectional_h_t = torch.cat((h_t[0], h_t[-1]), dim=-1)
bidirectional_h_t = self.utterance_dropout(bidirectional_h_t)
bidirectional_h_t = self.utterance_normlayer(bidirectional_h_t)
"""unpack not needed. We don't use the output
if seq_lengths is not None:
# unpack padded sequence
output, input_sizes = pad_packed_sequence(out1, batch_first=True)
"""
return bidirectional_h_t
def attention_over_memory(self, u_t, memory_bank):
# input for attention layer consists of pairs (utterance_j, memory_j_i), for each j, i
attn_input_list = []
for dial_idx, dial_mem in enumerate(memory_bank):
num_turns = dial_mem.shape[0]
#utterance_mem_concat shape N_TURNS x (utterance_size + memory_size)
utterance_mem_concat = torch.cat((u_t[dial_idx].expand(num_turns, -1), dial_mem), dim=-1)
attn_input_list.append(utterance_mem_concat)
scores = []
for idx, input_tensor in enumerate(attn_input_list):
curr_out = self.utterance_memory_attn(input_tensor)
scores.append(curr_out)
attn_weights = []
for score in scores:
attn = F.softmax(score, dim=0)
attn_weights.append(attn)
assert len(attn_weights) == len(memory_bank), 'Memory size and attention weights do not match'
weighted_sum_list = []
for attn, mem in zip(attn_weights, memory_bank):
weighted_mem = attn * mem
weighted_sum = torch.sum(weighted_mem, dim=0)
weighted_sum_list.append(weighted_sum)
weighted_sum = torch.stack(weighted_sum_list)
return weighted_sum
def collate_fn(self, batch):
"""This method prepares the batch for the LSTM: padding + preparation for pack_padded_sequence
Args:
batch (tuple): tuple of element returned by the Dataset.__getitem__()
Returns:
dial_ids (list): list of dialogue ids
turns (list): list of dialogue turn numbers
seq_tensor (torch.LongTensor): tensor with BxMAX_SEQ_LEN containing padded sequences of user transcript sorted by descending effective lengths
seq_lenghts: tensor with shape B containing the effective length of the correspondant transcript sequence
actions (torch.Longtensor): tensor with B shape containing target actions
attributes (torch.Longtensor): tensor with Bx33 shape containing attributes one-hot vectors, one for each sample.
"""
dial_ids = [item[0] for item in batch]
turns = [item[1] for item in batch]
transcripts = [torch.tensor(item[2]) for item in batch]
history = [item[3] for item in batch]
actions = torch.tensor([item[4] for item in batch])
attributes = torch.stack([item[5] for item in batch])
assert len(transcripts) == len(dial_ids), 'Batch sizes do not match'
assert len(transcripts) == len(turns), 'Batch sizes do not match'
assert len(transcripts) == len(history), 'Batch sizes do not match'
assert len(transcripts) == actions.shape[0], 'Batch sizes do not match'
assert len(transcripts) == attributes.shape[0], 'Batch sizes do not match'
# reorder the sequences from the longest one to the shortest one.
# keep the correspondance with the target
transcripts_lengths = torch.tensor(list(map(len, transcripts)), dtype=torch.long)
transcripts_tensor = torch.zeros((len(transcripts), transcripts_lengths.max()), dtype=torch.long)
for idx, (seq, seqlen) in enumerate(zip(transcripts, transcripts_lengths)):
transcripts_tensor[idx, :seqlen] = seq.clone().detach()
# sort instances by sequence length in descending order
transcripts_lengths, perm_idx = transcripts_lengths.sort(0, descending=True)
transcripts_tensor = transcripts_tensor[perm_idx]
actions = actions[perm_idx]
attributes = attributes[perm_idx]
sorted_dial_ids = []
sorted_dial_turns = []
sorted_dial_history = []
for idx in perm_idx:
sorted_dial_ids.append(dial_ids[idx])
sorted_dial_turns.append(turns[idx])
sorted_dial_history.append(history[idx])
batch_dict = {}
batch_dict['utterances'] = transcripts_tensor
batch_dict['history'] = sorted_dial_history
batch_dict['seq_lengths'] = transcripts_lengths
return sorted_dial_ids, sorted_dial_turns, batch_dict, actions, attributes
def __str__(self):
return super().__str__()
| 11,586 | 45.163347 | 154 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/translate.py | # -*- coding: utf-8 -*-
import logging
import torch
import os
from beaver.data import build_dataset
from beaver.infer import beam_search
from beaver.model import NMTModel
from beaver.utils import parseopt, get_device, calculate_bleu
logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.INFO)
opt = parseopt.parse_translate_args()
device = get_device()
def translate(dataset, fields, model):
already, hypothesis_1, hypothesis_2 = 0, [], []
for batch in dataset:
predictions_1, predictions_2 = beam_search(opt, model, batch.source, fields)
hypothesis_1 += [fields["summary_cn"].decode(p) for p in predictions_1]
hypothesis_2 += [fields["summary_en"].decode(p) for p in predictions_2]
already += len(predictions_1)
logging.info("Finished: %7d/%7d" % (already, dataset.num_examples))
origin = sorted(zip(hypothesis_1, hypothesis_2, dataset.seed), key=lambda t: t[2])
hypothesis_1 = [h for h, _, _ in origin]
hypothesis_2 = [h for _, h, _ in origin]
with open(opt.output[0], "w", encoding="UTF-8") as out_file:
out_file.write("\n".join(hypothesis_1))
out_file.write("\n")
with open(opt.output[1], "w", encoding="UTF-8") as out_file:
out_file.write("\n".join(hypothesis_2))
out_file.write("\n")
logging.info("All finished. ")
def main():
logging.info("Build dataset...")
dataset = build_dataset(opt, [opt.input, opt.input, opt.input], opt.vocab, device, train=False)
fields = dataset.fields
pad_ids = {"source": fields["source"].pad_id,
"summary_cn": fields["summary_cn"].pad_id,
"summary_en": fields["summary_en"].pad_id}
vocab_sizes = {"source": len(fields["source"].vocab),
"summary_cn": len(fields["summary_cn"].vocab),
"summary_en": len(fields["summary_en"].vocab)}
# load checkpoint from model_path
logging.info("Load checkpoint from %s." % opt.model_path)
checkpoint = torch.load(opt.model_path, map_location=lambda storage, loc: storage)
logging.info("Build model...")
model = NMTModel.load_model(checkpoint["opt"], pad_ids, vocab_sizes, checkpoint["model"]).to(device).eval()
logging.info("Start translation...")
with torch.set_grad_enabled(False):
translate(dataset, fields, model)
if __name__ == '__main__':
main()
| 2,389 | 33.142857 | 111 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/train.py | # -*- coding: utf-8 -*-
import logging
import torch
import torch.cuda
from beaver.data import build_dataset
from beaver.infer import beam_search
from beaver.loss import WarmAdam, LabelSmoothingLoss
from beaver.model import NMTModel
from beaver.utils import Saver
from beaver.utils import calculate_bleu
from beaver.utils import parseopt, get_device, printing_opt
from beaver.utils.metric import calculate_rouge
logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.INFO)
opt = parseopt.parse_train_args()
device = get_device()
logging.info("\n" + printing_opt(opt))
saver = Saver(opt)
def valid(model, criterion_cn, criterion_en, valid_dataset, step):
model.eval()
total_loss = total_cn_loss = total_en_loss = 0.0
total_n = 0
cn_hypothesis, cn_references = [], []
en_hypothesis, en_references = [], []
for batch in valid_dataset:
cn_scores, en_scores = model(batch.source, batch.summary_cn, batch.summary_en)
cn_loss = criterion_cn(cn_scores, batch.summary_cn)
en_loss = criterion_en(en_scores, batch.summary_en)
loss = cn_loss + en_loss
total_loss += loss.data
total_cn_loss += cn_loss.data
total_en_loss += en_loss.data
total_n += 1
_, cn_predictions = cn_scores.topk(k=1, dim=-1)
cn_hypothesis += [valid_dataset.fields["summary_cn"].decode(p) for p in cn_predictions]
cn_references += [valid_dataset.fields["summary_cn"].decode(t) for t in batch.summary_cn]
_, en_predictions = en_scores.topk(k=1, dim=-1)
en_hypothesis += [valid_dataset.fields["summary_en"].decode(p) for p in en_predictions]
en_references += [valid_dataset.fields["summary_en"].decode(t) for t in batch.summary_en]
bleu_cn = calculate_bleu(cn_hypothesis, cn_references)
bleu_en = calculate_bleu(en_hypothesis, en_references)
rouge1_cn, rouge2_cn = calculate_rouge(cn_hypothesis, cn_references)
rouge1_en, rouge2_en = calculate_rouge(en_hypothesis, en_references)
mean_loss = total_loss / total_n
mean_en_loss = total_en_loss / total_n
mean_cn_loss = total_cn_loss / total_n
logging.info("loss: %.2f\t loss-cn: %.2f \t loss-en %.2f \t bleu-cn: %3.2f\t bleu-en: %3.2f \t rouge1-cn: %3.2f \t rouge1-en: %3.2f \t rouge2-cn: %3.2f \t rouge2-en: %3.2f"
% (mean_loss, mean_cn_loss, mean_en_loss, bleu_cn, bleu_en, rouge1_cn, rouge1_en, rouge2_cn, rouge2_en))
checkpoint = {"model": model.state_dict(), "opt": opt}
saver.save(checkpoint, step, mean_loss, mean_cn_loss, mean_en_loss, bleu_cn, bleu_en, rouge1_cn, rouge1_en, rouge2_cn, rouge2_en)
def train(model, criterion_cn, criterion_en, optimizer, train_dataset, valid_dataset):
total_loss = total_cn_loss = total_en_loss = 0.0
model.zero_grad()
for i, batch in enumerate(train_dataset):
cn_scores, en_scores = model(batch.source, batch.summary_cn, batch.summary_en)
cn_loss = criterion_cn(cn_scores, batch.summary_cn)
en_loss = criterion_en(en_scores, batch.summary_en)
loss = cn_loss + en_loss
loss.backward()
total_loss += loss.data
total_cn_loss += cn_loss.data
total_en_loss += en_loss.data
if (i + 1) % opt.grad_accum == 0:
optimizer.step()
model.zero_grad()
if optimizer.n_step % opt.report_every == 0:
mean_loss = total_loss / opt.report_every / opt.grad_accum
mean_en_loss = total_en_loss / opt.report_every / opt.grad_accum
mean_cn_loss = total_cn_loss / opt.report_every / opt.grad_accum
logging.info("step: %7d\t loss: %.4f \t loss-cn: %.4f \t loss-en: %.4f"
% (optimizer.n_step, mean_loss, mean_cn_loss, mean_en_loss))
total_loss = total_cn_loss = total_en_loss = 0.0
if optimizer.n_step % opt.save_every == 0:
with torch.set_grad_enabled(False):
valid(model, criterion_cn, criterion_en, valid_dataset, optimizer.n_step)
model.train()
del loss
def main():
logging.info("Build dataset...")
train_dataset = build_dataset(opt, opt.train, opt.vocab, device, train=True)
valid_dataset = build_dataset(opt, opt.valid, opt.vocab, device, train=False)
fields = valid_dataset.fields = train_dataset.fields
logging.info("Build model...")
pad_ids = {"source": fields["source"].pad_id,
"summary_cn": fields["summary_cn"].pad_id,
"summary_en": fields["summary_en"].pad_id}
vocab_sizes = {"source": len(fields["source"].vocab),
"summary_cn": len(fields["summary_cn"].vocab),
"summary_en": len(fields["summary_en"].vocab)}
model = NMTModel.load_model(opt, pad_ids, vocab_sizes).to(device)
criterion_cn = LabelSmoothingLoss(opt.label_smoothing, vocab_sizes["summary_cn"], pad_ids["summary_cn"]).to(device)
criterion_en = LabelSmoothingLoss(opt.label_smoothing, vocab_sizes["summary_en"], pad_ids["summary_en"]).to(device)
n_step = int(opt.train_from.split("-")[-1]) if opt.train_from else 1
optimizer = WarmAdam(model.parameters(), opt.lr, opt.hidden_size, opt.warm_up, n_step)
logging.info("start training...")
train(model, criterion_cn, criterion_en, optimizer, train_dataset, valid_dataset)
if __name__ == '__main__':
main()
| 5,407 | 42.264 | 176 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/tools/model_average.py | # -*- coding: utf-8 -*-
import os
import torch
import sys
def main():
if len(sys.argv) != 3:
print("python model_average.py model_path n")
exit()
model_path = sys.argv[1]
n = int(sys.argv[2]) # last n model to be averaged
fs = [os.path.join(model_path, f) for f in os.listdir(model_path) if f.startswith("checkpoint")]
fs = sorted(fs, reverse=True)[:n] # last n file
n = len(fs) # actual file count
cks = [torch.load(f, map_location=lambda storage, loc: storage) for f in fs]
first_model = cks[0]["model"] # average all weights into first model and save it
for k, _ in first_model.items():
for ck in cks[1:]:
first_model[k] = (first_model[k] + ck["model"][k])
first_model[k] = first_model[k] / n
torch.save(cks[0], os.path.join(model_path, "averaged-%s-%s" % (fs[-1].split("-")[-1], fs[0].split("-")[-1])))
if __name__ == '__main__':
main()
| 941 | 29.387097 | 114 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/loss/optimizers.py | # -*- coding: utf-8 -*-
import torch.nn as nn
import torch.optim as optim
class WarmAdam(object):
def __init__(self, params, lr, hidden_size, warm_up, n_step):
self.original_lr = lr
self.n_step = n_step
self.hidden_size = hidden_size
self.warm_up_step = warm_up
self.optimizer = optim.Adam(params, betas=[0.9, 0.998], eps=1e-9)
def step(self):
self.n_step += 1
warm_up = min(self.n_step ** (-0.5), self.n_step * self.warm_up_step ** (-1.5))
lr = self.original_lr * (self.hidden_size ** (-0.5) * warm_up)
for param_group in self.optimizer.param_groups:
param_group['lr'] = lr
self.optimizer.step()
class LabelSmoothingLoss(nn.Module):
def __init__(self, label_smoothing, tgt_vocab_size, ignore_index):
self.padding_idx = ignore_index
self.label_smoothing = label_smoothing
self.vocab_size = tgt_vocab_size
super(LabelSmoothingLoss, self).__init__()
def forward(self, output, target):
target = target[:, 1:].contiguous().view(-1)
output = output.view(-1, self.vocab_size)
non_pad_mask = target.ne(self.padding_idx)
nll_loss = -output.gather(dim=-1, index=target.view(-1, 1))[non_pad_mask].sum()
smooth_loss = -output.sum(dim=-1, keepdim=True)[non_pad_mask].sum()
eps_i = self.label_smoothing / self.vocab_size
loss = (1. - self.label_smoothing) * nll_loss + eps_i * smooth_loss
return loss / non_pad_mask.float().sum()
| 1,529 | 36.317073 | 87 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/utils/saver.py | import json
import torch
import os
import datetime
class Saver(object):
def __init__(self, opt):
self.ckpt_names = []
self.model_path = opt.model_path + datetime.datetime.now().strftime("-%y%m%d-%H%M%S")
self.max_to_keep = opt.max_to_keep
os.mkdir(self.model_path)
with open(os.path.join(self.model_path, "params.json"), "w", encoding="UTF-8") as log:
log.write(json.dumps(vars(opt), indent=4) + "\n")
def save(self, save_dict, step, loss, loss_cn, loss_en, bleu_cn, bleu_en, rouge1_cn, rouge1_en, rouge2_cn, rouge2_en):
filename = "checkpoint-step-%06d" % step
full_filename = os.path.join(self.model_path, filename)
self.ckpt_names.append(full_filename)
torch.save(save_dict, full_filename)
with open(os.path.join(self.model_path, "log"), "a", encoding="UTF-8") as log:
log.write("%s\t" % datetime.datetime.now())
log.write("step: %6d\t" % step)
log.write("loss: %.2f\t" % loss)
log.write("loss-cn: %.2f\t" % loss_cn)
log.write("loss-en: %.2f\t" % loss_en)
log.write("bleu-cn: %3.2f\t" % bleu_cn)
log.write("bleu-en: %3.2f\t" % bleu_en)
log.write("rouge1-cn: %3.2f\t" % rouge1_cn)
log.write("rouge1-en: %3.2f\t" % rouge1_en)
log.write("rouge2-cn: %3.2f\t" % rouge2_cn)
log.write("rouge2-en: %3.2f\t" % rouge2_en)
log.write("\n")
if 0 < self.max_to_keep < len(self.ckpt_names):
earliest_ckpt = self.ckpt_names.pop(0)
os.remove(earliest_ckpt)
| 1,626 | 38.682927 | 122 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/utils/__init__.py | # -*- coding: utf-8 -*-
import torch.cuda
from beaver.utils.metric import calculate_bleu, file_bleu
from beaver.utils.saver import Saver
def get_device():
if torch.cuda.is_available():
return torch.device('cuda')
else:
return torch.device('cpu')
def printing_opt(opt):
return "\n".join(["%15s | %s" % (e[0], e[1]) for e in sorted(vars(opt).items(), key=lambda x: x[0])])
| 405 | 21.555556 | 105 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/data/field.py | # -*- coding: utf-8 -*-
from typing import List
import torch
EOS_TOKEN = "<eos>"
BOS_TOKEN = "<bos>"
UNK_TOKEN = "<unk>"
PAD_TOKEN = "<pad>"
class Field(object):
def __init__(self, bos: bool, eos: bool, pad: bool, unk: bool):
self.bos_token = BOS_TOKEN if bos else None
self.eos_token = EOS_TOKEN if eos else None
self.unk_token = UNK_TOKEN if unk else None
self.pad_token = PAD_TOKEN if pad else None
self.vocab = None
def load_vocab(self, words: List[str], specials: List[str]):
self.vocab = Vocab(words, specials)
def process(self, batch, device):
max_len = max(len(x) for x in batch)
padded, length = [], []
for x in batch:
bos = [self.bos_token] if self.bos_token else []
eos = [self.eos_token] if self.eos_token else []
pad = [self.pad_token] * (max_len - len(x))
padded.append(bos + x + eos + pad)
length.append(len(x) + len(bos) + len(eos))
padded = torch.tensor([self.encode(ex) for ex in padded])
return padded.long().to(device)
def encode(self, tokens):
ids = []
for tok in tokens:
if tok in self.vocab.stoi:
ids.append(self.vocab.stoi[tok])
else:
ids.append(self.unk_id)
return ids
def decode(self, ids):
tokens = []
for tok in ids:
tok = self.vocab.itos[tok]
if tok == self.eos_token:
break
if tok == self.bos_token:
continue
tokens.append(tok)
return " ".join(tokens).replace("@@ ", "").replace("@@", "")
@property
def special(self):
return [tok for tok in [self.unk_token, self.pad_token, self.bos_token, self.eos_token] if tok is not None]
@property
def pad_id(self):
return self.vocab.stoi[self.pad_token]
@property
def eos_id(self):
return self.vocab.stoi[self.eos_token]
@property
def bos_id(self):
return self.vocab.stoi[self.bos_token]
@property
def unk_id(self):
return self.vocab.stoi[self.unk_token]
class Vocab(object):
def __init__(self, words: List[str], specials: List[str]):
self.itos = specials + words
self.stoi = {tok: i for i, tok in enumerate(self.itos)}
def __len__(self):
return len(self.itos)
| 2,418 | 25.582418 | 115 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/data/dataset.py | # -*- coding: utf-8 -*-
import random
from collections import namedtuple
from typing import Dict
import torch
from beaver.data.field import Field
Batch = namedtuple("Batch", ['source', 'summary_cn', 'summary_en', 'batch_size'])
Example = namedtuple("Example", ['source', 'summary_cn', 'summary_en'])
class SumTransDataset(object):
def __init__(self,
source_path: str,
summary_cn_path: str,
summary_en_path: str,
batch_size: int,
device: torch.device,
train: bool,
fields: Dict[str, Field]):
self.batch_size = batch_size
self.train = train
self.device = device
self.fields = fields
self.sort_key = lambda ex: (len(ex.source), len(ex.summary_cn), len(ex.summary_en))
examples = []
for src_line, cn_line, en_line in zip(read_file(source_path),
read_file(summary_cn_path),
read_file(summary_en_path)):
examples.append(Example(src_line, cn_line, en_line))
examples, self.seed = self.sort(examples)
self.num_examples = len(examples)
self.batches = list(batch(examples, self.batch_size))
def __iter__(self):
while True:
if self.train:
random.shuffle(self.batches)
for minibatch in self.batches:
source = self.fields["source"].process([x.source for x in minibatch], self.device)
summary_cn = self.fields["summary_cn"].process([x.summary_cn for x in minibatch], self.device)
summary_en = self.fields["summary_en"].process([x.summary_en for x in minibatch], self.device)
yield Batch(source=source, summary_cn=summary_cn, summary_en=summary_en, batch_size=len(minibatch))
if not self.train:
break
def sort(self, examples):
seed = sorted(range(len(examples)), key=lambda idx: self.sort_key(examples[idx]))
return sorted(examples, key=self.sort_key), seed
def read_file(path):
with open(path, encoding="utf-8") as f:
for line in f:
yield line.strip().split()
def batch(data, batch_size):
minibatch, cur_source_len, cur_target_len = [], 0, 0
for ex in data:
minibatch.append(ex)
cur_source_len = max(cur_source_len, len(ex.source))
cur_target_len = max(cur_target_len, len(ex.summary_en), len(ex.summary_cn))
if (cur_target_len + cur_source_len) * len(minibatch) > batch_size:
yield minibatch[:-1]
minibatch, cur_source_len, cur_target_len = [ex], len(ex.source), max(len(ex.summary_cn), len(ex.summary_en))
if minibatch:
yield minibatch
| 2,812 | 35.532468 | 121 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/infer/beam.py | # -*- coding: utf-8 -*-
import torch
class Beam(object):
def __init__(self, beam_size, pad, bos, eos, device, lp):
self.size = beam_size
self.alpha = lp
self.scores = torch.full([beam_size], -1e20).float().to(device)
self.scores[0] = 0.
self.hypotheses = torch.full([1, beam_size], fill_value=pad).long().to(device)
self.hypotheses[0][0] = bos
self.eos = eos
self.finished = []
@property
def current_state(self):
return self.hypotheses[-1]
def advance(self, scores, origin, tokens):
self.scores = scores
self.hypotheses = torch.index_select(self.hypotheses, 1, origin)
self.hypotheses = torch.cat([self.hypotheses, tokens.unsqueeze(0)])
for idx, tok in enumerate(self.hypotheses[-1]):
if tok == self.eos:
self.finished.append((self.scores[idx].clone(), self.hypotheses[1:, idx]))
self.scores[idx] = -1e20
@property
def done(self):
max_score = max([self.length_penalty(score, self.hypotheses.size(0)) for score in self.scores])
max_finish = max([self.length_penalty(t[0], t[1].size(0)) for t in self.finished]) if self.finished else -1e20
return bool(max_score < max_finish)
@property
def best_hypothesis(self):
finished = sorted(self.finished, key=lambda t: self.length_penalty(t[0], t[1].size(0)), reverse=True)
if not finished:
return self.hypotheses[1:, 0]
return finished[0][1]
def length_penalty(self, score, length):
return score * (6 ** self.alpha) / ((5 + length) ** self.alpha)
| 1,652 | 32.06 | 118 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/infer/translator.py | # -*- coding: utf-8 -*-
import torch
from beaver.infer.beam import Beam
def beam_search(opt, model, src, fields):
batch_size = src.size(0)
beam_size = opt.beam_size
encoder = model.encoder
src = src.repeat(1, beam_size).view(batch_size * beam_size, -1)
src_pad = src.eq(fields["source"].pad_id)
src_out = encoder(src, src_pad)
p1 = beam_search_1(opt, batch_size, src, fields["summary_cn"], src_out, src_pad, model.cn_decoder, model.cn_generator)
p2 = beam_search_1(opt, batch_size, src, fields["summary_en"], src_out, src_pad, model.en_decoder, model.en_generator)
return p1, p2
def beam_search_1(opt, batch_size, src, field, src_out, src_pad, decoder, generator):
beam_size = opt.beam_size
device = src.device
num_words = generator.vocab_size
beams = [Beam(opt.beam_size, field.pad_id, field.bos_id, field.eos_id,
device, opt.length_penalty) for _ in range(batch_size)]
beam_expander = (torch.arange(batch_size) * beam_size).view(-1, 1).to(device)
previous = None
for i in range(opt.max_length):
if all((b.done for b in beams)):
break
# [batch_size x beam_size, 1]
current_token = torch.cat([b.current_state for b in beams]).unsqueeze(-1)
tgt_pad = current_token.eq(field.pad_id)
out, previous = decoder(current_token, src_out, src_pad, tgt_pad, previous, i)
previous_score = torch.stack([b.scores for b in beams]).unsqueeze(-1)
out = generator(out).view(batch_size, beam_size, -1)
if i < opt.min_length:
out[:, :, field.eos_id] = -1e15
# find topk candidates
scores, indexes = (out + previous_score).view(batch_size, -1).topk(beam_size)
# find origins and token
origins = (indexes.view(-1) // num_words).view(batch_size, beam_size)
tokens = (indexes.view(-1) % num_words).view(batch_size, beam_size)
for j, b in enumerate(beams):
b.advance(scores[j], origins[j], tokens[j])
origins = (origins + beam_expander).view(-1)
previous = torch.index_select(previous, 0, origins)
return [b.best_hypothesis for b in beams]
| 2,185 | 33.698413 | 122 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/model/embeddings.py | # -*- coding: utf-8 -*-
import math
import torch
import torch.nn as nn
def positional_encoding(dim, max_len=5000):
pe = torch.zeros(max_len, dim)
position = torch.arange(0, max_len).unsqueeze(1)
div_term = torch.exp((torch.arange(0, dim, 2, dtype=torch.float) * -(math.log(10000.0) / dim)))
pe[:, 0::2] = torch.sin(position.float() * div_term)
pe[:, 1::2] = torch.cos(position.float() * div_term)
return pe
class Embedding(nn.Module):
def __init__(self, embedding_dim, vocab_size, padding_idx, dropout):
self.word_padding_idx = padding_idx
self.embedding_dim = embedding_dim
pe = positional_encoding(embedding_dim)
super(Embedding, self).__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=padding_idx)
self.register_buffer('pe', pe)
self.dropout = nn.Dropout(p=dropout)
self.reset_parameters()
def reset_parameters(self):
nn.init.normal_(self.embedding.weight, mean=0.0, std=self.embedding_dim ** -0.5)
@property
def padding_idx(self):
return self.word_padding_idx
def forward(self, x, timestep=0):
embedding = self.embedding(x) * math.sqrt(self.embedding_dim) + self.pe[timestep:timestep + x.size(1)]
return self.dropout(embedding)
| 1,313 | 31.04878 | 110 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/model/transformer.py | # -*- coding: utf-8 -*-
import math
import torch
import torch.nn as nn
class FeedForward(nn.Module):
def __init__(self, hidden_size, inner_size, dropout):
super(FeedForward, self).__init__()
self.linear_in = nn.Linear(hidden_size, inner_size, bias=False)
self.linear_out = nn.Linear(inner_size, hidden_size, bias=False)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(dropout)
self.reset_parameters()
def reset_parameters(self):
nn.init.xavier_uniform_(self.linear_in.weight)
nn.init.xavier_uniform_(self.linear_out.weight)
def forward(self, x):
y = self.linear_in(x)
y = self.relu(y)
y = self.dropout(y)
y = self.linear_out(y)
return y
class EncoderLayer(nn.Module):
def __init__(self, hidden_size, dropout, head_count, ff_size):
super(EncoderLayer, self).__init__()
self.self_attn = MultiHeadedAttention(head_count, hidden_size, dropout)
self.feed_forward = FeedForward(hidden_size, ff_size, dropout)
self.dropout = nn.ModuleList([nn.Dropout(dropout) for _ in range(2)])
self.norm = nn.ModuleList([nn.LayerNorm(hidden_size) for _ in range(2)])
def forward(self, x, mask):
# self attention
y = self.self_attn(self.norm[0](x), mask=mask)
x = x + self.dropout[0](y)
# feed forward
y = self.feed_forward(self.norm[1](x))
x = x + self.dropout[1](y)
return x
class Encoder(nn.Module):
def __init__(self, num_layers, num_heads, hidden_size, dropout, ff_size, embedding):
self.num_layers = num_layers
super(Encoder, self).__init__()
self.embedding = embedding
self.layers = nn.ModuleList([EncoderLayer(hidden_size, dropout, num_heads, ff_size) for _ in range(num_layers)])
self.norm = nn.LayerNorm(hidden_size)
def forward(self, src, src_pad):
src_mask = src_pad.unsqueeze(1)
output = self.embedding(src)
for i in range(self.num_layers):
output = self.layers[i](output, src_mask)
return self.norm(output)
class DecoderLayer(nn.Module):
def __init__(self, hidden_size, dropout, head_count, ff_size):
super(DecoderLayer, self).__init__()
self.self_attn = MultiHeadedAttention(head_count, hidden_size, dropout)
self.src_attn = MultiHeadedAttention(head_count, hidden_size, dropout)
self.feed_forward = FeedForward(hidden_size, ff_size, dropout)
self.norm = nn.ModuleList([nn.LayerNorm(hidden_size, eps=1e-6) for _ in range(3)])
self.dropout = nn.ModuleList([nn.Dropout(dropout) for _ in range(3)])
def forward(self, x, enc_out, src_mask, tgt_mask, previous=None):
all_input = x if previous is None else torch.cat((previous, x), dim=1)
# self attention
y = self.self_attn(self.norm[0](x), self.norm[0](all_input), mask=tgt_mask)
x = x + self.dropout[0](y)
# encoder decoder attention
y = self.src_attn(self.norm[1](x), enc_out, mask=src_mask)
x = x + self.dropout[1](y)
# feed forward
y = self.feed_forward(self.norm[2](x))
x = x + self.dropout[2](y)
return x, all_input
class Decoder(nn.Module):
def __init__(self, num_layers, num_heads, hidden_size, dropout, ff_size, embedding):
self.num_layers = num_layers
super(Decoder, self).__init__()
self.embedding = embedding
self.layers = nn.ModuleList([DecoderLayer(hidden_size, dropout, num_heads, ff_size) for _ in range(num_layers)])
self.register_buffer("upper_triangle", torch.triu(torch.ones(1000, 1000), diagonal=1).byte())
self.register_buffer("zero_mask", torch.zeros(1).byte())
self.norm = nn.LayerNorm(hidden_size, eps=1e-6)
def forward(self, tgt, enc_out, src_pad, tgt_pad, previous=None, timestep=0):
output = self.embedding(tgt, timestep)
tgt_len = tgt.size(1)
src_mask = src_pad.unsqueeze(1)
tgt_mask = tgt_pad.unsqueeze(1)
upper_triangle = self.upper_triangle[:tgt_len, :tgt_len]
# tgt mask: 0 if not upper and not pad
tgt_mask = torch.gt(tgt_mask + upper_triangle, 0)
saved_inputs = []
for i in range(self.num_layers):
prev_layer = None if previous is None else previous[:, i]
tgt_mask = tgt_mask if previous is None else self.zero_mask
output, all_input = self.layers[i](output, enc_out, src_mask, tgt_mask, prev_layer)
saved_inputs.append(all_input)
return self.norm(output), torch.stack(saved_inputs, dim=1)
class MultiHeadedAttention(nn.Module):
def __init__(self, head_count, model_dim, dropout):
self.dim_per_head = model_dim // head_count
self.head_count = head_count
super(MultiHeadedAttention, self).__init__()
self.linear_q = nn.Linear(model_dim, model_dim, bias=False)
self.linear_k = nn.Linear(model_dim, model_dim, bias=False)
self.linear_v = nn.Linear(model_dim, model_dim, bias=False)
self.softmax = nn.Softmax(dim=-1)
self.dropout = nn.Dropout(dropout)
self.final_linear = nn.Linear(model_dim, model_dim)
self.reset_parameters()
def reset_parameters(self):
nn.init.xavier_uniform_(self.linear_q.weight)
nn.init.xavier_uniform_(self.linear_k.weight)
nn.init.xavier_uniform_(self.linear_v.weight)
nn.init.xavier_uniform_(self.final_linear.weight)
def forward(self, query, memory=None, mask=None):
memory = query if memory is None else memory
def split_head(x):
# B x L x D => B x h x L x d
return x.view(x.size(0), -1, self.head_count, self.dim_per_head).transpose(1, 2)
def combine_head(x):
# B x h x L x d => B x L x D
return x.transpose(1, 2).contiguous().view(x.size(0), -1, self.head_count * self.dim_per_head)
# 1) Project q, k, v.
q = split_head(self.linear_q(query))
k = split_head(self.linear_k(memory))
v = split_head(self.linear_v(memory))
# 2) Calculate and scale scores.
q = q / math.sqrt(self.dim_per_head)
scores = torch.matmul(q, k.transpose(2, 3))
mask = mask.unsqueeze(1).expand_as(scores)
scores.masked_fill_(mask, -1e18)
# 3) Apply attention dropout and compute context vectors.
weights = self.dropout(self.softmax(scores))
context = combine_head(torch.matmul(weights, v))
return self.final_linear(context)
| 6,591 | 35.622222 | 120 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task/beaver/model/nmt_model.py | # -*- coding: utf-8 -*-
from typing import Dict
import torch
import torch.nn as nn
from beaver.model.embeddings import Embedding
from beaver.model.transformer import Decoder, Encoder
class Generator(nn.Module):
def __init__(self, hidden_size: int, tgt_vocab_size: int):
self.vocab_size = tgt_vocab_size
super(Generator, self).__init__()
self.linear_hidden = nn.Linear(hidden_size, tgt_vocab_size)
self.lsm = nn.LogSoftmax(dim=-1)
self.reset_parameters()
def reset_parameters(self):
nn.init.xavier_uniform_(self.linear_hidden.weight)
def forward(self, dec_out):
score = self.linear_hidden(dec_out)
lsm_score = self.lsm(score)
return lsm_score
class NMTModel(nn.Module):
def __init__(self, encoder: Encoder,
cn_decoder: Decoder,
en_decoder: Decoder,
cn_generator: Generator,
en_generator: Generator):
super(NMTModel, self).__init__()
self.encoder = encoder
self.cn_decoder = cn_decoder
self.en_decoder = en_decoder
self.cn_generator = cn_generator
self.en_generator = en_generator
def forward(self, source, summary_cn, summary_en):
summary_cn = summary_cn[:, :-1] # shift left
summary_en = summary_en[:, :-1] # shift left
source_pad = source.eq(self.encoder.embedding.word_padding_idx)
summary_cn_pad = summary_cn.eq(self.cn_decoder.embedding.word_padding_idx)
summary_en_pad = summary_en.eq(self.en_decoder.embedding.word_padding_idx)
enc_out = self.encoder(source, source_pad)
cn_decoder_outputs, _ = self.cn_decoder(summary_cn, enc_out, source_pad, summary_cn_pad)
en_decoder_outputs, _ = self.en_decoder(summary_en, enc_out, source_pad, summary_en_pad)
cn_scores = self.cn_generator(cn_decoder_outputs)
en_scores = self.en_generator(en_decoder_outputs)
return cn_scores, en_scores
@classmethod
def load_model(cls, model_opt,
pad_ids: Dict[str, int],
vocab_sizes: Dict[str, int],
checkpoint=None):
source_embedding = Embedding(embedding_dim=model_opt.hidden_size,
dropout=model_opt.dropout,
padding_idx=pad_ids["source"],
vocab_size=vocab_sizes["source"])
summary_en_embedding = Embedding(embedding_dim=model_opt.hidden_size,
dropout=model_opt.dropout,
padding_idx=pad_ids["summary_en"],
vocab_size=vocab_sizes["summary_en"])
if model_opt.share_cn_embedding:
summary_cn_embedding = source_embedding
else:
summary_cn_embedding = Embedding(embedding_dim=model_opt.hidden_size,
dropout=model_opt.dropout,
padding_idx=pad_ids["summary_cn"],
vocab_size=vocab_sizes["summary_cn"])
encoder = Encoder(model_opt.layers,
model_opt.heads,
model_opt.hidden_size,
model_opt.dropout,
model_opt.ff_size,
source_embedding)
cn_decoder = Decoder(model_opt.layers,
model_opt.heads,
model_opt.hidden_size,
model_opt.dropout,
model_opt.ff_size,
summary_cn_embedding)
en_decoder = Decoder(model_opt.layers,
model_opt.heads,
model_opt.hidden_size,
model_opt.dropout,
model_opt.ff_size,
summary_en_embedding)
cn_generator = Generator(model_opt.hidden_size, vocab_sizes["summary_cn"])
en_generator = Generator(model_opt.hidden_size, vocab_sizes["summary_en"])
model = cls(encoder, cn_decoder, en_decoder, cn_generator, en_generator)
if checkpoint is None and model_opt.train_from:
checkpoint = torch.load(model_opt.train_from, map_location=lambda storage, loc: storage)
model.load_state_dict(checkpoint["model"])
elif checkpoint is not None:
model.load_state_dict(checkpoint)
return model
| 4,603 | 39.743363 | 100 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/translate.py | # -*- coding: utf-8 -*-
import logging
import torch
import os
from beaver.data import build_dataset
from beaver.infer import beam_search
from beaver.model import NMTModel
from beaver.utils import parseopt, get_device, calculate_bleu
logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.INFO)
opt = parseopt.parse_translate_args()
device = get_device()
def translate(dataset, fields, model):
already, hypothesis, references = 0, [], []
for batch in dataset:
if opt.tf:
scores = model(batch.src, batch.tgt)
_, predictions = scores.topk(k=1, dim=-1)
else:
predictions = beam_search(opt, model, batch.src, fields)
hypothesis += [fields["tgt"].decode(p) for p in predictions]
already += len(predictions)
logging.info("Translated: %7d/%7d" % (already, dataset.num_examples))
references += [fields["tgt"].decode(t) for t in batch.tgt]
if opt.bleu:
bleu = calculate_bleu(hypothesis, references)
logging.info("BLEU: %3.2f" % bleu)
origin = sorted(zip(hypothesis, dataset.seed), key=lambda t: t[1])
hypothesis = [h for h, _ in origin]
with open(opt.output, "w", encoding="UTF-8") as out_file:
out_file.write("\n".join(hypothesis))
out_file.write("\n")
logging.info("Translation finished. ")
def main():
logging.info("Build dataset...")
dataset = build_dataset(opt, [opt.input, opt.truth or opt.input], opt.vocab, device, train=False)
fields = dataset.fields
pad_ids = {"src": fields["src"].pad_id, "tgt": fields["tgt"].pad_id}
vocab_sizes = {"src": len(fields["src"].vocab), "tgt": len(fields["tgt"].vocab)}
# load checkpoint from model_path
logging.info("Load checkpoint from %s." % opt.model_path)
checkpoint = torch.load(opt.model_path, map_location=lambda storage, loc: storage)
logging.info("Build model...")
model = NMTModel.load_model(checkpoint["opt"], pad_ids, vocab_sizes, checkpoint["model"]).to(device).eval()
logging.info("Start translation...")
with torch.set_grad_enabled(False):
translate(dataset, fields, model)
if __name__ == '__main__':
main()
| 2,194 | 30.811594 | 111 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/train.py | # -*- coding: utf-8 -*-
import logging
import torch
import torch.cuda
from beaver.data import build_dataset
from beaver.infer import beam_search
from beaver.loss import WarmAdam, LabelSmoothingLoss
from beaver.model import NMTModel
from beaver.utils import Saver
from beaver.utils import calculate_bleu
from beaver.utils import parseopt, get_device, printing_opt
logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.INFO)
opt = parseopt.parse_train_args()
device = get_device()
logging.info("\n" + printing_opt(opt))
saver = Saver(opt)
def valid(model, criterion, valid_dataset, step):
model.eval()
total_loss, total = 0.0, 0
hypothesis, references = [], []
for batch in valid_dataset:
scores = model(batch.src, batch.tgt)
loss = criterion(scores, batch.tgt)
total_loss += loss.data
total += 1
if opt.tf:
_, predictions = scores.topk(k=1, dim=-1)
else:
predictions = beam_search(opt, model, batch.src, valid_dataset.fields)
hypothesis += [valid_dataset.fields["tgt"].decode(p) for p in predictions]
references += [valid_dataset.fields["tgt"].decode(t) for t in batch.tgt]
bleu = calculate_bleu(hypothesis, references)
logging.info("Valid loss: %.2f\tValid BLEU: %3.2f" % (total_loss / total, bleu))
checkpoint = {"model": model.state_dict(), "opt": opt}
saver.save(checkpoint, step, bleu, total_loss / total)
def train(model, criterion, optimizer, train_dataset, valid_dataset):
total_loss = 0.0
model.zero_grad()
for i, batch in enumerate(train_dataset):
scores = model(batch.src, batch.tgt)
loss = criterion(scores, batch.tgt)
loss.backward()
total_loss += loss.data
if (i + 1) % opt.grad_accum == 0:
optimizer.step()
model.zero_grad()
if optimizer.n_step % opt.report_every == 0:
mean_loss = total_loss / opt.report_every / opt.grad_accum
logging.info("step: %7d\t loss: %7f" % (optimizer.n_step, mean_loss))
total_loss = 0.0
if optimizer.n_step % opt.save_every == 0:
with torch.set_grad_enabled(False):
valid(model, criterion, valid_dataset, optimizer.n_step)
model.train()
del loss
def main():
logging.info("Build dataset...")
train_dataset = build_dataset(opt, opt.train, opt.vocab, device, train=True)
valid_dataset = build_dataset(opt, opt.valid, opt.vocab, device, train=False)
fields = valid_dataset.fields = train_dataset.fields
logging.info("Build model...")
pad_ids = {"src": fields["src"].pad_id, "tgt": fields["tgt"].pad_id}
vocab_sizes = {"src": len(fields["src"].vocab), "tgt": len(fields["tgt"].vocab)}
model = NMTModel.load_model(opt, pad_ids, vocab_sizes).to(device)
criterion = LabelSmoothingLoss(opt.label_smoothing, vocab_sizes["tgt"], pad_ids["tgt"]).to(device)
n_step = int(opt.train_from.split("-")[-1]) if opt.train_from else 1
optimizer = WarmAdam(model.parameters(), opt.lr, opt.hidden_size, opt.warm_up, n_step)
logging.info("start training...")
train(model, criterion, optimizer, train_dataset, valid_dataset)
if __name__ == '__main__':
main()
| 3,303 | 32.714286 | 102 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/tools/model_average.py | # -*- coding: utf-8 -*-
import os
import torch
import sys
def main():
if len(sys.argv) != 3:
print("python model_average.py model_path n")
exit()
model_path = sys.argv[1]
n = int(sys.argv[2]) # last n model to be averaged
fs = [os.path.join(model_path, f) for f in os.listdir(model_path) if f.startswith("checkpoint")]
fs = sorted(fs, reverse=True)[:n] # last n file
n = len(fs) # actual file count
cks = [torch.load(f, map_location=lambda storage, loc: storage) for f in fs]
first_model = cks[0]["model"] # average all weights into first model and save it
for k, _ in first_model.items():
for ck in cks[1:]:
first_model[k] = (first_model[k] + ck["model"][k])
first_model[k] = first_model[k] / n
torch.save(cks[0], os.path.join(model_path, "averaged-%s-%s" % (fs[-1].split("-")[-1], fs[0].split("-")[-1])))
if __name__ == '__main__':
main()
| 941 | 29.387097 | 114 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/loss/optimizers.py | # -*- coding: utf-8 -*-
import torch.nn as nn
import torch.optim as optim
class WarmAdam(object):
def __init__(self, params, lr, hidden_size, warm_up, n_step):
self.original_lr = lr
self.n_step = n_step
self.hidden_size = hidden_size
self.warm_up_step = warm_up
self.optimizer = optim.Adam(params, betas=[0.9, 0.998], eps=1e-9)
def step(self):
self.n_step += 1
warm_up = min(self.n_step ** (-0.5), self.n_step * self.warm_up_step ** (-1.5))
lr = self.original_lr * (self.hidden_size ** (-0.5) * warm_up)
for param_group in self.optimizer.param_groups:
param_group['lr'] = lr
self.optimizer.step()
class LabelSmoothingLoss(nn.Module):
def __init__(self, label_smoothing, tgt_vocab_size, ignore_index):
self.padding_idx = ignore_index
self.label_smoothing = label_smoothing
self.vocab_size = tgt_vocab_size
super(LabelSmoothingLoss, self).__init__()
def forward(self, output, target):
target = target[:, 1:].contiguous().view(-1)
output = output.view(-1, self.vocab_size)
non_pad_mask = target.ne(self.padding_idx)
nll_loss = -output.gather(dim=-1, index=target.view(-1, 1))[non_pad_mask].sum()
smooth_loss = -output.sum(dim=-1, keepdim=True)[non_pad_mask].sum()
eps_i = self.label_smoothing / self.vocab_size
loss = (1. - self.label_smoothing) * nll_loss + eps_i * smooth_loss
return loss / non_pad_mask.float().sum()
| 1,529 | 36.317073 | 87 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/utils/saver.py | import json
import torch
import os
import datetime
class Saver(object):
def __init__(self, opt):
self.ckpt_names = []
self.model_path = opt.model_path + datetime.datetime.now().strftime("-%y%m%d-%H%M%S")
self.max_to_keep = opt.max_to_keep
os.mkdir(self.model_path)
with open(os.path.join(self.model_path, "params.json"), "w", encoding="UTF-8") as log:
log.write(json.dumps(vars(opt), indent=4) + "\n")
def save(self, save_dict, step, bleu, loss):
filename = "checkpoint-step-%06d" % step
full_filename = os.path.join(self.model_path, filename)
self.ckpt_names.append(full_filename)
torch.save(save_dict, full_filename)
with open(os.path.join(self.model_path, "log"), "a", encoding="UTF-8") as log:
log.write("%s\t step: %6d\t loss: %.2f\t bleu: %.2f\n" % (datetime.datetime.now(), step, loss, bleu))
if 0 < self.max_to_keep < len(self.ckpt_names):
earliest_ckpt = self.ckpt_names.pop(0)
os.remove(earliest_ckpt)
| 1,063 | 34.466667 | 113 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/utils/__init__.py | # -*- coding: utf-8 -*-
import torch.cuda
from beaver.utils.metric import calculate_bleu, file_bleu
from beaver.utils.saver import Saver
def get_device():
if torch.cuda.is_available():
return torch.device('cuda')
else:
return torch.device('cpu')
def printing_opt(opt):
return "\n".join(["%15s | %s" % (e[0], e[1]) for e in sorted(vars(opt).items(), key=lambda x: x[0])])
| 405 | 21.555556 | 105 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/data/field.py | # -*- coding: utf-8 -*-
from typing import List
import torch
EOS_TOKEN = "<eos>"
BOS_TOKEN = "<bos>"
UNK_TOKEN = "<unk>"
PAD_TOKEN = "<pad>"
class Field(object):
def __init__(self, bos: bool, eos: bool, pad: bool, unk: bool):
self.bos_token = BOS_TOKEN if bos else None
self.eos_token = EOS_TOKEN if eos else None
self.unk_token = UNK_TOKEN if unk else None
self.pad_token = PAD_TOKEN if pad else None
self.vocab = None
def load_vocab(self, words: List[str], specials: List[str]):
self.vocab = Vocab(words, specials)
def process(self, batch, device):
max_len = max(len(x) for x in batch)
padded, length = [], []
for x in batch:
bos = [self.bos_token] if self.bos_token else []
eos = [self.eos_token] if self.eos_token else []
pad = [self.pad_token] * (max_len - len(x))
padded.append(bos + x + eos + pad)
length.append(len(x) + len(bos) + len(eos))
padded = torch.tensor([self.encode(ex) for ex in padded])
return padded.long().to(device)
def encode(self, tokens):
ids = []
for tok in tokens:
if tok in self.vocab.stoi:
ids.append(self.vocab.stoi[tok])
else:
ids.append(self.unk_id)
return ids
def decode(self, ids):
tokens = []
for tok in ids:
tok = self.vocab.itos[tok]
if tok == self.eos_token:
break
if tok == self.bos_token:
continue
tokens.append(tok)
# 删除BPE符号，按照T2T切分-。
return " ".join(tokens).replace("@@ ", "").replace("@@", "").replace("-", " - ")
@property
def special(self):
return [tok for tok in [self.unk_token, self.pad_token, self.bos_token, self.eos_token] if tok is not None]
@property
def pad_id(self):
return self.vocab.stoi[self.pad_token]
@property
def eos_id(self):
return self.vocab.stoi[self.eos_token]
@property
def bos_id(self):
return self.vocab.stoi[self.bos_token]
@property
def unk_id(self):
return self.vocab.stoi[self.unk_token]
class Vocab(object):
def __init__(self, words: List[str], specials: List[str]):
self.itos = specials + words
self.stoi = {tok: i for i, tok in enumerate(self.itos)}
def __len__(self):
return len(self.itos)
| 2,466 | 25.815217 | 115 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/data/dataset.py | # -*- coding: utf-8 -*-
import random
from collections import namedtuple
from typing import Dict
import torch
from beaver.data.field import Field
Batch = namedtuple("Batch", ['src', 'tgt', 'batch_size'])
Example = namedtuple("Example", ['src', 'tgt'])
class TranslationDataset(object):
def __init__(self,
src_path: str,
tgt_path: str,
batch_size: int,
device: torch.device,
train: bool,
fields: Dict[str, Field]):
self.batch_size = batch_size
self.train = train
self.device = device
self.fields = fields
self.sort_key = lambda ex: (len(ex.src), len(ex.tgt))
examples = []
for src_line, tgt_line in zip(read_file(src_path), read_file(tgt_path)):
examples.append(Example(src_line, tgt_line))
examples, self.seed = self.sort(examples)
self.num_examples = len(examples)
self.batches = list(batch(examples, self.batch_size))
def __iter__(self):
while True:
if self.train:
random.shuffle(self.batches)
for minibatch in self.batches:
src = self.fields["src"].process([x.src for x in minibatch], self.device)
tgt = self.fields["tgt"].process([x.tgt for x in minibatch], self.device)
yield Batch(src=src, tgt=tgt, batch_size=len(minibatch))
if not self.train:
break
def sort(self, examples):
seed = sorted(range(len(examples)), key=lambda idx: self.sort_key(examples[idx]))
return sorted(examples, key=self.sort_key), seed
def read_file(path):
with open(path, encoding="utf-8") as f:
for line in f:
yield line.strip().split()
def batch(data, batch_size):
minibatch, cur_len = [], 0
for ex in data:
minibatch.append(ex)
cur_len = max(cur_len, len(ex.src), len(ex.tgt))
if cur_len * len(minibatch) > batch_size:
yield minibatch[:-1]
minibatch, cur_len = [ex], max(len(ex.src), len(ex.tgt))
if minibatch:
yield minibatch
| 2,164 | 29.069444 | 89 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/infer/beam.py | # -*- coding: utf-8 -*-
import torch
class Beam(object):
def __init__(self, beam_size, pad, bos, eos, device, lp):
self.size = beam_size
self.alpha = lp
self.scores = torch.full([beam_size], -1e20).float().to(device)
self.scores[0] = 0.
self.hypotheses = torch.full([1, beam_size], fill_value=pad).long().to(device)
self.hypotheses[0][0] = bos
self.eos = eos
self.finished = []
@property
def current_state(self):
return self.hypotheses[-1]
def advance(self, scores, origin, tokens):
self.scores = scores
self.hypotheses = torch.index_select(self.hypotheses, 1, origin)
self.hypotheses = torch.cat([self.hypotheses, tokens.unsqueeze(0)])
for idx, tok in enumerate(self.hypotheses[-1]):
if tok == self.eos:
self.finished.append((self.scores[idx].clone(), self.hypotheses[1:, idx]))
self.scores[idx] = -1e20
@property
def done(self):
max_score = max([self.length_penalty(score, self.hypotheses.size(0)) for score in self.scores])
max_finish = max([self.length_penalty(t[0], t[1].size(0)) for t in self.finished]) if self.finished else -1e20
return bool(max_score < max_finish)
@property
def best_hypothesis(self):
finished = sorted(self.finished, key=lambda t: self.length_penalty(t[0], t[1].size(0)), reverse=True)
if not finished:
return self.hypotheses[1:, 0]
return finished[0][1]
def length_penalty(self, score, length):
return score * (6 ** self.alpha) / ((5 + length) ** self.alpha)
| 1,652 | 32.06 | 118 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/infer/translator.py | # -*- coding: utf-8 -*-
import torch
from beaver.infer.beam import Beam
def beam_search(opt, model, src, fields):
batch_size = src.size(0)
beam_size = opt.beam_size
device = src.device
num_words = model.generator.vocab_size
encoder = model.encoder
decoder = model.decoder
generator = model.generator
beams = [Beam(opt.beam_size, fields["tgt"].pad_id, fields["tgt"].bos_id, fields["tgt"].eos_id,
device, opt.length_penalty) for _ in range(batch_size)]
src = src.repeat(1, beam_size).view(batch_size*beam_size, -1)
src_pad = src.eq(fields["src"].pad_id)
src_out = encoder(src, src_pad)
beam_expander = (torch.arange(batch_size) * beam_size).view(-1, 1).to(device)
previous = None
for i in range(opt.max_length):
if all((b.done for b in beams)):
break
# [batch_size x beam_size, 1]
current_token = torch.cat([b.current_state for b in beams]).unsqueeze(-1)
tgt_pad = current_token.eq(fields["tgt"].pad_id)
out, previous = decoder(current_token, src_out, src_pad, tgt_pad, previous, i)
previous_score = torch.stack([b.scores for b in beams]).unsqueeze(-1)
out = generator(out).view(batch_size, beam_size, -1)
if i < opt.min_length:
out[:, :, fields["tgt"].eos_id] = -1e15
# find topk candidates
scores, indexes = (out + previous_score).view(batch_size, -1).topk(beam_size)
# find origins and token
origins = (indexes.view(-1) // num_words).view(batch_size, beam_size)
tokens = (indexes.view(-1) % num_words).view(batch_size, beam_size)
for j, b in enumerate(beams):
b.advance(scores[j], origins[j], tokens[j])
origins = (origins + beam_expander).view(-1)
previous = torch.index_select(previous, 0, origins)
return [b.best_hypothesis for b in beams]
| 1,903 | 32.403509 | 98 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/model/embeddings.py | # -*- coding: utf-8 -*-
import math
import torch
import torch.nn as nn
def positional_encoding(dim, max_len=5000):
pe = torch.zeros(max_len, dim)
position = torch.arange(0, max_len).unsqueeze(1)
div_term = torch.exp((torch.arange(0, dim, 2, dtype=torch.float) * -(math.log(10000.0) / dim)))
pe[:, 0::2] = torch.sin(position.float() * div_term)
pe[:, 1::2] = torch.cos(position.float() * div_term)
return pe
class Embedding(nn.Module):
def __init__(self, embedding_dim, vocab_size, padding_idx, dropout):
self.word_padding_idx = padding_idx
self.embedding_dim = embedding_dim
pe = positional_encoding(embedding_dim)
super(Embedding, self).__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=padding_idx)
self.register_buffer('pe', pe)
self.dropout = nn.Dropout(p=dropout)
self.reset_parameters()
def reset_parameters(self):
nn.init.normal_(self.embedding.weight, mean=0.0, std=self.embedding_dim ** -0.5)
@property
def padding_idx(self):
return self.word_padding_idx
def forward(self, x, timestep=0):
embedding = self.embedding(x) * math.sqrt(self.embedding_dim) + self.pe[timestep:timestep + x.size(1)]
return self.dropout(embedding)
| 1,313 | 31.04878 | 110 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/model/transformer.py | # -*- coding: utf-8 -*-
import math
import torch
import torch.nn as nn
class FeedForward(nn.Module):
def __init__(self, hidden_size, inner_size, dropout):
super(FeedForward, self).__init__()
self.linear_in = nn.Linear(hidden_size, inner_size, bias=False)
self.linear_out = nn.Linear(inner_size, hidden_size, bias=False)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(dropout)
self.reset_parameters()
def reset_parameters(self):
nn.init.xavier_uniform_(self.linear_in.weight)
nn.init.xavier_uniform_(self.linear_out.weight)
def forward(self, x):
y = self.linear_in(x)
y = self.relu(y)
y = self.dropout(y)
y = self.linear_out(y)
return y
class EncoderLayer(nn.Module):
def __init__(self, hidden_size, dropout, head_count, ff_size):
super(EncoderLayer, self).__init__()
self.self_attn = MultiHeadedAttention(head_count, hidden_size, dropout)
self.feed_forward = FeedForward(hidden_size, ff_size, dropout)
self.dropout = nn.ModuleList([nn.Dropout(dropout) for _ in range(2)])
self.norm = nn.ModuleList([nn.LayerNorm(hidden_size) for _ in range(2)])
def forward(self, x, mask):
# self attention
y = self.self_attn(self.norm[0](x), mask=mask)
x = x + self.dropout[0](y)
# feed forward
y = self.feed_forward(self.norm[1](x))
x = x + self.dropout[1](y)
return x
class Encoder(nn.Module):
def __init__(self, num_layers, num_heads, hidden_size, dropout, ff_size, embedding):
self.num_layers = num_layers
super(Encoder, self).__init__()
self.embedding = embedding
self.layers = nn.ModuleList([EncoderLayer(hidden_size, dropout, num_heads, ff_size) for _ in range(num_layers)])
self.norm = nn.LayerNorm(hidden_size)
def forward(self, src, src_pad):
src_mask = src_pad.unsqueeze(1)
output = self.embedding(src)
for i in range(self.num_layers):
output = self.layers[i](output, src_mask)
return self.norm(output)
class DecoderLayer(nn.Module):
def __init__(self, hidden_size, dropout, head_count, ff_size):
super(DecoderLayer, self).__init__()
self.self_attn = MultiHeadedAttention(head_count, hidden_size, dropout)
self.src_attn = MultiHeadedAttention(head_count, hidden_size, dropout)
self.feed_forward = FeedForward(hidden_size, ff_size, dropout)
self.norm = nn.ModuleList([nn.LayerNorm(hidden_size, eps=1e-6) for _ in range(3)])
self.dropout = nn.ModuleList([nn.Dropout(dropout) for _ in range(3)])
def forward(self, x, enc_out, src_mask, tgt_mask, previous=None):
all_input = x if previous is None else torch.cat((previous, x), dim=1)
# self attention
y = self.self_attn(self.norm[0](x), self.norm[0](all_input), mask=tgt_mask)
x = x + self.dropout[0](y)
# encoder decoder attention
y = self.src_attn(self.norm[1](x), enc_out, mask=src_mask)
x = x + self.dropout[1](y)
# feed forward
y = self.feed_forward(self.norm[2](x))
x = x + self.dropout[2](y)
return x, all_input
class Decoder(nn.Module):
def __init__(self, num_layers, num_heads, hidden_size, dropout, ff_size, embedding):
self.num_layers = num_layers
super(Decoder, self).__init__()
self.embedding = embedding
self.layers = nn.ModuleList([DecoderLayer(hidden_size, dropout, num_heads, ff_size) for _ in range(num_layers)])
self.register_buffer("upper_triangle", torch.triu(torch.ones(1000, 1000), diagonal=1).byte())
self.register_buffer("zero_mask", torch.zeros(1).byte())
self.norm = nn.LayerNorm(hidden_size, eps=1e-6)
def forward(self, tgt, enc_out, src_pad, tgt_pad, previous=None, timestep=0):
output = self.embedding(tgt, timestep)
tgt_len = tgt.size(1)
src_mask = src_pad.unsqueeze(1)
tgt_mask = tgt_pad.unsqueeze(1)
upper_triangle = self.upper_triangle[:tgt_len, :tgt_len]
# tgt mask: 0 if not upper and not pad
tgt_mask = torch.gt(tgt_mask + upper_triangle, 0)
saved_inputs = []
for i in range(self.num_layers):
prev_layer = None if previous is None else previous[:, i]
tgt_mask = tgt_mask if previous is None else self.zero_mask
output, all_input = self.layers[i](output, enc_out, src_mask, tgt_mask, prev_layer)
saved_inputs.append(all_input)
return self.norm(output), torch.stack(saved_inputs, dim=1)
class MultiHeadedAttention(nn.Module):
def __init__(self, head_count, model_dim, dropout):
self.dim_per_head = model_dim // head_count
self.head_count = head_count
super(MultiHeadedAttention, self).__init__()
self.linear_q = nn.Linear(model_dim, model_dim, bias=False)
self.linear_k = nn.Linear(model_dim, model_dim, bias=False)
self.linear_v = nn.Linear(model_dim, model_dim, bias=False)
self.softmax = nn.Softmax(dim=-1)
self.dropout = nn.Dropout(dropout)
self.final_linear = nn.Linear(model_dim, model_dim)
self.reset_parameters()
def reset_parameters(self):
nn.init.xavier_uniform_(self.linear_q.weight)
nn.init.xavier_uniform_(self.linear_k.weight)
nn.init.xavier_uniform_(self.linear_v.weight)
nn.init.xavier_uniform_(self.final_linear.weight)
def forward(self, query, memory=None, mask=None):
memory = query if memory is None else memory
def split_head(x):
# B x L x D => B x h x L x d
return x.view(x.size(0), -1, self.head_count, self.dim_per_head).transpose(1, 2)
def combine_head(x):
# B x h x L x d => B x L x D
return x.transpose(1, 2).contiguous().view(x.size(0), -1, self.head_count * self.dim_per_head)
# 1) Project q, k, v.
q = split_head(self.linear_q(query))
k = split_head(self.linear_k(memory))
v = split_head(self.linear_v(memory))
# 2) Calculate and scale scores.
q = q / math.sqrt(self.dim_per_head)
scores = torch.matmul(q, k.transpose(2, 3))
mask = mask.unsqueeze(1).expand_as(scores)
scores.masked_fill_(mask, -1e18)
# 3) Apply attention dropout and compute context vectors.
weights = self.dropout(self.softmax(scores))
context = combine_head(torch.matmul(weights, v))
return self.final_linear(context)
| 6,591 | 35.622222 | 120 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-base/beaver/model/nmt_model.py | # -*- coding: utf-8 -*-
from typing import Dict
import torch
import torch.nn as nn
from beaver.model.embeddings import Embedding
from beaver.model.transformer import Decoder, Encoder
class Generator(nn.Module):
def __init__(self, hidden_size: int, tgt_vocab_size: int):
self.vocab_size = tgt_vocab_size
super(Generator, self).__init__()
self.linear_hidden = nn.Linear(hidden_size, tgt_vocab_size)
self.lsm = nn.LogSoftmax(dim=-1)
self.reset_parameters()
def reset_parameters(self):
nn.init.xavier_uniform_(self.linear_hidden.weight)
def forward(self, dec_out):
score = self.linear_hidden(dec_out)
lsm_score = self.lsm(score)
return lsm_score
class NMTModel(nn.Module):
def __init__(self, encoder: Encoder, decoder: Decoder, generator: Generator):
super(NMTModel, self).__init__()
self.encoder = encoder
self.decoder = decoder
self.generator = generator
def forward(self, src, tgt):
tgt = tgt[:, :-1] # shift left
src_pad = src.eq(self.encoder.embedding.word_padding_idx)
tgt_pad = tgt.eq(self.decoder.embedding.word_padding_idx)
enc_out = self.encoder(src, src_pad)
decoder_outputs, _ = self.decoder(tgt, enc_out, src_pad, tgt_pad)
scores = self.generator(decoder_outputs)
return scores
@classmethod
def load_model(cls, model_opt,
pad_ids: Dict[str, int],
vocab_sizes: Dict[str, int],
checkpoint=None):
src_embedding = Embedding(embedding_dim=model_opt.hidden_size,
dropout=model_opt.dropout,
padding_idx=pad_ids["src"],
vocab_size=vocab_sizes["src"])
if len(model_opt.vocab) == 2:
tgt_embedding = Embedding(embedding_dim=model_opt.hidden_size,
dropout=model_opt.dropout,
padding_idx=pad_ids["tgt"],
vocab_size=vocab_sizes["tgt"])
else:
# use shared word embedding for source and target
tgt_embedding = src_embedding
encoder = Encoder(model_opt.layers,
model_opt.heads,
model_opt.hidden_size,
model_opt.dropout,
model_opt.ff_size,
src_embedding)
decoder = Decoder(model_opt.layers,
model_opt.heads,
model_opt.hidden_size,
model_opt.dropout,
model_opt.ff_size,
tgt_embedding)
generator = Generator(model_opt.hidden_size, vocab_sizes["tgt"])
model = cls(encoder, decoder, generator)
if model_opt.train_from and checkpoint is None:
checkpoint = torch.load(model_opt.train_from, map_location=lambda storage, loc: storage)
model.load_state_dict(checkpoint["model"])
elif checkpoint is not None:
model.load_state_dict(checkpoint)
return model
| 3,231 | 34.516484 | 100 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/translate.py | # -*- coding: utf-8 -*-
import logging
import torch
import os
from beaver.data import build_dataset
from beaver.infer import beam_search
from beaver.model import NMTModel
from beaver.utils import parseopt, get_device, calculate_bleu
logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.INFO)
opt = parseopt.parse_translate_args()
device = get_device()
def translate(dataset, fields, model):
already_1, hypothesis_1, references_1 = 0, [], []
already_2, hypothesis_2, references_2 = 0, [], []
for batch, flag in dataset:
predictions = beam_search(opt, model, batch.src, fields, flag)
if flag:
hypothesis_1 += [fields["task1_tgt"].decode(p) for p in predictions]
already_1 += len(predictions)
logging.info("Task 1: %7d/%7d" % (already_1, dataset.task1_dataset.num_examples))
else:
hypothesis_2 += [fields["task2_tgt"].decode(p) for p in predictions]
already_2 += len(predictions)
logging.info("Task 2: %7d/%7d" % (already_2, dataset.task2_dataset.num_examples))
origin_1 = sorted(zip(hypothesis_1, dataset.task1_dataset.seed), key=lambda t: t[1])
hypothesis_1 = [h for h, _ in origin_1]
with open(opt.output[0], "w", encoding="UTF-8") as out_file:
out_file.write("\n".join(hypothesis_1))
out_file.write("\n")
origin_2 = sorted(zip(hypothesis_2, dataset.task2_dataset.seed), key=lambda t: t[1])
hypothesis_2 = [h for h, _ in origin_2]
with open(opt.output[1], "w", encoding="UTF-8") as out_file:
out_file.write("\n".join(hypothesis_2))
out_file.write("\n")
logging.info("Translation finished. ")
def main():
logging.info("Build dataset...")
dataset = build_dataset(opt, [opt.input[0], opt.input[0], opt.input[1], opt.input[1]], opt.vocab, device, train=False)
fields = dataset.fields
pad_ids = {"src": fields["src"].pad_id,
"task1_tgt": fields["task1_tgt"].pad_id,
"task2_tgt": fields["task2_tgt"].pad_id}
vocab_sizes = {"src": len(fields["src"].vocab),
"task1_tgt": len(fields["task1_tgt"].vocab),
"task2_tgt": len(fields["task2_tgt"].vocab)}
# load checkpoint from model_path
logging.info("Load checkpoint from %s." % opt.model_path)
checkpoint = torch.load(opt.model_path, map_location=lambda storage, loc: storage)
logging.info("Build model...")
model = NMTModel.load_model(checkpoint["opt"], pad_ids, vocab_sizes, checkpoint["model"]).to(device).eval()
logging.info("Start translation...")
with torch.set_grad_enabled(False):
translate(dataset, fields, model)
if __name__ == '__main__':
main()
| 2,731 | 33.582278 | 122 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/train.py | # -*- coding: utf-8 -*-
import logging
import torch
import torch.cuda
from beaver.data import build_dataset
from beaver.infer import beam_search
from beaver.loss import WarmAdam, LabelSmoothingLoss
from beaver.model import NMTModel
from beaver.utils import Saver
from beaver.utils import calculate_bleu
from beaver.utils import parseopt, get_device, printing_opt
from beaver.utils.metric import calculate_rouge
logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.INFO)
opt = parseopt.parse_train_args()
device = get_device()
logging.info("\n" + printing_opt(opt))
saver = Saver(opt)
def valid(model, criterion_task1, criterion_task2, valid_dataset, step):
model.eval()
total_n = 0
total_task1_loss = total_task2_loss = 0.0
task1_hypothesis, task1_references = [], []
task2_hypothesis, task2_references = [], []
for i, (batch, flag) in enumerate(valid_dataset):
scores = model(batch.src, batch.tgt, flag)
if flag:
loss = criterion_task1(scores, batch.tgt)
else:
loss = criterion_task2(scores, batch.tgt)
_, predictions = scores.topk(k=1, dim=-1)
if flag: # task1
total_task1_loss += loss.data
task1_hypothesis += [valid_dataset.fields["task1_tgt"].decode(p) for p in predictions]
task1_references += [valid_dataset.fields["task1_tgt"].decode(t) for t in batch.tgt]
else:
total_task2_loss += loss.data
task2_hypothesis += [valid_dataset.fields["task2_tgt"].decode(p) for p in predictions]
task2_references += [valid_dataset.fields["task2_tgt"].decode(t) for t in batch.tgt]
total_n += 1
bleu_task1 = calculate_bleu(task1_hypothesis, task1_references)
bleu_task2 = calculate_bleu(task2_hypothesis, task2_references)
rouge1_task1, rouge2_task1 = calculate_rouge(task1_hypothesis, task1_references)
rouge1_task2, rouge2_task2 = calculate_rouge(task2_hypothesis, task2_references)
mean_task1_loss = total_task1_loss / total_n
mean_task2_loss = total_task2_loss / total_n
logging.info("loss-task1: %.2f \t loss-task2 %.2f \t bleu-task1: %3.2f\t bleu-task2: %3.2f \t rouge1-task1: %3.2f \t rouge1-task2: %3.2f \t rouge2-task1: %3.2f \t rouge2-task2: %3.2f"
% (mean_task1_loss, mean_task2_loss, bleu_task1, bleu_task2, rouge1_task1, rouge1_task2, rouge2_task1, rouge2_task2))
checkpoint = {"model": model.state_dict(), "opt": opt}
saver.save(checkpoint, step, mean_task1_loss, mean_task2_loss, bleu_task1, bleu_task2, rouge1_task1, rouge1_task2, rouge2_task1, rouge2_task2)
def train(model, criterion_task1, criterion_task2, optimizer, train_dataset, valid_dataset):
total_task1_loss = total_task2_loss = 0.0
model.zero_grad()
for i, (batch, flag) in enumerate(train_dataset):
scores = model(batch.src, batch.tgt, flag)
if flag:
loss = criterion_task1(scores, batch.tgt)
else:
loss = criterion_task2(scores, batch.tgt)
loss.backward()
if flag: # task1
total_task1_loss += loss.data
else:
total_task2_loss += loss.data
if (i + 1) % opt.grad_accum == 0:
optimizer.step()
model.zero_grad()
if optimizer.n_step % opt.report_every == 0:
mean_task1_loss = total_task1_loss / opt.report_every / opt.grad_accum * 2
mean_task2_loss = total_task2_loss / opt.report_every / opt.grad_accum * 2
logging.info("step: %7d\t loss-task1: %.4f \t loss-task2: %.4f"
% (optimizer.n_step, mean_task1_loss, mean_task2_loss))
total_task1_loss = total_task2_loss = 0.0
if optimizer.n_step % opt.save_every == 0:
with torch.set_grad_enabled(False):
valid(model, criterion_task1, criterion_task2, valid_dataset, optimizer.n_step)
model.train()
del loss
def main():
logging.info("Build dataset...")
train_dataset = build_dataset(opt, opt.train, opt.vocab, device, train=True)
valid_dataset = build_dataset(opt, opt.valid, opt.vocab, device, train=False)
fields = valid_dataset.fields = train_dataset.fields
logging.info("Build model...")
pad_ids = {"src": fields["src"].pad_id,
"task1_tgt": fields["task1_tgt"].pad_id,
"task2_tgt": fields["task2_tgt"].pad_id}
vocab_sizes = {"src": len(fields["src"].vocab),
"task1_tgt": len(fields["task1_tgt"].vocab),
"task2_tgt": len(fields["task2_tgt"].vocab)}
model = NMTModel.load_model(opt, pad_ids, vocab_sizes).to(device)
criterion_task1 = LabelSmoothingLoss(opt.label_smoothing, vocab_sizes["task1_tgt"], pad_ids["task1_tgt"]).to(device)
criterion_task2 = LabelSmoothingLoss(opt.label_smoothing, vocab_sizes["task2_tgt"], pad_ids["task2_tgt"]).to(device)
n_step = int(opt.train_from.split("-")[-1]) if opt.train_from else 1
optimizer = WarmAdam(model.parameters(), opt.lr, opt.hidden_size, opt.warm_up, n_step)
logging.info("start training...")
train(model, criterion_task1, criterion_task2, optimizer, train_dataset, valid_dataset)
if __name__ == '__main__':
main()
| 5,295 | 40.700787 | 187 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/tools/model_average.py | # -*- coding: utf-8 -*-
import os
import torch
import sys
def main():
if len(sys.argv) != 3:
print("python model_average.py model_path n")
exit()
model_path = sys.argv[1]
n = int(sys.argv[2]) # last n model to be averaged
fs = [os.path.join(model_path, f) for f in os.listdir(model_path) if f.startswith("checkpoint")]
fs = sorted(fs, reverse=True)[:n] # last n file
n = len(fs) # actual file count
cks = [torch.load(f, map_location=lambda storage, loc: storage) for f in fs]
first_model = cks[0]["model"] # average all weights into first model and save it
for k, _ in first_model.items():
for ck in cks[1:]:
first_model[k] = (first_model[k] + ck["model"][k])
first_model[k] = first_model[k] / n
torch.save(cks[0], os.path.join(model_path, "averaged-%s-%s" % (fs[-1].split("-")[-1], fs[0].split("-")[-1])))
if __name__ == '__main__':
main()
| 941 | 29.387097 | 114 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/loss/optimizers.py | # -*- coding: utf-8 -*-
import torch.nn as nn
import torch.optim as optim
class WarmAdam(object):
def __init__(self, params, lr, hidden_size, warm_up, n_step):
self.original_lr = lr
self.n_step = n_step
self.hidden_size = hidden_size
self.warm_up_step = warm_up
self.optimizer = optim.Adam(params, betas=[0.9, 0.998], eps=1e-9)
def step(self):
self.n_step += 1
warm_up = min(self.n_step ** (-0.5), self.n_step * self.warm_up_step ** (-1.5))
lr = self.original_lr * (self.hidden_size ** (-0.5) * warm_up)
for param_group in self.optimizer.param_groups:
param_group['lr'] = lr
self.optimizer.step()
class LabelSmoothingLoss(nn.Module):
def __init__(self, label_smoothing, tgt_vocab_size, ignore_index):
self.padding_idx = ignore_index
self.label_smoothing = label_smoothing
self.vocab_size = tgt_vocab_size
super(LabelSmoothingLoss, self).__init__()
def forward(self, output, target):
target = target[:, 1:].contiguous().view(-1)
output = output.view(-1, self.vocab_size)
non_pad_mask = target.ne(self.padding_idx)
nll_loss = -output.gather(dim=-1, index=target.view(-1, 1))[non_pad_mask].sum()
smooth_loss = -output.sum(dim=-1, keepdim=True)[non_pad_mask].sum()
eps_i = self.label_smoothing / self.vocab_size
loss = (1. - self.label_smoothing) * nll_loss + eps_i * smooth_loss
return loss / non_pad_mask.float().sum()
| 1,529 | 36.317073 | 87 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/utils/saver.py | import json
import torch
import os
import datetime
class Saver(object):
def __init__(self, opt):
self.ckpt_names = []
self.model_path = opt.model_path + datetime.datetime.now().strftime("-%y%m%d-%H%M%S")
self.max_to_keep = opt.max_to_keep
os.mkdir(self.model_path)
with open(os.path.join(self.model_path, "params.json"), "w", encoding="UTF-8") as log:
log.write(json.dumps(vars(opt), indent=4) + "\n")
def save(self, save_dict, step, loss_task1, loss_task2, bleu_task1, bleu_task2, rouge1_task1, rouge1_task2, rouge2_task1, rouge2_task2):
filename = "checkpoint-step-%06d" % step
full_filename = os.path.join(self.model_path, filename)
self.ckpt_names.append(full_filename)
torch.save(save_dict, full_filename)
with open(os.path.join(self.model_path, "log"), "a", encoding="UTF-8") as log:
log.write("%s\t" % datetime.datetime.now())
log.write("step: %6d\t" % step)
log.write("loss-task1: %.2f\t" % loss_task1)
log.write("loss-task2: %.2f\t" % loss_task2)
log.write("bleu-task1: %3.2f\t" % bleu_task1)
log.write("bleu-task2: %3.2f\t" % bleu_task2)
log.write("rouge1-task1: %3.2f\t" % rouge1_task1)
log.write("rouge1-task2: %3.2f\t" % rouge1_task2)
log.write("rouge2-task1: %3.2f\t" % rouge2_task1)
log.write("rouge2-task2: %3.2f\t" % rouge2_task2)
log.write("\n")
if 0 < self.max_to_keep < len(self.ckpt_names):
earliest_ckpt = self.ckpt_names.pop(0)
os.remove(earliest_ckpt)
| 1,647 | 40.2 | 140 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/utils/__init__.py | # -*- coding: utf-8 -*-
import torch.cuda
from beaver.utils.metric import calculate_bleu, file_bleu
from beaver.utils.saver import Saver
def get_device():
if torch.cuda.is_available():
return torch.device('cuda')
else:
return torch.device('cpu')
def printing_opt(opt):
return "\n".join(["%15s | %s" % (e[0], e[1]) for e in sorted(vars(opt).items(), key=lambda x: x[0])])
| 405 | 21.555556 | 105 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.