update

app.py

@@ -14,7 +14,8 @@ from infer import (
     load_models, 
     load_audio, 
     apply_fade, 
-    process_segment
+    process_segment,
+    batch_process_segments
 )
 
 # Global variables for models
@@ -115,7 +116,9 @@ def process_with_progress(
     slicer_min_length=3000,
     slicer_min_interval=100,
     slicer_hop_size=10,
-    slicer_max_sil_kept=200
+    slicer_max_sil_kept=200,
+    # Batch processing
+    batch_size=1
 ):
     global svc_model, vocoder, rmvpe, hubert, rms_extractor, spk2idx, dataset_cfg
     
@@ -182,41 +185,71 @@ def process_with_progress(
         progress(0.2, desc="处理中: 开始转换...")
         
         with torch.no_grad():
-            for i, (start_sample, chunk) in enumerate(segments_with_pos):
-                segment_progress = 0.2 + (0.7 * (i / len(segments_with_pos)))
-                progress(segment_progress, desc=f"处理中: 片段 {i+1}/{len(segments_with_pos)}")
-                
-                # Process the segment
-                audio_out = process_segment(
-                    chunk, svc_model, vocoder, rmvpe, hubert, rms_extractor,
+            if batch_size > 1:
+                # Use batch processing
+                progress_desc = f"处理中: 批次 {{0}}/{{1}}"
+                processed_segments = batch_process_segments(
+                    segments_with_pos, svc_model, vocoder, rmvpe, hubert, rms_extractor,
                     speaker_id, sample_rate, hop_length, device,
                     key_shift, infer_steps, ds_cfg_strength, spk_cfg_strength,
                     skip_cfg_strength, cfg_skip_layers, cfg_rescale,
-                    cvec_downsample_rate, target_loudness, restore_loudness, sliced_inference,
-                    robust_f0, use_fp16
+                    cvec_downsample_rate, target_loudness, restore_loudness,
+                    robust_f0, use_fp16, batch_size, progress, progress_desc
                 )
                 
-                # Ensure consistent length
-                expected_length = len(chunk)
-                if len(audio_out) > expected_length:
-                    audio_out = audio_out[:expected_length]
-                elif len(audio_out) < expected_length:
-                    audio_out = np.pad(audio_out, (0, expected_length - len(audio_out)), 'constant')
-                
-                # Apply fades
-                if i > 0:  # Not first segment
-                    audio_out = apply_fade(audio_out.copy(), fade_samples, fade_in=True)
-                    result_audio[start_sample:start_sample + fade_samples] *= \
-                        np.linspace(1, 0, fade_samples)  # Fade out previous
-                
-                if i < len(segments_with_pos) - 1:  # Not last segment
-                    audio_out[-fade_samples:] *= np.linspace(1, 0, fade_samples)  # Fade out
-                
-                # Add to result
-                result_audio[start_sample:start_sample + len(audio_out)] += audio_out
-                
-                # Clean up memory after each segment
-                torch.cuda.empty_cache()
+                for idx, (start_sample, audio_out, expected_length) in enumerate(processed_segments):
+                    # Apply fades
+                    if idx > 0:  # Not first segment
+                        audio_out = apply_fade(audio_out.copy(), fade_samples, fade_in=True)
+                        result_audio[start_sample:start_sample + fade_samples] *= \
+                            np.linspace(1, 0, fade_samples)  # Fade out previous
+                    
+                    if idx < len(processed_segments) - 1:  # Not last segment
+                        audio_out[-fade_samples:] *= np.linspace(1, 0, fade_samples)  # Fade out
+                    
+                    # Add to result
+                    result_audio[start_sample:start_sample + len(audio_out)] += audio_out
+                    
+                    # Clean up memory after each segment
+                    if idx % 5 == 0:  # Clean up every 5 segments
+                        torch.cuda.empty_cache()
+            else:
+                # Use sequential processing
+                for i, (start_sample, chunk) in enumerate(segments_with_pos):
+                    segment_progress = 0.2 + (0.7 * (i / len(segments_with_pos)))
+                    progress(segment_progress, desc=f"处理中: 片段 {i+1}/{len(segments_with_pos)}")
+                    
+                    # Process the segment
+                    audio_out = process_segment(
+                        chunk, svc_model, vocoder, rmvpe, hubert, rms_extractor,
+                        speaker_id, sample_rate, hop_length, device,
+                        key_shift, infer_steps, ds_cfg_strength, spk_cfg_strength,
+                        skip_cfg_strength, cfg_skip_layers, cfg_rescale,
+                        cvec_downsample_rate, target_loudness, restore_loudness, sliced_inference,
+                        robust_f0, use_fp16
+                    )
+                    
+                    # Ensure consistent length
+                    expected_length = len(chunk)
+                    if len(audio_out) > expected_length:
+                        audio_out = audio_out[:expected_length]
+                    elif len(audio_out) < expected_length:
+                        audio_out = np.pad(audio_out, (0, expected_length - len(audio_out)), 'constant')
+                    
+                    # Apply fades
+                    if i > 0:  # Not first segment
+                        audio_out = apply_fade(audio_out.copy(), fade_samples, fade_in=True)
+                        result_audio[start_sample:start_sample + fade_samples] *= \
+                            np.linspace(1, 0, fade_samples)  # Fade out previous
+                    
+                    if i < len(segments_with_pos) - 1:  # Not last segment
+                        audio_out[-fade_samples:] *= np.linspace(1, 0, fade_samples)  # Fade out
+                    
+                    # Add to result
+                    result_audio[start_sample:start_sample + len(audio_out)] += audio_out
+                    
+                    # Clean up memory after each segment
+                    torch.cuda.empty_cache()
         
         progress(0.9, desc="处理中: 完成音频...")
         # Trim any extra padding
@@ -230,7 +263,8 @@ def process_with_progress(
         torchaudio.save(output_path, torch.from_numpy(result_audio).unsqueeze(0).float(), sample_rate)
         
         progress(1.0, desc="处理完成!")
-        return (sample_rate, result_audio), f"✅ 转换完成! 已转换为 **{speaker}** 并调整 **{key_shift}** 个半音。"
+        batch_text = f"批处理大小 {batch_size}" if batch_size > 1 else "顺序处理"
+        return (sample_rate, result_audio), f"✅ 转换完成! 已转换为 **{speaker}** 并调整 **{key_shift}** 个半音。{batch_text}"
         
     except RuntimeError as e:
         # Handle CUDA out of memory errors
@@ -341,6 +375,9 @@ def create_ui():
                     robust_f0 = gr.Radio(choices=[0, 1, 2], value=1, label="音高滤波", 
                                         info="0=无，1=轻度过滤，2=强力过滤（有助于解决断音/破音问题）", 
                                         elem_id="robust_f0")
+                    batch_size = gr.Slider(minimum=1, maximum=64, step=1, value=4, label="批处理大小", 
+                                          info="使用批处理可以加速转换，但需要更多VRAM。1=不使用批处理", 
+                                          elem_id="batch_size")
                 
                 with gr.Accordion("🔬 高级CFG参数", open=True):
                     ds_cfg_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, value=0.2, 
@@ -403,6 +440,7 @@ def create_ui():
                         <li><strong>音调调整：</strong> 以半音为单位上调或下调音高。</li>
                         <li><strong>推理步骤：</strong> 步骤越多 = 质量越好但速度越慢。</li>
                         <li><strong>音高滤波：</strong> 有助于提高具有挑战性的音频中的音高稳定性。</li>
+                        <li><strong>批处理大小：</strong> 值越大 = 转换越快，但需要更多GPU内存。遇到内存不足时降低此值。</li>
                         <li><strong>CFG参数：</strong> 调整转换质量和音色。</li>
                     </ul>
                 </div>
@@ -426,7 +464,8 @@ def create_ui():
             inputs=[
                 input_audio, speaker, key_shift, infer_steps, robust_f0,
                 ds_cfg_strength, spk_cfg_strength, skip_cfg_strength, cfg_skip_layers, cfg_rescale, cvec_downsample_rate,
-                slicer_threshold, slicer_min_length, slicer_min_interval, slicer_hop_size, slicer_max_sil_kept
+                slicer_threshold, slicer_min_length, slicer_min_interval, slicer_hop_size, slicer_max_sil_kept,
+                batch_size
             ],
             outputs=[output_audio, output_message],
             show_progress_on=output_audio

infer.py

@@ -184,12 +184,31 @@ def run_inference(
     model, mel, cvec, f0, rms, cvec_ds, spk_id, 
     infer_steps, ds_cfg_strength, spk_cfg_strength, 
     skip_cfg_strength, cfg_skip_layers, cfg_rescale,
-    sliced_inference=False, use_fp16=True
+    sliced_inference=False, use_fp16=True, frame_lengths=None
 ):
     """Run the actual inference through the model"""
     device_type = 'cuda' if mel.device.type == 'cuda' else 'cpu'
     
-    if sliced_inference:
+    if frame_lengths is not None:
+        # Use batch inference with frame lengths
+        with autocast(device_type=device_type, enabled=use_fp16):
+            mel_out, _ = model.sample(
+                src_mel=mel,
+                spk_id=spk_id,
+                f0=f0,
+                rms=rms,
+                cvec=cvec,
+                steps=infer_steps,
+                bad_cvec=cvec_ds,
+                ds_cfg_strength=ds_cfg_strength,
+                spk_cfg_strength=spk_cfg_strength,
+                skip_cfg_strength=skip_cfg_strength,
+                cfg_skip_layers=cfg_skip_layers,
+                cfg_rescale=cfg_rescale,
+                frame_len=frame_lengths,
+            )
+        return mel_out
+    elif sliced_inference:
         # Use sliced inference for long segments
         sliced_len = 256
         mel_crossfade_len = 8  # Number of frames to crossfade in mel domain
@@ -392,6 +411,191 @@ def process_segment(
     return audio_out
 
 
+def pad_tensor_to_length(tensor, length):
+    """Pad a tensor to the specified length along the sequence dimension (dim=1)"""
+    curr_len = tensor.shape[1]
+    if curr_len >= length:
+        return tensor
+    
+    pad_len = length - curr_len
+    
+    if tensor.dim() == 2:
+        padding = (0, pad_len)
+    elif tensor.dim() == 3:
+        padding = (0, 0, 0, pad_len)
+    else:
+        raise ValueError(f"Unsupported tensor dimension: {tensor.dim()}")
+    
+    padded = torch.nn.functional.pad(tensor, padding, "constant", 0)
+    return padded
+
+
+def batch_process_segments(
+    segments_with_pos, 
+    svc_model, vocoder, rmvpe, hubert, rms_extractor, 
+    speaker_id, sample_rate, hop_length, device,
+    key_shift=0, 
+    infer_steps=32,
+    ds_cfg_strength=0.0, 
+    spk_cfg_strength=0.0, 
+    skip_cfg_strength=0.0, 
+    cfg_skip_layers=None, 
+    cfg_rescale=0.7,
+    cvec_downsample_rate=2,
+    target_loudness=-18.0,
+    restore_loudness=True,
+    robust_f0=0,
+    use_fp16=True,
+    batch_size=1,
+    gr_progress=None,
+    progress_desc=None
+):
+    """Process audio segments in batches for faster inference"""
+    if batch_size <= 1:
+        results = []
+        for i, (start_sample, chunk) in enumerate(tqdm(segments_with_pos, desc="Processing segments")):
+            if gr_progress is not None:
+                gr_progress(0.2 + (0.7 * (i / len(segments_with_pos))), desc=progress_desc.format(i+1, len(segments_with_pos)))
+            audio_out = process_segment(
+                chunk, svc_model, vocoder, rmvpe, hubert, rms_extractor,
+                speaker_id, sample_rate, hop_length, device,
+                key_shift, infer_steps, ds_cfg_strength, spk_cfg_strength,
+                skip_cfg_strength, cfg_skip_layers, cfg_rescale,
+                cvec_downsample_rate, target_loudness, restore_loudness,
+                robust_f0, use_fp16
+            )
+            results.append((start_sample, audio_out, len(chunk)))
+        return results
+    
+    sorted_with_idx = sorted(enumerate(segments_with_pos), key=lambda x: len(x[1][1]))
+    sorted_segments = []
+    original_indices = []
+    
+    for orig_idx, (pos, chunk) in sorted_with_idx:
+        original_indices.append(orig_idx)
+        sorted_segments.append((pos, chunk))
+
+    batched_segments = [sorted_segments[i:i + batch_size] for i in range(0, len(sorted_segments), batch_size)]
+    
+    all_results = []
+    
+    for batch_idx, batch in enumerate(tqdm(batched_segments, desc="Processing batches")):
+        if gr_progress is not None:
+            gr_progress(
+                0.2 + (0.7 * (batch_idx / len(batched_segments))),
+                desc=progress_desc.format(batch_idx+1, len(batched_segments)))
+
+        batch_start_samples = [pos for pos, _ in batch]
+        batch_chunks = [chunk for _, chunk in batch]
+        batch_lengths = [len(chunk) for chunk in batch_chunks]
+        
+        batch_features = []
+        for chunk in batch_chunks:
+            mel, cvec, cvec_ds, f0, rms, original_loudness = extract_features(
+                chunk, sample_rate, hop_length, rmvpe, hubert, rms_extractor, 
+                device, key_shift, ds_cfg_strength, cvec_downsample_rate, target_loudness,
+                robust_f0, use_fp16
+            )
+            batch_features.append({
+                'mel': mel, 
+                'cvec': cvec, 
+                'cvec_ds': cvec_ds, 
+                'f0': f0, 
+                'rms': rms, 
+                'original_loudness': original_loudness,
+                'length': mel.shape[1]
+            })
+        
+        max_length = max(feat['length'] for feat in batch_features)
+        
+        padded_mels = []
+        padded_cvecs = []
+        padded_f0s = []
+        padded_rmss = []
+        frame_lengths = []
+        original_loudness_values = []
+        
+        if ds_cfg_strength > 0:
+            padded_cvec_ds = []
+        
+        for feat in batch_features:
+            curr_len = feat['length']
+            frame_lengths.append(curr_len)
+            
+            padded_mels.append(pad_tensor_to_length(feat['mel'], max_length))
+            padded_cvecs.append(pad_tensor_to_length(feat['cvec'], max_length))
+            padded_f0s.append(pad_tensor_to_length(feat['f0'], max_length))
+            padded_rmss.append(pad_tensor_to_length(feat['rms'], max_length))
+            
+            if ds_cfg_strength > 0:
+                padded_cvec_ds.append(pad_tensor_to_length(feat['cvec_ds'], max_length))
+            
+            original_loudness_values.append(feat['original_loudness'])
+        
+        batched_mel = torch.cat(padded_mels, dim=0)
+        batched_cvec = torch.cat(padded_cvecs, dim=0)
+        batched_f0 = torch.cat(padded_f0s, dim=0)
+        batched_rms = torch.cat(padded_rmss, dim=0)
+        
+        if ds_cfg_strength > 0:
+            batched_cvec_ds = torch.cat(padded_cvec_ds, dim=0)
+        else:
+            batched_cvec_ds = None
+        
+        frame_lengths = torch.tensor(frame_lengths, device=device)
+        
+        batch_spk_id = torch.LongTensor([speaker_id] * len(batch)).to(device)
+        
+        with torch.no_grad():
+            mel_out = run_inference(
+                model=svc_model,
+                mel=batched_mel,
+                cvec=batched_cvec,
+                f0=batched_f0,
+                rms=batched_rms,
+                cvec_ds=batched_cvec_ds,
+                spk_id=batch_spk_id,
+                infer_steps=infer_steps,
+                ds_cfg_strength=ds_cfg_strength,
+                spk_cfg_strength=spk_cfg_strength,
+                skip_cfg_strength=skip_cfg_strength,
+                cfg_skip_layers=cfg_skip_layers,
+                cfg_rescale=cfg_rescale,
+                frame_lengths=frame_lengths,
+                use_fp16=use_fp16
+            )
+            
+            with autocast(device_type='cuda' if device.type == 'cuda' else 'cpu', enabled=use_fp16):
+                audio_out = vocoder(mel_out.transpose(1, 2), batched_f0)
+            
+            for i in range(len(batch)):
+                expected_audio_length = batch_lengths[i]
+                
+                curr_audio = audio_out[i].squeeze().cpu().numpy()
+                
+                if len(curr_audio) > expected_audio_length:
+                    curr_audio = curr_audio[:expected_audio_length]
+                elif len(curr_audio) < expected_audio_length:
+                    curr_audio = np.pad(curr_audio, (0, expected_audio_length - len(curr_audio)), 'constant')
+                
+                if restore_loudness:
+                    meter = pyln.Meter(44100, block_size=0.1)
+                    curr_loudness = meter.integrated_loudness(curr_audio)
+                    curr_audio = pyln.normalize.loudness(curr_audio, curr_loudness, original_loudness_values[i])
+                    
+                    max_amp = np.max(np.abs(curr_audio))
+                    if max_amp > 1.0:
+                        curr_audio = curr_audio * (0.99 / max_amp)
+                
+                expected_length = batch_lengths[i]
+                
+                all_results.append((batch_idx, i, batch_start_samples[i], curr_audio, expected_length, original_indices[batch_size * batch_idx + i]))
+    
+    all_results.sort(key=lambda x: x[5])
+    
+    return [(pos, audio, length) for _, _, pos, audio, length, _ in all_results]
+
+
 @click.command()
 @click.option('--model', type=click.Path(exists=True), required=True, help='Path to model checkpoint')
 @click.option('--input', type=click.Path(exists=True), required=True, help='Input audio file')
@@ -417,6 +621,7 @@ def process_segment(
 @click.option('--slicer-hop-size', type=int, default=10, help='Hop size for audio slicing in milliseconds')
 @click.option('--slicer-max-sil-kept', type=int, default=200, help='Maximum silence kept in milliseconds')
 @click.option('--use-fp16', is_flag=True, default=True, help='Use float16 precision for faster inference')
+@click.option('--batch-size', type=int, default=1, help='Batch size for parallel inference')
 def main(
     model,
     input,
@@ -441,7 +646,8 @@ def main(
     slicer_min_interval,
     slicer_hop_size,
     slicer_max_sil_kept,
-    use_fp16
+    use_fp16,
+    batch_size
 ):
     """Convert the voice in an audio file to a target speaker."""
 
@@ -486,40 +692,68 @@ def main(
     fade_samples = int(fade_duration * sample_rate / 1000)
 
     # Process segments
-    click.echo(f"Processing {len(segments_with_pos)} segments...")
-    result_audio = np.zeros(len(audio) + fade_samples)  # Extra space for potential overlap
-
-    with torch.no_grad():
-        for idx, (start_sample, chunk) in enumerate(tqdm(segments_with_pos)):
-
-            # Process the segment
-            audio_out = process_segment(
-                chunk, svc_model, vocoder, rmvpe, hubert, rms_extractor,
+    if batch_size > 1:
+        click.echo(f"Processing {len(segments_with_pos)} segments with batch size {batch_size}...")
+        result_audio = np.zeros(len(audio) + fade_samples)  # Extra space for potential overlap
+        
+        with torch.no_grad():
+            processed_segments = batch_process_segments(
+                segments_with_pos, svc_model, vocoder, rmvpe, hubert, rms_extractor,
                 speaker_id, sample_rate, hop_length, device,
                 key_shift, infer_steps, ds_cfg_strength, spk_cfg_strength,
                 skip_cfg_strength, cfg_skip_layers, cfg_rescale,
-                cvec_downsample_rate, target_loudness, restore_loudness, sliced_inference,
-                robust_f0, use_fp16
+                cvec_downsample_rate, target_loudness, restore_loudness,
+                robust_f0, use_fp16, batch_size
             )
             
-            # Ensure consistent length
-            expected_length = len(chunk)
-            if len(audio_out) > expected_length:
-                audio_out = audio_out[:expected_length]
-            elif len(audio_out) < expected_length:
-                audio_out = np.pad(audio_out, (0, expected_length - len(audio_out)), 'constant')
-            
+        for idx, (start_sample, audio_out, expected_length) in enumerate(processed_segments):
             # Apply fades
             if idx > 0:  # Not first segment
                 audio_out = apply_fade(audio_out.copy(), fade_samples, fade_in=True)
                 result_audio[start_sample:start_sample + fade_samples] *= \
                     np.linspace(1, 0, fade_samples)  # Fade out previous
             
-            if idx < len(segments_with_pos) - 1:  # Not last segment
+            if idx < len(processed_segments) - 1:  # Not last segment
                 audio_out[-fade_samples:] *= np.linspace(1, 0, fade_samples)  # Fade out
             
             # Add to result
             result_audio[start_sample:start_sample + len(audio_out)] += audio_out
+    else:
+        # Original processing method using sliced_inference
+        click.echo(f"Processing {len(segments_with_pos)} segments...")
+        result_audio = np.zeros(len(audio) + fade_samples)  # Extra space for potential overlap
+
+        with torch.no_grad():
+            for idx, (start_sample, chunk) in enumerate(tqdm(segments_with_pos)):
+
+                # Process the segment
+                audio_out = process_segment(
+                    chunk, svc_model, vocoder, rmvpe, hubert, rms_extractor,
+                    speaker_id, sample_rate, hop_length, device,
+                    key_shift, infer_steps, ds_cfg_strength, spk_cfg_strength,
+                    skip_cfg_strength, cfg_skip_layers, cfg_rescale,
+                    cvec_downsample_rate, target_loudness, restore_loudness, sliced_inference,
+                    robust_f0, use_fp16
+                )
+                
+                # Ensure consistent length
+                expected_length = len(chunk)
+                if len(audio_out) > expected_length:
+                    audio_out = audio_out[:expected_length]
+                elif len(audio_out) < expected_length:
+                    audio_out = np.pad(audio_out, (0, expected_length - len(audio_out)), 'constant')
+                
+                # Apply fades
+                if idx > 0:  # Not first segment
+                    audio_out = apply_fade(audio_out.copy(), fade_samples, fade_in=True)
+                    result_audio[start_sample:start_sample + fade_samples] *= \
+                        np.linspace(1, 0, fade_samples)  # Fade out previous
+                
+                if idx < len(segments_with_pos) - 1:  # Not last segment
+                    audio_out[-fade_samples:] *= np.linspace(1, 0, fade_samples)  # Fade out
+                
+                # Add to result
+                result_audio[start_sample:start_sample + len(audio_out)] += audio_out
 
     # Trim any extra padding
     result_audio = result_audio[:len(audio)]

rift_svc/rf.py

@@ -84,34 +84,138 @@ class RF(nn.Module):
 
         # Define the ODE function
         def fn(t, x):
-            pred = self.transformer(
-                x=x, 
-                spk=spk_id, 
-                f0=f0, 
-                rms=rms, 
-                cvec=cvec, 
-                time=t, 
-                mask=mask
-            )
-            cfg_flag = (ds_cfg_strength > 1e-5) or (skip_cfg_strength > 1e-5) or (spk_cfg_strength > 1e-5)
-            if cfg_rescale > 1e-5 and cfg_flag:
-                std_pred = pred.std()
-
+            # Check if we need to do batched processing
+            need_batched = False
+            num_cond = 1  # Regular prediction
+            
             if ds_cfg_strength > 1e-5:
                 assert exists(bad_cvec), "bad_cvec is required when cfg_strength is greater than 0"
-                bad_cvec_pred = self.transformer(
+                need_batched = True
+                num_cond += 1
+            
+            if spk_cfg_strength > 1e-5:
+                need_batched = True
+                num_cond += 1
+            
+            if not need_batched:
+                # Standard case - just do the regular prediction
+                pred = self.transformer(
                     x=x, 
                     spk=spk_id, 
                     f0=f0, 
                     rms=rms, 
-                    cvec=bad_cvec, 
+                    cvec=cvec, 
                     time=t, 
-                    mask=mask,
-                    skip_layers=cfg_skip_layers
+                    mask=mask
                 )
+            else:
+                # Get original batch size
+                orig_batch = x.shape[0]
+                total_batch = orig_batch * num_cond
+                
+                # Batched processing - prepare inputs by repeating interleaved
+                # For each input sample, we'll create num_cond versions in sequence
+                
+                # Handle x: reshape as [total_batch, seq_len, feat_dim]
+                x_batched = x.repeat_interleave(num_cond, dim=0)
+                
+                # Handle speaker ID: reshape as [total_batch]
+                spk_batched = spk_id.repeat_interleave(num_cond, dim=0)
+                
+                # Handle f0 and rms: reshape as [total_batch, seq_len]
+                f0_batched = f0.repeat_interleave(num_cond, dim=0)
+                rms_batched = rms.repeat_interleave(num_cond, dim=0)
+                
+                # Create batched cvec, handling bad_cvec if needed
+                if ds_cfg_strength > 1e-5 and spk_cfg_strength > 1e-5:
+                    # Need to create interleaved: [cvec, bad_cvec, cvec] for each original batch item
+                    cvec_expanded = []
+                    for i in range(orig_batch):
+                        cvec_expanded.append(cvec[i:i+1])  # Regular
+                        cvec_expanded.append(bad_cvec[i:i+1])  # Bad cvec
+                        cvec_expanded.append(cvec[i:i+1])  # Regular (for null spk)
+                    cvec_batched = torch.cat(cvec_expanded, dim=0)
+                elif ds_cfg_strength > 1e-5:
+                    # Interleave: [cvec, bad_cvec] for each original batch item
+                    cvec_list = []
+                    for i in range(orig_batch):
+                        cvec_list.append(cvec[i:i+1])
+                        cvec_list.append(bad_cvec[i:i+1])
+                    cvec_batched = torch.cat(cvec_list, dim=0)
+                elif spk_cfg_strength > 1e-5:
+                    # Interleave: [cvec, cvec] for each original batch item
+                    cvec_batched = cvec.repeat_interleave(num_cond, dim=0)
+                
+                if isinstance(t, torch.Tensor) and t.ndim > 0:
+                    t_batched = t.repeat_interleave(num_cond, dim=0)
+                else:
+                    t_batched = t  # It's a scalar, handled by the transformer
+                
+                # Handle mask if exists
+                mask_batched = mask.repeat_interleave(num_cond, dim=0) if exists(mask) else None
+                
+                # Create drop_speaker flag tensor - only activate for the appropriate indices
+                drop_speaker_batched = torch.zeros(total_batch, dtype=torch.bool, device=x.device)
+                
+                if spk_cfg_strength > 1e-5:
+                    # Set drop_speaker=True for the third condition of each original batch item
+                    if ds_cfg_strength > 1e-5:
+                        # Pattern is [False, False, True] repeated
+                        for i in range(orig_batch):
+                            drop_speaker_batched[i*num_cond + 2] = True
+                    else:
+                        # Pattern is [False, True] repeated
+                        for i in range(orig_batch):
+                            drop_speaker_batched[i*num_cond + 1] = True
+                
+                # Single batched forward pass
+                preds_batched = self.transformer(
+                    x=x_batched,
+                    spk=spk_batched,
+                    f0=f0_batched,
+                    rms=rms_batched,
+                    cvec=cvec_batched,
+                    time=t_batched,
+                    mask=mask_batched,
+                    drop_speaker=drop_speaker_batched
+                )
+                
+                # Reshape and extract the predictions for each condition
+                # First, reshape the predictions to [orig_batch, num_cond, seq_len, feat_dim]
+                predictions = []
+                
+                # Extract predictions for each original batch item
+                for b in range(orig_batch):
+                    batch_predictions = []
+                    for c in range(num_cond):
+                        idx = b * num_cond + c
+                        batch_predictions.append(preds_batched[idx:idx+1])
+                    predictions.append(batch_predictions)
+                
+                # Apply classifier-free guidance per original batch item
+                pred_results = []
+                for b in range(orig_batch):
+                    pred = predictions[b][0]  # Regular prediction
+                    
+                    cond_idx = 1
+                    if ds_cfg_strength > 1e-5:
+                        bad_cvec_pred = predictions[b][cond_idx]
+                        pred = pred + (pred - bad_cvec_pred) * ds_cfg_strength
+                        cond_idx += 1
+                    
+                    if spk_cfg_strength > 1e-5:
+                        null_spk_pred = predictions[b][cond_idx]
+                        pred = pred + (pred - null_spk_pred) * spk_cfg_strength
+                    
+                    pred_results.append(pred)
+                
+                # Combine back to original batch dimension
+                pred = torch.cat(pred_results, dim=0)
+
+            cfg_flag = (ds_cfg_strength > 1e-5) or (skip_cfg_strength > 1e-5) or (spk_cfg_strength > 1e-5)
+            if cfg_rescale > 1e-5 and cfg_flag:
+                std_pred = pred.std()
 
-                pred = pred + (pred - bad_cvec_pred) * ds_cfg_strength
-            
             if skip_cfg_strength > 1e-5:
                 skip_pred = self.transformer(
                     x=x, 
@@ -125,20 +229,6 @@ class RF(nn.Module):
                 )
 
                 pred = pred + (pred - skip_pred) * skip_cfg_strength
-            
-            if spk_cfg_strength > 1e-5:
-                null_spk_pred = self.transformer(
-                    x=x, 
-                    spk=spk_id, 
-                    f0=f0, 
-                    rms=rms, 
-                    cvec=cvec, 
-                    time=t, 
-                    mask=mask,
-                    drop_speaker=True
-                )
-
-                pred = pred + (pred - null_spk_pred) * spk_cfg_strength
 
             if cfg_rescale > 1e-5 and cfg_flag:
                 std_cfg = pred.std()