Upload 2 files

app.py

@@ -1,76 +1,150 @@
-import gradio as gr
-import torch
+from flask import Flask, render_template, request, jsonify
+import sys
 import os
+import gzip
+import shutil
+import warnings
+from huggingface_hub import hf_hub_download
 from predictor import load_models, predict_text
 
-# モデルの読み込み
-print("=== モデル読み込み開始 ===")
-try:
-    load_models()
-    print("✅ モデルの読み込みが完了しました")
-except Exception as e:
-    print(f"❌ モデルの読み込みに失敗しました: {e}")
-    print("⚠️  モデルファイルが存在しない可能性があります")
+# 警告を抑制
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", message="Distant resource does not have an ETag")
 
-def predict_age_gender(text):
-    """年代・性別予測関数"""
-    if not text.strip():
-        return "テキストを入力してください。", "", ""
-    
+# ETagチェックを無効にする環境変数を設定
+os.environ['HF_HUB_DISABLE_TELEMETRY'] = '1'
+os.environ['TRANSFORMERS_OFFLINE'] = '0'
+
+app = Flask(__name__)
+
+def download_and_extract_models():
+    """Hugging Face Hubからモデルをダウンロードして展開"""
     try:
-        result = predict_text(text)
+        print("=== モデルダウンロード開始 ===")
+        
+        # リポジトリ名（あなたのユーザー名に変更してください）
+        repo_name = "vola2004/bert-japanese-age-gender"  # ここを変更してください
+        
+        # モデルファイルをダウンロード
+        model_files = [
+            "bert_age_model.bin",
+            "bert_gender_model.bin"
+        ]
+        
+        for model_file in model_files:
+            if not os.path.exists(model_file):
+                print(f"📥 {model_file} をダウンロード中...")
+                try:
+                    hf_hub_download(
+                        repo_id=repo_name,
+                        filename=model_file,
+                        local_dir=".",
+                        force_download=True,
+                        resume_download=False
+                    )
+                    print(f"✅ {model_file} のダウンロードが完了しました")
+                except Exception as download_error:
+                    print(f"❌ {model_file} のダウンロードに失敗: {download_error}")
+                    return False
+            else:
+                print(f"✅ {model_file} は既に存在します")
+
+        return True
+        
+    except Exception as e:
+        print(f"❌ ダウンロードエラー: {e}")
+        return False
+
+# モデルのダウンロード、展開、読み込み
+print("=== アプリケーション初期化 ===")
+
+# モデルをダウンロード・展開
+if download_and_extract_models():
+    # モデルの読み込み
+    print("=== モデル読み込み開始 ===")
+    try:
+        load_models()
+        print("✅ モデルの読み込みが完了しました")
+    except Exception as e:
+        print(f"❌ モデルの読み込みに失敗しました: {e}")
+        print("⚠️  モデルファイルが存在しない可能性があります")
+        print("⚠️  予測機能は利用できません")
+else:
+    print("❌ モデルのダウンロード・展開に失敗しました")
+    print("⚠️  予測機能は利用できません")
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        # POSTリクエストの場合は予測処理を実行
+        try:
+            text = request.form.get('text', '')
+            
+            print(f"=== 予測リクエスト受信 ===", flush=True)
+            print(f"入力テキスト: '{text}'", flush=True)
+            sys.stdout.flush()
+            
+            if not text.strip():
+                print("⚠️  空のテキストが入力されました", flush=True)
+                sys.stdout.flush()
+                return render_template('index.html', 
+                                     input_text=text,
+                                     error='テキストを入力してください。')
+            
+            # 予測実行
+            result = predict_text(text)
+            
+            print(f"✅ 予測完了: {result}", flush=True)
+            sys.stdout.flush()
+            
+            return render_template('index.html', 
+                                 input_text=text,
+                                 result=result)
+            
+        except Exception as e:
+            print(f"❌ 予測エラー: {e}", flush=True)
+            sys.stdout.flush()
+            return render_template('index.html', 
+                                 input_text=text,
+                                 error=str(e))
+    else:
+        # GETリクエストの場合は通常のページ表示
+        return render_template('index.html')
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    try:
+        data = request.get_json()
+        text = data.get('text', '')
         
