def __init__(self,
seed,
nS,
nA,
nB,
params,
hidden_dims=(64, 64),
activation=F.leaky_relu):
super().__init__()
self.activation = activation
self.nS = nS
self.nA = nA
self.nB = nB
self.combined_output = nA - 2 + nB
self.helper_functions = NetworkFunctions(self.nA, self.nB)
self.maxlen = params['maxlen']
self.process_input = PreProcessLayer(params)
# self.seed = torch.manual_seed(seed)
self.mapping = params['mapping']
self.hand_emb = Embedder(5, 64)
self.action_emb = Embedder(6, 64)
self.betsize_emb = Embedder(self.nB, 64)
self.noise = GaussianNoise()
self.emb = 1248
n_heads = 8
depth = 2
self.lstm = nn.LSTM(self.emb, 128)
# self.transformer = CTransformer(emb,n_heads,depth,self.max_length,self.nA)
self.fc1 = nn.Linear(528, hidden_dims[0])
self.fc2 = nn.Linear(hidden_dims[0], hidden_dims[1])
self.fc3 = nn.Linear(1280, self.combined_output)
self.dropout = nn.Dropout(0.5)
def __init__(self,
seed,
nO,
nA,
nB,
params,
hidden_dims=(64, 64),
activation=F.leaky_relu):
super().__init__()
self.activation = activation
self.nO = nO
self.nA = nA
self.nB = nB
self.combined_output = nA - 2 + nB
self.maxlen = params['maxlen']
self.mapping = params['state_mapping']
self.device = params['device']
# self.emb = params['embedding_size']
self.helper_functions = NetworkFunctions(self.nA, self.nB)
self.process_input = PreProcessLayer(params)
self.lstm = nn.LSTM(1280, 128)
self.policy_out = nn.Linear(1280, self.combined_output)
self.noise = GaussianNoise(self.device)
emb = params['transformer_in']
n_heads = 8
depth = 2
self.transformer = CTransformer(emb, n_heads, depth, self.maxlen,
params['transformer_out'])
self.dropout = nn.Dropout(0.5)
self.value_output = nn.Linear(params['transformer_out'], 1)
self.advantage_output = nn.Linear(params['transformer_out'],
self.combined_output)
def __init__(self,seed,nS,nA,nB,params,hidden_dims=(64,64),activation=F.leaky_relu):
"""
Network capable of processing any number of prior actions
Num Categories: nA (check,fold,call,bet,raise)
Num Betsizes: nB (various betsizes)
"""
super().__init__()
self.activation = activation
# self.seed = torch.manual_seed(seed)
self.nS = nS
self.nA = nA
self.nB = nB
self.hand_emb = Embedder(5,64)
self.action_emb = Embedder(6,63)
self.combined_output = nA - 2 + nB
self.helper_functions = NetworkFunctions(self.nA,self.nB)
self.preprocess = PreProcessHistory(params)
self.max_length = 10
self.emb = 512
n_heads = 8
depth = 2
self.positional_emb = Embedder(self.max_length,128)
self.lstm = nn.LSTM(self.emb, 256)
# self.transformer = CTransformer(self.emb,n_heads,depth,self.max_length,self.combined_output,max_pool=False)
self.mapping = params['mapping']
self.noise = GaussianNoise(is_relative_detach=True)
self.fc1 = nn.Linear(128,hidden_dims[0])
self.fc2 = nn.Linear(hidden_dims[0],hidden_dims[1])
self.fc3 = nn.Linear(2560,self.combined_output)
def __init__(self,seed,nS,nC,nA,params,hidden_dims=(64,64),activation=F.leaky_relu):
super().__init__()
self.activation = activation
self.nS = nS
self.nC = nC
self.nA = nA
# self.seed = torch.manual_seed(seed)
self.mapping = params['mapping']
self.hand_emb = Embedder(5,64)
self.action_emb = Embedder(6,64)
self.noise = GaussianNoise()
self.fc1 = nn.Linear(64+64,hidden_dims[0])
self.fc2 = nn.Linear(hidden_dims[0],hidden_dims[1])
self.fc3 = nn.Linear(hidden_dims[1],nC)
def __init__(self,seed,nS,nA,nB,params,hidden_dims=(64,64),activation=F.leaky_relu):
"""
Num Categories: nA (check,fold,call,bet,raise)
Num Betsizes: nB (various betsizes)
"""
super().__init__()
self.activation = activation
self.nS = nS
self.nA = nA
self.nB = nB
self.combined_output = nA - 2 + nB
self.helper_functions = NetworkFunctions(self.nA,self.nB)
self.mapping = params['mapping']
self.hand_emb = Embedder(5,64)
self.action_emb = Embedder(6,64)
self.betsize_emb = Embedder(self.nB,64)
self.noise = GaussianNoise()
self.fc1 = nn.Linear(129,hidden_dims[0])
self.fc2 = nn.Linear(hidden_dims[0],hidden_dims[1])
self.fc3 = nn.Linear(hidden_dims[1],self.combined_output)
def __init__(self,
seed,
nS,
nA,
nB,
params,
hidden_dims=(64, 64),
activation=F.leaky_relu):
super().__init__()
self.activation = activation
self.nS = nS
self.nA = nA
self.nB = nB
self.combined_output = nA - 2 + nB
self.helper_functions = NetworkFunctions(self.nA, self.nB)
self.maxlen = params['maxlen']
self.device = params['device']
self.epsilon = params['epsilon']
self.epsilon_weights = params['epsilon_weights'].to(self.device)
self.process_input = PreProcessLayer(params)
# self.seed = torch.manual_seed(seed)
self.state_mapping = params['state_mapping']
self.action_emb = Embedder(Action.UNOPENED, 64)
self.betsize_emb = Embedder(self.nB, 64)
self.noise = GaussianNoise(self.device)
self.emb = 1248
n_heads = 8
depth = 2
# self.attention = EncoderAttention(params['lstm_in'],params['lstm_out'])
self.lstm = nn.LSTM(params['lstm_in'],
params['lstm_out'],
bidirectional=True)
self.batchnorm = nn.BatchNorm1d(self.maxlen)
# self.blocks = nn.Sequential(
# IdentityBlock(hidden_dims=(2560,2560,512),activation=F.leaky_relu),
# IdentityBlock(hidden_dims=(512,512,256),activation=F.leaky_relu),
# )
self.fc_final = nn.Linear(5120, self.combined_output)
def __init__(self,seed,nS,nC,nA,params,hidden_dims=(64,64),activation=F.leaky_relu):
"""
Num Categories: nC (check,fold,call,bet,raise)
Num Betsizes: nA (various betsizes)
"""
super().__init__()
self.activation = activation
self.nS = nS
self.nC = nC
self.nA = nA
self.seed = torch.manual_seed(seed)
self.mapping = params['mapping']
self.hand_emb = Embedder(5,64)
self.action_emb = Embedder(6,64)
self.betsize_emb = Embedder(self.nA,64)
self.noise = GaussianNoise()
self.fc1 = nn.Linear(128,hidden_dims[0])
self.fc2 = nn.Linear(hidden_dims[0],hidden_dims[1])
self.fc3 = nn.Linear(hidden_dims[1],nC)
self.bfc1 = nn.Linear(64,hidden_dims[0])
self.bfc2 = nn.Linear(hidden_dims[0],hidden_dims[1])
self.bfc3 = nn.Linear(hidden_dims[1],nA)