Update app.py

app.py

@@ -1,69 +1,461 @@
+import os
+import spaces
 import gradio as gr
+import torch
+import torchaudio
+import librosa
+from modules.commons import build_model, load_checkpoint, recursive_munch
+import yaml
+from hf_utils import load_custom_model_from_hf
+import numpy as np
+from pydub import AudioSegment
 
-# 画像とMP3の情報
-image_data = {
-    "sikokumetan": {
-        "webp": "default/sikokumetan.webp",
-        "mp3": "default/sikokumetan.mp3"
-    }
+# Load model and configuration
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+dit_checkpoint_path, dit_config_path = load_custom_model_from_hf("Plachta/Seed-VC",
+                                                "DiT_seed_v2_uvit_whisper_small_wavenet_bigvgan_pruned.pth",
+                                                "config_dit_mel_seed_uvit_whisper_small_wavenet.yml")
+# dit_checkpoint_path = "E:/DiT_epoch_00018_step_801000.pth"
+# dit_config_path = "configs/config_dit_mel_seed_uvit_whisper_small_encoder_wavenet.yml"
+config = yaml.safe_load(open(dit_config_path, 'r'))
+model_params = recursive_munch(config['model_params'])
+model = build_model(model_params, stage='DiT')
+hop_length = config['preprocess_params']['spect_params']['hop_length']
+sr = config['preprocess_params']['sr']
+
+# Load checkpoints
+model, _, _, _ = load_checkpoint(model, None, dit_checkpoint_path,
+                                 load_only_params=True, ignore_modules=[], is_distributed=False)
+for key in model:
+    model[key].eval()
+    model[key].to(device)
+model.cfm.estimator.setup_caches(max_batch_size=1, max_seq_length=8192)
+
+# Load additional modules
+from modules.campplus.DTDNN import CAMPPlus
+
+campplus_ckpt_path = load_custom_model_from_hf("funasr/campplus", "campplus_cn_common.bin", config_filename=None)
+campplus_model = CAMPPlus(feat_dim=80, embedding_size=192)
+campplus_model.load_state_dict(torch.load(campplus_ckpt_path, map_location="cpu"))
+campplus_model.eval()
+campplus_model.to(device)
+
+from modules.bigvgan import bigvgan
+
+bigvgan_model = bigvgan.BigVGAN.from_pretrained('nvidia/bigvgan_v2_22khz_80band_256x', use_cuda_kernel=False)
+
+# remove weight norm in the model and set to eval mode
+bigvgan_model.remove_weight_norm()
+bigvgan_model = bigvgan_model.eval().to(device)
+
+ckpt_path, config_path = load_custom_model_from_hf("Plachta/FAcodec", 'pytorch_model.bin', 'config.yml')
+
+codec_config = yaml.safe_load(open(config_path))
+codec_model_params = recursive_munch(codec_config['model_params'])
+codec_encoder = build_model(codec_model_params, stage="codec")
+
+ckpt_params = torch.load(ckpt_path, map_location="cpu")
+
+for key in codec_encoder:
+    codec_encoder[key].load_state_dict(ckpt_params[key], strict=False)
+_ = [codec_encoder[key].eval() for key in codec_encoder]
+_ = [codec_encoder[key].to(device) for key in codec_encoder]
+
+# whisper
+from transformers import AutoFeatureExtractor, WhisperModel
+
+whisper_name = model_params.speech_tokenizer.whisper_name if hasattr(model_params.speech_tokenizer,
+                                                                     'whisper_name') else "openai/whisper-small"
+whisper_model = WhisperModel.from_pretrained(whisper_name, torch_dtype=torch.float16).to(device)
+del whisper_model.decoder
+whisper_feature_extractor = AutoFeatureExtractor.from_pretrained(whisper_name)
+
+# Generate mel spectrograms
+mel_fn_args = {
+    "n_fft": config['preprocess_params']['spect_params']['n_fft'],
+    "win_size": config['preprocess_params']['spect_params']['win_length'],
+    "hop_size": config['preprocess_params']['spect_params']['hop_length'],
+    "num_mels": config['preprocess_params']['spect_params']['n_mels'],
+    "sampling_rate": sr,
+    "fmin": 0,
+    "fmax": None,
+    "center": False
 }
+from modules.audio import mel_spectrogram
+
+to_mel = lambda x: mel_spectrogram(x, **mel_fn_args)
+
+# f0 conditioned model
+dit_checkpoint_path, dit_config_path = load_custom_model_from_hf("Plachta/Seed-VC",
+                                                "DiT_seed_v2_uvit_whisper_base_f0_44k_bigvgan_pruned_ft_ema.pth",
+                                                "config_dit_mel_seed_uvit_whisper_base_f0_44k.yml")
+
+config = yaml.safe_load(open(dit_config_path, 'r'))
+model_params = recursive_munch(config['model_params'])
+model_f0 = build_model(model_params, stage='DiT')
+hop_length = config['preprocess_params']['spect_params']['hop_length']
+sr = config['preprocess_params']['sr']
+
+# Load checkpoints
+model_f0, _, _, _ = load_checkpoint(model_f0, None, dit_checkpoint_path,
+                                 load_only_params=True, ignore_modules=[], is_distributed=False)
+for key in model_f0:
+    model_f0[key].eval()
+    model_f0[key].to(device)
+model_f0.cfm.estimator.setup_caches(max_batch_size=1, max_seq_length=8192)
+
+# f0 extractor
+from modules.rmvpe import RMVPE
+
+model_path = load_custom_model_from_hf("lj1995/VoiceConversionWebUI", "rmvpe.pt", None)
+rmvpe = RMVPE(model_path, is_half=False, device=device)
+
+mel_fn_args_f0 = {
+    "n_fft": config['preprocess_params']['spect_params']['n_fft'],
+    "win_size": config['preprocess_params']['spect_params']['win_length'],
+    "hop_size": config['preprocess_params']['spect_params']['hop_length'],
+    "num_mels": config['preprocess_params']['spect_params']['n_mels'],
+    "sampling_rate": sr,
+    "fmin": 0,
+    "fmax": None,
+    "center": False
+}
+to_mel_f0 = lambda x: mel_spectrogram(x, **mel_fn_args_f0)
+bigvgan_44k_model = bigvgan.BigVGAN.from_pretrained('nvidia/bigvgan_v2_44khz_128band_512x', use_cuda_kernel=False)
+
+# remove weight norm in the model and set to eval mode
+bigvgan_44k_model.remove_weight_norm()
+bigvgan_44k_model = bigvgan_44k_model.eval().to(device)
+
+def adjust_f0_semitones(f0_sequence, n_semitones):
+    factor = 2 ** (n_semitones / 12)
+    return f0_sequence * factor
+
+def crossfade(chunk1, chunk2, overlap):
+    fade_out = np.cos(np.linspace(0, np.pi / 2, overlap)) ** 2
+    fade_in = np.cos(np.linspace(np.pi / 2, 0, overlap)) ** 2
+    chunk2[:overlap] = chunk2[:overlap] * fade_in + chunk1[-overlap:] * fade_out
+    return chunk2
+
+# streaming and chunk processing related params
+bitrate = "320k"
+overlap_frame_len = 16
+@spaces.GPU
+@torch.no_grad()
+@torch.inference_mode()
+def voice_conversion(source, target, diffusion_steps, length_adjust, inference_cfg_rate, f0_condition, auto_f0_adjust, pitch_shift):
+    inference_module = model if not f0_condition else model_f0
+    mel_fn = to_mel if not f0_condition else to_mel_f0
+    bigvgan_fn = bigvgan_model if not f0_condition else bigvgan_44k_model
+    sr = 22050 if not f0_condition else 44100
+    hop_length = 256 if not f0_condition else 512
+    max_context_window = sr // hop_length * 30
+    overlap_wave_len = overlap_frame_len * hop_length
+    # Load audio
+    source_audio = librosa.load(source, sr=sr)[0]
+    ref_audio = librosa.load(target, sr=sr)[0]
+
+    # Process audio
+    source_audio = torch.tensor(source_audio).unsqueeze(0).float().to(device)
+    ref_audio = torch.tensor(ref_audio[:sr * 25]).unsqueeze(0).float().to(device)
+
+    # Resample
+    ref_waves_16k = torchaudio.functional.resample(ref_audio, sr, 16000)
+    converted_waves_16k = torchaudio.functional.resample(source_audio, sr, 16000)
+    # if source audio less than 30 seconds, whisper can handle in one forward
+    if converted_waves_16k.size(-1) <= 16000 * 30:
+        alt_inputs = whisper_feature_extractor([converted_waves_16k.squeeze(0).cpu().numpy()],
+                                               return_tensors="pt",
+                                               return_attention_mask=True,
+                                               sampling_rate=16000)
+        alt_input_features = whisper_model._mask_input_features(
+            alt_inputs.input_features, attention_mask=alt_inputs.attention_mask).to(device)
+        alt_outputs = whisper_model.encoder(
+            alt_input_features.to(whisper_model.encoder.dtype),
+            head_mask=None,
+            output_attentions=False,
+            output_hidden_states=False,
+            return_dict=True,
+        )
+        S_alt = alt_outputs.last_hidden_state.to(torch.float32)
+        S_alt = S_alt[:, :converted_waves_16k.size(-1) // 320 + 1]
+    else:
+        overlapping_time = 5  # 5 seconds
+        S_alt_list = []
+        buffer = None
+        traversed_time = 0
+        while traversed_time < converted_waves_16k.size(-1):
+            if buffer is None:  # first chunk
+                chunk = converted_waves_16k[:, traversed_time:traversed_time + 16000 * 30]
+            else:
+                chunk = torch.cat([buffer, converted_waves_16k[:, traversed_time:traversed_time + 16000 * (30 - overlapping_time)]], dim=-1)
+            alt_inputs = whisper_feature_extractor([chunk.squeeze(0).cpu().numpy()],
+                                                   return_tensors="pt",
+                                                   return_attention_mask=True,
+                                                   sampling_rate=16000)
+            alt_input_features = whisper_model._mask_input_features(
+                alt_inputs.input_features, attention_mask=alt_inputs.attention_mask).to(device)
+            alt_outputs = whisper_model.encoder(
+                alt_input_features.to(whisper_model.encoder.dtype),
+                head_mask=None,
+                output_attentions=False,
+                output_hidden_states=False,
+                return_dict=True,
+            )
+            S_alt = alt_outputs.last_hidden_state.to(torch.float32)
+            S_alt = S_alt[:, :chunk.size(-1) // 320 + 1]
+            if traversed_time == 0:
+                S_alt_list.append(S_alt)
+            else:
+                S_alt_list.append(S_alt[:, 50 * overlapping_time:])
+            buffer = chunk[:, -16000 * overlapping_time:]
+            traversed_time += 30 * 16000 if traversed_time == 0 else chunk.size(-1) - 16000 * overlapping_time
+        S_alt = torch.cat(S_alt_list, dim=1)
+
+    ori_waves_16k = torchaudio.functional.resample(ref_audio, sr, 16000)
+    ori_inputs = whisper_feature_extractor([ori_waves_16k.squeeze(0).cpu().numpy()],
+                                           return_tensors="pt",
+                                           return_attention_mask=True)
+    ori_input_features = whisper_model._mask_input_features(
+        ori_inputs.input_features, attention_mask=ori_inputs.attention_mask).to(device)
+    with torch.no_grad():
+        ori_outputs = whisper_model.encoder(
+            ori_input_features.to(whisper_model.encoder.dtype),
+            head_mask=None,
+            output_attentions=False,
+            output_hidden_states=False,
+            return_dict=True,
+        )
+    S_ori = ori_outputs.last_hidden_state.to(torch.float32)
+    S_ori = S_ori[:, :ori_waves_16k.size(-1) // 320 + 1]
 
-def on_image_select(image_name):
-    # 画像が選択されたとき、対応するMP3ファイルを返す
-    return image_data[image_name]["mp3"]
+    mel = mel_fn(source_audio.to(device).float())
+    mel2 = mel_fn(ref_audio.to(device).float())
 
-def voice_conversion(source_audio, reference_audio, steps, length_adjustment, cfg, use_f0_model, auto_f0, pitch_shift):
-    # 音声変換のロジック（仮の関数）
-    pass
+    target_lengths = torch.LongTensor([int(mel.size(2) * length_adjust)]).to(mel.device)
+    target2_lengths = torch.LongTensor([mel2.size(2)]).to(mel2.device)
 
-if __name__ == "__main__":
-    description = ("Zero-shot音声変換モデル（学習不要）。ローカルでの利用方法は[GitHubリポジトリ](https://github.com/Plachtaa/seed-vc)をご覧ください。"
-                   "参考音声が25秒を超える場合、自動的に25秒にクリップされます。"
-                   "また、元音声と参考音声の合計時間が30秒を超える場合、元音声は分割処理されます。")
+    feat2 = torchaudio.compliance.kaldi.fbank(ref_waves_16k,
+                                              num_mel_bins=80,
+                                              dither=0,
+                                              sample_frequency=16000)
+    feat2 = feat2 - feat2.mean(dim=0, keepdim=True)
+    style2 = campplus_model(feat2.unsqueeze(0))
+
+    if f0_condition:
+        F0_ori = rmvpe.infer_from_audio(ref_waves_16k[0], thred=0.5)
+        F0_alt = rmvpe.infer_from_audio(converted_waves_16k[0], thred=0.5)
+
+        F0_ori = torch.from_numpy(F0_ori).to(device)[None]
+        F0_alt = torch.from_numpy(F0_alt).to(device)[None]
+
+        voiced_F0_ori = F0_ori[F0_ori > 1]
+        voiced_F0_alt = F0_alt[F0_alt > 1]
+
+        log_f0_alt = torch.log(F0_alt + 1e-5)
+        voiced_log_f0_ori = torch.log(voiced_F0_ori + 1e-5)
+        voiced_log_f0_alt = torch.log(voiced_F0_alt + 1e-5)
+        median_log_f0_ori = torch.median(voiced_log_f0_ori)
+        median_log_f0_alt = torch.median(voiced_log_f0_alt)
+
+        # shift alt log f0 level to ori log f0 level
+        shifted_log_f0_alt = log_f0_alt.clone()
+        if auto_f0_adjust:
+            shifted_log_f0_alt[F0_alt > 1] = log_f0_alt[F0_alt > 1] - median_log_f0_alt + median_log_f0_ori
+        shifted_f0_alt = torch.exp(shifted_log_f0_alt)
+        if pitch_shift != 0:
+            shifted_f0_alt[F0_alt > 1] = adjust_f0_semitones(shifted_f0_alt[F0_alt > 1], pitch_shift)
+    else:
+        F0_ori = None
+        F0_alt = None
+        shifted_f0_alt = None
+
+    # Length regulation
+    cond, _, codes, commitment_loss, codebook_loss = inference_module.length_regulator(S_alt, ylens=target_lengths, n_quantizers=3, f0=shifted_f0_alt)
+    prompt_condition, _, codes, commitment_loss, codebook_loss = inference_module.length_regulator(S_ori, ylens=target2_lengths, n_quantizers=3, f0=F0_ori)
+
+    max_source_window = max_context_window - mel2.size(2)
+    # split source condition (cond) into chunks
+    processed_frames = 0
+    generated_wave_chunks = []
+    # generate chunk by chunk and stream the output
+    while processed_frames < cond.size(1):
+        chunk_cond = cond[:, processed_frames:processed_frames + max_source_window]
+        is_last_chunk = processed_frames + max_source_window >= cond.size(1)
+        cat_condition = torch.cat([prompt_condition, chunk_cond], dim=1)
+        with torch.autocast(device_type='cuda', dtype=torch.float16):
+            # Voice Conversion
+            vc_target = inference_module.cfm.inference(cat_condition,
+                                                       torch.LongTensor([cat_condition.size(1)]).to(mel2.device),
+                                                       mel2, style2, None, diffusion_steps,
+                                                       inference_cfg_rate=inference_cfg_rate)
+            vc_target = vc_target[:, :, mel2.size(-1):]
+        vc_wave = bigvgan_fn(vc_target.float())[0]
+        if processed_frames == 0:
+            if is_last_chunk:
+                output_wave = vc_wave[0].cpu().numpy()
+                generated_wave_chunks.append(output_wave)
+                output_wave = (output_wave * 32768.0).astype(np.int16)
+                mp3_bytes = AudioSegment(
+                    output_wave.tobytes(), frame_rate=sr,
+                    sample_width=output_wave.dtype.itemsize, channels=1
+                ).export(format="mp3", bitrate=bitrate).read()
+                yield mp3_bytes, (sr, np.concatenate(generated_wave_chunks))
+                break
+            output_wave = vc_wave[0, :-overlap_wave_len].cpu().numpy()
+            generated_wave_chunks.append(output_wave)
+            previous_chunk = vc_wave[0, -overlap_wave_len:]
+            processed_frames += vc_target.size(2) - overlap_frame_len
+            output_wave = (output_wave * 32768.0).astype(np.int16)
+            mp3_bytes = AudioSegment(
+                output_wave.tobytes(), frame_rate=sr,
+                sample_width=output_wave.dtype.itemsize, channels=1
+            ).export(format="mp3", bitrate=bitrate).read()
+            yield mp3_bytes, None
+        elif is_last_chunk:
+            output_wave = crossfade(previous_chunk.cpu().numpy(), vc_wave[0].cpu().numpy(), overlap_wave_len)
+            generated_wave_chunks.append(output_wave)
+            processed_frames += vc_target.size(2) - overlap_frame_len
+            output_wave = (output_wave * 32768.0).astype(np.int16)
+            mp3_bytes = AudioSegment(
+                output_wave.tobytes(), frame_rate=sr,
+                sample_width=output_wave.dtype.itemsize, channels=1
+            ).export(format="mp3", bitrate=bitrate).read()
+            yield mp3_bytes, (sr, np.concatenate(generated_wave_chunks))
+            break
+        else:
+            output_wave = crossfade(previous_chunk.cpu().numpy(), vc_wave[0, :-overlap_wave_len].cpu().numpy(), overlap_wave_len)
+            generated_wave_chunks.append(output_wave)
+            previous_chunk = vc_wave[0, -overlap_wave_len:]
+            processed_frames += vc_target.size(2) - overlap_frame_len
+            output_wave = (output_wave * 32768.0).astype(np.int16)
+            mp3_bytes = AudioSegment(
+                output_wave.tobytes(), frame_rate=sr,
+                sample_width=output_wave.dtype.itemsize, channels=1
+            ).export(format="mp3", bitrate=bitrate).read()
+            yield mp3_bytes, None
+
+
+import gradio as gr
+from g4f.client import Client
+import markdown2  # より豊富なマークダウン対応
+import base64
+from io import BytesIO
+import json
+
+client = Client()
+
+def format_output(text):
+    """
+    チャットGPTスタイルのマークダウン形式に対応するためのフォーマット関数
+    """
+    return markdown2.markdown(text, extras=[
+        "fenced-code-blocks",
+        "tables",
+        "task_list",
+        "strike",
+        "spoiler",
+        "markdown-in-html"
+    ])
+
+def image_to_data_url(image):
+    """
+    画像をBase64形式のdataURLに変換する関数
+    """
+    buffered = BytesIO()
+    image.save(buffered, format="PNG")
+    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return f"data:image/png;base64,{img_str}"
+
+def respond(message, history, system_message, max_tokens, temperature, top_p, model_choice, web_search, image=None):
+    # システムメッセージを先頭に追加
+    messages = [{"role": "system", "content": system_message}]
+    
+    # これまでの会話履歴を追加
+    for user_msg, assistant_msg in history:
+        if user_msg:
+            messages.append({"role": "user", "content": user_msg})
+        if assistant_msg:
+            messages.append({"role": "assistant", "content": assistant_msg})
+    
+    # 今回のユーザーメッセージを追加
+    if image:
+        message += f"\n![image]({image})"  # 画像をマークダウンで追加
+    messages.append({"role": "user", "content": message})
+    
+    # API 呼び出し
+    response = client.chat.completions.create(
+        model=model_choice,
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        top_p=top_p,
+        web_search=web_search
+    )
+    
+    formatted_response = format_output(response.choices[0].message.content)
+    return formatted_response
+
+def chat(message, history, system_message, max_tokens, temperature, top_p, model_choice, web_search, image):
+    if message.strip() == "" and not image:
+        return "", history, history
+    if image:
+        image_data_url = image_to_data_url(image)
+    else:
+        image_data_url = None
+    
+    print("メッセージ送信直後の履歴:")
+    print(json.dumps(history, ensure_ascii=False, indent=2))  # メッセージ送信前の履歴をJSONで表示
+    
+    response = respond(message, history, system_message, max_tokens, temperature, top_p, model_choice, web_search, image_data_url)
+    history = history + [(message, response)]
+    
+    print("AIの回答直後の履歴:")
+    print(json.dumps(history, ensure_ascii=False, indent=2))  # AIの回答後の履歴をJSONで表示
+    
+    # 入力欄をクリアして、更新済みのチャット履歴と状態を返す
+    return "", history, history
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        # 左側のカラム：入力欄と各オプションを配置
+        with gr.Column():
+            # オプション（システムメッセージや各種パラメータ）
+            system_message = gr.Textbox(
+                value="あなたは日本語しか話せません。あなたは最新の医療支援AIです。薬の紹介、薬の提案、薬の作成など、さまざまなタスクに答えます。また、新しい薬を開発する際は、既存のものに頼らずに画期的なアイデアを出します。",
+                label="システムメッセージ"
+            )
+            max_tokens = gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="トークン制限")
+            temperature = gr.Slider(minimum=0.1, maximum=4.0, value=2, step=0.1, label="Temperature (数値が大きいほど様々な回答をします。)")
+            top_p = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p (nucleus sampling) (数値が低いと回答候補が上位のみになります。)")
+            model_choice = gr.Radio(choices=["gpt-4o-mini", "o3-mini"], value="gpt-4o-mini", label="モデル選択")
+            web_search = gr.Checkbox(value=True, label="WEB検索")
+            
+            # チャット入力欄と送信ボタン
+            chatbot_input = gr.Textbox(show_label=False, placeholder="ここにメッセージを入力してください...", lines=2)
+            image_input = gr.Image(type="pil", label="画像をアップロード", visible=False)  # 画像アップロード
+            submit_btn = gr.Button("送信")
+        
+        # 右側のカラム：チャットの履歴を表示
+        with gr.Column():
+            chat_history_display = gr.Chatbot(label="チャット履歴")
+    
+    # 会話の状態（履歴）を保持する State コンポーネント
+    state = gr.State([])
+
+    # 送信ボタン押下時の挙動
+    submit_btn.click(
+        chat,
+        inputs=[chatbot_input, state, system_message, max_tokens, temperature, top_p, model_choice, web_search, image_input],
+        outputs=[chatbot_input, chat_history_display, state]
+    )
     
-    # 入力欄の定義
-    inputs = [
-        gr.Audio(type="filepath", label="元音声"),
-        gr.Audio(type="filepath", label="参考音声"),
-        gr.Slider(minimum=1, maximum=200, value=10, step=1, label="拡散ステップ数", info="デフォルトは10、50～100が最適な品質"),
-        gr.Slider(minimum=0.5, maximum=2.0, step=0.1, value=1.0, label="長さ調整", info="1.0未満で速度を上げ、1.0以上で速度を遅くします"),
-        gr.Slider(minimum=0.0, maximum=1.0, step=0.1, value=0.7, label="推論CFG率", info="わずかな影響があります"),
-        gr.Checkbox(label="F0条件付きモデルを使用", value=False, info="歌声変換には必須です"),
-        gr.Checkbox(label="F0自動調整", value=True, info="F0をおおよそ調整して目標音声に合わせます。F0条件付きモデル使用時にのみ有効です"),
-        gr.Slider(label='音程変換', minimum=-24, maximum=24, step=1, value=0, info="半音単位の音程変換。F0条件付きモデル使用時にのみ有効です"),
-    ]
-
-    examples = [["examples/source/yae_0.wav", "examples/reference/dingzhen_0.wav", 25, 1.0, 0.7, False, True, 0],
-                ["examples/source/jay_0.wav", "examples/reference/azuma_0.wav", 25, 1.0, 0.7, True, True, 0],
-                ["examples/source/Wiz Khalifa,Charlie Puth - See You Again [vocals]_[cut_28sec].wav",
-                 "examples/reference/teio_0.wav", 100, 1.0, 0.7, True, False, 0],
-                ["examples/source/TECHNOPOLIS - 2085 [vocals]_[cut_14sec].wav",
-                 "examples/reference/trump_0.wav", 50, 1.0, 0.7, True, False, -12],
-                ]
-
-    outputs = [gr.Audio(label="ストリーム出力音声", streaming=True, format='mp3'),
-               gr.Audio(label="完全出力音声", streaming=False, format='wav')]
-
-    # ギャラリーに渡す画像のパスリスト
-    gallery_images = [image_data["sikokumetan"]["webp"]]  # 画像のファイルパスを直接渡す
-
-    # ギャラリーを追加
-    gallery = gr.Gallery(
-        value=gallery_images,
-        label="選択した画像に基づく参考音声",
-        elem_id="image_gallery",
-        interactive=True,
-        grid=2  # 画像を2列に並べる
+    # エンターキーでの送信にも対応
+    chatbot_input.submit(
+        chat,
+        inputs=[chatbot_input, state, system_message, max_tokens, temperature, top_p, model_choice, web_search, image_input],
+        outputs=[chatbot_input, chat_history_display, state]
     )
 
-    # ギャラリーの選択時にMP3ファイルを更新する処理
-    gallery.change(fn=on_image_select, inputs=gallery, outputs=inputs[1])  # 参考音声を更新
-
-    gr.Interface(fn=voice_conversion,
-                 description=description,
-                 inputs=inputs,
-                 outputs=outputs,
-                 title="Seed Voice Conversion",
-                 examples=examples,
-                 cache_examples=False,
-                 ).launch()
+demo.launch()