From 7498bd7388afdde8d5e6f8a4cb6aeb8be8ac60fa Mon Sep 17 00:00:00 2001
From: shixian.shi <shixian.shi@alibaba-inc.com>
Date: 星期五, 08 三月 2024 11:37:46 +0800
Subject: [PATCH] update code
---
funasr/models/seaco_paraformer/model.py | 167 ++++++++++++++++++++++---------------------------------
1 files changed, 67 insertions(+), 100 deletions(-)
diff --git a/funasr/models/seaco_paraformer/model.py b/funasr/models/seaco_paraformer/model.py
index b3b9133..5d0f602 100644
--- a/funasr/models/seaco_paraformer/model.py
+++ b/funasr/models/seaco_paraformer/model.py
@@ -19,20 +19,18 @@
from funasr.register import tables
from funasr.utils import postprocess_utils
-from funasr.metrics.compute_acc import th_accuracy
from funasr.models.paraformer.model import Paraformer
from funasr.utils.datadir_writer import DatadirWriter
from funasr.models.paraformer.search import Hypothesis
-from funasr.models.paraformer.cif_predictor import mae_loss
from funasr.train_utils.device_funcs import force_gatherable
from funasr.models.bicif_paraformer.model import BiCifParaformer
from funasr.losses.label_smoothing_loss import LabelSmoothingLoss
-from funasr.utils.timestamp_tools import ts_prediction_lfr6_standard
from funasr.models.transformer.utils.add_sos_eos import add_sos_eos
+from funasr.utils.timestamp_tools import ts_prediction_lfr6_standard
from funasr.models.transformer.utils.nets_utils import make_pad_mask, pad_list
from funasr.utils.load_utils import load_audio_text_image_video, extract_fbank
-import pdb
+
if LooseVersion(torch.__version__) >= LooseVersion("1.6.0"):
from torch.cuda.amp import autocast
else:
@@ -76,7 +74,7 @@
self.lstm_proj = torch.nn.Linear(self.inner_dim*2, self.inner_dim)
else:
self.lstm_proj = None
- self.bias_embed = torch.nn.Embedding(self.vocab_size, self.inner_dim)
+ # self.bias_embed = torch.nn.Embedding(self.vocab_size, self.inner_dim)
elif self.bias_encoder_type == 'mean':
self.bias_embed = torch.nn.Embedding(self.vocab_size, self.inner_dim)
else:
@@ -101,6 +99,7 @@
)
self.train_decoder = kwargs.get("train_decoder", False)
self.NO_BIAS = kwargs.get("NO_BIAS", 8377)
+ self.predictor_name = kwargs.get("predictor")
def forward(
self,
@@ -132,7 +131,6 @@
dha_pad = kwargs.get("dha_pad")
batch_size = speech.shape[0]
- self.step_cur += 1
# for data-parallel
text = text[:, : text_lengths.max()]
speech = speech[:, :speech_lengths.max()]
@@ -173,6 +171,12 @@
def _merge(self, cif_attended, dec_attended):
return cif_attended + dec_attended
+ def calc_predictor(self, encoder_out, encoder_out_lens):
+ encoder_out_mask = (~make_pad_mask(encoder_out_lens, maxlen=encoder_out.size(1))[:, None, :]).to(
+ encoder_out.device)
+ predictor_outs = self.predictor(encoder_out, None, encoder_out_mask, ignore_id=self.ignore_id)
+ return predictor_outs[:4]
+
def _calc_seaco_loss(
self,
encoder_out: torch.Tensor,
@@ -212,88 +216,55 @@
nfilter=50,
seaco_weight=1.0):
# decoder forward
- pdb.set_trace()
+
decoder_out, decoder_hidden, _ = self.decoder(encoder_out, encoder_out_lens, sematic_embeds, ys_pad_lens, return_hidden=True, return_both=True)
- pdb.set_trace()
+
decoder_pred = torch.log_softmax(decoder_out, dim=-1)
if hw_list is not None:
- pdb.set_trace()
hw_lengths = [len(i) for i in hw_list]
hw_list_ = [torch.Tensor(i).long() for i in hw_list]
hw_list_pad = pad_list(hw_list_, 0).to(encoder_out.device)
- pdb.set_trace()
selected = self._hotword_representation(hw_list_pad, torch.Tensor(hw_lengths).int().to(encoder_out.device))
- pdb.set_trace()
+
contextual_info = selected.squeeze(0).repeat(encoder_out.shape[0], 1, 1).to(encoder_out.device)
- pdb.set_trace()
num_hot_word = contextual_info.shape[1]
_contextual_length = torch.Tensor([num_hot_word]).int().repeat(encoder_out.shape[0]).to(encoder_out.device)
- pdb.set_trace()
+
# ASF Core
if nfilter > 0 and nfilter < num_hot_word:
- for dec in self.seaco_decoder.decoders:
- dec.reserve_attn = True
- pdb.set_trace()
- # cif_attended, _ = self.decoder2(contextual_info, _contextual_length, sematic_embeds, ys_pad_lens)
- dec_attended, _ = self.seaco_decoder(contextual_info, _contextual_length, decoder_hidden, ys_pad_lens)
- # cif_filter = torch.topk(self.decoder2.decoders[-1].attn_mat[0][0].sum(0).sum(0)[:-1], min(nfilter, num_hot_word-1))[1].tolist()
- pdb.set_trace()
- hotword_scores = self.seaco_decoder.decoders[-1].attn_mat[0][0].sum(0).sum(0)[:-1]
+ hotword_scores = self.seaco_decoder.forward_asf6(contextual_info, _contextual_length, decoder_hidden, ys_pad_lens)
+ hotword_scores = hotword_scores[0].sum(0).sum(0)
# hotword_scores /= torch.sqrt(torch.tensor(hw_lengths)[:-1].float()).to(hotword_scores.device)
- pdb.set_trace()
dec_filter = torch.topk(hotword_scores, min(nfilter, num_hot_word-1))[1].tolist()
- pdb.set_trace()
add_filter = dec_filter
- pdb.set_trace()
add_filter.append(len(hw_list_pad)-1)
# filter hotword embedding
- pdb.set_trace()
selected = selected[add_filter]
# again
- pdb.set_trace()
contextual_info = selected.squeeze(0).repeat(encoder_out.shape[0], 1, 1).to(encoder_out.device)
- pdb.set_trace()
num_hot_word = contextual_info.shape[1]
_contextual_length = torch.Tensor([num_hot_word]).int().repeat(encoder_out.shape[0]).to(encoder_out.device)
- pdb.set_trace()
- for dec in self.seaco_decoder.decoders:
- dec.attn_mat = []
- dec.reserve_attn = False
- pdb.set_trace()
+
# SeACo Core
cif_attended, _ = self.seaco_decoder(contextual_info, _contextual_length, sematic_embeds, ys_pad_lens)
- pdb.set_trace()
dec_attended, _ = self.seaco_decoder(contextual_info, _contextual_length, decoder_hidden, ys_pad_lens)
- pdb.set_trace()
merged = self._merge(cif_attended, dec_attended)
- pdb.set_trace()
dha_output = self.hotword_output_layer(merged) # remove the last token in loss calculation
- pdb.set_trace()
dha_pred = torch.log_softmax(dha_output, dim=-1)
- pdb.set_trace()
def _merge_res(dec_output, dha_output):
- pdb.set_trace()
lmbd = torch.Tensor([seaco_weight] * dha_output.shape[0])
- pdb.set_trace()
dha_ids = dha_output.max(-1)[-1]# [0]
- pdb.set_trace()
- dha_mask = (dha_ids == 8377).int().unsqueeze(-1)
- pdb.set_trace()
+ dha_mask = (dha_ids == self.NO_BIAS).int().unsqueeze(-1)
a = (1 - lmbd) / lmbd
b = 1 / lmbd
- pdb.set_trace()
a, b = a.to(dec_output.device), b.to(dec_output.device)
- pdb.set_trace()
dha_mask = (dha_mask + a.reshape(-1, 1, 1)) / b.reshape(-1, 1, 1)
# logits = dec_output * dha_mask + dha_output[:,:,:-1] * (1-dha_mask)
- pdb.set_trace()
logits = dec_output * dha_mask + dha_output[:,:,:] * (1-dha_mask)
return logits
merged_pred = _merge_res(decoder_pred, dha_pred)
- pdb.set_trace()
- # import pdb; pdb.set_trace()
return merged_pred
else:
return decoder_pred
@@ -303,6 +274,8 @@
hotword_lengths):
if self.bias_encoder_type != 'lstm':
logging.error("Unsupported bias encoder type")
+
+ '''
hw_embed = self.decoder.embed(hotword_pad)
hw_embed, (_, _) = self.bias_encoder(hw_embed)
if self.lstm_proj is not None:
@@ -310,26 +283,20 @@
_ind = np.arange(0, hw_embed.shape[0]).tolist()
selected = hw_embed[_ind, [i-1 for i in hotword_lengths.detach().cpu().tolist()]]
return selected
+ '''
- '''
- def calc_predictor(self, encoder_out, encoder_out_lens):
- encoder_out_mask = (~make_pad_mask(encoder_out_lens, maxlen=encoder_out.size(1))[:, None, :]).to(
- encoder_out.device)
- pre_acoustic_embeds, pre_token_length, alphas, pre_peak_index, pre_token_length2 = self.predictor(encoder_out,
- None,
- encoder_out_mask,
- ignore_id=self.ignore_id)
- return pre_acoustic_embeds, pre_token_length, alphas, pre_peak_index
-
-
- def calc_predictor_timestamp(self, encoder_out, encoder_out_lens, token_num):
- encoder_out_mask = (~make_pad_mask(encoder_out_lens, maxlen=encoder_out.size(1))[:, None, :]).to(
- encoder_out.device)
- ds_alphas, ds_cif_peak, us_alphas, us_peaks = self.predictor.get_upsample_timestamp(encoder_out,
- encoder_out_mask,
- token_num)
- return ds_alphas, ds_cif_peak, us_alphas, us_peaks
- '''
+ # hw_embed = self.sac_embedding(hotword_pad)
+ hw_embed = self.decoder.embed(hotword_pad)
+ hw_embed = torch.nn.utils.rnn.pack_padded_sequence(hw_embed, hotword_lengths.cpu().type(torch.int64), batch_first=True, enforce_sorted=False)
+ packed_rnn_output, _ = self.bias_encoder(hw_embed)
+ rnn_output = torch.nn.utils.rnn.pad_packed_sequence(packed_rnn_output, batch_first=True)[0]
+ if self.lstm_proj is not None:
+ hw_hidden = self.lstm_proj(rnn_output)
+ else:
+ hw_hidden = rnn_output
+ _ind = np.arange(0, hw_hidden.shape[0]).tolist()
+ selected = hw_hidden[_ind, [i-1 for i in hotword_lengths.detach().cpu().tolist()]]
+ return selected
def inference(self,
data_in,
@@ -347,7 +314,6 @@
logging.info("enable beam_search")
self.init_beam_search(**kwargs)
self.nbest = kwargs.get("nbest", 1)
- pdb.set_trace()
meta_data = {}
# extract fbank feats
@@ -355,7 +321,6 @@
audio_sample_list = load_audio_text_image_video(data_in, fs=frontend.fs, audio_fs=kwargs.get("fs", 16000))
time2 = time.perf_counter()
meta_data["load_data"] = f"{time2 - time1:0.3f}"
- pdb.set_trace()
speech, speech_lengths = extract_fbank(audio_sample_list, data_type=kwargs.get("data_type", "sound"),
frontend=frontend)
time3 = time.perf_counter()
@@ -366,36 +331,36 @@
speech = speech.to(device=kwargs["device"])
speech_lengths = speech_lengths.to(device=kwargs["device"])
- pdb.set_trace()
# hotword
self.hotword_list = self.generate_hotwords_list(kwargs.get("hotword", None), tokenizer=tokenizer, frontend=frontend)
- pdb.set_trace()
# Encoder
encoder_out, encoder_out_lens = self.encode(speech, speech_lengths)
if isinstance(encoder_out, tuple):
encoder_out = encoder_out[0]
-
- pdb.set_trace()
# predictor
predictor_outs = self.calc_predictor(encoder_out, encoder_out_lens)
- pre_acoustic_embeds, pre_token_length, _, _ = predictor_outs[0], predictor_outs[1], \
- predictor_outs[2], predictor_outs[3]
+ pre_acoustic_embeds, pre_token_length = predictor_outs[0], predictor_outs[1]
pre_token_length = pre_token_length.round().long()
if torch.max(pre_token_length) < 1:
return []
- pdb.set_trace()
- decoder_out = self._seaco_decode_with_ASF(encoder_out, encoder_out_lens,
- pre_acoustic_embeds,
- pre_token_length,
- hw_list=self.hotword_list)
- pdb.set_trace()
+ decoder_out = self._seaco_decode_with_ASF(encoder_out,
+ encoder_out_lens,
+ pre_acoustic_embeds,
+ pre_token_length,
+ hw_list=self.hotword_list
+ )
+
# decoder_out, _ = decoder_outs[0], decoder_outs[1]
- _, _, us_alphas, us_peaks = self.calc_predictor_timestamp(encoder_out, encoder_out_lens,
- pre_token_length)
- pdb.set_trace()
+ if self.predictor_name == "CifPredictorV3":
+ _, _, us_alphas, us_peaks = self.calc_predictor_timestamp(encoder_out,
+ encoder_out_lens,
+ pre_token_length)
+ else:
+ us_alphas = None
+
results = []
b, n, d = decoder_out.size()
for i in range(b):
@@ -440,23 +405,25 @@
# Change integer-ids to tokens
token = tokenizer.ids2tokens(token_int)
text = tokenizer.tokens2text(token)
-
- _, timestamp = ts_prediction_lfr6_standard(us_alphas[i][:encoder_out_lens[i] * 3],
- us_peaks[i][:encoder_out_lens[i] * 3],
- copy.copy(token),
- vad_offset=kwargs.get("begin_time", 0))
-
- text_postprocessed, time_stamp_postprocessed, word_lists = postprocess_utils.sentence_postprocess(
- token, timestamp)
-
- result_i = {"key": key[i], "text": text_postprocessed,
- "timestamp": time_stamp_postprocessed
- }
-
- if ibest_writer is not None:
- ibest_writer["token"][key[i]] = " ".join(token)
- ibest_writer["timestamp"][key[i]] = time_stamp_postprocessed
- ibest_writer["text"][key[i]] = text_postprocessed
+ if us_alphas is not None:
+ _, timestamp = ts_prediction_lfr6_standard(us_alphas[i][:encoder_out_lens[i] * 3],
+ us_peaks[i][:encoder_out_lens[i] * 3],
+ copy.copy(token),
+ vad_offset=kwargs.get("begin_time", 0))
+ text_postprocessed, time_stamp_postprocessed, _ = \
+ postprocess_utils.sentence_postprocess(token, timestamp)
+ result_i = {"key": key[i], "text": text_postprocessed,
+ "timestamp": time_stamp_postprocessed}
+ if ibest_writer is not None:
+ ibest_writer["token"][key[i]] = " ".join(token)
+ ibest_writer["timestamp"][key[i]] = time_stamp_postprocessed
+ ibest_writer["text"][key[i]] = text_postprocessed
+ else:
+ text_postprocessed, _ = postprocess_utils.sentence_postprocess(token)
+ result_i = {"key": key[i], "text": text_postprocessed}
+ if ibest_writer is not None:
+ ibest_writer["token"][key[i]] = " ".join(token)
+ ibest_writer["text"][key[i]] = text_postprocessed
else:
result_i = {"key": key[i], "token_int": token_int}
results.append(result_i)
--
Gitblit v1.9.1