生成AIを使ってAIを学ぶ（コードが合ってるかは検証してない）

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB

# トレーニングデータとラベル
texts = ["I love this movie", "This movie is terrible", "I like this film", "This film is awful"]
labels = [1, 0, 1, 0]  # 1: positive, 0: negative

# テキストをベクトルに変換
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(texts)

# ナイーブベイズモデルの訓練
model = MultinomialNB()
model.fit(X, labels)

# 新しいテキストの分類
new_texts = ["I enjoy this movie", "This film is bad"]
new_X = vectorizer.transform(new_texts)
predictions = model.predict(new_X)

print(predictions)  # 出力: [1, 0]

import numpy as np
from scipy.stats import entropy

P = [0.4, 0.6]
Q = [0.5, 0.5]

kl_divergence = entropy(P, Q)
print("KL Divergence:", kl_divergence)

import numpy as np
from scipy.spatial.distance import jensenshannon

# 仮のテーブルデータのカテゴリカル分布
data1 = [50, 30, 20]  # カテゴリ A, B, C の出現数
data2 = [40, 35, 25]  # 別の期間のカテゴリ A, B, C の出現数

# 分布を確率に変換
p = np.array(data1) / np.sum(data1)
q = np.array(data2) / np.sum(data2)

# JSダイバージェンスの計算
js_divergence = jensenshannon(p, q)
print("JS Divergence:", js_divergence)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.metrics import mean_squared_error

# データ生成
np.random.seed(0)
n_samples = 30
X = np.sort(np.random.rand(n_samples))
y = np.sin(2 * np.pi * X) + np.random.normal(scale=0.1, size=n_samples)

# トレーニングデータとテストデータに分割
X_train, X_test = X[:n_samples // 2], X[n_samples // 2:]
y_train, y_test = y[:n_samples // 2], y[n_samples // 2:]

# モデルのトレーニングと予測
degrees = [1, 3, 10]
plt.figure(figsize=(15, 5))

for i, degree in enumerate(degrees):
    model = make_pipeline(PolynomialFeatures(degree), LinearRegression())
    model.fit(X_train[:, np.newaxis], y_train)
    y_pred = model.predict(X_test[:, np.newaxis])

    # プロット
    plt.subplot(1, len(degrees), i + 1)
    plt.scatter(X_train, y_train, label='Train data')
    plt.scatter(X_test, y_test, label='Test data')
    plt.plot(X_test, y_pred, label=f'Degree {degree} prediction')
    plt.title(f'Degree {degree}\nMSE: {mean_squared_error(y_test, y_pred):.2f}')
    plt.xlabel('x')
    plt.ylabel('y')
    plt.legend()

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.metrics import mean_squared_error

# データ生成
np.random.seed(0)
n_samples = 30
X = np.sort(np.random.rand(n_samples))
y = np.sin(2 * np.pi * X) + np.random.normal(scale=0.1, size=n_samples)

# トレーニングデータとテストデータに分割
X_train, X_test = X[:n_samples // 2], X[n_samples // 2:]
y_train, y_test = y[:n_samples // 2], y[n_samples // 2:]

# モデルのトレーニングと予測
degrees = [1, 3, 10]
plt.figure(figsize=(15, 5))

for i, degree in enumerate(degrees):
    model = make_pipeline(PolynomialFeatures(degree), LinearRegression())
    model.fit(X_train[:, np.newaxis], y_train)
    y_pred = model.predict(X_test[:, np.newaxis])

    # プロット
    plt.subplot(1, len(degrees), i + 1)
    plt.scatter(X_train, y_train, label='Train data')
    plt.scatter(X_test, y_test, label='Test data')
    plt.plot(X_test, y_pred, label=f'Degree {degree} prediction')
    plt.title(f'Degree {degree}\nMSE: {mean_squared_error(y_test, y_pred):.2f}')
    plt.xlabel('x')
    plt.ylabel('y')
    plt.legend()

plt.tight_layout()
plt.show()

import torch
import torch.nn as nn
import torch.optim as optim

# シンプルなニューラルネットワークの定義
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 5)
        self.fc2 = nn.Linear(5, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# モデルのインスタンス作成
model = SimpleNN()

# モデルの学習などを行う
# optimizer = optim.SGD(model.parameters(), lr=0.01)
# loss_fn = nn.MSELoss()
# ...

import shap

# モデルをSHAPのDeepExplainerに渡す
explainer = shap.DeepExplainer(model, background_data)

# 入力データに対してSHAP値を計算
shap_values = explainer.shap_values(input_data)

# SHAP値を可視化
shap.summary_plot(shap_values, input_data)

import torch
import torch.nn as nn
import torch.optim as optim

class FeatureExtractor(nn.Module):
    def __init__(self):
        super(FeatureExtractor, self).__init__()
        # シンプルなCNNベースの特徴抽出ネットワーク
        self.conv = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=5),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 48, kernel_size=5),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.fc = nn.Sequential(
            nn.Linear(48 * 4 * 4, 100),
            nn.ReLU(),
        )

    def forward(self, x):
        x = self.conv(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

class Classifier(nn.Module):
    def __init__(self):
        super(Classifier, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(100, 50),
            nn.ReLU(),
            nn.Linear(50, 10),
        )

    def forward(self, x):
        return self.fc(x)

class DomainDiscriminator(nn.Module):
    def __init__(self):
        super(DomainDiscriminator, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(100, 50),
            nn.ReLU(),
            nn.Linear(50, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.fc(x)

# モデルの初期化
feature_extractor = FeatureExtractor()
classifier = Classifier()
domain_discriminator = DomainDiscriminator()

# オプティマイザーの定義
optimizer_feature = optim.Adam(feature_extractor.parameters(), lr=0.001)
optimizer_classifier = optim.Adam(classifier.parameters(), lr=0.001)
optimizer_discriminator = optim.Adam(domain_discriminator.parameters(), lr=0.001)

# 損失関数の定義
criterion_classifier = nn.CrossEntropyLoss()
criterion_discriminator = nn.BCELoss()

# 訓練ループ
for epoch in range(num_epochs):
    for (source_data, source_labels), (target_data, _) in zip(source_loader, target_loader):
        # ステップ1: ソースドメインでの特徴抽出と分類
        features = feature_extractor(source_data)
        outputs = classifier(features)
        loss_classifier = criterion_classifier(outputs, source_labels)

        # ステップ2: ドメイン判別器の訓練
        domain_labels = torch.cat([torch.ones(source_data.size(0)), torch.zeros(target_data.size(0))])
        features_combined = torch.cat([features, feature_extractor(target_data)])
        domain_outputs = domain_discriminator(features_combined.detach())
        loss_discriminator = criterion_discriminator(domain_outputs, domain_labels)

        # ステップ3: 特徴抽出ネットワークの訓練（逆伝播）
        loss_domain_adv = criterion_discriminator(domain_discriminator(features), torch.zeros(source_data.size(0)))

        # オプティマイザーのステップ
        optimizer_feature.zero_grad()
        optimizer_classifier.zero_grad()
        optimizer_discriminator.zero_grad()

        loss_classifier.backward(retain_graph=True)
        optimizer_classifier.step()

        loss_discriminator.backward()
        optimizer_discriminator.step()

        loss_domain_adv.backward()
        optimizer_feature.step()

    print(f'Epoch {epoch}/{num_epochs}, Classifier Loss: {loss_classifier.item()}, Discriminator Loss: {loss_discriminator.item()}')