def load_saved_state(self, args: Namespace, unparsed_args: List[str],
metadata: Any, state: NeuralPredictorState) -> None:
model = maybe_cuda(
self._get_model(args, get_word_feature_vocab_sizes(metadata),
get_vec_features_size(metadata),
get_num_indices(metadata),
get_num_tokens(metadata)))
model.load_state_dict(state.weights)
self._model = model
self.training_loss = state.loss
self.num_epochs = state.epoch
self.training_args = args
self.unparsed_args = unparsed_args
self._metadata = metadata
def _optimize_model(
self, arg_values: Namespace) -> Iterable[FeaturesPolyargState]:
with print_time("Loading data", guard=arg_values.verbose):
if arg_values.start_from:
_, (old_arg_values, unparsed_args, metadata,
state) = torch.load(arg_values.start_from)
_, data_lists, \
(word_features_size, vec_features_size) = \
features_polyarg_tensors_with_meta(
extract_dataloader_args(arg_values),
str(arg_values.scrape_file),
metadata)
else:
metadata, data_lists, \
(word_features_size, vec_features_size) = \
features_polyarg_tensors(
extract_dataloader_args(arg_values),
str(arg_values.scrape_file))
with print_time("Converting data to tensors",
guard=arg_values.verbose):
unpadded_tokenized_hyp_types, \
unpadded_hyp_features, \
num_hyps, \
tokenized_goals, \
goal_masks, \
word_features, \
vec_features, \
tactic_stem_indices, \
arg_indices = data_lists
tensors = [
pad_sequence([
torch.LongTensor(tokenized_hyps_list)
for tokenized_hyps_list in unpadded_tokenized_hyp_types
],
batch_first=True),
pad_sequence([
torch.FloatTensor(hyp_features_vec)
for hyp_features_vec in unpadded_hyp_features
],
batch_first=True),
torch.LongTensor(num_hyps),
torch.LongTensor(tokenized_goals),
torch.ByteTensor(goal_masks),
torch.LongTensor(word_features),
torch.FloatTensor(vec_features),
torch.LongTensor(tactic_stem_indices),
torch.LongTensor(arg_indices)
]
with open("tensors.pickle", 'wb') as f:
torch.save(tensors, f)
eprint(tensors, guard=arg_values.print_tensors)
with print_time("Building the model", guard=arg_values.verbose):
if arg_values.start_from:
self.load_saved_state(arg_values, unparsed_args, metadata,
state)
model = self._model
epoch_start = self.num_epochs
else:
model = self._get_model(arg_values, word_features_size,
vec_features_size,
get_num_indices(metadata),
get_num_tokens(metadata))
epoch_start = 1
assert model
assert epoch_start
return ((metadata, state) for state in optimize_checkpoints(
tensors, arg_values, model,
lambda batch_tensors, model: self._getBatchPredictionLoss(
arg_values, batch_tensors, model), epoch_start))
def action_word_features_sizes(self) -> List[int]:
return [get_num_indices(self.fpa_metadata), 3]