３層ニューラルネットワーク

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
import numpy as np
from torch.utils.data import DataLoader, TensorDataset
from collections import Counter
from sklearn.metrics import classification_report

def generate_data(seed=42):
    '''
    10個の特徴量を持つダミーデータXを作成し、
    特徴量の合計値が5以上ならクラス1、
    そうでなければクラス0とする。
    '''
    np.random.seed(seed) # 乱数のシード値を設定する
    X = np.random.rand(1000, 10) # ランダムな数値データを生成
    y = (np.sum(X, axis=1) >= 5.0).astype(int)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=seed) # データを訓練データとテストデータに分割
    
    # PyTorchのテンソルに変換して返す
    return (torch.tensor(X_train, dtype=torch.float32),
            torch.tensor(y_train, dtype=torch.long),
            torch.tensor(X_test, dtype=torch.float32),
            torch.tensor(y_test, dtype=torch.long))


def print_class_distribution(y_train, y_test):
    def print_distribution(label, counts, total):
        print(f"{label} class distribution:")
        for key, count in counts.items():
            print(f"  Class {key}: {count} samples ({count / total:.2%})")
    
    print_distribution("Training set", Counter(y_train.numpy()), len(y_train))
    print_distribution("Test set", Counter(y_test.numpy()), len(y_test))

def get_dataloader(X_train, y_train, batch_size=32):
    train_data = TensorDataset(X_train, y_train)
    return DataLoader(train_data, batch_size=batch_size, shuffle=True)

#　ここにニューラルネットワークを定義する
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        # ここに必要なレイヤーを定義する
        
    def forward(self, x):
        # ここにネットワークの順伝搬を記載する
        


# ここに学習用のコードを書く
def train_loop(model, train_loader, criterion, optimizer, device, epochs=100):
    # 学習ループの中身を書く

# ここに推論用のコードを書く
def evaluate_loop(model, X_test, y_test, device):
    model.eval()
    with torch.no_grad(): # 勾配計算を無効化
        X_test, y_test = X_test.to(device), y_test.to(device)
        outputs = nn.functional.softmax(model(X_test), dim=-1)
        _, predicted = torch.max(outputs, 1)
    print(classification_report(y_test.cpu().numpy(), predicted.cpu().numpy(), target_names=['Class 0', 'Class 1'], digits=3))
    print(f"予測値: \n クラス0      クラス1\n{np.array2string(outputs[:5].cpu().detach().numpy(), suppress_small=True)}")

def main():
    X_train, y_train, X_test, y_test = generate_data()
    print_class_distribution(y_train, y_test)
    train_dataloader = get_dataloader(X_train, y_train)
    
    device = torch.device("cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu")
    model = SimpleNN()
    model.to(device)
    criterion = nn.NLLLoss()
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    
    train_loop(model, train_dataloader, criterion, optimizer, device, epochs=100)
    evaluate_loop(model, X_test, y_test, device)

if __name__ == "__main__":
    main()

def train_loop(model, train_loader, criterion, optimizer, device, epochs=100):
    model.train()

def train_loop(model, train_loader, criterion, optimizer, device, epochs=100):
    model.train()
    for epoch in range(epochs):
        for batch_X, batch_y in train_loader:
　　　　　　　# ここに学習の中身を書く

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.metrics import classification_report
from collections import Counter
from transformers import AutoTokenizer
import pandas as pd
import numpy as np

# BERTトークナイザと語彙取得
tokenizer = AutoTokenizer.from_pretrained("tohoku-nlp/bert-base-japanese-v3")
vocab = tokenizer.get_vocab()  # 語彙は {token: index} の辞書

# BoWベクトルを作成する関数（語彙は固定でtokenizerのものを使う）
def build_bow_features(texts, vocab):
    bow_vectors = []

    for text in texts:
        tokens = tokenizer.tokenize(text)
        vec = np.zeros(len(vocab), dtype=np.float32)
        for token in tokens:
            if token in vocab:
                vec[vocab[token]] += 1
        bow_vectors.append(vec)

    return np.array(bow_vectors)

# CSVファイルを読み込んでBoWとラベルを返す
def load_csv_bow(csv_path, vocab):
    label_mapping = {'a': 0, 'e': 1, 'm': 2}
    df = pd.read_csv(csv_path, header=None, names=["label", "text"])
    texts = df['text'].astype(str).tolist()
    labels = (df['label'].astype(str)).map(label_mapping).tolist()
    X_bow = build_bow_features(texts, vocab)
    return torch.tensor(X_bow, dtype=torch.float32), torch.tensor(labels, dtype=torch.long)

def main():
    train_file = '../data/train.csv'
    dev_file = '../data/dev.csv'
    test_file = '../data/test.csv'

    # 語彙はすでに上で定義済み（tokenizer.get_vocab()）
    print("Loading data...")
    X_train, y_train = load_csv_bow(train_file, vocab)
    X_dev, y_dev = load_csv_bow(dev_file, vocab)
    X_test, y_test = load_csv_bow(test_file, vocab)

    print_class_distribution(y_train, "Train")
    print_class_distribution(y_dev, "Dev")
    print_class_distribution(y_test, "Test")

    train_loader = get_dataloader(X_train, y_train)
    dev_loader = get_dataloader(X_dev, y_dev, batch_size=32, shuffle=False)
    test_loader = get_dataloader(X_test, y_test, batch_size=32, shuffle=False)

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = SimpleNN(input_dim=X_train.shape[1]).to(device)
    criterion = nn.NLLLoss()
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

    print("Training model...")
    train_loop(model, train_loader, criterion, optimizer, device,
               epochs=20)

    
    print("Evaluating on Test set:")
    evaluate(model, test_loader, device)