Upload 24 files

checkpoints/checkpoint_epoch_1.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:439098a93f74427e7cc5fb9c16de240d63ebd1aa38d9b26b051fb447c9c2d473
+size 58448329

checkpoints/checkpoint_epoch_10.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7578398a03530523dbacd3a8ad819c4254ac58aad5aa3d61334669dfdc13f426
+size 58448471

checkpoints/checkpoint_epoch_10c.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a67256fd0190f15b14d4734d2d981aae39aac6d089c997cbb13eaedb221f4af1
+size 58450327

checkpoints/checkpoint_epoch_1c.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6448bdc6bea43ab61a3bf484e871671c83d1a52155e9ea3a8c0bc6f5bd01e42c
+size 58450185

checkpoints/checkpoint_epoch_2.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:decf7ce6657fcd760e94f6fa8d37de8656f62e6fdb14901d68a4a3f4260bdc8a
+size 58448329

checkpoints/checkpoint_epoch_20c.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28497c0f6a47ce6c1dd6ac550c86c4de4c3b6e184dc29f718a1f0a493d8dc7fe
+size 58450327

checkpoints/checkpoint_epoch_27c.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a696719435fa7ceae9088bcc5f66a66e44bc813c33ab316d1d29908ac533805e
+size 58450327

checkpoints/checkpoint_epoch_3.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3539477308b9a8067fcc9bbc4b5398a82c1d8861469ab23db0fbd31dcd223288
+size 58448329

checkpoints/checkpoint_epoch_3c.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9083a952fcd6b1681017d3cbf9ce2ebf2fe2785cc0cd4ad31c006883ad8aeac1
+size 58450185

checkpoints/checkpoint_epoch_4.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e46c6d7c0f39920f02e5e4d17ca249c208e7be126e2fee50fcc1be70736b8d8
+size 58448329

checkpoints/checkpoint_epoch_5.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af14ef31d745a42a941d1f6c2440fd7f9dd427af96cd747c5abb3f89e2f376eb
+size 58448329

checkpoints/checkpoint_epoch_50c.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d5e0b69ad7122206fbed43a8e7ecbaabffa79d200281fd21a05cad73d73354e
+size 58450327

checkpoints/checkpoint_epoch_6.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12f7a6c0543ab15f012e9731b66e3123ad8c6a4715ba6d288403525022a50cfd
+size 58448329

checkpoints/checkpoint_epoch_7.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d573bc3563dd133a2ea36e3d5d5fd78814d577bf9508fe4749defb58ae7083dc
+size 58448329

checkpoints/checkpoint_epoch_8.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f975cca0b65ec75102f187ea09891c3e84ed836cb164fb66f82853e09c05738
+size 58448329

checkpoints/checkpoint_epoch_9.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a36e891bb4ba4ea65e74d87797e43c305ac6546d6c037354e84157a3623dd5a
+size 58448329

model/dataset.py

