ベイズ統計の考え方——事前知識と証拠を組み合わせる推論

def bayes_medical(prevalence, sensitivity, specificity):
    """
    prevalence: 有病率 P(病気)
    sensitivity: 感度 P(陽性|病気)
    specificity: 特異度 P(陰性|健康)
    """
    p_disease = prevalence
    p_healthy = 1 - prevalence

    p_positive_given_disease = sensitivity
    p_positive_given_healthy = 1 - specificity  # 偽陽性率

    # ベイズの定理
    # P(病気|陽性) = P(陽性|病気) × P(病気) / P(陽性)

    # P(陽性) = P(陽性|病気)×P(病気) + P(陽性|健康)×P(健康)
    p_positive = (
        p_positive_given_disease * p_disease +
        p_positive_given_healthy * p_healthy
    )

    p_disease_given_positive = (
        p_positive_given_disease * p_disease / p_positive
    )

    return p_disease_given_positive

result = bayes_medical(
    prevalence=0.01,    # 有病率 1%
    sensitivity=0.99,   # 感度 99%
    specificity=0.95    # 特異度 95%
)
print(f"陽性的中率: {result:.1%}")  # 約 16.7%

import numpy as np
from collections import defaultdict

class NaiveBayesSpamFilter:
    def __init__(self):
        self.word_spam_count = defaultdict(int)
        self.word_ham_count = defaultdict(int)
        self.spam_total = 0
        self.ham_total = 0
        self.vocab = set()

    def train(self, emails):
        """emails: [(テキスト, ラベル)] のリスト"""
        for text, label in emails:
            words = text.lower().split()
            self.vocab.update(words)
            if label == 'spam':
                self.spam_total += 1
                for word in words:
                    self.word_spam_count[word] += 1
            else:
                self.ham_total += 1
                for word in words:
                    self.word_ham_count[word] += 1

    def predict(self, text):
        total = self.spam_total + self.ham_total

        # 事前確率 P(スパム), P(正常)
        log_prob_spam = np.log(self.spam_total / total)
        log_prob_ham = np.log(self.ham_total / total)

        words = text.lower().split()
        for word in words:
            if word not in self.vocab:
                continue
            # ラプラス平滑化（未知語を0にしない）
            vocab_size = len(self.vocab)

            p_word_spam = (self.word_spam_count[word] + 1) / (
                sum(self.word_spam_count.values()) + vocab_size
            )
            p_word_ham = (self.word_ham_count[word] + 1) / (
                sum(self.word_ham_count.values()) + vocab_size
            )

            log_prob_spam += np.log(p_word_spam)
            log_prob_ham += np.log(p_word_ham)

        return 'spam' if log_prob_spam > log_prob_ham else 'ham'

# 使用例
filter = NaiveBayesSpamFilter()
training_data = [
    ("無料 お金 今すぐ クリック", "spam"),
    ("会議 明日 資料 送ります", "ham"),
    ("当選 お祝い 無料 プレゼント", "spam"),
    ("プロジェクト 進捗 報告 よろしく", "ham"),
]
filter.train(training_data)
print(filter.predict("無料 クリック 当選"))  # spam
print(filter.predict("明日 会議 資料"))       # ham

import numpy as np
import matplotlib.pyplot as plt

def beta_posterior(heads, tails, alpha_prior=1, beta_prior=1):
    """
    ベータ分布を事前分布として使ったベイズ推定
    alpha_prior, beta_prior: 事前分布のパラメータ（均一分布=1,1）
    """
    alpha_posterior = alpha_prior + heads
    beta_posterior = beta_prior + tails
    return alpha_posterior, beta_posterior

def posterior_mean(alpha, beta):
    return alpha / (alpha + beta)

# 初期状態（均一事前分布: どんな確率値も等しく可能）
alpha, beta = 1, 1
print(f"初期推定: {posterior_mean(alpha, beta):.2f}")

# コインを投げるたびに更新
observations = [1, 0, 1, 1, 0, 1, 1, 0, 1, 1]  # 1=表, 0=裏
for i, obs in enumerate(observations):
    if obs == 1:
        alpha, beta = beta_posterior(1, 0, alpha, beta)
    else:
        alpha, beta = beta_posterior(0, 1, alpha, beta)
    print(f"投げ {i+1}回後: 表率推定 = {posterior_mean(alpha, beta):.2f} "
          f"(α={alpha}, β={beta})")

# 概念コード（実際は PyMC や TensorFlow Probability を使う）

# 通常のNN: 重みは固定値
# weight = 0.7

# ベイズNN: 重みは分布
# weight ~ Normal(mean=0.7, std=0.1)
# 予測時にサンプリングして不確かさを推定

# 実用的な近似: モンテカルロドロップアウト
import torch
import torch.nn as nn

class BayesianApproxNet(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout_p=0.1):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(p=dropout_p)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.dropout(x)  # 推論時もドロップアウトをONにする
        return self.fc2(x)

    def predict_with_uncertainty(self, x, n_samples=50):
        """複数回予測して分散を不確かさとして使う"""
        self.train()  # ドロップアウトを有効にする
        predictions = torch.stack([self(x) for _ in range(n_samples)])
        mean = predictions.mean(0)
        std = predictions.std(0)
        return mean, std

# scikit-optimize ライブラリを使ったベイズ最適化の例
from skopt import gp_minimize
from skopt.space import Real, Integer

def objective(params):
    learning_rate, n_layers = params
    # ここで実際にモデルを学習して検証スコアを返す
    # （サンプルなので代替の計算を使う）
    return -(learning_rate * 10 - (learning_rate - 0.01)**2 * 1000)

result = gp_minimize(
    objective,
    dimensions=[
        Real(1e-4, 1e-1, prior='log-uniform'),  # 学習率
        Integer(1, 5)                            # 層数
    ],
    n_calls=20,          # 試行回数
    random_state=42
)
print(f"最適パラメータ: lr={result.x[0]:.4f}, layers={result.x[1]}")