自己教師あり学習の概要と各種アルゴリズム及び実装例について

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# ハイパーパラメータ
num_samples = 16000  # 1秒間のサンプル数
num_channels = 1  # モノラル音声
latent_dim = 100  # 潜在ベクトルの次元数

# 生成器ネットワーク
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        
        self.layers = nn.Sequential(
            nn.ConvTranspose1d(latent_dim, 256, kernel_size=4, stride=2, padding=1),
            nn.ReLU(),
            nn.ConvTranspose1d(256, 128, kernel_size=4, stride=2, padding=1),
            nn.ReLU(),
            nn.ConvTranspose1d(128, 64, kernel_size=4, stride=2, padding=1),
            nn.ReLU(),
            nn.ConvTranspose1d(64, num_channels, kernel_size=4, stride=2, padding=1),
            nn.Tanh()
        )
    
    def forward(self, z):
        return self.layers(z)

# ノイズ生成
def generate_noise(num_samples, latent_dim):
    return torch.randn(num_samples, latent_dim)

# 生成器のインスタンス化
generator = Generator()

# 損失関数とオプティマイザ
criterion = nn.MSELoss()
optimizer = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))

# 学習ループ
num_epochs = 200
for epoch in range(num_epochs):
    noise = generate_noise(num_samples, latent_dim)
    fake_samples = generator(noise)
    
    target = torch.zeros(fake_samples.size())
    loss = criterion(fake_samples, target)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch + 1) % 10 == 0:
        print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}")

# 生成された音声波形の表示
generated_noise = generate_noise(num_samples, latent_dim)
generated_waveforms = generator(generated_noise).detach().numpy()

plt.figure(figsize=(10, 4))
for i in range(10):
    plt.subplot(2, 10, i+1)
    plt.plot(generated_waveforms[i].squeeze())
    plt.axis('off')

plt.tight_layout()
plt.show()

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import confusion_matrix, classification_report

# データのロード（KDD Cup 1999データセット）
data = torch.load('kddcup_data.pt')  # 事前にデータを準備する

# データの標準化
scaler = StandardScaler()
data = scaler.fit_transform(data)

# 訓練データとテストデータに分割
train_data, test_data = train_test_split(data, test_size=0.2, random_state=42)

# Autoencoderの定義
class Autoencoder(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(Autoencoder, self).__init__()
        
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU()
        )
        
        self.decoder = nn.Sequential(
            nn.Linear(hidden_dim, input_dim),
            nn.ReLU()
        )
    
    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded

# ハイパーパラメータ
input_dim = train_data.shape[1]
hidden_dim = 16
learning_rate = 0.001
num_epochs = 20

# モデルのインスタンス化と訓練
model = Autoencoder(input_dim, hidden_dim)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

for epoch in range(num_epochs):
    model.train()
    train_loss = 0.0
    
    for data in train_data:
        optimizer.zero_grad()
        input_data = torch.tensor(data, dtype=torch.float32)
        output_data = model(input_data)
        loss = criterion(output_data, input_data)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
    
    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {train_loss / len(train_data):.4f}")

# テストデータで異常検出を行う
model.eval()
with torch.no_grad():
    test_losses = []
    anomaly_scores = []
    for data in test_data:
        input_data = torch.tensor(data, dtype=torch.float32)
        output_data = model(input_data)
        test_loss = criterion(output_data, input_data)
        test_losses.append(test_loss.item())
        anomaly_scores.append(test_loss.item())
    
    threshold = torch.mean(torch.tensor(anomaly_scores)) + torch.std(torch.tensor(anomaly_scores))
    predicted_labels = [1 if score > threshold else 0 for score in anomaly_scores]

# 評価
true_labels = [1 if loss > threshold else 0 for loss in test_losses]
conf_matrix = confusion_matrix(true_labels, predicted_labels)
report = classification_report(true_labels, predicted_labels)

print("Confusion Matrix:")
print(conf_matrix)
print("\nClassification Report:")
print(report)

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# データの前処理とロード
transform = transforms.Compose([
    transforms.ToTensor()
])

train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_data, unlabeled_data = train_test_split(train_dataset, test_size=0.8, random_state=42)