@@ -0,0 +1,117 @@
+import torch
+import torchaudio
+import pandas as pd
+import os
+import soundfile as sf
+from torch.utils.data import Dataset, DataLoader
+from torch.nn.utils.rnn import pad_sequence
+
+
+# --- CONFIGURATION ---
+# We map characters to integers. 
+# We reserve 0 for padding, 1 for 'unknown'.
+vocab = "_ abcdefghijklmnopqrstuvwxyz'.?"
+char_to_id = {char: i+2 for i, char in enumerate(vocab)}
+id_to_char = {i+2: char for i, char in enumerate(vocab)}
+
+class TextProcessor:
+    @staticmethod
+    def text_to_sequence(text):
+        text = text.lower()
+        sequence = [char_to_id.get(c, 1) for c in text if c in vocab]
+        return torch.tensor(sequence, dtype=torch.long)
+
+class LJSpeechDataset(Dataset):
+    def __init__(self, metadata_path, wavs_dir):
+        """
+        metadata_path: Path to metadata.csv
+        wavs_dir: Path to the folder containing .wav files
+        """
+        self.wavs_dir = wavs_dir
+        # Load CSV (Format: ID | Transcription | Normalized Transcription)
+        self.metadata = pd.read_csv(metadata_path, sep='|', header=None, quoting=3).iloc[:100]
+        
+        # Audio Processing Setup (Mel Spectrogram)
+        self.mel_transform = torchaudio.transforms.MelSpectrogram(
+            sample_rate=22050,
+            n_fft=1024,
+            win_length=256,
+            hop_length=256,
+            n_mels=80     # Standard for TTS (Match this with your network.py!)
+        )
+
+    def __len__(self):
+        return len(self.metadata)
+
+    def __getitem__(self, idx):
+        # 1. Get Text
+        row = self.metadata.iloc[idx]
+        file_id = row[0]
+        text = row[2] 
+        text_tensor = TextProcessor.text_to_sequence(str(text))
+        
+        # 2. Get Audio (BYPASSING TORCHAUDIO LOADER)
+        wav_path = os.path.join(self.wavs_dir, f"{file_id}.wav")
+        
+        # Use soundfile directly to read the audio
+        # sf.read returns: audio_array (numpy), sample_rate (int)
+        audio_np, sample_rate = sf.read(wav_path)
+        
+        # Convert Numpy -> PyTorch Tensor
+        # Soundfile gives [time] or [time, channels], but PyTorch wants [channels, time]
+        waveform = torch.from_numpy(audio_np).float()
+        
+        if waveform.dim() == 1:
+            # If mono, add channel dimension: [time] -> [1, time]
+            waveform = waveform.unsqueeze(0)
+        else:
+            # If stereo, transpose: [time, channels] -> [channels, time]
+            waveform = waveform.transpose(0, 1)
+        
+        # Resample if necessary
+        if sample_rate != 22050:
+            resampler = torchaudio.transforms.Resample(sample_rate, 22050)
+            waveform = resampler(waveform)
+        
+        # Convert to Mel Spectrogram
+        mel_spec = self.mel_transform(waveform).squeeze(0)
+        mel_spec = mel_spec.transpose(0, 1)
+        
+        return text_tensor, mel_spec
+
+# --- BATCHING MAGIC (Collate Function) ---
+# Since sentences have different lengths, we must pad them to match the longest in the batch.
+def collate_fn_tts(batch):
+    # batch is a list of tuples: [(text1, mel1), (text2, mel2), ...]
+    
+    # Separate text and mels
+    text_list = [item[0] for item in batch]
+    mel_list = [item[1] for item in batch]
+    
+    # Pad sequences
+    # batch_first=True makes output [batch, max_len, ...]
+    text_padded = pad_sequence(text_list, batch_first=True, padding_value=0)
+    mel_padded = pad_sequence(mel_list, batch_first=True, padding_value=0.0)
+    
+    return text_padded, mel_padded
+
+# --- SANITY CHECK ---
+if __name__ == "__main__":
+    # UPDATE THESE PATHS TO MATCH YOUR FOLDER
+    BASE_PATH = "LJSpeech-1.1" 
+    csv_path = os.path.join(BASE_PATH, "metadata.csv")
+    wav_path = os.path.join(BASE_PATH, "wavs")
+    
+    if os.path.exists(csv_path):
+        print("Loading Dataset...")
+        dataset = LJSpeechDataset(csv_path, wav_path)
+        loader = DataLoader(dataset, batch_size=2, collate_fn=collate_fn_tts)
+        
+        # Get one batch
+        text_batch, mel_batch = next(iter(loader))
+        
+        print(f"Text Batch Shape: {text_batch.shape} (Batch, Max Text Len)")
+        print(f"Mel Batch Shape:  {mel_batch.shape}  (Batch, Max Audio Len, 80)")
+        print("\nSUCCESS: Data pipeline is working!")
+    else:
+        print("Dataset not found. Please download LJSpeech-1.1 to run this test.")

