.

app.py

@@ -6,8 +6,6 @@ from enum import Enum, auto
 import torch
 from transformers import AutoTokenizer, pipeline
 import spaces
-import concurrent.futures
-import time
 
 # ロガーの設定
 logging.basicConfig(
@@ -162,152 +160,32 @@ 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ボタンのハンドラ - 並列処理版"""
-    start_time = time.time()
-    logger.info("Starting parallel model execution")
-    
-    # 結果を格納する配列（順番を保持するため、最初に空の配列を作成）
-    results = [""] * (len(TEXT_GENERATION_MODELS) + len(CLASSIFICATION_MODELS))
-    
-    # ローカルの生成モデルを一括処理するための準備
-    local_gen_models = []
-    local_gen_texts = []
-    local_gen_indices = []
+    """Invokeボタンのハンドラ"""
+    results = []
     
-    # ローカルの分類モデルを一括処理するための準備
-    local_cls_models = []
-    local_cls_texts = []
-    local_cls_indices = []
-    
-    # APIモデルとその他のタスク
-    api_tasks = []
-    
-    # テキスト生成モデルの分類
-    for i, model in enumerate(TEXT_GENERATION_MODELS):
+    # テキスト生成モデルの実行
+    for model in TEXT_GENERATION_MODELS:
         if model["type"] in selected_types:
             if model["type"] == LOCAL:
-                local_gen_models.append(model["model_path"])
-                local_gen_texts.append(text)
-                local_gen_indices.append(i)
+                result = generate_text_local(model["model_path"], text)
             else:  # api
-                api_tasks.append((i, model, "gen_api"))
+                result = generate_text_api(model["model_id"], text)
+            results.append(f"{model['name']}: {result}")
     
-    # 分類モデルの分類
-    for i, model in enumerate(CLASSIFICATION_MODELS):
-        idx = i + len(TEXT_GENERATION_MODELS)
+    # 分類モデルの実行
+    for model in CLASSIFICATION_MODELS:
         if model["type"] in selected_types:
             if model["type"] == LOCAL:
-                local_cls_models.append(model["model_path"])
-                local_cls_texts.append(text)
-                local_cls_indices.append(idx)
+                result = classify_text_local(model["model_path"], text)
             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)
-                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
+            results.append(f"{model['name']}: {result}")
     
-    # 実行時間を記録
-    elapsed_time = time.time() - start_time
-    logger.info(f"Parallel model execution completed in {elapsed_time:.2f} seconds")
+    # 結果リストの長さを調整
+    while len(results) < len(TEXT_GENERATION_MODELS) + len(CLASSIFICATION_MODELS):
+        results.append("")
     
     return results