-        # 年代予測結果を整形
-        age_results = []
-        for age, percentage in result['age_percentages'].items():
-            age_results.append(f"{age}: {percentage}%")
-        age_text = "\n".join(age_results)
+        print(f"=== 予測リクエスト受信 ===", flush=True)
+        print(f"入力テキスト: '{text}'", flush=True)
+        sys.stdout.flush()
         
-        # 性別予測結果を整形
-        gender_results = []
-        for gender, percentage in result['gender_percentages'].items():
-            gender_results.append(f"{gender}: {percentage}%")
-        gender_text = "\n".join(gender_results)
+        if not text.strip():
+            print("⚠️  空のテキストが入力されました", flush=True)
+            sys.stdout.flush()
+            return jsonify({
+                'error': 'テキストを入力してください。'
+            })
         
-        # 最も高い確率の年代を特定
-        max_age = max(result['age_percentages'].items(), key=lambda x: x[1])
-        max_gender = max(result['gender_percentages'].items(), key=lambda x: x[1])
+        # 予測実行
+        result = predict_text(text)
         
-        summary = f"推定結果: {max_age[0]} ({max_age[1]}%), {max_gender[0]} ({max_gender[1]}%)"
+        print(f"✅ 予測完了: {result}", flush=True)
+        sys.stdout.flush()
         
-        return summary, age_text, gender_text
+        return jsonify({
+            'age_percentages': result['age_percentages'],
+            'gender_percentages': result['gender_percentages']
+        })
         
     except Exception as e:
-        return f"エラーが発生しました: {str(e)}", "", ""
-
-# Gradioインターフェース
-interface = gr.Interface(
-    fn=predict_age_gender,
-    inputs=gr.Textbox(
-        label="日本語テキストを入力してください",
-        placeholder="例: 今日はとても良い天気ですね。友達と一緒に散歩をしました。",
-        lines=3
-    ),
-    outputs=[
-        gr.Textbox(label="推定結果サマリー"),
-        gr.Textbox(label="年代予測詳細"),
-        gr.Textbox(label="性別予測詳細")
-    ],
-    title="🧠 年代・性別推定システム",
-    description="日本語テキストから年代と性別を推定するAIシステムです。",
-    examples=[
-        "今日はとても良い天気ですね。",
-        "友達と一緒に散歩をしました。",
-        "新しいスマートフォンを買いました。",
-        "仕事が忙しくて疲れました。"
-    ],
-    theme=gr.themes.Soft()
-)
+        print(f"❌ 予測エラー: {e}", flush=True)
+        sys.stdout.flush()
+        return jsonify({'error': str(e)})
 
-# アプリケーション起動
-if __name__ == "__main__":
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False  # Hugging Face SpacesではFalse
-    )
+if __name__ == '__main__':
+    # 環境変数でデバッグモードを制御（デフォルトはFalse）
+    debug_mode = os.environ.get('FLASK_DEBUG', 'False').lower() == 'true'
+    app.run(debug=debug_mode, host='0.0.0.0', port=5002)

predictor.py

@@ -2,11 +2,44 @@ import torch
 import torch.nn.functional as F
 import os
 from transformers import BertJapaneseTokenizer
+import warnings
+warnings.filterwarnings("ignore")
+warnings.filterwarnings("ignore", message="Distant resource does not have an ETag")
+warnings.filterwarnings("ignore", category=UserWarning)
 
 # 年代モデルと性別モデルの定義をインポート
