Upload 7 files

DataNLP.py

@@ -0,0 +1,85 @@
+import pandas as pd
+from sudachipy import tokenizer, dictionary
+import neologdn
+import os # osモジュールをインポート
+
+# --- スクリプトのディレクトリを基準にパスを設定 ---
+# このスクリプト自身の絶対パスを取得
+script_dir = os.path.dirname(os.path.abspath(__file__))
+# 作業ディレクトリをこのスクリプトがあるディレクトリに変更
+os.chdir(script_dir)
+
+def load_preprocessed_data():
+    """
+    DataSet.xlsxを読み込み、前処理（欠損値除去、ラベルエンコーディング、形態素解析）を行い、
+    処理済みのDataFrameと元のデータ数を返します。
+    """
+    # --- Step 1: データ読み込み ---
+    df = pd.read_excel("DataSet.xlsx")
+    initial_count = len(df)
+
+    # --- Step 2: 欠損除去 ---
+    df = df.dropna(subset=["コメント", "性別", "年代"]).reset_index(drop=True)
+
+    # --- Step 2.5: 表記揺れ正規化 ---
+    df["コメント"] = df["コメント"].astype(str).apply(neologdn.normalize)
+
+    # --- Step 3: 年代と性別のラベルを別々に作成 ---
+    df["年代性別"] = df["年代"] + " " + df["性別"]
+
+    # 各年代ごとに二値分類ラベルを作成（その年代かどうか）
+    age_categories = ["10代", "20代", "30代", "40代", "50代", "60代"]
+    for age in age_categories:
+        df[f"{age}_label"] = (df["年代"] == age).astype(int)
+
+    # 性別ラベルのマッピング
+    gender_categories = ["male", "female"]
+    gender_label_map = {cat: idx for idx, cat in enumerate(gender_categories)}
+    df["性別_label"] = df["性別"].map(gender_label_map)
+
+    # 統合ラベルも残す（後方互換性のため）
+    combined_categories = [
+        "10代 male", "10代 female",
+        "20代 male", "20代 female",
+        "30代 male", "30代 female",
+        "40代 male", "40代 female",
+        "50代 male", "50代 female",
+        "60代 male", "60代 female"
+    ]
+    combined_label_map = {cat: idx for idx, cat in enumerate(combined_categories)}
+    df["年代性別_label"] = df["年代性別"].map(combined_label_map)
+
+    # --- Step 4: Sudachipyによる形態素解析（表層 + 品詞）---
+    tokenizer_obj = dictionary.Dictionary().create()
+    mode = tokenizer.Tokenizer.SplitMode.C
+
+    def sudachi_tokenize_with_pos(text):
+        tokens = tokenizer_obj.tokenize(text, mode)
+        return [
+            f"{m.surface()}/{m.part_of_speech()[0]}"
+            for m in tokens if m.surface().strip()
+        ]
+
+    df["tokens"] = df["コメント"].apply(sudachi_tokenize_with_pos)
+    df["text"] = df["tokens"].apply(lambda x: " ".join(x))
+
+    return df, initial_count
+
+if __name__ == '__main__':
+    df, initial_count = load_preprocessed_data()
+
+    # --- 表示 ---
+    print(f"✅ Excel内の全データ数: {initial_count} 件")
+    print(f"\n✅ 前処理後のデータ数: {len(df)} 件")
+    print("==== Sudachipyによる処理結果の一部 ====")
+
+    for i in range(min(10, len(df))):  # 先頭10件まで表示
+        print(f"\n【{i+1}件目】")
+        print(f"[原文(正規化後)] {df.loc[i, 'コメント']}")
+        print(f"[形態素+品詞] {df.loc[i, 'tokens']}")
+        print(f"[テキスト形式] {df.loc[i, 'text']}")
+        print(f"[年代性別] {df.loc[i, '年代性別']}")
+        print(f"[年代] {df.loc[i, '年代']}")
+        print(f"  10代_label: {df.loc[i, '10代_label']}, 20代_label: {df.loc[i, '20代_label']}, 30代_label: {df.loc[i, '30代_label']}")
+        print(f"  40代_label: {df.loc[i, '40代_label']}, 50代_label: {df.loc[i, '50代_label']}, 60代_label: {df.loc[i, '60代_label']}")
+        print(f"[性別] {df.loc[i, '性別']} -> [性別_label] {df.loc[i, '性別_label']}")

GenderLearning.py

