def __init__(self, n_in, n_mid, n_out):
super(Net, self).__init__()
self.util = RLUtil.RLUtil()
# デバイスの設定
d = self.util.getDEVICE()
self.device = torch.device(d)
if self.device.type == "cuda":
self.fc1 = nn.Linear(n_in, n_mid).cuda()
self.fc2 = nn.Linear(n_mid, n_mid).cuda()
# Actor-Critic
# 行動を決めるのではなく出力は行動の種類数
self.actor = nn.Linear(n_mid, n_out).cuda()
# 状態価値なので出力は1つ
self.critic = nn.Linear(n_mid, 1).cuda()
else:
self.fc1 = nn.Linear(n_in, n_mid)
self.fc2 = nn.Linear(n_mid, n_mid)
# Actor-Critic
# 行動を決めるのではなく出力は行動の種類数
self.actor = nn.Linear(n_mid, n_out)
# 状態価値なので出力は1つ
self.critic = nn.Linear(n_mid, 1)
def __init__(self, n_in, n_mid, n_out):
super(Net, self).__init__()
# Utilクラスインスタンス生成
self.util = RLUtil.RLUtil()
# デバイス情報の設定
d = self.util.getDEVICE()
self.device = torch.device(d)
if self.device.type == "cuda":
self.fc1 = nn.Linear(n_in, n_mid).cuda()
self.fc2 = nn.Linear(n_mid, n_mid).cuda()
# Dueling Network
# fc3_adv = Advantage, fc3_v = Value
self.fc3_adv = nn.Linear(n_mid, n_out).cuda()
self.fc3_v = nn.Linear(n_mid, 1).cuda()
else:
self.fc1 = nn.Linear(n_in, n_mid)
self.fc2 = nn.Linear(n_mid, n_mid)
# Dueling Network
# fc3_adv = Advantage, fc3_v = Value
self.fc3_adv = nn.Linear(n_mid, n_out)
self.fc3_v = nn.Linear(n_mid, 1)
def __init__(self):
# Utilクラスインスタンス生成
self.util = RLUtil.RLUtil()
# 同時実行する環境数分、envを生成
self.envs = [
gym.make(self.util.getENV())
for i in range(self.util.getNUM_PROCESSES())
]
# 全エージェントが共有して持つBrainを生成
# 状態は4
# n_in, n_out, n_midは数値情報
n_in = self.envs[0].observation_space.shape[0]
# 行動は2
n_out = self.envs[0].action_space.n
n_mid = 32
# DNNの生成
self.actor_critic = RLNet.Net(n_in, n_mid, n_out)
self.global_brain = RLBrain.RLBrain(self.actor_critic)
self.obs_shape = n_in
# デバイス情報の設定
d = self.util.getDEVICE()
self.device = torch.device(d)
def __init__(self, num_states, num_actions):
self.util = RLUtil.RLUtil()
# Cartpoleの行動（左右どちらかに押す）の2を取得する
self.num_actions = num_actions
# 経験を記憶するメモリオブジェクトを生成
self.memory = ReplayMemory.ReplayMemory(self.util.getCAPACITY())
# デバイス情報の設定
d = self.util.getDEVICE()
self.device = torch.device(d)
# NNの構築
self.model = nn.Sequential()
if self.device.type == "cuda":
self.model.add_module('fc1', nn.Linear(num_states, 32).cuda())
self.model.add_module('relu1', nn.ReLU().cuda())
self.model.add_module('fc2', nn.Linear(32, 32).cuda())
self.model.add_module('relu2', nn.ReLU().cuda())
self.model.add_module('fc3', nn.Linear(32, num_actions).cuda())
else:
self.model.add_module('fc1', nn.Linear(num_states, 32))
self.model.add_module('relu1', nn.ReLU())
self.model.add_module('fc2', nn.Linear(32, 32))
self.model.add_module('relu2', nn.ReLU())
self.model.add_module('fc3', nn.Linear(32, num_actions))
# NWの形を出力
print(self.model)
# 最適化手法の設定
self.optimizer = optim.Adam(self.model.parameters(), lr=0.0001)
def __init__(self, num_steps, num_processes, obs_shape):
self.util = RLUtil.RLUtil()
# デバイス情報の設定
d = self.util.getDEVICE()
self.device = torch.device(d)
self.observations = torch.zeros(num_steps + 1,
num_processes,
4,
device=self.device)
self.masks = torch.ones(num_steps + 1,
num_processes,
1,
device=self.device)
self.rewards = torch.zeros(num_steps,
num_processes,
1,
device=self.device)
if self.device.type == "cuda":
self.actions = torch.zeros(num_steps, num_processes,
1).type(torch.cuda.LongTensor)
else:
self.actions = torch.zeros(num_steps, num_processes,
1).type(torch.LongTensor)
# 割引報酬和を格納
self.returns = torch.zeros(num_steps + 1,
num_processes,
1,
device=self.device)
# insertするindex値
self.index = 0
def __init__(self, capacity):
# メモリの最大長さ
self.capacity = capacity
# 経験を保存する変数
self.memory = []
# 保存するindexを示す変数
self.index = 0
# Utilクラスインスタンス生成
self.util = RLUtil.RLUtil()
def __init__(self, capacity):
# 定数用クラス
self.util = RLUtil.RLUtil()
# メモリの最大長さ
self.capacity = capacity
# 経験を保存する変数
self.memory = []
# 保存するindexを示す変数
self.index = 0
def __init__(self, actor_critic):
self.util = RLUtil.RLUtil()
# actor_criticがクラスNetのDNNとなる
self.actor_critic = actor_critic
self.optimizer = optim.Adam(self.actor_critic.parameters(), lr=0.01)
# デバイスの設定
d = self.util.getDEVICE()
self.device = torch.device(d)
def __init__(self, n_in, n_mid, n_out):
super(Net, self).__init__()
self.util = RLUtil.RLUtil()
# デバイスの設定
d = self.util.getDEVICE()
self.device = torch.device(d)
if self.device.type == "cuda":
self.fc1 = nn.Linear(n_in, n_mid).cuda()
self.fc2 = nn.Linear(n_mid, n_mid).cuda()
self.fc3 = nn.Linear(n_mid, n_out).cuda()
else:
self.fc1 = nn.Linear(n_in, n_mid)
self.fc2 = nn.Linear(n_mid, n_mid)
self.fc3 = nn.Linear(n_mid, n_out)
def __init__(self):
# Utilクラスインスタンス生成
self.util = RLUtil.RLUtil()
# 実行する課題を設定
self.env = gym.make(self.util.getENV())
# 課題の状態と行動の数を設定
self.num_states = self.env.observation_space.shape[0]
self.num_actions = self.env.action_space.n
# このとき、cartpoleの行動（left/right）の2を取得
# Agentクラスのインスタンスを生成
self.agent = RLAgent.RLAgent(self.num_states, self.num_actions)
# デバイス情報の設定
d = self.util.getDEVICE()
self.device = torch.device(d)
def __init__(self, num_states, num_actions):
self.util = RLUtil.RLUtil()
# Cartpoleの行動（左右どちらかに押す）の2を取得する
self.num_actions = num_actions
# 経験を記憶するメモリオブジェクトを生成
self.memory = ReplayMemory.ReplayMemory(self.util.getCAPACITY())
# NNの構築
n_in, n_mid, n_out = num_states, 32, num_actions
self.main_q_network = RLNet.Net(n_in, n_mid, n_out)
self.target_q_network = RLNet.Net(n_in, n_mid, n_out)
# NNの形を出力
print(self.main_q_network)
# 最適化手法の設定
self.optimizer = optim.Adam(self.main_q_network.parameters(),
lr=0.0001)
# デバイスの設定
d = self.util.getDEVICE()
self.device = torch.device(d)