def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
model.register_classification_head(
'sentence_classification_head',
num_classes=1,
)
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
model.register_classification_head(
getattr(args, 'classification_head_name', 'sentence_classification_head'),
num_classes=self.args.num_classes,
)
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
if args.multiple_encoders == 'False' and not isinstance(model, FairseqFactoredOneEncoderModel):
raise ValueError('FactoredTranslationTask with one encoder requires a '
'FairseqFactoredOneEncoderModel architecture')
if not args.multiple_encoders == 'False' and (not isinstance(model, FairseqFactoredMultiModel) and not isinstance(model, FairseqFactoredMultiSumModel)):
raise ValueError('FactoredTranslationTask with multiple encoders requires a '
'FairseqFactoredMultiModel or FairseqFactoredMultiSumModel architecture')
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
model.register_classification_list(
'funcbound',
num_classes=self.args.num_classes,
)
return model
def _test_full_ensemble_export(self, test_args):
samples, src_dict, tgt_dict = test_utils.prepare_inputs(test_args)
num_models = 3
model_list = []
for _ in range(num_models):
model_list.append(models.build_model(test_args, src_dict,
tgt_dict))
encoder_ensemble = EncoderEnsemble(model_list)
# test equivalence
# The discrepancy in types here is a temporary expedient.
# PyTorch indexing requires int64 while support for tracing
# pack_padded_sequence() requires int32.
sample = next(samples)
src_tokens = sample["net_input"]["src_tokens"][0:1].t()
src_lengths = sample["net_input"]["src_lengths"][0:1].int()
pytorch_encoder_outputs = encoder_ensemble(src_tokens, src_lengths)
decoder_step_ensemble = DecoderStepEnsemble(model_list, beam_size=5)
tmp_dir = tempfile.mkdtemp()
decoder_step_pb_path = os.path.join(tmp_dir, "decoder_step.pb")
decoder_step_ensemble.onnx_export(decoder_step_pb_path,
pytorch_encoder_outputs)
# single EOS
input_token = torch.LongTensor(
np.array([[model_list[0].dst_dict.eos()]]))
timestep = torch.LongTensor(np.array([[0]]))
pytorch_decoder_outputs = decoder_step_ensemble(
input_token, timestep, *pytorch_encoder_outputs)
onnx_decoder = caffe2_backend.prepare_zip_archive(decoder_step_pb_path)
decoder_inputs_numpy = [input_token.numpy(), timestep.numpy()]
for tensor in pytorch_encoder_outputs:
decoder_inputs_numpy.append(tensor.detach().numpy())
caffe2_decoder_outputs = onnx_decoder.run(tuple(decoder_inputs_numpy))
for i in range(len(pytorch_decoder_outputs)):
caffe2_out_value = caffe2_decoder_outputs[i]
pytorch_out_value = pytorch_decoder_outputs[i].detach().numpy()
np.testing.assert_allclose(caffe2_out_value,
pytorch_out_value,
rtol=1e-4,
atol=1e-6)
decoder_step_ensemble.save_to_db(
os.path.join(tmp_dir, "decoder_step.predictor_export"),
pytorch_encoder_outputs,
)
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
model.register_classification_head(
getattr(args, "ranking_head_name", "sentence_classification_head"),
num_classes=1,
)
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
xml_estimator = None
estimator = None
if not self.uniform_prior and not hasattr(model, 'gating_network'):
if self.args.mean_pool_gating_network:
if getattr(args, 'mean_pool_gating_network_encoder_dim', None):
encoder_dim = args.mean_pool_gating_network_encoder_dim
elif getattr(args, 'encoder_embed_dim', None):
# assume that encoder_embed_dim is the encoder's output dimension
encoder_dim = args.encoder_embed_dim
else:
raise ValueError('Must specify --mean-pool-gating-network-encoder-dim')
if getattr(args, 'mean_pool_gating_network_dropout', None):
dropout = args.mean_pool_gating_network_dropout
elif getattr(args, 'dropout', None):
dropout = args.dropout
else:
raise ValueError('Must specify --mean-pool-gating-network-dropout')
model.gating_network = modules.MeanPoolGatingNetwork(
encoder_dim, args.num_experts, dropout,
)
else:
raise ValueError(
'translation_moe task with learned prior requires the model to '
'have a gating network; try using --mean-pool-gating-network'
)
if self.share_xml_dict:
estimator = Estimator(self.estimator_hidden_dim, args.estimator_xml_dim + args.estimator_transformer_dim,
dropout, topk_time_step=self.topk_time_step)
elif self.estimator_xml_only:
estimator = Estimator(self.estimator_hidden_dim, args.estimator_xml_dim, dropout,
topk_time_step=self.topk_time_step)
elif args.estimator_transformer_dim != 0:
if self.share_estimator:
estimator = Estimator(self.estimator_hidden_dim, args.estimator_transformer_dim, dropout,
share_estimator=True, topk_time_step=self.topk_time_step)
else:
estimator = Estimator(self.estimator_hidden_dim, args.estimator_transformer_dim, dropout,
topk_time_step=self.topk_time_step)
if args.estimator_xml_dim != 0:
xml_estimator = Estimator(self.estimator_hidden_dim, args.estimator_xml_dim, dropout,
topk_time_step=self.topk_time_step)
else:
raise ValueError(
'translation_moe task with learned prior requires the model to '
'have a gating network; try using --mean-pool-gating-network'
)
return model, estimator, xml_estimator
def build_model(self, args):
from fairseq import models, quantization_utils
model = models.build_model(args, self)
model.register_classification_head(
getattr(args, "classification_head_name", "sentence_classification_head"),
num_classes=self.args.num_classes,
)
model = quantization_utils.quantize_model_scalar(model, args)
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
model.register_classification_head(
'sentence_classification_head',
num_classes=self.args.num_classes,
)
#print(model,"sentece_prediction.py")
return model
def build_model(self, args):
# Check if task args are consistant with model args
if len(set(self.args.lang_pairs).symmetric_difference(args.lang_pairs)) != 0:
raise ValueError('--lang-pairs should include all the language pairs {}.'.format(args.lang_pairs))
from fairseq import models
model = models.build_model(args, self)
from .laser_lstm import LaserModel
if not isinstance(model, LaserModel):
raise ValueError('TranslationLaserTask requires a LaserModel architecture')
return model
def build_model(self, args, from_checkpoint=False):
from fairseq import models
model = models.build_model(args, self)
model.register_classification_head(
"sentence_classification_head",
num_classes=1,
)
return model
def test_basic_generate(self):
test_args = test_utils.ModelParamsDict()
_, src_dict, tgt_dict = test_utils.prepare_inputs(test_args)
model = models.build_model(test_args, src_dict, tgt_dict)
translator = beam_decode.SequenceGenerator([model])
src_tokens = torch.LongTensor([[0, 0, 0], [0, 0, 0]])
src_lengths = torch.LongTensor([3, 3])
translator.generate(
src_tokens=src_tokens,
src_lengths=src_lengths,
)
def build_model(self, args):
model = models.build_model(args, self)
self.model = model
if not isinstance(model, FairseqMultiModel):
raise ValueError(
"PytorchTranslateSemiSupervised task requires a FairseqMultiModel "
"architecture")
forward_pair = "-".join([self.source_lang, self.target_lang])
backward_pair = "-".join([self.target_lang, self.source_lang])
self.forward_model = model.models[forward_pair]
self.backward_model = model.models[backward_pair]
return model
def build_model(self, args):
if self.retrieve_fn is None:
from fairseq import models
model = models.build_model(args, self)
def retrieve_fn(samples, split, model_=model):
return model_.classifier(samples, split)
self.retrieve_fn = retrieve_fn
self.model = model
return self.model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
for mp in model.parameters():
mp.requires_grad = False
model.register_lm_head(
'lm_head_probe',
num_embeddings=len(args.probe_features.split(",")) + 1)
return model
def test_char_rnn_equivalent(self):
"""Ensure that the CharRNNEncoder.onnx_export_model path does not
change computation"""
test_args = test_utils.ModelParamsDict(encoder_bidirectional=True,
sequence_lstm=True)
lexical_dictionaries = test_utils.create_lexical_dictionaries()
test_args.vocab_reduction_params = {
"lexical_dictionaries": lexical_dictionaries,
"num_top_words": 5,
"max_translation_candidates_per_word": 1,
}
test_args.arch = "char_source"
test_args.char_source_dict_size = 126
test_args.char_embed_dim = 8
test_args.char_rnn_units = 12
test_args.char_rnn_layers = 2
_, src_dict, tgt_dict = test_utils.prepare_inputs(test_args)
num_models = 3
model_list = []
for _ in range(num_models):
model_list.append(models.build_model(test_args, src_dict,
tgt_dict))
encoder_ensemble = CharSourceEncoderEnsemble(model_list)
length = 5
src_tokens = torch.LongTensor(
np.random.randint(0, len(src_dict), (length, 1), dtype="int64"))
src_lengths = torch.IntTensor(np.array([length], dtype="int32"))
word_length = 3
char_inds = torch.LongTensor(
np.random.randint(0, 126, (1, length, word_length), dtype="int64"))
word_lengths = torch.IntTensor(
np.array([word_length] * length, dtype="int32")).reshape(
(1, length))
onnx_path_outputs = encoder_ensemble(src_tokens, src_lengths,
char_inds, word_lengths)
for model in encoder_ensemble.models:
model.encoder.onnx_export_model = False
original_path_outputs = encoder_ensemble(src_tokens, src_lengths,
char_inds, word_lengths)
for (onnx_out, original_out) in zip(onnx_path_outputs,
original_path_outputs):
onnx_array = onnx_out.detach().numpy()
original_array = original_out.detach().numpy()
assert onnx_array.shape == original_array.shape
np.testing.assert_allclose(onnx_array, original_array)
def build_model(self, args):
"""
Build the :class:`~fairseq.models.BaseFairseqModel` instance for this
task.
Args:
args (argparse.Namespace): parsed command-line arguments
Returns:
a :class:`~fairseq.models.BaseFairseqModel` instance
"""
from fairseq import models
return models.build_model(args, self)
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
for mp in model.parameters():
mp.requires_grad = False
model.register_classification_head(
'sentence_classification_head_probe',
num_classes=self.args.num_classes,
)
return model
def build_model(self, args):
"""
Build the :class:`~fairseq.models.BaseFairseqModel` instance for this
task.
Args:
args (argparse.Namespace): parsed command-line arguments
Returns:
a :class:`~fairseq.models.BaseFairseqModel` instance
"""
from fairseq import models
return models.build_model(args, self)
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
# register a SpanPredictionHead
register_span_prediction_head(
model,
args,
"span_prediction_head",
num_classes=2,
)
assert "span_prediction_head" in model.classification_heads
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
register_dependency_parse_head(
model,
args,
"dependency_parse_head",
num_classes0=args.num_classes0,
)
assert "dependency_parse_head" in model.classification_heads
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
register_sequence_tagging_head(
model,
args,
"sequence_tagging_head",
num_classes=args.num_classes,
)
assert "sequence_tagging_head" in model.classification_heads
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
model.register_classification_head(
'classification_head',
num_classes=self.args.num_classes,
)
model.remove_momentum_encoder()
model.remove_lm_head()
if args.no_state:
model.remove_state()
return model
def build_model(self, cfg):
from fairseq import models
with open_dict(cfg) if OmegaConf.is_config(
cfg) else contextlib.ExitStack():
cfg.max_positions = self.cfg.max_positions
model = models.build_model(cfg, self)
model.register_classification_head(
self.cfg.classification_head_name,
num_classes=self.cfg.num_classes,
)
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(
args, self
) #/home/gsir059/Documents/PhD/MulFie/fairseq/fairseq/models/__init__.py'
print("Model Initialization Done")
model.register_classification_head(
'emotion_classification_head_old',
num_classes=self.args.num_classes,
)
#print(model,"sentece_prediction.py")
return model
def build_model(self, args):
"""
Build the :class:`~fairseq.models.BaseFairseqModel` instance for this
task.
Args:
args (argparse.Namespace): parsed command-line arguments
Returns:
a :class:`~fairseq.models.BaseFairseqModel` instance
"""
from fairseq import models, quantization_utils
model = models.build_model(args, self)
return quantization_utils.quantize_model_scalar(model, args)
def build_model(self, args):
model = models.build_model(args, self)
if not isinstance(model, SemiSupervisedModel):
raise ValueError(
"PytorchTranslateDenoisingAutoencoder task requires a "
"SemiSupervisedModel architecture")
# TODO(T35539829): implement a Noising registry so this can be built
# with any noising class as long as it has a @register_noising decorator
self.noiser = noising.UnsupervisedMTNoising(
dictionary=self.source_dictionary,
max_word_shuffle_distance=args.max_word_shuffle_distance,
word_dropout_prob=args.word_dropout_prob,
word_blanking_prob=args.word_blanking_prob,
)
return model
def build_model(self, args):
# from .modeling import BertMultiwayMatch
# model = BertMultiwayMatch.from_pretrained(args.bert_model,
# cache_dir=PYTORCH_PRETRAINED_BERT_CACHE / 'distributed_{}'.format(
# args.local_rank),
# num_choices=args.num_labels)
from fairseq import models
model = models.build_model(args, self)
model.register_classification_head(
'sentence_classification_head',
num_classes=1,
)
return model
def build_model(self, args):
from fairseq import models
model = models.build_model(args, self)
model.register_ke_head(
args.ke_head_name,
gamma=args.gamma,
nrelations=args.nrelation
)
if self.args.double_ke:
model.register_ke_head(
args.ke_head_name2,
gamma=args.gamma2,
nrelations=args.nrelation2
)
return model
def build_model(self, cfg: FairseqDataclass):
"""
Build the :class:`~fairseq.models.BaseFairseqModel` instance for this
task.
Args:
cfg (FairseqDataclass): configuration object
Returns:
a :class:`~fairseq.models.BaseFairseqModel` instance
"""
from fairseq import models, quantization_utils
model = models.build_model(cfg, self)
model = quantization_utils.quantize_model_scalar(model, cfg)
return model
def _test_forced_decoder_export(self, test_args):
_, src_dict, tgt_dict = test_utils.prepare_inputs(test_args)
num_models = 3
model_list = []
for _ in range(num_models):
model_list.append(models.build_model(test_args, src_dict,
tgt_dict))
forced_decoder_ensemble = ForcedDecoder(model_list,
word_reward=0.25,
unk_reward=-0.5)
tmp_dir = tempfile.mkdtemp()
forced_decoder_pb_path = os.path.join(tmp_dir, "forced_decoder.pb")
forced_decoder_ensemble.onnx_export(forced_decoder_pb_path)