-from SupervisedLearning import BertForAgeClassification, PRE_TRAINED_MODEL_NAME, DEVICE, NUM_AGE_CLASSIFIERS, AGE_CATEGORIES
+from SupervisedLearning import BertForAgeClassification, DEVICE, NUM_AGE_CLASSIFIERS, AGE_CATEGORIES
 from GenderLearning import BertForGenderClassification, NUM_GENDER_LABELS
 
+# 統合モデル用のクラス定義
+class BertForClassification(torch.nn.Module):
+    """統合分類モデル（年代と性別を同時に分類）"""
+    def __init__(self, model_name, num_classes):
+        super().__init__()
+        from transformers import BertModel
+        
+        if model_name is None:
+            self.bert = BertModel.from_pretrained('cl-tohoku/bert-large-japanese', use_safetensors=True)
+        else:
+            self.bert = BertModel.from_pretrained(model_name, use_safetensors=True)
+        
+        self.dropout = torch.nn.Dropout(0.3)
+        self.classifier = torch.nn.Linear(self.bert.config.hidden_size, num_classes)
+    
+    def forward(self, input_ids, attention_mask, labels=None):
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        pooled_output = outputs.pooler_output
+        pooled_output = self.dropout(pooled_output)
+        
+        logits = self.classifier(pooled_output)
+        
+        loss = None
+        if labels is not None:
+            loss_fct = torch.nn.CrossEntropyLoss()
+            loss = loss_fct(logits, labels)
+        
+        return loss, logits
+
 # モデルファイルのパス
 AGE_MODEL_PATH = 'bert_age_model.bin'
 GENDER_MODEL_PATH = 'bert_gender_model.bin'
@@ -19,131 +52,310 @@ GENDER_CATEGORIES_JP = ["男性", "女性"]
 TOKENIZER = None
 AGE_MODEL = None
 GENDER_MODEL = None
+MODELS_LOADED = False  # モデル読み込み状態を追跡
 
-def load_models():
-    """アプリケーション起動時にモデルを一度だけ読み込む"""
-    global TOKENIZER, AGE_MODEL, GENDER_MODEL
+def load_shared_tokenizer():
+    """共有トークナイザーを読み込む"""
+    global TOKENIZER
+    
+    if TOKENIZER is not None:
+        return  # 既に読み込み済み
+    
+    print("🔧 共有トークナイザーの読み込みを開始します...")
+    
+    # 共有トークナイザー読み込み戦略（Largeモデル用）
+    tokenizer_loaded = False
+    tokenizer_models = ['cl-tohoku/bert-large-japanese', 'cl-tohoku/bert-base-japanese-v3']
+    
+    for model_name in tokenizer_models:
+        if tokenizer_loaded:
+            break
+            
+        print(f"共有トークナイザー読み込み試行: {model_name}")
+        
+        # 戦略1: オンラインモード
+        try:
+            print(f"オンラインモードでトークナイザーを読み込み中... ({model_name})")
+            TOKENIZER = BertJapaneseTokenizer.from_pretrained(
+                model_name,
+                use_fast=False,
+                force_download=False,
+                resume_download=True
+            )
+            print(f"✅ オンラインモードでトークナイザーの読み込みが完了しました ({model_name})")
+            tokenizer_loaded = True
+            
+        except Exception as e:
+            print(f"オンラインモード失敗 ({model_name}): {e}")
+            
+            # 戦略2: オフラインモード
+            try:
+                print(f"オフラインモードでトークナイザーを読み込み中... ({model_name})")
+                os.environ['TRANSFORMERS_OFFLINE'] = '1'
+                TOKENIZER = BertJapaneseTokenizer.from_pretrained(
+                    model_name,
+                    local_files_only=True,
+                    use_fast=False
+                )
+                print(f"✅ オフラインモードでトークナイザーの読み込みが完了しました ({model_name})")
+                tokenizer_loaded = True
+                
+            except Exception as e2:
+                print(f"オフラインモード失敗 ({model_name}): {e2}")
+    
+    if not tokenizer_loaded:
+        raise Exception("共有トークナイザーの読み込みに失敗しました")
+
+def load_age_model():
+    """年代予測用モデルを読み込む"""
+    global TOKENIZER, AGE_MODEL
     
     # モデルファイルの存在確認
     if not os.path.exists(AGE_MODEL_PATH):
         raise FileNotFoundError(f"エラー: 年代学習済みモデル '{AGE_MODEL_PATH}' が見つかりません。")
     
