Run on CPU

app.py

@@ -53,7 +53,6 @@ def tts(text,
         random_seed):
     
     torch.manual_seed(random_seed)
-    torch.cuda.manual_seed(random_seed)
     np.random.seed(random_seed)
 
     text_len = len(text)
@@ -63,12 +62,12 @@ def tts(text,
     else:
         text = text_to_sequence(str(text), ["english_cleaners2"])
         
-        token = add_blank_token(text).unsqueeze(0).cuda()
-        token_length = torch.LongTensor([token.size(-1)]).cuda() 
+        token = add_blank_token(text).unsqueeze(0)
+        token_length = torch.LongTensor([token.size(-1)])
 
         # Prompt load
         # sample_rate, audio = prompt
-        # audio = torch.FloatTensor([audio]).cuda()
+        # audio = torch.FloatTensor([audio])
         # if audio.shape[0] != 1:
         #     audio = audio[:1,:] 
         # audio = audio / 32768 
@@ -89,28 +88,28 @@ def tts(text,
         # If you have a memory issue during denosing the prompt, try to denoise the prompt with cpu before TTS 
         # We will have a plan to replace a memory-efficient denoiser 
         if denoise == 0:
-            audio = torch.cat([audio.cuda(), audio.cuda()], dim=0)
+            audio = torch.cat([audio, audio], dim=0)
         else:
             with torch.no_grad():
                 
                 if ori_prompt_len > 80000:
                     denoised_audio = []
                     for i in range((ori_prompt_len//80000)):
-                        denoised_audio.append(denoise(audio.squeeze(0).cuda()[i*80000:(i+1)*80000], denoiser, hps_denoiser))
+                        denoised_audio.append(denoise(audio.squeeze(0)[i*80000:(i+1)*80000], denoiser, hps_denoiser))
                     
-                    denoised_audio.append(denoise(audio.squeeze(0).cuda()[(i+1)*80000:], denoiser, hps_denoiser))
+                    denoised_audio.append(denoise(audio.squeeze(0)[(i+1)*80000:], denoiser, hps_denoiser))
                     denoised_audio = torch.cat(denoised_audio, dim=1)
                 else:
-                    denoised_audio = denoise(audio.squeeze(0).cuda(), denoiser, hps_denoiser)
+                    denoised_audio = denoise(audio.squeeze(0), denoiser, hps_denoiser)
 
-            audio = torch.cat([audio.cuda(), denoised_audio[:,:audio.shape[-1]]], dim=0)
+            audio = torch.cat([audio, denoised_audio[:,:audio.shape[-1]]], dim=0)
 
         audio = audio[:,:ori_prompt_len]  # 20231108 We found that large size of padding decreases a performance so we remove the paddings after denosing.
 
         if audio.shape[-1]<48000:
             audio = torch.cat([audio,audio,audio,audio,audio], dim=1)
 
-        src_mel = mel_fn(audio.cuda())
+        src_mel = mel_fn(audio)
 
         src_length = torch.LongTensor([src_mel.size(2)]).to(device)
         src_length2 = torch.cat([src_length,src_length], dim=0)
@@ -120,9 +119,9 @@ def tts(text,
             w2v_x, pitch = text2w2v.infer_noise_control(token, token_length, src_mel, src_length2, 
                                                         noise_scale=ttv_temperature, noise_scale_w=duratuion_temperature, 
                                                         length_scale=duratuion_length, denoise_ratio=denoise_ratio)
-            src_length = torch.LongTensor([w2v_x.size(2)]).cuda()  
+            src_length = torch.LongTensor([w2v_x.size(2)])  
         
-            pitch[pitch<torch.log(torch.tensor([55]).cuda())]  = 0
+            pitch[pitch<torch.log(torch.tensor([55]))]  = 0
 
             ## Hierarchical Speech Synthesizer (W2V, F0 --> 16k Audio)
             converted_audio = \
@@ -165,7 +164,7 @@ def main():
     a = parser.parse_args()
 
     global device, hps, hps_t2w2v,h_sr,h_sr48, hps_denoiser
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    device = 'cpu'
 
     hps = utils.get_hparams_from_file(os.path.join(os.path.split(a.ckpt)[0], 'config.json'))
     hps_t2w2v = utils.get_hparams_from_file(os.path.join(os.path.split(a.ckpt_text2w2v)[0], 'config.json'))
@@ -184,27 +183,27 @@ def main():
         f_max=hps.data.mel_fmax,
         n_mels=hps.data.n_mel_channels,
         window_fn=torch.hann_window
-    ).cuda()  
+    )  
 
     net_g = SynthesizerTrn(hps.data.filter_length // 2 + 1,
         hps.train.segment_size // hps.data.hop_length,
-        **hps.model).cuda()
+        **hps.model)
     net_g.load_state_dict(torch.load(a.ckpt))
     _ = net_g.eval()
 
     text2w2v = Text2W2V(hps.data.filter_length // 2 + 1,
     hps.train.segment_size // hps.data.hop_length,
-    **hps_t2w2v.model).cuda()
+    **hps_t2w2v.model)
     text2w2v.load_state_dict(torch.load(a.ckpt_text2w2v))
     text2w2v.eval()
   
     speechsr = SpeechSR48(h_sr48.data.n_mel_channels,
         h_sr48.train.segment_size // h_sr48.data.hop_length,
-        **h_sr48.model).cuda()
+        **h_sr48.model)
     utils.load_checkpoint(a.ckpt_sr48, speechsr, None)
     speechsr.eval()
            
-    denoiser = MPNet(hps_denoiser).cuda()
+    denoiser = MPNet(hps_denoiser)
     state_dict = load_checkpoint(a.denoiser_ckpt, device)
     denoiser.load_state_dict(state_dict['generator'])
     denoiser.eval()
@@ -219,7 +218,7 @@ def main():
                                gr.Slider(0,1,0), 
                                gr.Slider(0,9999,1111)],
                      outputs = 'audio', 
-                     title = 'HierSpeech++',
+                     title = 'HierSpeech++ (CPU)',
                      description  =  '''<div>
                             <p style="text-align: left"> HierSpeech++ is a zero-shot speech synthesis model.</p>
                             <p style="text-align: left"> Our model is trained with LibriTTS dataset so this model only supports english. We will release a multi-lingual HierSpeech++ soon.</p>