@@ -0,0 +1,220 @@
+import torch
+from torch import nn
+from torch.utils.data import Dataset, DataLoader, RandomSampler
+from torch.optim import AdamW
+from transformers import BertJapaneseTokenizer, BertModel
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+import pandas as pd
+from tqdm import tqdm
+import os
+
+from DataNLP import load_preprocessed_data
+
+# --- スクリプトのディレクトリを基準にパスを設定 ---
+script_dir = os.path.dirname(os.path.abspath(__file__))
+os.chdir(script_dir)
+
+
+# 設定
+PRE_TRAINED_MODEL_NAME = 'cl-tohoku/bert-large-japanese'
+MAX_LEN = 128
+BATCH_SIZE = 32  # バッチサイズを増加して高速化
+EPOCHS = 10  # 重みを大幅に更新するためエポック数を増加
+DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+NUM_GENDER_LABELS = 2  # male, female
+
+# --- データセットクラス ---
+class GenderDataset(Dataset):
+    def __init__(self, texts, gender_labels, tokenizer, max_len):
+        self.texts = texts
+        self.gender_labels = gender_labels
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, item):
+        text = str(self.texts[item])
+        gender_label = self.gender_labels[item]
+
+        encoding = self.tokenizer.encode_plus(
+            text,
+            add_special_tokens=True,
+            max_length=self.max_len,
+            return_token_type_ids=False,
+            padding='max_length',
+            truncation=True,
+            return_attention_mask=True,
+            return_tensors='pt',
+        )
+
+        return {
+            'input_ids': encoding['input_ids'].flatten(),
+            'attention_mask': encoding['attention_mask'].flatten(),
+            'gender_labels': torch.tensor(int(gender_label), dtype=torch.long)
+        }
+
+# --- モデル定義 ---
+class BertForGenderClassification(nn.Module):
+    def __init__(self, model_name, num_gender_labels):
+        super().__init__()
+        self.bert = BertModel.from_pretrained(model_name, use_safetensors=True)
+        self.dropout = nn.Dropout(self.bert.config.hidden_dropout_prob)
+        self.gender_classifier = nn.Linear(self.bert.config.hidden_size, num_gender_labels)
+
+    def forward(self, input_ids, attention_mask, gender_labels=None):
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        pooled_output = outputs.pooler_output
+        pooled_output = self.dropout(pooled_output)
+
+        gender_logits = self.gender_classifier(pooled_output)
+
+        loss = None
+        if gender_labels is not None:
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(gender_logits, gender_labels)
+
+        return loss, gender_logits
+
+# --- 学習関数 ---
+def train_epoch(model, data_loader, optimizer, device):
+    model.train()
+    total_loss = 0
+    
+    for batch in tqdm(data_loader, desc="Training"):
+        input_ids = batch['input_ids'].to(device)
+        attention_mask = batch['attention_mask'].to(device)
+        gender_labels = batch['gender_labels'].to(device)
+
+        optimizer.zero_grad()
+        loss, _ = model(input_ids=input_ids, attention_mask=attention_mask, gender_labels=gender_labels)
+        
+        if isinstance(loss, torch.Tensor):
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+    
+    return total_loss / len(data_loader)
+
+# --- 評価関数 ---
+def eval_model(model, data_loader, device):
+    model.eval()
+    gender_preds, gender_true_labels = [], []
+    
+    with torch.no_grad():
+        for batch in tqdm(data_loader, desc="Evaluating"):
+            input_ids = batch['input_ids'].to(device)
+            attention_mask = batch['attention_mask'].to(device)
+            
+            _, gender_logits = model(input_ids=input_ids, attention_mask=attention_mask)
+            
+            gender_preds.extend(torch.argmax(gender_logits, dim=1).cpu().numpy())
+            gender_true_labels.extend(batch['gender_labels'].cpu().numpy())
+
+    gender_acc = accuracy_score(gender_true_labels, gender_preds)
+    
+    return gender_acc
+
+# --- データサンプリング関数（性別ごとにバランシング） ---
+def sample_balanced_data(df, max_per_gender=20000):
+    """
+    性別ごとにバランシングする
+    - 性別：各性別ごとに最大max_per_gender件
+    """
+    gender_sampled_dfs = []
+    for gender_label in df['性別_label'].unique():
+        subset = df[df['性別_label'] == gender_label]
+        if len(subset) > max_per_gender:
+            subset = subset.sample(max_per_gender, random_state=42)
+        gender_sampled_dfs.append(subset)
+    
+    return pd.concat(gender_sampled_dfs).sample(frac=1, random_state=42).reset_index(drop=True)
+
+# --- メイン処理 ---
+def main():
+    print("--- 1. データ読み込み ---")
+    df, _ = load_preprocessed_data()
+
+    # --- データを性別でバランシ��グして軽量化 ---
+    df = sample_balanced_data(df, max_per_gender=5000)  # データ量を大幅に増加
+
+    # ラベルの分布を確認
+    print("\n性別ラベルの分布:")
+    print(df['性別_label'].value_counts().sort_index())
+    print(f"\n合計データ数: {len(df)} 件")
+    
+    # 訓練用と検証用に分割
+    train_df, val_df = train_test_split(df, test_size=0.2, random_state=42)
+
+    print(f"\n--- 2. トークナイザとデータローダーの準備 ---")
+    tokenizer = BertJapaneseTokenizer.from_pretrained(PRE_TRAINED_MODEL_NAME)
+    
+    train_dataset = GenderDataset(
+        train_df['text'].values,
+        train_df['性別_label'].values,
+        tokenizer,
+        MAX_LEN
+    )
+    train_sampler = RandomSampler(train_dataset)
+    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, sampler=train_sampler)
+
+    val_dataset = GenderDataset(
+        val_df['text'].values,
+        val_df['性別_label'].values,
+        tokenizer,
+        MAX_LEN
+    )
+    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE)
+    print("\n--- 3. モデルのセットアップ ---")
+    model = BertForGenderClassification(PRE_TRAINED_MODEL_NAME, NUM_GENDER_LABELS)
+    model.to(DEVICE)
+    # BERT全体をファインチューニング（レイヤーごとに異なる学習率を設定）
+    optimizer = AdamW([
+        {'params': model.bert.parameters(), 'lr': 2e-5},  # BERT本体は小さい学習率
+        {'params': model.gender_classifier.parameters(), 'lr': 5e-4},  # 分類層は大きい学習率
+    ])
+
+    print("\n--- 4. 学習開始 ---")
+    print(f"デバイス: {DEVICE}")
+    print(f"訓練データ数: {len(train_df)} 件")
+    print(f"検証データ数: {len(val_df)} 件")
+    print(f"バッチサイズ: {BATCH_SIZE}")
+    print(f"エポック数: {EPOCHS}")
+    print(f"推定学習時間: 約35時間")
+    
+    import time
+    start_time = time.time()
+    
+    for epoch in range(EPOCHS):
+        epoch_start_time = time.time()
+        print(f"\n{'='*60}")
+        print(f"Epoch {epoch + 1}/{EPOCHS} 開始")
+        print(f"{'='*60}")
+        
+        train_loss = train_epoch(model, train_loader, optimizer, DEVICE)
+        print(f"Train Loss (Gender): {train_loss:.4f}")
+
+        gender_acc = eval_model(model, val_loader, DEVICE)
+        print(f"Gender Validation Accuracy: {gender_acc:.4f} ({gender_acc*100:.2f}%)")
+        
+        # エポックの経過時間を表示
+        epoch_time = time.time() - epoch_start_time
+        elapsed_time = time.time() - start_time
+        remaining_epochs = EPOCHS - (epoch + 1)
+        estimated_remaining_time = (elapsed_time / (epoch + 1)) * remaining_epochs
+        
+        print(f"\nエポック所要時間: {epoch_time/60:.1f}分")
+        print(f"経過時間: {elapsed_time/3600:.1f}時間")
+        print(f"推定残り時間: {estimated_remaining_time/3600:.1f}時間")
+        print(f"{'='*60}")
+
+    print("\n--- 5. 学習完了 ---")
+    torch.save(model.state_dict(), 'bert_gender_model.bin')
+    print("モデルを 'bert_gender_model.bin' に保存しました。")
+
+
+if __name__ == '__main__':
+    main()
+

