forked from facebookresearch/seamless_communication
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathmt.py
182 lines (154 loc) · 7.18 KB
/
mt.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
# Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
# This source code is licensed under the license found in the
# MIT_LICENSE file in the root directory of this source tree.
#
# This script contains the builder and loader for the MT models. It has some
# overlaps with fairseq2.models.nllb, except for a few subtle changes
# in the tokenizer, patches of layers, etc.
from pathlib import Path
from typing import Any, Mapping, Optional, Literal
import torch
from torch.nn.parameter import Parameter
from fairseq2.assets import InProcAssetMetadataProvider, asset_store, download_manager
from fairseq2.generation.beam_search import BeamSearchSeq2SeqGenerator
from fairseq2.nn.embedding import StandardEmbedding
from fairseq2.models.nllb.builder import NllbBuilder, NllbConfig
from fairseq2.models.nllb.loader import load_nllb_config
from fairseq2.nn.projection import TiedProjection
from fairseq2.models.transformer.model import TransformerModel
from fairseq2.models.utils import ModelLoader
from fairseq2.typing import Device, DataType
from fairseq2.models.utils.checkpoint import convert_fairseq_checkpoint
import sentencepiece as spm
class MTBuilder(NllbBuilder):
def build_embedding(self) -> StandardEmbedding:
return StandardEmbedding(
num_embeddings=self.config.vocab_info.size,
embedding_dim=self.config.model_dim,
pad_idx=self.config.vocab_info.pad_idx,
init_fn=lambda x: x,
device=self.device,
dtype=self.dtype,
).requires_grad_(False)
def build_model(self) -> TransformerModel:
"""Build a model."""
encoder_embed = self.build_embedding()
decoder_embed = self.build_embedding()
encoder_frontend = self.build_frontend(encoder_embed)
decoder_frontend = self.build_frontend(decoder_embed)
encoder = self.build_encoder()
decoder = self.build_decoder()
# Unlike NLLB, in MT we de-couple
new_weight = Parameter(torch.zeros_like(
encoder_embed.weight, requires_grad=False)
)
final_proj = TiedProjection(new_weight, bias=None)
return TransformerModel(
encoder_frontend,
encoder,
decoder_frontend,
decoder,
final_proj,
self.config.vocab_info,
)
def create_mt_model(
config: NllbConfig,
*,
device: Optional[Device] = None,
dtype: Optional[DataType] = None,
) -> TransformerModel:
return MTBuilder(config, device=device, dtype=dtype).build_model()
def convert_mt_checkpoint(
ckpt: Mapping[str, Any], config: NllbConfig,
) -> Mapping[str, Any]:
global_key_map = {
# fmt: off
r"^encoder\.embed_tokens\.": r"encoder_frontend.embed.",
r"^decoder\.embed_tokens\.": r"decoder_frontend.embed.",
r"^encoder\.embed_positions.weights": r"encoder_frontend.pos_encoder.freqs",
r"^decoder\.embed_positions.weights": r"decoder_frontend.pos_encoder.freqs",
r"^encoder\.layernorm_embedding\.": r"encoder_frontend.layer_norm.",
r"^decoder\.layernorm_embedding\.": r"decoder_frontend.layer_norm.",
r"^decoder\.layers\.([0-9]+)\.self_attn\.out_proj\.": r"decoder.layers.\1.self_attn.output_proj.",
r"^encoder\.layers\.([0-9]+)\.self_attn\.out_proj\.": r"encoder.layers.\1.self_attn.output_proj.",
r"^decoder\.layers\.([0-9]+)\.encoder_attn\.out_proj\.": r"decoder.layers.\1.encoder_decoder_attn.output_proj.",
r"^decoder\.layers\.([0-9]+)\.encoder_attn\.": r"decoder.layers.\1.encoder_decoder_attn.",
r"^decoder\.layers\.([0-9]+)\.encoder_attn_layer_norm\.": r"decoder.layers.\1.encoder_decoder_attn_layer_norm.",
r"^encoder\.layers\.([0-9]+)\.fc1\.": r"encoder.layers.\1.ffn.inner_proj.",
r"^decoder\.layers\.([0-9]+)\.fc1\.": r"decoder.layers.\1.ffn.inner_proj.",
r"^encoder\.layers\.([0-9]+)\.fc2\.": r"encoder.layers.\1.ffn.output_proj.",
r"^decoder\.layers\.([0-9]+)\.fc2\.": r"decoder.layers.\1.ffn.output_proj.",
r"^encoder\.layers\.([0-9]+)\.final_layer_norm\.": r"encoder.layers.\1.ffn_layer_norm.",
r"^decoder\.layers\.([0-9]+)\.final_layer_norm\.": r"decoder.layers.\1.ffn_layer_norm.",
r"^decoder\.output_projection\.": r"final_proj.",
# fmt: on
}
return convert_fairseq_checkpoint(ckpt, global_key_map)
def load_vocab(model_dir: str, mode: Literal["src", "tgt"]):
vocab_file = f"{model_dir}/{mode}.spm"
spmp = spm.SentencePieceProcessor(vocab_file)
return [
(spmp.id_to_piece(id).replace("▁", " "), spmp.get_score(id))
for id in range(spmp.get_piece_size())
], spmp
def load_mt_model(model_dir: str):
"""
Load MT model and the vocabulary processors (spm) for source and target languages
Args:
model_dir: Directory of the model. It must contain files averaged_checkpoint.pt, src.spm and tgt.spm
"""
# Create a fairseq2 model card on the fly. This must ensure that we do not have any other fairseq2
# environment resolvers and always return
model_dir = Path(model_dir)
model_card_info = [
{
"name": "mt_model",
"model_type": "nllb", # Re-use the same encoder-decoder arch of NLLB
"model_arch": "dense_600m", # Dummy value to pass fairseq2 asset's valdilation logic
"checkpoint": "file://" + str(model_dir / "averaged_checkpoint.pt"),
"model_config": {
"model_dim": 512,
"num_encoder_layers": 4,
"num_decoder_layers": 2,
"ffn_inner_dim": 2048,
"vocab_info": {
"size": 10000,
"unk_idx": 3,
"bos_idx": 0,
"eos_idx": 2,
"pad_idx": 1,
}
}
}
]
asset_store.metadata_providers.append(
InProcAssetMetadataProvider(model_card_info)
)
mt_card = asset_store.retrieve_card("mt_model")
return ModelLoader[TransformerModel, NllbConfig](
asset_store,
download_manager,
load_nllb_config,
create_mt_model,
convert_mt_checkpoint,
restrict_checkpoints=False,
)(mt_card)
def test_mt(
model: TransformerModel,
src_spm: spm.SentencePieceProcessor,
tgt_spm: spm.SentencePieceProcessor,
):
from fairseq2.nn.padding import pad_seqs
# Tokens of "This is an example"
src_tokens = torch.LongTensor([688, 153, 62, 4581, 2])
src_seqs, src_padding_mask = pad_seqs(src_tokens, src_spm.pad_id())
# Force the developer begins with the EOS <s> token
prompt_tokens = torch.LongTensor([[2]])
generator = BeamSearchSeq2SeqGenerator(model)
output = generator(src_seqs, src_padding_mask, prompt_tokens, None)
print(output.hypotheses[0][0].seq)
tgt_tokens = output.hypotheses[0][0].seq.tolist()
out_text = tgt_spm.decode(tgt_tokens)
# assert out_text == "Este es un ejemplo"
print(out_text)