.

app.py

@@ -6,6 +6,8 @@ from enum import Enum, auto
 import torch
 from transformers import AutoTokenizer, pipeline
 import spaces
+import concurrent.futures
+import time
 
 # ロガーの設定
 logging.basicConfig(
@@ -160,32 +162,152 @@ def classify_text_api(model_id, text):
         logger.error(f"Error in API classification with {model_id}: {str(e)}")
         return f"Error: {str(e)}"
 
+@spaces.GPU
+def parallel_text_generation(model_paths, texts):
+    """複数のローカルモデルを一度のGPU割り当てで実行するための最適化関数"""
+    try:
+        logger.info(f"Running parallel text generation for {len(model_paths)} models")
+        results = {}
+        
+        # 各モデルのパイプラインが既にロードされている前提で実行
+        for i, (model_path, text) in enumerate(zip(model_paths, texts)):
+            try:
+                logger.info(f"Processing model {i+1}/{len(model_paths)}: {model_path}")
+                outputs = pipelines[model_path](
+                    text,
+                    max_new_tokens=40,
+                    do_sample=False,
+                    num_return_sequences=1
+                )
+                results[model_path] = outputs[0]["generated_text"]
+            except Exception as e:
+                logger.error(f"Error in text generation with {model_path}: {str(e)}")
+                results[model_path] = f"Error: {str(e)}"
+        
+        return results
+    except Exception as e:
+        logger.error(f"Error in parallel text generation: {str(e)}")
+        return {model_path: f"Error: {str(e)}" for model_path in model_paths}
+
+@spaces.GPU
+def parallel_text_classification(model_paths, texts):
+    """複数のローカル分類モデルを一度のGPU割り当てで実行するための最適化関数"""
+    try:
+        logger.info(f"Running parallel text classification for {len(model_paths)} models")
+        results = {}
+        
+        # 各モデルのパイプラインが既にロードされている前提で実行
+        for i, (model_path, text) in enumerate(zip(model_paths, texts)):
+            try:
+                logger.info(f"Processing classification model {i+1}/{len(model_paths)}: {model_path}")
+                result = pipelines[model_path](text)
+                results[model_path] = str(result)
+            except Exception as e:
+                logger.error(f"Error in classification with {model_path}: {str(e)}")
+                results[model_path] = f"Error: {str(e)}"
+        
+        return results
+    except Exception as e:
+        logger.error(f"Error in parallel text classification: {str(e)}")
+        return {model_path: f"Error: {str(e)}" for model_path in model_paths}
+
 # Invokeボタンのハンドラ
 def handle_invoke(text, selected_types):
-    """Invokeボタンのハンドラ"""
-    results = []
+    """Invokeボタンのハンドラ - 並列処理版"""
+    start_time = time.time()
+    logger.info("Starting parallel model execution")
     
-    # テキスト生成モデルの実行
-    for model in TEXT_GENERATION_MODELS:
+    # 結果を格納する配列（順番を保持するため、最初に空の配列を作成）
+    results = [""] * (len(TEXT_GENERATION_MODELS) + len(CLASSIFICATION_MODELS))
+    
+    # ローカルの生成モデルを一括処理するための準備
+    local_gen_models = []
+    local_gen_texts = []
+    local_gen_indices = []
+    
+    # ローカルの分類モデルを一括処理するための準備
+    local_cls_models = []
+    local_cls_texts = []
+    local_cls_indices = []
+    
+    # APIモデルとその他のタスク
+    api_tasks = []
+    
+    # テキスト生成モデルの分類
+    for i, model in enumerate(TEXT_GENERATION_MODELS):
         if model["type"] in selected_types:
             if model["type"] == LOCAL:
-                result = generate_text_local(model["model_path"], text)
+                local_gen_models.append(model["model_path"])
+                local_gen_texts.append(text)
+                local_gen_indices.append(i)
             else:  # api
-                result = generate_text_api(model["model_id"], text)
-            results.append(f"{model['name']}: {result}")
+                api_tasks.append((i, model, "gen_api"))
     
-    # 分類モデルの実行
-    for model in CLASSIFICATION_MODELS:
+    # 分類モデルの分類
+    for i, model in enumerate(CLASSIFICATION_MODELS):
+        idx = i + len(TEXT_GENERATION_MODELS)
         if model["type"] in selected_types:
             if model["type"] == LOCAL:
-                result = classify_text_local(model["model_path"], text)
+                local_cls_models.append(model["model_path"])
+                local_cls_texts.append(text)
+                local_cls_indices.append(idx)
             else:  # api
+                api_tasks.append((idx, model, "cls_api"))
+    
+    # APIタスクを処理する関数
+    def process_api_task(task_data):
+        idx, model, task_type = task_data
+        try:
+            if task_type == "gen_api":
+                result = generate_text_api(model["model_id"], text)
+                return idx, f"{model['name']}: {result}"
+            elif task_type == "cls_api":
                 result = classify_text_api(model["model_id"], text)
-            results.append(f"{model['name']}: {result}")
+                return idx, f"{model['name']}: {result}"
+        except Exception as e:
+            logger.error(f"Error in {model['name']}: {str(e)}")
+            return idx, f"{model['name']}: Error - {str(e)}"
+    
+    # API処理を並列実行
+    futures = []
+    if api_tasks:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=len(api_tasks)) as executor:
+            futures = [executor.submit(process_api_task, task) for task in api_tasks]
+    
+    # ローカル生成モデルを並列処理
+    if local_gen_models:
+        try:
+            local_gen_results = parallel_text_generation(local_gen_models, local_gen_texts)
+            for model_path, idx in zip(local_gen_models, local_gen_indices):
+                model_name = next(m["name"] for m in TEXT_GENERATION_MODELS if m["model_path"] == model_path)
+                results[idx] = f"{model_name}: {local_gen_results[model_path]}"
+        except Exception as e:
+            logger.error(f"Error in parallel text generation: {str(e)}")
+            for model_path, idx in zip(local_gen_models, local_gen_indices):
+                model_name = next(m["name"] for m in TEXT_GENERATION_MODELS if m["model_path"] == model_path)
+                results[idx] = f"{model_name}: Error - {str(e)}"
+    
+    # ローカル分類モデルを並列処理
+    if local_cls_models:
+        try:
+            local_cls_results = parallel_text_classification(local_cls_models, local_cls_texts)
+            for model_path, idx in zip(local_cls_models, local_cls_indices):
+                model_name = next(m["name"] for m in CLASSIFICATION_MODELS if m["model_path"] == model_path)
+                results[idx] = f"{model_name}: {local_cls_results[model_path]}"
+        except Exception as e:
+            logger.error(f"Error in parallel text classification: {str(e)}")
+            for model_path, idx in zip(local_cls_models, local_cls_indices):
+                model_name = next(m["name"] for m in CLASSIFICATION_MODELS if m["model_path"] == model_path)
+                results[idx] = f"{model_name}: Error - {str(e)}"
+    
+    # APIタスクの結果を収集
+    for future in concurrent.futures.as_completed(futures):
+        idx, result = future.result()
+        results[idx] = result
     
-    # 結果リストの長さを調整
-    while len(results) < len(TEXT_GENERATION_MODELS) + len(CLASSIFICATION_MODELS):
-        results.append("")
+    # 実行時間を記録
+    elapsed_time = time.time() - start_time
+    logger.info(f"Parallel model execution completed in {elapsed_time:.2f} seconds")
     
     return results