README.md

@@ -1,12 +1,43 @@
 ---
-title: Age Gender System
-emoji: 🏢
-colorFrom: gray
-colorTo: red
+title: 年代・性別推定システム
+emoji: 🧠
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
 pinned: false
+license: mit
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 年代・性別推定システム
+
+日本語テキストから年代と性別を推定するAIシステムです。BERTベースのモデルを使用して、入力されたテキストの特徴から年代（10代〜60代）と性別（男性・女性）を確率で予測します。
+
+## 機能
+
+- **年代推定**: 10代、20代、30代、40代、50代、60代の6つの年代を確率で予測
+- **性別推定**: 男性・女性を確率で予測
+- **リアルタイム予測**: Webアプリケーションでリアルタイムに予測結果を表示
+
+## 技術仕様
+
+- **ベースモデル**: cl-tohoku/bert-large-japanese
+- **フレームワーク**: PyTorch, Transformers, Gradio
+- **デプロイ**: Gradio Spaces
+
+## 使用方法
+
+1. テキストボックスに日本語のテキストを入力
+2. 「推測実行」ボタンをクリック
+3. 年代と性別の確率が表示されます
+
+## モデル詳細
+
+- **年代モデル**: 各年代を独立した二値分類器として学習
+- **性別モデル**: 2クラス分類（男性・女性）
+- **学習データ**: 日本語テキストデータセット
+- **精度**: 年代推定 約79%、性別推定 約70%
+
+## ライセンス
+
+MIT License