model/inference.py

@@ -0,0 +1,61 @@
+import torch
+import torchaudio
+from model.network import MiniTTS
+from model.dataset import TextProcessor  # We reuse the text logic we already wrote!
+
+class TTSInference:
+    def __init__(self, checkpoint_path, device='cpu'):
+        self.device = device
+        self.model = self.load_model(checkpoint_path)
+        print(f"Model loaded from {checkpoint_path}")
+
+    def load_model(self, path):
+        # 1. Initialize the same architecture as training
+        model = MiniTTS(num_chars=40, num_mels=80) 
+        
+        # 2. Load the weights
+        # map_location ensures it loads on CPU even if trained on GPU
+        state_dict = torch.load(path, map_location=self.device)
+        model.load_state_dict(state_dict)
+        
+        return model.eval().to(self.device)
+
+    def predict(self, text):
+        # 1. Text Preprocessing
+        text_tensor = TextProcessor.text_to_sequence(text).unsqueeze(0).to(self.device)
+        
+        # 2. Autoregressive Inference (The Loop)
+        # We start with ONE silent frame. The model predicts the next, and we feed it back.
+        with torch.no_grad():
+            # Start with [Batch, Time=1, Mels=80] of zeros
+            decoder_input = torch.zeros(1, 1, 80).to(self.device)
+            
+            # Generate 150 frames (about 1.5 seconds of audio)
+            # You can increase this range for longer sentences
+            for _ in range(150):
+                # Ask model to predict based on what we have so far
+                prediction = self.model(text_tensor, decoder_input)
+                
+                # Take ONLY the newest frame it predicted (the last one)
+                new_frame = prediction[:, -1:, :]
+                
+                # Add it to our growing list of frames
+                decoder_input = torch.cat([decoder_input, new_frame], dim=1)
+            
+            # The result is our generated spectrogram
+            # Shape: [1, 151, 80] -> [1, 80, 151]
+            mel_spec = decoder_input.transpose(1, 2)
+
+        # 3. Vocoder (Spectrogram -> Audio)
+        # Inverse Mel Scale
+        inverse_mel_scaler = torchaudio.transforms.InverseMelScale(
+            n_stft=513, n_mels=80, sample_rate=22050
+        ).to(self.device)
+        
+        linear_spec = inverse_mel_scaler(mel_spec)
+        
+        # Griffin-Lim
+        griffin_lim = torchaudio.transforms.GriffinLim(n_fft=1024, n_iter=32).to(self.device)
+        audio = griffin_lim(linear_spec)
+        
+        return audio.squeeze(0).cpu().numpy(), 22050, mel_spec.squeeze(0).cpu().numpy()

model/network.py

