lt-tensor 0.0.1a12__py3-none-any.whl → 0.0.1a13__py3-none-any.whl

lt_tensor/processors/audio.py

@@ -5,11 +5,14 @@ from lt_utils.type_utils import is_file, is_array
 from lt_tensor.misc_utils import log_tensor
 import librosa
 import torchaudio
-
+import numpy as np
 from lt_tensor.transform import InverseTransformConfig, InverseTransform
 from lt_utils.file_ops import FileScan, get_file_name, path_to_str
-
+from torchaudio.functional import detect_pitch_frequency
 from lt_tensor.model_base import Model
+import torch.nn.functional as F
+
+DEFAULT_DEVICE = torch.tensor([0]).device
 
 
 class AudioProcessor(Model):
@@ -21,14 +24,14 @@ class AudioProcessor(Model):
         win_length: Optional[int] = None,
         hop_length: Optional[int] = None,
         f_min: float = 0,
-        f_max: float | None = None,
+        f_max: float = 12000.0,
         center: bool = True,
         mel_scale: Literal["htk", "slaney"] = "htk",
         std: int = 4,
         mean: int = -4,
         n_iter: int = 32,
         window: Optional[Tensor] = None,
-        normalized: bool =False,
+        normalized: bool = False,
         onesided: Optional[bool] = None,
     ):
         super().__init__()
@@ -38,7 +41,7 @@ class AudioProcessor(Model):
         self.n_fft = n_fft
         self.n_stft = n_fft // 2 + 1
         self.f_min = f_min
-        self.f_max = f_max
+        self.f_max = max(min(f_max, 12000), self.f_min + 1)
         self.n_iter = n_iter
         self.hop_length = hop_length or n_fft // 4
         self.win_length = win_length or n_fft
@@ -76,7 +79,176 @@ class AudioProcessor(Model):
             "window",
             (torch.hann_window(self.win_length) if window is None else window),
         )