-    # 性別モデルはまだ学習されていない可能性があるので、警告のみ表示
-    if not os.path.exists(GENDER_MODEL_PATH):
-        print(f"警告: 性別学習済みモデル '{GENDER_MODEL_PATH}' が���つかりません。")
-        print("性別予測は利用できません。年代予測のみ実行されます。")
-
-    print("--- モデルの読み込みを開始します ---")
-    TOKENIZER = BertJapaneseTokenizer.from_pretrained(PRE_TRAINED_MODEL_NAME)
+    print("--- 年代モデルの読み込みを開始します ---")
     
-    # 年代モデルの読み込み
-    print("  年代モデルを読み込み中...")
-    AGE_MODEL = BertForAgeClassification(PRE_TRAINED_MODEL_NAME, NUM_AGE_CLASSIFIERS)
+    # 共有トークナイザーの読み込み
+    load_shared_tokenizer()
+    
+    # 年代モデルの読み込み（bert-large-japanese を使用）
+    print("📊 年代モデルの読み込みを開始します...")
+    age_model_loaded = False
+    
+    # 戦略1: bert-large-japanese で試行（学習時と同じ）
     try:
-        if torch.__version__.startswith('1.'):
-            AGE_MODEL.load_state_dict(torch.load(AGE_MODEL_PATH, map_location=DEVICE))
-        else:
-            AGE_MODEL.load_state_dict(torch.load(AGE_MODEL_PATH, map_location=DEVICE, weights_only=True))
+        print("年代モデル: bert-large-japanese で試行中...")
+        AGE_MODEL = BertForAgeClassification('cl-tohoku/bert-large-japanese', NUM_AGE_CLASSIFIERS)
+        AGE_MODEL.load_state_dict(torch.load(AGE_MODEL_PATH, map_location=DEVICE))
+        AGE_MODEL.to(DEVICE)
+        AGE_MODEL.eval()
+        print("✅ 年代モデル（bert-large-japanese）の読み込みが完了しました")
+        age_model_loaded = True
     except Exception as e:
-        print(f"年代モデルの読み込み中にエラーが発生しました: {e}")
-        raise
-    AGE_MODEL.to(DEVICE)
-    AGE_MODEL.eval()
-    
-    # 性別モデルの読み込み（存在する場合のみ）
-    if os.path.exists(GENDER_MODEL_PATH):
-        print("  性別モデルを読み込み中...")
-        GENDER_MODEL = BertForGenderClassification(PRE_TRAINED_MODEL_NAME, NUM_GENDER_LABELS)
+        print(f"年代モデル（bert-large-japanese）失敗: {e}")
+        
+        # 戦略2: bert-base-japanese-v3 で試行
         try:
-            if torch.__version__.startswith('1.'):
-                GENDER_MODEL.load_state_dict(torch.load(GENDER_MODEL_PATH, map_location=DEVICE))
-            else:
-                GENDER_MODEL.load_state_dict(torch.load(GENDER_MODEL_PATH, map_location=DEVICE, weights_only=True))
-        except Exception as e:
-            print(f"性別モデルの読み込み中にエラーが発生しました: {e}")
-            raise
+            print("年代モデル: bert-base-japanese-v3 で試行中...")
+            AGE_MODEL = BertForAgeClassification('cl-tohoku/bert-base-japanese-v3', NUM_AGE_CLASSIFIERS)
+            AGE_MODEL.load_state_dict(torch.load(AGE_MODEL_PATH, map_location=DEVICE))
+            AGE_MODEL.to(DEVICE)
+            AGE_MODEL.eval()
+            print("✅ 年代モデル（bert-base-japanese-v3）の読み込みが完了しました")
+            age_model_loaded = True
+        except Exception as e2:
+            print(f"年代モデル（bert-base-japanese-v3）も失敗: {e2}")
+    
+    if not age_model_loaded:
+        raise Exception("年代モデルの読み込みに失敗しました")
+    
+    print("🎉 年代モデルの読み込みが完了しました！")
+
+def load_gender_model():
+    """性別予測用モデルを読み込む"""
+    global TOKENIZER, GENDER_MODEL
+    
+    # 統合モデルファイルの存在確認
+    classification_model_path = 'bert_classification_model.bin'
+    if not os.path.exists(classification_model_path):
+        print(f"警告: 統合学習済みモデル '{classification_model_path}' が見つかりません。")
+        print("性別予測は利用できません。")
+        return
+    
+    print("--- 性別モデルの読み込みを開始します（統合モデル使用） ---")
+    
+    # 共有トークナイザーの読み込み
+    load_shared_tokenizer()
+    
+    # 統合モデルの読み込み（bert-large-japanese を使用）
+    print("👥 性別モデルの読み込みを開始します（統合モデル）...")
+    gender_model_loaded = False
+    
+    # 戦略1: bert-large-japanese で試行（統合モデルはLarge）
+    try:
+        print("性別モデル: bert-large-japanese で試行中（統合モデル）...")
+        GENDER_MODEL = BertForClassification('cl-tohoku/bert-large-japanese', 12)  # 12クラス分類
+        GENDER_MODEL.load_state_dict(torch.load(classification_model_path, map_location=DEVICE))
         GENDER_MODEL.to(DEVICE)
         GENDER_MODEL.eval()
-    else:
+        print("✅ 性別モデル（統合モデル）の読み込みが完了しました")
+        gender_model_loaded = True
+    except Exception as e:
+        print(f"性別モデル（統合モデル）失敗: {e}")
+        
+        # 戦略2: bert-base-japanese-v3 で試行
+        try:
+            print("性別モデル: bert-base-japanese-v3 で試行中（統合モデル）...")
+            GENDER_MODEL = BertForClassification('cl-tohoku/bert-base-japanese-v3', 12)  # 12クラス分類
+            GENDER_MODEL.load_state_dict(torch.load(classification_model_path, map_location=DEVICE))
+            GENDER_MODEL.to(DEVICE)
+            GENDER_MODEL.eval()
+            print("✅ 性別モデル（統合モデル）の読み込みが完了しました")
+            gender_model_loaded = True
+        except Exception as e2:
+            print(f"性別モデル（統合モデル）も失敗: {e2}")
+    
+    if not gender_model_loaded:
+        print("❌ 性別モデルの読み込みに失敗しました")
+        print("⚠️  性別予測は利用できません")
         GENDER_MODEL = None
+    else:
+        print("🎉 性別モデル（統合モデル）の読み込みが完了しました！")
+
+def load_models():
+    """アプリケーション起動時にモデルを一度だけ読み込む（後方互換性のため）"""
+    global MODELS_LOADED
+    
+    # 既に読み込み済みの場合はスキップ
+    if MODELS_LOADED:
+        print("✅ モデルは既に読み込み済みです。スキップします。")
+        return
     
-    print("--- モデルの読み込みが完了しました ---")
+    # 年代モデルと性別モデルを個別に読み込み
+    load_age_model()
+    load_gender_model()
+    
+    MODELS_LOADED = True  # 読み込み完了フラグを設定
 
+def predict_age(text):
+    """テキストから年代を予測（統合関数を使用）"""
+    # 統合予測を実行
+    full_result = predict_text(text)
+    return full_result['age_percentages']
 