@@ -0,0 +1,138 @@
+import torch
+import torch.nn as nn
+import math
+
+class PositionalEncoding(nn.Module):
+    """
+    Injects information about the relative or absolute position of the tokens
+    in the sequence. The model needs this because it has no recurrence.
+    """
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        
+        # Register buffer allows us to save this with state_dict but not train it
+        self.register_buffer('pe', pe.unsqueeze(0))
+
+    def forward(self, x):
+        # x shape: [batch_size, seq_len, d_model]
+        x = x + self.pe[:, :x.size(1)]
+        return self.dropout(x)
+
+class MiniTTS(nn.Module):
+    def __init__(self, num_chars, num_mels, d_model=256, nhead=4, num_layers=4):
+        super(MiniTTS, self).__init__()
+        
+        # 1. Text Encoder Layers
+        self.embedding = nn.Embedding(num_chars, d_model)
+        self.pos_encoder = PositionalEncoding(d_model)
+        
+        encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, batch_first=True)
+        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        
+        # 2. Spectrogram Decoder Layers
+        # We process the mel spectrogram frames (Standard Transformers use teacher forcing during training)
+        self.mel_embedding = nn.Linear(num_mels, d_model) # Project mel dimension to model dimension
+        self.pos_decoder = PositionalEncoding(d_model)
+        
+        decoder_layer = nn.TransformerDecoderLayer(d_model=d_model, nhead=nhead, batch_first=True)
+        self.transformer_decoder = nn.TransformerDecoder(decoder_layer, num_layers=num_layers)
+        
+        # 3. Final Projection
+        # Project back from model dimension to Mel Spectrogram dimension (usually 80 channels)
+        self.output_layer = nn.Linear(d_model, num_mels)
+        
+        # 4. Post-Net (Optional but recommended for TTS quality)
+        # Simple convolutional network to refine the output
+        self.post_net = nn.Sequential(
+            nn.Conv1d(num_mels, 512, kernel_size=5, padding=2),
+            nn.BatchNorm1d(512),
+            nn.Tanh(),
+            nn.Dropout(0.5),
+            nn.Conv1d(512, num_mels, kernel_size=5, padding=2)
+        )
+
+    def forward(self, text_tokens, mel_target=None):
+        """
+        text_tokens: [batch, text_len] (Integers representing phonemes)
+        mel_target: [batch, mel_len, num_mels] (The target spectrogram for training)
+        """
+        # --- ENCODING ---
+        # [batch, text_len] -> [batch, text_len, d_model]
+        src = self.embedding(text_tokens)
+        src = self.pos_encoder(src)
+        
+        # Memory is the output of the encoder that the decoder attends to
+        memory = self.transformer_encoder(src)
+        
+        # --- DECODING ---
+        if mel_target is not None:
+            # TRAINING MODE (Teacher Forcing)
+            # We feed the real spectrogram (shifted) into the decoder
+            tgt = self.mel_embedding(mel_target)
+            tgt = self.pos_decoder(tgt)
+            
+            # Create a casual mask (prevent decoder from peeking at future frames)
+            batch_size, tgt_len, _ = tgt.shape
+            tgt_mask = self.generate_square_subsequent_mask(tgt_len).to(tgt.device)
+            
+            output = self.transformer_decoder(tgt, memory, tgt_mask=tgt_mask)
+            output_mel = self.output_layer(output)
+            
+            # Post-net refinement
+            # Conv1d expects [batch, channels, time], so we transpose
+            output_mel_post = output_mel.transpose(1, 2)
+            output_mel_post = self.post_net(output_mel_post)
+            output_mel_post = output_mel_post.transpose(1, 2)
+            
+            # Combine raw output + residual
+            final_output = output_mel + output_mel_post
+            
+            return final_output
+        else:
+            # INFERENCE MODE (Greedy Decoding)
+            # We will handle this loop inside inference.py later
+            # For now, we just return the encoder memory so we can debug shapes
+            return memory
+
+    def generate_square_subsequent_mask(self, sz):
+        """Generates an upper-triangular matrix of -inf, with zeros on diag."""
+        mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
+        mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
+        return mask
+
+# --- SANITY CHECK ---
+# Run this file directly to check if dimensions work!
+if __name__ == "__main__":
+    print("Testing Model Dimensions...")
+    
+    # Dummy Config
+    num_chars = 50   # Size of vocabulary (phonemes)
+    num_mels = 80    # Standard Mel Spectrogram channels
+    batch_size = 2
+    text_len = 10
+    mel_len = 100
+    
+    # Instantiate Model
+    model = MiniTTS(num_chars, num_mels)
+    
+    # Create Dummy Data
+    dummy_text = torch.randint(0, num_chars, (batch_size, text_len))
+    dummy_mel = torch.randn(batch_size, mel_len, num_mels)
+    
+    # Forward Pass
+    try:
+        output = model(dummy_text, dummy_mel)
+        print(f"Input Text Shape: {dummy_text.shape}")
+        print(f"Input Mel Shape:  {dummy_mel.shape}")
+        print(f"Output Shape:     {output.shape}")
+        print("\nSUCCESS: The architecture is valid!")
+    except Exception as e:
+        print(f"\nERROR: {e}")