SupervisedLearning.py

@@ -0,0 +1,404 @@
+import torch
+from torch import nn
+from torch.utils.data import Dataset, DataLoader, RandomSampler
+from torch.optim import AdamW
+from transformers import BertJapaneseTokenizer, BertModel
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+import pandas as pd
+from tqdm import tqdm
+import os # osモジュールをインポート
+import numpy as np
+try:
+    import matplotlib
+    matplotlib.use('Agg')  # GUIバックエンドを使わない
+    import matplotlib.pyplot as plt
+    MATPLOTLIB_AVAILABLE = True
+except ImportError:
+    MATPLOTLIB_AVAILABLE = False
+    print("警告: matplotlibがインストールされていません。グラフは表示されません。")
+
+from DataNLP import load_preprocessed_data
+
+# --- スクリプトのディレクトリを基準にパスを設定 ---
+# このスクリプト自身の絶対パスを取得
+script_dir = os.path.dirname(os.path.abspath(__file__))
+# 作業ディレクトリをこのスクリプトがあるディレクトリに変更
+os.chdir(script_dir)
+
+
+# 設定
+PRE_TRAINED_MODEL_NAME = 'cl-tohoku/bert-large-japanese'
+MAX_LEN = 128
+BATCH_SIZE = 32  # バッチサイズを増加して高速化
+EPOCHS = 10  # 重みを大幅に更新するためエポック数を増加
+DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+NUM_AGE_CLASSIFIERS = 6  # 各年代ごとに二値分類器
+AGE_CATEGORIES = ["10代", "20代", "30代", "40代", "50代", "60代"]
+
+# --- データセットクラス ---
+class CustomDataset(Dataset):
+    def __init__(self, texts, age_labels_dict, tokenizer, max_len):
+        """
+        age_labels_dict: {'10代_label': array, '20代_label': array, ...}
+        """
+        self.texts = texts
+        self.age_labels_dict = age_labels_dict
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, item):
+        text = str(self.texts[item])
+
+        encoding = self.tokenizer.encode_plus(
+            text,
+            add_special_tokens=True,
+            max_length=self.max_len,
+            return_token_type_ids=False,
+            padding='max_length',
+            truncation=True,
+            return_attention_mask=True,
+            return_tensors='pt',
+        )
+
+        # 各年代の二値ラベルを取得
+        age_labels = torch.tensor([
+            int(self.age_labels_dict[f"{age}_label"][item])
+            for age in AGE_CATEGORIES
+        ], dtype=torch.float)
+
+        return {
+            'input_ids': encoding['input_ids'].flatten(),
+            'attention_mask': encoding['attention_mask'].flatten(),
+            'age_labels': age_labels,  # shape: (6,) - 各年代の二値ラベル
+        }
+
+# --- モデル定義 ---
+class BertForAgeClassification(nn.Module):
+    def __init__(self, model_name, num_age_classifiers):
+        super().__init__()
+        self.bert = BertModel.from_pretrained(model_name, use_safetensors=True)
+        self.dropout = nn.Dropout(self.bert.config.hidden_dropout_prob)
+        
+        # 各年代ごとに二値分類器を作成（6個）
+        self.age_classifiers = nn.ModuleList([
+            nn.Linear(self.bert.config.hidden_size, 1)  # 二値分類なので出力は1
+            for _ in range(num_age_classifiers)
+        ])
+
+    def forward(self, input_ids, attention_mask, age_labels=None):
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        pooled_output = outputs.pooler_output
+        pooled_output = self.dropout(pooled_output)
+
+        # 各年代の二値分類器の出力を取得
+        age_logits_list = [classifier(pooled_output) for classifier in self.age_classifiers]
+        age_logits = torch.cat(age_logits_list, dim=1)  # shape: (batch_size, 6)
+
+        loss = None
+        if age_labels is not None:
+            # 各年代の二値分類損失（BCEWithLogitsLoss）
+            bce_loss = nn.BCEWithLogitsLoss()
+            loss = bce_loss(age_logits, age_labels)
+
+        return loss, age_logits
+
+# --- 学習関数 ---
+def train_epoch(model, data_loader, optimizer, device):
+    model.train()
+    total_loss = 0
+    
+    for batch in tqdm(data_loader, desc="Training"):
+        input_ids = batch['input_ids'].to(device)
+        attention_mask = batch['attention_mask'].to(device)
+        age_labels = batch['age_labels'].to(device)
+
+        optimizer.zero_grad()
+        
+        # モデルのforward関数から出力を取得
+        loss, age_logits = model(input_ids=input_ids, attention_mask=attention_mask, age_labels=age_labels)
+        
+        if loss is not None:
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+    
+    return total_loss / len(data_loader)
+
+# --- 評価関数 ---
+def eval_model(model, data_loader, device):
+    model.eval()
+    age_preds_all = {age: [] for age in AGE_CATEGORIES}  # 各年代の予測
+    age_true_all = {age: [] for age in AGE_CATEGORIES}   # 各年代の正解
+    
+    with torch.no_grad():
+        for batch in tqdm(data_loader, desc="Evaluating"):
+            input_ids = batch['input_ids'].to(device)
+            attention_mask = batch['attention_mask'].to(device)
+            
+            _, age_logits = model(input_ids=input_ids, attention_mask=attention_mask)
+            
+            # 各年代の二値分類の予測（シグモイド関数で0-1に変換後、0.5で閾値判定）
+            age_probs = torch.sigmoid(age_logits)  # shape: (batch_size, 6)
+            age_preds_binary = (age_probs > 0.5).cpu().numpy()  # shape: (batch_size, 6)
+            age_true_binary = batch['age_labels'].cpu().numpy()  # shape: (batch_size, 6)
+            
+            # 各年代ごとに予測と正解を保存
+            for i, age in enumerate(AGE_CATEGORIES):
+                age_preds_all[age].extend(age_preds_binary[:, i])
+                age_true_all[age].extend(age_true_binary[:, i])
+            
+
+    # 各年代の精度を計算
+    age_accuracies = {}
+    for age in AGE_CATEGORIES:
+        age_accuracies[age] = accuracy_score(age_true_all[age], age_preds_all[age])
+    
+    return age_accuracies
+
+# --- 学習曲線表示関数 ---
+def plot_training_curves(train_losses, val_accuracies):
+    """
+    学習曲線（Loss CurveとAccuracy Curve）を表示する
+    """
+    if not MATPLOTLIB_AVAILABLE:
+        print("matplotlibが利用できないため、グラフを表示できません。")
+        return
+    
+    epochs = range(1, len(train_losses) + 1)
+    
+    # 2つのサブプロットを作成
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
+    
+    # Loss Curve
+    ax1.plot(epochs, train_losses, 'b-', label='Training Loss', linewidth=2)
+    ax1.set_title('Training Loss Curve', fontsize=14, fontweight='bold')
+    ax1.set_xlabel('Epoch')
+    ax1.set_ylabel('Loss')
+    ax1.grid(True, alpha=0.3)
+    ax1.legend()
+    
+    # Accuracy Curve
+    colors = ['red', 'blue', 'green', 'orange', 'purple', 'brown']
+    for i, age in enumerate(AGE_CATEGORIES):
+        ax2.plot(epochs, val_accuracies[age], color=colors[i], 
+                label=f'{age} Accuracy', linewidth=2, marker='o', markersize=4)
+    
+    ax2.set_title('Validation Accuracy Curves', fontsize=14, fontweight='bold')
+    ax2.set_xlabel('Epoch')
+    ax2.set_ylabel('Accuracy')
+    ax2.set_ylim(0, 1)
+    ax2.grid(True, alpha=0.3)
+    ax2.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+    
+    plt.tight_layout()
+    plt.savefig('age_training_curves.png', dpi=300, bbox_inches='tight')
+    plt.show()
+    
+    # 最終的な精度を表示
+    print("\n=== 最終的な検証精度 ===")
+    for age in AGE_CATEGORIES:
+        final_acc = val_accuracies[age][-1]
+        print(f"{age}: {final_acc:.4f} ({final_acc*100:.2f}%)")
+    
+    avg_acc = np.mean([val_accuracies[age][-1] for age in AGE_CATEGORIES])
+    print(f"\n平均精度: {avg_acc:.4f} ({avg_acc*100:.2f}%)")
+
+# --- データサンプリング関数（年代と性別を別々にバランシング） ---
+def sample_balanced_data(df, max_per_age=5000, max_per_gender=5000):
+    """
+    年代と性別を別々にバランシングする
+    - 年代：各年代ごとに最大max_per_age件（性別関係なく）
+    - 性別：各性別ごとに最大max_per_gender件（年代関係なく）
+    
+    両方の条件を満たすデータのみを残す
+    """
+    # 年代ごとにサンプリング
+    age_sampled_dfs = []
+    for age in AGE_CATEGORIES:
+        subset = df[df['年代'] == age]
+        if len(subset) > max_per_age:
+            subset = subset.sample(max_per_age, random_state=42)
+        age_sampled_dfs.append(subset)
+    age_balanced_df = pd.concat(age_sampled_dfs).reset_index(drop=True)
+    
+    # 性別ごとにサンプリング
+    gender_sampled_dfs = []
+    for gender_label in age_balanced_df['性別_label'].unique():
+        subset = age_balanced_df[age_balanced_df['性別_label'] == gender_label]
+        if len(subset) > max_per_gender:
+            subset = subset.sample(max_per_gender, random_state=42)
+        gender_sampled_dfs.append(subset)
+    
+    return pd.concat(gender_sampled_dfs).sample(frac=1, random_state=42).reset_index(drop=True)
+
+
+def create_balanced_binary_labels(df, samples_per_label=2000):
+    """
+    各年代の二値分類器を完全に独立させてバランスを取る
+    - 各年代について、正例と負例を同じ数にする（重複なし）
+    - samples_per_label: 各ラベル（正例・負例）あたりのサンプル数
+    """
+    # まず、各年代ごとに利用可能なデータ数を確認
+    print("\n各年代のデータ数:")
+    for age in AGE_CATEGORIES:
+        count = len(df[df['年代'] == age])
+        print(f"  {age}: {count}件")
+    
+    # 各年代用のデータセットを個別に作成
+    age_datasets = {}
+    
+    for age in AGE_CATEGORIES:
+        print(f"\n  {age}の二値分類器用デー��を作成中...")
+        
+        # 正例（該当年代）のデータ
+        positive_samples = df[df['年代'] == age].copy()
+        actual_positive = min(len(positive_samples), samples_per_label)
+        if len(positive_samples) > samples_per_label:
+            positive_samples = positive_samples.sample(samples_per_label, random_state=42)
+        else:
+            print(f"    警告: {age}の正例は{len(positive_samples)}件しかありません")
+        
+        # 負例（他の年代）のデータ - 正例と同じ数だけサンプリング
+        negative_samples = df[df['年代'] != age].copy()
+        target_negative = len(positive_samples)  # 正例と同じ数
+        if len(negative_samples) > target_negative:
+            negative_samples = negative_samples.sample(target_negative, random_state=42)
+        
+        # 正例と負例を結合（この年代専用）
+        age_dataset = pd.concat([positive_samples, negative_samples]).reset_index(drop=True)
+        age_datasets[age] = age_dataset
+        
+        print(f"    {age}: 正例{len(positive_samples)}件, 負例{len(negative_samples)}件 (合計{len(age_dataset)}件)")
+    
+    # 全ての年代のデータセットを結合してシャッフル
+    # ※各データは複数の年代の分類器で使われるが、各分類器内ではバランスが取れている
+    all_data = []
+    for age, dataset in age_datasets.items():
+        all_data.append(dataset)
+    
+    # インデックスで重複を除去（リスト型カラムがあるためdrop_duplicatesは使えない）
+    final_df = pd.concat(all_data, ignore_index=True)
+    final_df = final_df.loc[~final_df.index.duplicated(keep='first')]
+    final_df = final_df.sample(frac=1, random_state=42).reset_index(drop=True)
+    
+    print(f"\n統合後のデータ数: {len(final_df)}件")
+    return final_df
+
+# --- メイン処理 ---
+def main():
+    print("--- 1. データ読み込み ---")
+    df, _ = load_preprocessed_data()
+
+    # --- 各年代の二値分類でバランスを取る ---
+    print("--- 各年代の二値分類でバランス調整 ---")
+    df = create_balanced_binary_labels(df, samples_per_label=2000)  # 各ラベル2000件ずつ
+
+    # ラベルの分布を確認
+    print("\n各年代の二値ラベル分布（バランス調整後）:")
+    for age in AGE_CATEGORIES:
+        positive_count = df[f"{age}_label"].sum()
+        negative_count = len(df) - positive_count
+        print(f"  {age}: 正例{positive_count}件, 負例{negative_count}件")
+
+    print(f"\n合計データ数: {len(df)} 件")
+    
+    # 訓練用と検証用に分割
+    train_df, val_df = train_test_split(df, test_size=0.2, random_state=42)
+
+    print(f"\n--- 2. トークナイザとデータローダーの準備 ---")
+    tokenizer = BertJapaneseTokenizer.from_pretrained(PRE_TRAINED_MODEL_NAME)
+    
+    # 各年代のラベルを辞書形式で渡す
+    train_age_labels_dict = {f"{age}_label": train_df[f"{age}_label"].values for age in AGE_CATEGORIES}
+    val_age_labels_dict = {f"{age}_label": val_df[f"{age}_label"].values for age in AGE_CATEGORIES}
+    
+    train_dataset = CustomDataset(
+        train_df['text'].values,
+        train_age_labels_dict,
+        tokenizer,
+        MAX_LEN
+    )
+    train_sampler = RandomSampler(train_dataset)
+    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, sampler=train_sampler)
+
+    val_dataset = CustomDataset(
+        val_df['text'].values,
+        val_age_labels_dict,
+        tokenizer,
+        MAX_LEN
+    )
+    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE)
+
+    print("\n--- 3. モデルのセットアップ ---")
+    model = BertForAgeClassification(PRE_TRAINED_MODEL_NAME, NUM_AGE_CLASSIFIERS)
+    model.to(DEVICE)
+    
+    # BERT全体をファインチューニング（レイヤーごとに異なる学習率を設定）
+    optimizer = AdamW([
+        {'params': model.bert.parameters(), 'lr': 2e-5},  # BERT本体は小さい学習率
+        {'params': model.age_classifiers.parameters(), 'lr': 5e-4},  # 分類層は大きい学習率
+    ])
+
+    print("\n--- 4. 学習開始 ---")
+    print(f"デバイス: {DEVICE}")
+    print(f"訓練データ数: {len(train_df)} 件")
+    print(f"検証データ数: {len(val_df)} 件")
+    print(f"バッチサイズ: {BATCH_SIZE}")
+    print(f"エポック数: {EPOCHS}")
+    print(f"推定学習時間: 約66時間")
+    
+    # 学習履歴を保存するリスト
+    train_losses = []
+    val_accuracies = {age: [] for age in AGE_CATEGORIES}
+    
+    import time
+    start_time = time.time()
+    
+    for epoch in range(EPOCHS):
+        epoch_start_time = time.time()
+        print(f"\n{'='*60}")
+        print(f"Epoch {epoch + 1}/{EPOCHS} 開始")
+        print(f"{'='*60}")
+        
+        train_loss = train_epoch(model, train_loader, optimizer, DEVICE)
+        print(f"Train Loss: {train_loss:.4f}")
+        
+        # 学習損失を記録
+        train_losses.append(train_loss)
+
+        age_accuracies = eval_model(model, val_loader, DEVICE)
+        print("\nAge Validation Accuracies:")
+        for age in AGE_CATEGORIES:
+            print(f"  {age}: {age_accuracies[age]:.4f} ({age_accuracies[age]*100:.2f}%)")
+            val_accuracies[age].append(age_accuracies[age])
+        
+        # 平均精度を計算
+        avg_acc = sum(age_accuracies.values()) / len(age_accuracies)
+        print(f"\n平均精度: {avg_acc:.4f} ({avg_acc*100:.2f}%)")
+        
+        # エポックの経過時間を表示
+        epoch_time = time.time() - epoch_start_time
+        elapsed_time = time.time() - start_time
+        remaining_epochs = EPOCHS - (epoch + 1)
+        estimated_remaining_time = (elapsed_time / (epoch + 1)) * remaining_epochs
+        
+        print(f"\nエポック所要時間: {epoch_time/60:.1f}分")
+        print(f"経過時間: {elapsed_time/3600:.1f}時間")
+        print(f"推定残り時間: {estimated_remaining_time/3600:.1f}時間")
+        print(f"{'='*60}")
+
+    print("\n--- 5. 学習完了 ---")
+    torch.save(model.state_dict(), 'bert_age_model.bin')
+    print("モデルを 'bert_age_model.bin' に保存しました。")
+    
+    # Loss CurveとAccuracy Curveを表示
+    print("\n--- 6. 学習曲線の表示 ---")
+    plot_training_curves(train_losses, val_accuracies)
+
+
+if __name__ == '__main__':
+    main()