-        # self._inv_transform = InverseTransform(**inverse_transform_config.to_dict())
+
+    def from_numpy(
+        self,
+        array: np.ndarray,
+        device: Optional[torch.device] = None,
+        dtype: Optional[torch.dtype] = None,
+    ):
+        converted = torch.from_numpy(array)
+        if not any([device is not None, dtype is not None]):
+            return converted
+        return converted.to(device=device, dtype=dtype)
+
+    def from_numpy_batch(
+        self,
+        arrays: List[np.ndarray],
+        device: Optional[torch.device] = None,
+        dtype: Optional[torch.dtype] = None,
+    ):
+        stacked = torch.stack([torch.from_numpy(x) for x in arrays])
+        if not any([device is not None, dtype is not None]):
+            return stacked
+        return stacked.to(device=device, dtype=dtype)
+
+    def to_numpy_safe(self, tensor: Tensor):
+        return tensor.detach().to(DEFAULT_DEVICE).numpy(force=True)
+
+    def compute_rms(
+        self, audio: Union[Tensor, np.ndarray], mel: Optional[Tensor] = None
+    ):
+        default_dtype = audio.dtype
+        default_device = audio.device
+        assert audio.ndim in [1, 2], (
+            f"Audio should have 1D for unbatched and 2D for batched"
+            ", received instead a: {audio.ndim}D"
+        )
+        if mel is not None:
+            assert mel.ndim in [2, 3], (
+                "Mel spectogram should have 2D dim for non-batched or 3D dim for both non-batched or batched"
+                f". Received instead {mel.ndim}D."
+            )
+        if audio.ndim == 2:
+            B = audio.shape[0]
+        else:
+            B = 1
+            audio = audio.unsqueeze(0)
+
+        if mel is not None:
+            if mel.ndim == 2:
+                assert B == 1, "Batch from mel and audio must be the same!"
+                mel = mel.unsqueeze(0)
+            else:
+                assert B == mel.shape[0], "Batch from mel and audio must be the same!"
+            mel = self.to_numpy_safe(mel)
+            gt_mel = lambda idx: mel[idx, :, :]
+
+        else:
+            gt_mel = lambda idx: None
+        audio = self.to_numpy_safe(audio)
+        if B == 1:
+            _r = librosa.feature.rms(
+                y=audio, frame_length=self.n_fft, hop_length=self.hop_length
+            )[0]
+            rms = self.from_numpy(_r, default_device, default_dtype)
+
+        else:
+            rms_ = []
+            for i in range(B):
+                _r = librosa.feature.rms(
+                    y=audio[i, :],
+                    S=gt_mel(i),
+                    frame_length=self.n_fft,
+                    hop_length=self.hop_length,
+                )[0]
+                rms_.append(_r)
+            rms = self.from_numpy_batch(rms_, default_device, default_dtype)
+
+        return rms
+
+    def compute_pitch(
+        self,
+        audio: Tensor,
+    ):
+        default_dtype = audio.dtype
+        default_device = audio.device
+        assert audio.ndim in [1, 2], (
+            f"Audio should have 1D for unbatched and 2D for batched"
+            ", received instead a: {audio.ndim}D"
+        )
+        if audio.ndim == 2:
+            B = audio.shape[0]
+        else:
+            B = 1
+        fmin = max(self.f_min, 80)
+        if B == 1:
+            f0 = self.from_numpy(
+                librosa.yin(
+                    self.to_numpy_safe(audio),
+                    fmin=fmin,
+                    fmax=self.f_max,
+                    frame_length=self.n_fft,
+                    sr=self.sample_rate,
+                    hop_length=self.hop_length,
+                    center=self.center,
+                ),
+                default_device,
+                default_dtype,
+            )
+
+        else:
+            f0_ = []
+            for i in range(B):
+                r = librosa.yin(
+                    self.to_numpy_safe(audio[i, :]),
+                    fmin=fmin,
+                    fmax=self.f_max,
+                    frame_length=self.n_fft,
+                    sr=self.sample_rate,
+                    hop_length=self.hop_length,
+                    center=self.center,
+                )
+                f0_.append(r)
+            f0 = self.from_numpy_batch(f0_, default_device, default_dtype)
+
+        # librosa.pyin(self.f_min, self.f_max)
+        return f0  # dict(f0=f0, attention_mask=f0 != f_max)
+
+    def compute_pitch_torch(self, audio: Tensor):
+        return detect_pitch_frequency(
+            audio,
+            sample_rate=self.sample_rate,
+            frame_time=self.n_fft,
+            win_length=self.win_length,
+            freq_low=max(self.f_min, 35),
+            freq_high=self.f_max,
+        )
+
+    def interpolate_tensor(
+        self,
+        tensor: Tensor,
+        target_len: int,
+        mode: Literal[
+            "nearest",
+            "linear",
+            "bilinear",
+            "bicubic",
+            "trilinear",
+            "area",
+            "nearest-exact",
+        ] = "nearest",
+        align_corners: Optional[bool] = None,
+        scale_factor: Optional[list[float]] = None,
+        recompute_scale_factor: Optional[bool] = None,
+        antialias: bool = False,
+    ):
+        """
+        The modes available for upsampling are: `nearest`, `linear` (3D-only),
+        `bilinear`, `bicubic` (4D-only), `trilinear` (5D-only)
+        """
+
+        if tensor.ndim == 2:  # [1, T]
+            tensor = tensor.unsqueeze(1)  # [1, 1, T]
+        return F.interpolate(
+            tensor,
+            size=target_len,
+            mode=mode,
+            align_corners=align_corners,
+            scale_factor=scale_factor,
+            recompute_scale_factor=recompute_scale_factor,
+            antialias=antialias,
+        )
 
     def inverse_transform(
         self,
@@ -95,7 +267,9 @@ class AudioProcessor(Model):
                 n_fft=n_fft or self.n_fft,
                 hop_length=hop_length or self.hop_length,
                 win_length=win_length or self.win_length,
-                window=torch.hann_window(win_length or self.win_length, device=spec.device),
+                window=torch.hann_window(
+                    win_length or self.win_length, device=spec.device
+                ),
                 center=self.center,
                 normalized=self.normalized,
                 onesided=self.onesided,
@@ -105,10 +279,12 @@ class AudioProcessor(Model):
         except RuntimeError as e:
             if not _recall and spec.device != self.window.device:
                 self.window = self.window.to(spec.device)
-                return self.inverse_transform(spec, phase, n_fft, hop_length, win_length, length, _recall=True)
+                return self.inverse_transform(
+                    spec, phase, n_fft, hop_length, win_length, length, _recall=True
+                )
             raise e
 
-    def rebuild_spectrogram(
+    def normalize_audio(
         self,
         wave: Tensor,
         length: Optional[int] = None,
@@ -148,7 +324,7 @@ class AudioProcessor(Model):
         except RuntimeError as e:
             if not _recall and wave.device != self.window.device:
                 self.window = self.window.to(wave.device)
-                return self.rebuild_spectrogram(wave, length, _recall=True)
+                return self.normalize_audio(wave, length, _recall=True)
             raise e
 
     def compute_mel(
@@ -167,12 +343,7 @@ class AudioProcessor(Model):
 
     def inverse_mel_spectogram(self, mel: Tensor, n_iter: Optional[int] = None):
         if isinstance(n_iter, int) and n_iter != self.n_iter:
-            self.giffin_lim = torchaudio.transforms.GriffinLim(
-                n_fft=self.n_fft,
-                n_iter=n_iter,
-                win_length=self.win_length,
-                hop_length=self.hop_length,
-            )
+            self.giffin_lim.n_iter = n_iter
             self.n_iter = n_iter
         return self.giffin_lim.forward(
             self.mel_rscale(mel),
@@ -182,21 +353,26 @@ class AudioProcessor(Model):
         self,
         path: PathLike,
         top_db: float = 30,
+        normalize: bool = False,
+        alpha: float = 1.0,
     ) -> Tensor:
         is_file(path, True)
         wave, sr = librosa.load(str(path), sr=self.sample_rate)
         wave, _ = librosa.effects.trim(wave, top_db=top_db)
-        return (
-            torch.from_numpy(
-                librosa.resample(wave, orig_sr=sr, target_sr=self.sample_rate)
-                if sr != self.sample_rate
-                else wave
-            )
-            .float()
-            .unsqueeze(0)
-        )
+        if sr != self.sample_rate:
+            wave = librosa.resample(wave, orig_sr=sr, target_sr=self.sample_rate)
+        if normalize:
+            wave = librosa.util.normalize(wave)
+        if alpha not in [0.0, 1.0]:
+            wave = wave * alpha
+        return torch.from_numpy(wave).float().unsqueeze(0)
 
-    def find_audios(self, path: PathLike, additional_extensions: List[str] = []):
+    def find_audios(
+        self,
+        path: PathLike,
+        additional_extensions: List[str] = [],
+        maximum: int | None = None,
+    ):
         extensions = [
             "*.wav",
             "*.aac",
@@ -212,6 +388,7 @@ class AudioProcessor(Model):
         return FileScan.files(
             path,
             extensions,
+            maximum,
         )
 
     def find_audio_text_pairs(
@@ -240,57 +417,6 @@ class AudioProcessor(Model):
                     break
         return results
 
-    def slice_mismatch_outputs(
-        self,
-        tensor_1: Tensor,
-        tensor_2: Tensor,
-        smallest_size: Optional[int] = None,
-        left_to_right: bool = True,
-    ):
-        assert tensor_1.ndim == tensor_2.ndim, (
-            "Tensors must have the same dimentions to be sliced! \n"
-            f"Received instead a tensor_1 with {tensor_1.ndim}D and tensor_2 with {tensor_1.ndim}D."
-        )
-        dim = tensor_1.ndim
-        assert dim < 5, (
-            "Excpected to receive tensors with from 1D up to 4D. "
-            f"Received instead a {dim}D tensor."
-        )
-
-        if tensor_1.shape[-1] == tensor_2.shape[-1]:
-            return tensor_1, tensor_2
-
-        if smallest_size is None:
-            smallest_size = min(tensor_1.shape[-1], tensor_2.shape[-1])
-        if dim == 0:
-            tensor_1 = tensor_1.unsqueeze(0)
-            tensor_2 = tensor_2.unsqueeze(0)
-            dim = 1
-
-        if dim == 1:
-            if left_to_right:
-                return tensor_1[:smallest_size], tensor_2[:smallest_size]
-            return tensor_1[-smallest_size:], tensor_2[-smallest_size:]
-        elif dim == 2:
-            if left_to_right:
-                return tensor_1[:, :smallest_size], tensor_2[:, :smallest_size]
-            return tensor_1[:, -smallest_size:], tensor_2[:, -smallest_size:]
-        elif dim == 3:
-            if left_to_right:
-                return tensor_1[:, :, :smallest_size], tensor_2[:, :, :smallest_size]
-            return tensor_1[:, :, -smallest_size:], tensor_2[:, :, -smallest_size:]
-
-        # else:
-        if left_to_right:
-            return (
-                tensor_1[:, :, :, :smallest_size],
-                tensor_2[:, :, :, :smallest_size],
-            )
-        return (
-            tensor_1[:, :, :, -smallest_size:],
-            tensor_2[:, :, :, -smallest_size:],
-        )
-
     def stft_loss(
         self,
         signal: Tensor,
@@ -302,11 +428,23 @@ class AudioProcessor(Model):
             smallest = min(signal.shape[-1], ground.shape[-1])
             signal = signal[:, -smallest:]
             ground = ground[:, -smallest:]
-        sig_mel = self.compute_mel(signal, base, True).detach().cpu()
-        gnd_mel = self.compute_mel(ground, base, True).detach().cpu()
+        sig_mel = self.compute_mel(signal, base, True)
+        gnd_mel = self.compute_mel(ground, base, True)
         return torch.norm(gnd_mel - sig_mel, p=1) / torch.norm(gnd_mel, p=1)
 
-    # def forward(self, wave: Tensor, base: Optional[float] = None):
+    @staticmethod
+    def plot_spectrogram(spectrogram, ax_):
+        import matplotlib.pylab as plt
+
+        fig, ax = plt.subplots(figsize=(10, 2))
+        im = ax.imshow(spectrogram, aspect="auto", origin="lower", interpolation="none")
+        plt.colorbar(im, ax=ax)
+
+        fig.canvas.draw()
+        plt.close()
+
+        return fig
+
     def forward(
         self,
         *inputs: Union[Tensor, float],

lt_tensor/transform.py

@@ -316,18 +316,6 @@ def inverse_transform(
     )
 
 
-def is_nand(a: bool, b: bool):
-    """[a -> b = result]
-    ```
-    False -> False = True
-    False -> True = True
-    True -> False = True
-    True -> True = False
-    ```
-    """
-    return not (a and b)
-
-
 class InverseTransformConfig:
     def __init__(
         self,
@@ -413,9 +401,11 @@ class InverseTransform(Model):
         self.return_complex = return_complex
         self.onesided = onesided
         self.normalized = normalized
-        self.register_buffer('window', torch.hann_window(self.win_length) if window is None else window)
+        self.register_buffer(
+            "window", torch.hann_window(self.win_length) if window is None else window
+        )
 
-    def forward(self, spec: Tensor, phase: Tensor, *, _recall:bool = False):
+    def forward(self, spec: Tensor, phase: Tensor, *, _recall: bool = False):
         """
         Perform the inverse short-time Fourier transform.
 
@@ -434,7 +424,7 @@ class InverseTransform(Model):
         try:
             return torch.istft(
                 spec * torch.exp(phase * 1j),
-                n_fft = self.n_fft,
+                n_fft=self.n_fft,
                 hop_length=self.hop_length,
                 win_length=self.win_length,
                 window=self.window,
@@ -448,4 +438,5 @@ class InverseTransform(Model):
             if not _recall and spec.device != self.window.device:
                 self.window = self.window.to(spec.device)
                 return self.forward(spec, phase, _recall=True)
-            raise e
+            raise e
+

{lt_tensor-0.0.1a12.dist-info → lt_tensor-0.0.1a13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a12
+Version: 0.0.1a13
 Summary: General utilities for PyTorch and others. Built for general use.
 Home-page: https://github.com/gr1336/lt-tensor/
 Author: gr1336
@@ -11,15 +11,17 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Utilities
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: torch>=2.2.0
-Requires-Dist: torchaudio>=2.2.0
+Requires-Dist: torch>=2.7.0
+Requires-Dist: torchaudio>=2.7.0
 Requires-Dist: numpy>=1.26.4
 Requires-Dist: tokenizers
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: numba>0.60.0
 Requires-Dist: lt-utils>=0.0.2a1
-Requires-Dist: librosa>=0.11.0
+Requires-Dist: librosa==0.11.*
+Requires-Dist: einops
 Requires-Dist: plotly
+Requires-Dist: scipy
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

lt_tensor-0.0.1a13.dist-info/RECORD

@@ -0,0 +1,32 @@
+lt_tensor/__init__.py,sha256=XxNCGcVL-haJyMpifr-GRaamo32R6jmqe3iOuS4ecfs,469
+lt_tensor/config_templates.py,sha256=FRN4-i1amoqMh_wyp4gNsw61ABWTIhGC62Uc3l3SNss,3515
+lt_tensor/losses.py,sha256=zvkCOnE5XpF3v6ymivRIdqPTsMM5zc94ZMom7YDi3zM,4946
+lt_tensor/lr_schedulers.py,sha256=LSZzqrOOLzSthD8k-W4cYPJt0vCjmHkiJkLr5e3yRTE,3659
+lt_tensor/math_ops.py,sha256=TkD4WQG42KsQ9Fg7FXOjf8f-ixtW0apf2XjaooecVx4,2257
+lt_tensor/misc_utils.py,sha256=UNba6UEsAv1oZ60IAaKBNGbhXK2WPxRI9E4QcjP-_w0,28755
+lt_tensor/model_base.py,sha256=lxzRXfPlR_t_6LfgRw2dct55evrtmwTiDqZGAe3jLro,20026
+lt_tensor/monotonic_align.py,sha256=LhBd8p1xdBzg6jQrQX1j7b4PNeYGwIqM24zcU-pHOLE,2239
+lt_tensor/noise_tools.py,sha256=wFeAsHhLhSlEc5XU5LbFKaXoHeVxrWjiMeljjGdIKyM,11363
+lt_tensor/torch_commons.py,sha256=fntsEU8lhBQo0ebonI1iXBkMbWMN3HpBsG13EWlP5s8,718
+lt_tensor/transform.py,sha256=dZm8T_ov0blHMQu6nGiehsdG1VSB7bZBUVmTkT-PBdc,13257
+lt_tensor/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lt_tensor/datasets/audio.py,sha256=j73oRyXt-AK4tWWYWjH-3c5RYouQBgDSCTuWHmyG8kQ,7450
+lt_tensor/model_zoo/__init__.py,sha256=RzG7fltZLyiIU_Za4pgfBPli5uPITiJkq4sTCd4uA_0,319
+lt_tensor/model_zoo/basic.py,sha256=_26H_jJk5Ld3DZiNpIhGosGfMxoFDZrI8bpDAYUOYno,10660
+lt_tensor/model_zoo/discriminator.py,sha256=dS5UmJZV5MxIFiaBlIXfgGLDdUT3y0Vuv9lDGHsjJE8,5849
+lt_tensor/model_zoo/features.py,sha256=CTFMidzza31pqQjwPfp_g0BNVfuQ8Dlo5JnxpYpKgag,13144
+lt_tensor/model_zoo/fusion.py,sha256=usC1bcjQRNivDc8xzkIS5T1glm78OLcs2V_tPqfp-eI,5422
+lt_tensor/model_zoo/pos_encoder.py,sha256=3d1EYLinCU9UAy-WuEWeYMGhMqaGknCiQ5qEmhw_UYM,4487
+lt_tensor/model_zoo/residual.py,sha256=knVLxzrLUjNQ6vdBESTZOk3r86ldi5PHetoBuJmymcw,6388
+lt_tensor/model_zoo/transformer.py,sha256=HUFoFFh7EQJErxdd9XIxhssdjvNVx2tNGDJOTUfwG2A,4301
+lt_tensor/model_zoo/istft/__init__.py,sha256=SV96w9WUWfHMee8Vjgn2MP0igKft7_mLTju9rFVYGHY,102
+lt_tensor/model_zoo/istft/generator.py,sha256=lotGkMu67fctzwa5FSwX_xtHILOuV95uP-djCz2N3C8,5261
+lt_tensor/model_zoo/istft/sg.py,sha256=EaEi3otw_uY5QfqDBNIWBWTJSg3KnwzzR4FBr0u09C0,4838
+lt_tensor/model_zoo/istft/trainer.py,sha256=EPuGtvfgR8vCrVc72p5OwVy73nNVlx510VxnH3NeErY,16080
+lt_tensor/processors/__init__.py,sha256=4b9MxAJolXiJfSm20ZEspQTDm1tgLazwlPWA_jB1yLM,63
+lt_tensor/processors/audio.py,sha256=uBvMls4u_B1M-pk3xAiOIRnwM2l_3LcdfESNkE0Ch30,15314
+lt_tensor-0.0.1a13.dist-info/licenses/LICENSE,sha256=HUnu_iSPpnDfZS_PINhO3AoVizJD1A2vee8WX7D7uXo,11358
+lt_tensor-0.0.1a13.dist-info/METADATA,sha256=yzNtg91vOGZCoXi6XWpn1kWk7LgVD2mIWQXL-7tw_Uc,1033
+lt_tensor-0.0.1a13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lt_tensor-0.0.1a13.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
+lt_tensor-0.0.1a13.dist-info/RECORD,,

lt_tensor/model_zoo/fsn.py

@@ -1,67 +0,0 @@
-__all__ = [
-    "ConcatFusion",
-    "FiLMFusion",
-    "BilinearFusion",
-    "CrossAttentionFusion",
-    "GatedFusion",
-]
-
-from lt_tensor.torch_commons import *
-from lt_tensor.model_base import Model
-
-
-class ConcatFusion(Model):
-    def __init__(self, in_dim_a: int, in_dim_b: int, out_dim: int):
-        super().__init__()
-        self.proj = nn.Linear(in_dim_a + in_dim_b, out_dim)
-
-    def forward(self, a: Tensor, b: Tensor) -> Tensor:
-        x = torch.cat([a, b], dim=-1)
-        return self.proj(x)
-
-
-class FiLMFusion(Model):
-    def __init__(self, cond_dim: int, feature_dim: int):
-        super().__init__()
-        self.modulator = nn.Linear(cond_dim, 2 * feature_dim)
-
-    def forward(self, x: Tensor, cond: Tensor) -> Tensor:
-        scale, shift = self.modulator(cond).chunk(2, dim=-1)
-        return x * scale + shift
-
-
-class BilinearFusion(Model):
-    def __init__(self, in_dim_a: int, in_dim_b: int, out_dim: int):
-        super().__init__()
-        self.bilinear = nn.Bilinear(in_dim_a, in_dim_b, out_dim)
-
-    def forward(self, a: Tensor, b: Tensor) -> Tensor:
-        return self.bilinear(a, b)
-
-
-class CrossAttentionFusion(Model):
-    def __init__(self, q_dim: int, kv_dim: int, n_heads: int = 4, d_model: int = 256):
-        super().__init__()
-        self.q_proj = nn.Linear(q_dim, d_model)
-        self.k_proj = nn.Linear(kv_dim, d_model)
-        self.v_proj = nn.Linear(kv_dim, d_model)
-        self.attn = nn.MultiheadAttention(
-            embed_dim=d_model, num_heads=n_heads, batch_first=True
-        )
-
-    def forward(self, query: Tensor, context: Tensor, mask: Tensor = None) -> Tensor:
-        Q = self.q_proj(query)
-        K = self.k_proj(context)
-        V = self.v_proj(context)
-        output, _ = self.attn(Q, K, V, key_padding_mask=mask)
-        return output
-
-
-class GatedFusion(Model):
-    def __init__(self, in_dim: int):
-        super().__init__()
-        self.gate = nn.Sequential(nn.Linear(in_dim * 2, in_dim), nn.Sigmoid())
-
-    def forward(self, a: Tensor, b: Tensor) -> Tensor:
-        gate = self.gate(torch.cat([a, b], dim=-1))
-        return gate * a + (1 - gate) * b