シミュレーションと機械学習の組み合わせと各種実装例

import numpy as np
import gym

# シミュレーション環境の作成
env = gym.make('CartPole-v1')

# エージェントの定義
class Agent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.weights = np.random.rand(state_size, action_size)
    
    def get_action(self, state):
        # Q値の計算
        q_values = np.dot(state, self.weights)
        # 最大のQ値に対応する行動を選択
        action = np.argmax(q_values)
        return action
    
    def train(self, state, action, reward, next_state, done, learning_rate, discount_factor):
        # Q値の更新
        q_values = np.dot(state, self.weights)
        next_q_values = np.dot(next_state, self.weights)
        target = reward + discount_factor * np.max(next_q_values)
        q_values[action] = (1 - learning_rate) * q_values[action] + learning_rate * target
        # 重みの更新
        self.weights = np.dot(state.T, q_values)

# ハイパーパラメータの設定
state_size = env.observation_space.shape[0]
action_size = env.action_space.n
learning_rate = 0.001
discount_factor = 0.99
episodes = 1000

# エージェントの初期化
agent = Agent(state_size, action_size)

# エピソードのループ
for episode in range(episodes):
    state = env.reset()
    state = np.reshape(state, [1, state_size])
    
    done = False
    while not done:
        # 行動の選択
        action = agent.get_action(state)
        
        # 行動の実行
        next_state, reward, done, _ = env.step(action)
        next_state = np.reshape(next_state, [1, state_size])
        
        # 学習
        agent.train(state, action, reward, next_state, done, learning_rate, discount_factor)
        
        state = next_state
    
    # エピソードの結果の表示
    print("Episode:", episode+1)
    print("Score:", env._max_episode_steps - env._elapsed_steps)

# 学習済みエージェントのテスト
state = env.reset()
state = np.reshape(state, [1, state_size])
done = False
score = 0

while not done:
    env.render()
    action = agent.get_action(state)
    next_state, reward, done, _ = env.step(action)
    next_state = np.reshape(next_state, [1, state_size])
    state = next_state
    score += reward

print("Test Score:", score)

env.close()

import numpy as np
import matplotlib.pyplot as plt

# シミュレーション環境の定義
class RobotEnvironment:
    def __init__(self):
        self.goal = np.array([8, 8])  # 目標位置
    
    def get_state(self):
        return np.random.rand(2) * 10  # ランダムな初期位置
    
    def step(self, action):
        # ロボットの移動
        next_state = action
        
        # 報酬の計算
        distance_to_goal = np.linalg.norm(self.goal - next_state)
        reward = -distance_to_goal
        
        # 終了判定
        done = (distance_to_goal < 0.5)
        
        return next_state, reward, done

# エージェントの定義
class Agent:
    def __init__(self):
        self.weights = np.random.rand(2)
    
    def get_action(self, state):
        return self.weights * state
    
    def update_weights(self, delta_weights, learning_rate):
        self.weights += learning_rate * delta_weights

# ハイパーパラメータの設定
learning_rate = 0.01
episodes = 1000

# シミュレーション環境とエージェントの初期化
env = RobotEnvironment()
agent = Agent()

# 学習の実行
for episode in range(episodes):
    state = env.get_state()
    
    total_reward = 0
    done = False
    while not done:
        # 行動の選択
        action = agent.get_action(state)
        
        # 状態の遷移と報酬の計算
        next_state, reward, done = env.step(action)
        
        # 重みの更新
        delta_weights = (reward - total_reward) * state
        agent.update_weights(delta_weights, learning_rate)
        
        state = next_state
        total_reward = reward
    
    # エピソードの結果の表示
    print("Episode:", episode+1)
    print("Total Reward:", total_reward)

# テストの実行
state = env.get_state()
path = [state]
done = False
while not done:
    action = agent.get_action(state)
    next_state, _, done = env.step(action)
    path.append(next_state)
    state = next_state

# 結果の可視化
path = np.array(path)
plt.plot(path[:, 0], path[:, 1], marker='o')
plt.plot(env.goal[0], env.goal[1], marker='x', color='red')
plt.xlim(0, 10)
plt.ylim(0, 10)
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Robot Path')
plt.show()

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error

# データの読み込み
data = pd.read_csv('traffic_data.csv')

# 特徴量の選択
features = ['Hour', 'DayOfWeek', 'Weather', 'Temperature', 'Holiday']

# 特徴量のスケーリング
scaler = MinMaxScaler()
data_scaled = scaler.fit_transform(data[features])

# 目的変数の作成（交通量）
target = data['TrafficVolume'].values

# 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(data_scaled, target, test_size=0.2, shuffle=False)

# ランダムフォレストモデルの定義と学習
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# テストデータに対する予測
y_pred = model.predict(X_test)

# テストデータの評価（平均絶対誤差）
mae = mean_absolute_error(y_test, y_pred)
print("Mean Absolute Error:", mae)

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.svm import SVR
from sklearn.metrics import mean_squared_error

# データの読み込み
data = pd.read_csv('stock_prices.csv')

# 特徴量の選択
features = ['Open', 'High', 'Low', 'Volume']

# 特徴量のスケーリング
scaler = MinMaxScaler()
data_scaled = scaler.fit_transform(data[features])

# 目的変数の作成（株価のClose）
target = data['Close'].values

# 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(data_scaled, target, test_size=0.2, shuffle=False)

# SVRモデルの定義と学習
model = SVR(kernel='rbf', C=100, epsilon=0.1)
model.fit(X_train, y_train)

# テストデータに対する予測
y_pred = model.predict(X_test)

# テストデータの評価（平均二乗誤差）
mse = mean_squared_error(y_test, y_pred)
print("Mean Squared Error:", mse)

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# データの前処理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# データセットの読み込み
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

# データローダーの作成
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# モデルの定義
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc = nn.Linear(14*14*16, 10)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

# モデルの初期化
model = CNN()

# 損失関数とオプティマイザの定義
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# 学習の実行
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

epochs = 10
for epoch in range(epochs):
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader):
        inputs = inputs.to(device)
        labels = labels.to(device)
        
        optimizer.zero_grad()
        
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
        
    print(f"Epoch {epoch+1}, Loss: {running_loss/len(train_loader)}")

# テストの実行
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        inputs = inputs.to(device)
        labels = labels.to(device)
        
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = correct / total
print(f"Test Accuracy: {accuracy}")