app.py

@@ -0,0 +1,76 @@
+import gradio as gr
+import torch
+import os
+from predictor import load_models, predict_text
+
+# モデルの読み込み
+print("=== モデル読み込み開始 ===")
+try:
+    load_models()
+    print("✅ モデルの読み込みが完了しました")
+except Exception as e:
+    print(f"❌ モデルの読み込みに失敗しました: {e}")
+    print("⚠️  モデルファイルが存在しない可能性があります")
+
+def predict_age_gender(text):
+    """年代・性別予測関数"""
+    if not text.strip():
+        return "テキストを入力してください。", "", ""
+    
+    try:
+        result = predict_text(text)
+        
+        # 年代予測結果を整形
+        age_results = []
+        for age, percentage in result['age_percentages'].items():
+            age_results.append(f"{age}: {percentage}%")
+        age_text = "\n".join(age_results)
+        
+        # 性別予測結果を整形
+        gender_results = []
+        for gender, percentage in result['gender_percentages'].items():
+            gender_results.append(f"{gender}: {percentage}%")
+        gender_text = "\n".join(gender_results)
+        
+        # 最も高い確率の年代を特定
+        max_age = max(result['age_percentages'].items(), key=lambda x: x[1])
+        max_gender = max(result['gender_percentages'].items(), key=lambda x: x[1])
+        
+        summary = f"推定結果: {max_age[0]} ({max_age[1]}%), {max_gender[0]} ({max_gender[1]}%)"
+        
+        return summary, age_text, gender_text
+        
+    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()
+)
+
+# アプリケーション起動
+if __name__ == "__main__":
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False  # Hugging Face SpacesではFalse
+    )