-def predict_text(text: str):
-    """
-    入力されたテキストから「年代」と「性別」の各ラベルのパーセンテージを返す関数
-    """
-    if AGE_MODEL is None or TOKENIZER is None:
-        load_models()
+def predict_gender(text):
+    """テキストから性別を予測（統合関数を使用）"""
+    # 統合予測を実行
+    full_result = predict_text(text)
+    return full_result['gender_percentages']
 
-    print(f"DEBUG: 入力テキスト: '{text}'")
+def predict_text(text):
+    """テキストから年代と性別を統合予測"""
+    global TOKENIZER, AGE_MODEL, GENDER_MODEL
+    
+    # モデルが読み込まれていない場合は読み込み
+    if AGE_MODEL is None:
+        load_age_model()
+    if GENDER_MODEL is None:
+        load_gender_model()
+    
+    if TOKENIZER is None or AGE_MODEL is None or GENDER_MODEL is None:
+        raise Exception("モデルが読み込まれていません。")
     
     # テキストの前処理
-    encoding = TOKENIZER.encode_plus(
+    if not text or not text.strip():
+        raise ValueError("テキストが空です。")
+    
+    # トークン化（一度だけ実行）
+    inputs = TOKENIZER.encode_plus(
         text,
         add_special_tokens=True,
         max_length=128,
-        return_token_type_ids=False,
         padding='max_length',
         truncation=True,
-        return_attention_mask=True,
-        return_tensors='pt',
+        return_tensors='pt'
     )
-    input_ids = encoding['input_ids'].to(DEVICE)
-    attention_mask = encoding['attention_mask'].to(DEVICE)
     
-    print(f"DEBUG: input_ids shape: {input_ids.shape}")
-    print(f"DEBUG: attention_mask shape: {attention_mask.shape}")
-
-    # 年代の予測
+    # デバイスに移動
+    input_ids = inputs['input_ids'].to(DEVICE)
+    attention_mask = inputs['attention_mask'].to(DEVICE)
+    
+    # 年代と性別を同時に予測
     with torch.no_grad():
-        _, age_logits = AGE_MODEL(input_ids=input_ids, attention_mask=attention_mask)
-    
-    print(f"DEBUG: age_logits shape: {age_logits.shape}")
-    print(f"DEBUG: age_logits values: {age_logits}")
-    
-    # 各年代の二値分類の確率（シグモイド関数）
-    age_probs = torch.sigmoid(age_logits)[0]  # shape: (6,)
-    print(f"DEBUG: age_probs shape: {age_probs.shape}")
-    print(f"DEBUG: age_probs values: {age_probs}")
-    
-    # 年代の確率を辞書形式で保存
-    age_percentages = {}
-    for i, age in enumerate(AGE_CATEGORIES):
-        percentage = float(f"{age_probs[i].item() * 100:.2f}")  # 小数第2位まで
-        age_percentages[age] = percentage
-        print(f"DEBUG: {age}: {age_probs[i].item()} -> {percentage}%")
-
-    # 性別の予測（モデルが存在する場合のみ）
-    if GENDER_MODEL is not None:
-        with torch.no_grad():
-            _, gender_logits = GENDER_MODEL(input_ids=input_ids, attention_mask=attention_mask)
-        
-        print(f"DEBUG: gender_logits shape: {gender_logits.shape}")
-        print(f"DEBUG: gender_logits values: {gender_logits}")
+        # 年代予測
+        age_output = AGE_MODEL(input_ids, attention_mask)
+        if isinstance(age_output, tuple):
+            age_logits = age_output[1]
+        else:
+            age_logits = age_output
+        age_probs = torch.sigmoid(age_logits)
+        age_probs = age_probs.cpu().numpy().flatten()
         
-        # 性別の確率（Softmax関数）
-        gender_probs = F.softmax(gender_logits, dim=1)[0]  # shape: (2,)
-        print(f"DEBUG: gender_probs shape: {gender_probs.shape}")
-        print(f"DEBUG: gender_probs values: {gender_probs}")
+        # 性別予測（統合モデルから性別部分を抽出）
+        classification_output = GENDER_MODEL(input_ids, attention_mask)
+        if isinstance(classification_output, tuple):
+            all_logits = classification_output[1]
+        else:
+            all_logits = classification_output
         
-        # 性別の確率を辞書形式で保存
-        gender_percentages = {}
-        for i, gender_jp in enumerate(GENDER_CATEGORIES_JP):
-            percentage = float(f"{gender_probs[i].item() * 100:.2f}")  # 小数第2位まで
-            gender_percentages[gender_jp] = percentage
-            print(f"DEBUG: {gender_jp}: {gender_probs[i].item()} -> {percentage}%")
-    else:
-        # 性別モデルが存在しない場合はデフォルト値を設定
-        gender_percentages = {"男性": 50.0, "女性": 50.0}
-        print("DEBUG: 性別モデルが存在しないため、デフォルト値を設定しました")
-
-    # 結果を返す
-    results = {
-        "age_percentages": age_percentages,
-        "gender_percentages": gender_percentages
+        # 統合モデルの12クラス出力から性別部分（最後の2クラス）を抽出
+        gender_logits = all_logits[:, -2:]
+        gender_probs = torch.softmax(gender_logits, dim=1)
+        gender_probs = gender_probs.cpu().numpy().flatten()
+    
+    # 結果の整形
+    age_result = {}
+    for i, category in enumerate(AGE_CATEGORIES):
+        age_result[category] = float(age_probs[i] * 100)
+    
+    gender_result = {}
+    for i, category in enumerate(GENDER_CATEGORIES_JP):
+        gender_result[category] = float(gender_probs[i] * 100)
+    
+    result = {
+        'age_percentages': age_result,
+        'gender_percentages': gender_result
     }
     
-    print(f"DEBUG: 最終結果: {results}")
-    return results
+    return result
+
+def get_top_predictions(result, top_k=3):
+    """予測結果から上位k個を取得"""
+    # 年代の上位予測
+    age_sorted = sorted(result['age_percentages'].items(), key=lambda x: x[1], reverse=True)
+    top_ages = age_sorted[:top_k]
+    
+    # 性別の上位予測
+    gender_sorted = sorted(result['gender_percentages'].items(), key=lambda x: x[1], reverse=True)
+    top_genders = gender_sorted[:top_k]
+    
+    return {
+        'top_ages': top_ages,
+        'top_genders': top_genders
+    }
+
+def format_prediction_result(result):
+    """予測結果を読みやすい形式に整形"""
+    formatted = "=== 予測結果 ===\n"
+    
+    # 年代予測結果
+    formatted += "\n📊 年代予測:\n"
+    for age, percentage in sorted(result['age_percentages'].items(), key=lambda x: x[1], reverse=True):
+        formatted += f"  {age}: {percentage:.1f}%\n"
+    
+    # 性別予測結果
+    formatted += "\n👥 性別予測:\n"
+    for gender, percentage in sorted(result['gender_percentages'].items(), key=lambda x: x[1], reverse=True):
+        formatted += f"  {gender}: {percentage:.1f}%\n"
+    
+    return formatted
+
+# テスト用の関数
+def test_prediction():
+    """予測機能のテスト（統合予測）"""
+    test_text = "こんにちは、今日は良い天気ですね。"
+    print(f"テストテキスト: {test_text}")
+    
+    try:
+        result = predict_text(test_text)
+        print(format_prediction_result(result))
+        
+        # 個別予測もテスト
+        print("\n=== 個別予測テスト ===")
+        age_result = predict_age(test_text)
+        print(f"年代予測: {age_result}")
+        
+        gender_result = predict_gender(test_text)
+        print(f"性別予測: {gender_result}")
+        
+    except Exception as e:
+        print(f"予測エラー: {e}")
+
+if __name__ == "__main__":
+    # モデルの読み込みテスト
+    try:
+        load_models()
+        test_prediction()
+    except Exception as e:
+        print(f"エラー: {e}")