python/FunASR-XL.git

			@@ -15,6 +15,7 @@
			from typing import Optional, Tuple, Union
			import math


			class TooShortUttError(Exception):
			"""Raised when the utt is too short for subsampling.

			@@ -102,6 +103,7 @@
			if key != -1:
			raise NotImplementedError("Support only `-1` (for `reset_parameters`).")
			return self.out[key]


			class Conv2dSubsamplingPad(torch.nn.Module):
			"""Convolutional 2D subsampling (to 1/4 length).
			@@ -326,6 +328,7 @@
			return x, None
			return x, x_mask[:, :, :-2:2][:, :, :-2:2][:, :, :-2:2]


			class Conv1dSubsampling(torch.nn.Module):
			"""Convolutional 1D subsampling (to 1/2 length).

			@@ -337,7 +340,13 @@

			"""

			def __init__(self, idim, odim, kernel_size, stride, pad,
			def __init__(
			self,
			idim,
			odim,
			kernel_size,
			stride,
			pad,
			tf2torch_tensor_name_prefix_torch: str = "stride_conv",
			tf2torch_tensor_name_prefix_tf: str = "seq2seq/proj_encoder/downsampling",
			):
			@@ -353,13 +362,11 @@
			return self.odim

			def forward(self, x, x_len):
			"""Subsample x.

			"""
			"""Subsample x."""
			x = x.transpose(1, 2) # (b, d ,t)
			x = self.pad_fn(x)
			#x = F.relu(self.conv(x))
			x = F.leaky_relu(self.conv(x), negative_slope=0.)
			x = F.leaky_relu(self.conv(x), negative_slope=0.0)
			x = x.transpose(1, 2) # (b, t ,d)

			if x_len is None:
			@@ -395,14 +402,38 @@
			conv_size1, conv_size2 = conv_size

			self.conv = torch.nn.Sequential(
			torch.nn.Conv2d(1, conv_size1, conv_kernel_size, stride=1, padding=(conv_kernel_size-1)//2),
			torch.nn.Conv2d(
			1,
			conv_size1,
			conv_kernel_size,
			stride=1,
			padding=(conv_kernel_size - 1) // 2,
			),
			torch.nn.ReLU(),
			torch.nn.Conv2d(conv_size1, conv_size1, conv_kernel_size, stride=1, padding=(conv_kernel_size-1)//2),
			torch.nn.Conv2d(
			conv_size1,
			conv_size1,
			conv_kernel_size,
			stride=1,
			padding=(conv_kernel_size - 1) // 2,
			),
			torch.nn.ReLU(),
			torch.nn.MaxPool2d((1, 2)),
			torch.nn.Conv2d(conv_size1, conv_size2, conv_kernel_size, stride=1, padding=(conv_kernel_size-1)//2),
			torch.nn.Conv2d(
			conv_size1,
			conv_size2,
			conv_kernel_size,
			stride=1,
			padding=(conv_kernel_size - 1) // 2,
			),
			torch.nn.ReLU(),
			torch.nn.Conv2d(conv_size2, conv_size2, conv_kernel_size, stride=1, padding=(conv_kernel_size-1)//2),
			torch.nn.Conv2d(
			conv_size2,
			conv_size2,
			conv_kernel_size,
			stride=1,
			padding=(conv_kernel_size - 1) // 2,
			),
			torch.nn.ReLU(),
			torch.nn.MaxPool2d((1, 2)),
			)
			@@ -421,14 +452,38 @@
			kernel_1 = int(subsampling_factor / 2)

			self.conv = torch.nn.Sequential(
			torch.nn.Conv2d(1, conv_size1, conv_kernel_size, stride=1, padding=(conv_kernel_size-1)//2),
			torch.nn.Conv2d(
			1,
			conv_size1,
			conv_kernel_size,
			stride=1,
			padding=(conv_kernel_size - 1) // 2,
			),
			torch.nn.ReLU(),
			torch.nn.Conv2d(conv_size1, conv_size1, conv_kernel_size, stride=1, padding=(conv_kernel_size-1)//2),
			torch.nn.Conv2d(
			conv_size1,
			conv_size1,
			conv_kernel_size,
			stride=1,
			padding=(conv_kernel_size - 1) // 2,
			),
			torch.nn.ReLU(),
			torch.nn.MaxPool2d((kernel_1, 2)),
			torch.nn.Conv2d(conv_size1, conv_size2, conv_kernel_size, stride=1, padding=(conv_kernel_size-1)//2),
			torch.nn.Conv2d(
			conv_size1,
			conv_size2,
			conv_kernel_size,
			stride=1,
			padding=(conv_kernel_size - 1) // 2,
			),
			torch.nn.ReLU(),
			torch.nn.Conv2d(conv_size2, conv_size2, conv_kernel_size, stride=1, padding=(conv_kernel_size-1)//2),
			torch.nn.Conv2d(
			conv_size2,
			conv_size2,
			conv_kernel_size,
			stride=1,
			padding=(conv_kernel_size - 1) // 2,
			),
			torch.nn.ReLU(),
			torch.nn.MaxPool2d((2, 2)),
			)
			@@ -467,7 +522,9 @@
			self.conv = torch.nn.Sequential(
			torch.nn.Conv2d(1, conv_size, 3, 2, [1,0]),
			torch.nn.ReLU(),
			torch.nn.Conv2d(conv_size, conv_size, kernel_2, stride_2, [(kernel_2-1)//2, 0]),
			torch.nn.Conv2d(
			conv_size, conv_size, kernel_2, stride_2, [(kernel_2 - 1) // 2, 0]
			),
			torch.nn.ReLU(),
			)

			@@ -509,7 +566,9 @@

			if chunk_size is not None:
			max_input_length = int(
			chunk_size * self.subsampling_factor * (math.ceil(float(t) / (chunk_size * self.subsampling_factor) ))
			chunk_size
			* self.subsampling_factor
			* (math.ceil(float(t) / (chunk_size * self.subsampling_factor)))
			)
			x = map(lambda inputs: pad_to_len(inputs, max_input_length, 1), x)
			x = list(x)