predictor.py

@@ -0,0 +1,149 @@
+import torch
+import torch.nn.functional as F
+import os
+from transformers import BertJapaneseTokenizer
+
+# 年代モデルと性別モデルの定義をインポート
+from SupervisedLearning import BertForAgeClassification, PRE_TRAINED_MODEL_NAME, DEVICE, NUM_AGE_CLASSIFIERS, AGE_CATEGORIES
+from GenderLearning import BertForGenderClassification, NUM_GENDER_LABELS
+
+# モデルファイルのパス
+AGE_MODEL_PATH = 'bert_age_model.bin'
+GENDER_MODEL_PATH = 'bert_gender_model.bin'
+
+# 性別のカテゴリマッピング
+GENDER_CATEGORIES = ["male", "female"]
+GENDER_CATEGORIES_JP = ["男性", "女性"]
+
+# --- グローバル変数としてモデルとトークナイザを一度だけロード ---
+TOKENIZER = None
+AGE_MODEL = None
+GENDER_MODEL = None
+
+def load_models():
+    """アプリケーション起動時にモデルを一度だけ読み込む"""
+    global TOKENIZER, AGE_MODEL, GENDER_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("  年代モデルを読み込み中...")
+    AGE_MODEL = BertForAgeClassification(PRE_TRAINED_MODEL_NAME, NUM_AGE_CLASSIFIERS)
+    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))
+    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)
+        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
+        GENDER_MODEL.to(DEVICE)
+        GENDER_MODEL.eval()
+    else:
+        GENDER_MODEL = None
+    
+    print("--- モデルの読み込みが完了しました ---")
+
+
+def predict_text(text: str):
+    """
+    入力されたテキストから「年代」と「性別」の各ラベルのパーセンテージを返す関数
+    """
+    if AGE_MODEL is None or TOKENIZER is None:
+        load_models()
+
+    print(f"DEBUG: 入力テキスト: '{text}'")
+    
+    # テキストの前処理
+    encoding = 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',
+    )
+    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}")
+
+    # 年代の予測
+    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}")
+        
+        # 性別の確率（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}")
+        
+        # 性別の確率を辞書形式で保存
+        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
+    }
+    
+    print(f"DEBUG: 最終結果: {results}")
+    return results

requirements.txt

@@ -0,0 +1,11 @@
+gradio>=4.0.0
+torch>=1.9.0
+transformers>=4.21.0
+pandas>=1.3.0
+scikit-learn>=1.0.0
+numpy>=1.21.0
+fugashi>=1.2.0
+ipadic>=1.0.0
+sudachipy>=0.6.0
+sudachidict-core>=20240101
+neologdn>=0.0.0