labeled_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=64, shuffle=True)
unlabeled_loader = torch.utils.data.DataLoader(dataset=unlabeled_data, batch_size=64, shuffle=True)

# モデルの定義
class Classifier(nn.Module):
    def __init__(self):
        super(Classifier, self).__init__()
        
        self.layers = nn.Sequential(
            nn.Linear(28*28, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
        )
    
    def forward(self, x):
        x = x.view(x.size(0), -1)
        return self.layers(x)

# モデルのインスタンス化と訓練（ラベル付きデータ）
classifier = Classifier()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(classifier.parameters(), lr=0.001)

num_epochs = 10
for epoch in range(num_epochs):
    classifier.train()
    for data in labeled_loader:
        images, labels = data
        optimizer.zero_grad()
        outputs = classifier(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    
    # ラベル付きデータでの評価
    classifier.eval()
    with torch.no_grad():
        all_labels = []
        all_predictions = []
        for data in labeled_loader:
            images, labels = data
            outputs = classifier(images)
            predictions = torch.argmax(outputs, dim=1)
            all_labels.extend(labels.tolist())
            all_predictions.extend(predictions.tolist())
        
        accuracy = accuracy_score(all_labels, all_predictions)
        print(f"Epoch {epoch+1}: Labeled Data Accuracy = {accuracy:.4f}")

# ラベルなしデータを使った自己教師あり学習
classifier.train()
for epoch in range(num_epochs):
    for data in unlabeled_loader:
        images, _ = data
        optimizer.zero_grad()
        outputs = classifier(images)
        pseudo_labels = torch.argmax(outputs, dim=1)  # 自己教師あり学習での仮ラベル
        loss = criterion(outputs, pseudo_labels)
        loss.backward()
        optimizer.step()

    # ラベルなしデータでの評価
    classifier.eval()
    with torch.no_grad():
        all_labels = []
        all_predictions = []
        for data in unlabeled_loader:
            images, _ = data
            outputs = classifier(images)
            predictions = torch.argmax(outputs, dim=1)
            all_predictions.extend(predictions.tolist())
        
        accuracy = accuracy_score(all_labels, all_predictions)
        print(f"Epoch {epoch+1}: Unlabeled Data Accuracy = {accuracy:.4f}")

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# データのロード（UCI HAR Dataset）
data = torch.load('uci_har_data.pt')  # 事前にデータを準備する

# データの前処理
scaler = StandardScaler()
data = scaler.fit_transform(data)

# 訓練データとテストデータに分割
train_data, test_data = train_test_split(data, test_size=0.2, random_state=42)

# Autoencoderの定義
class Autoencoder(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(Autoencoder, self).__init__()
        
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU()
        )
        
        self.decoder = nn.Sequential(
            nn.Linear(hidden_dim, input_dim),
            nn.ReLU()
        )
    
    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded

# ハイパーパラメータ
input_dim = train_data.shape[1]
hidden_dim = 16
learning_rate = 0.001
num_epochs = 20

# モデルのインスタンス化と訓練
model = Autoencoder(input_dim, hidden_dim)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

for epoch in range(num_epochs):
    model.train()
    train_loss = 0.0
    
    for data in train_data:
        optimizer.zero_grad()
        input_data = torch.tensor(data, dtype=torch.float32)
        output_data = model(input_data)
        loss = criterion(output_data, input_data)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
    
    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {train_loss / len(train_data):.4f}")

# テストデータで異常検出を行う
model.eval()
with torch.no_grad():
    test_losses = []
    for data in test_data:
        input_data = torch.tensor(data, dtype=torch.float32)
        output_data = model(input_data)
        test_loss = criterion(output_data, input_data)
        test_losses.append(test_loss.item())
    
    threshold = torch.mean(torch.tensor(test_losses)) + torch.std(torch.tensor(test_losses))
    predicted_labels = [1 if loss > threshold else 0 for loss in test_losses]

# 評価
true_labels = [1 if loss > threshold else 0 for loss in test_losses]
conf_matrix = confusion_matrix(true_labels, predicted_labels)
accuracy = np.sum(np.diag(conf_matrix)) / np.sum(conf_matrix)

print("Confusion Matrix:")
print(conf_matrix)
print("\nAccuracy:", accuracy)