def LSTMCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):
"""
LSTM.weight_ih_l[k] = (4*hidden_size, input_size)
将三个gate的ih和输入的ih上下拼接合成一个矩阵weight_ih_l[k],
所以为什么是４倍hidden_size拼接顺序无所谓
同理 LSTM.weight_hh_l[k] = (4*hidden_size, hidden_size)，也是四个hh矩阵拼接合成一个矩阵
weight_ih =
[ih_in
ih_forget
ih_cell
ih_out
]
"""
hx, cx = hidden
gates = F.linear(input, w_ih, b_ih) + F.linear(hx, w_hh, b_hh)
# 此处沿着1轴切成４块，分别作为４个输入, 返回顺序无所谓，都是原始参数矩阵的输出
# 重要是之后的激活函数确定是那个门
# 分解出来的四个矩阵shape是(hidden_size, hidden_size)
ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1)
ingate = F.sigmoid(ingate)
forgetgate = F.sigmoid(forgetgate)
cellgate = F.tanh(cellgate)
outgate = F.sigmoid(outgate)
cy = (forgetgate * cx) + (ingate * cellgate)
hy = outgate * F.tanh(cy)
return hy, cy
def forward(self, output, target):
t0 = time.time()
#output : BxAs*(4+1+num_classes)*H*W
t0 = time.time()
nB, _, nH, nW = output.size()
nA = self.num_anchors
nC = self.num_classes
output = output.view(nB, nA, (5 + nC), nH, nW)
coordinate_x = F.sigmoid(
output.index_select(2, Variable(torch.cuda.LongTensor([0]))).view(
nB, nA, nH, nW))
coordinate_y = F.sigmoid(
output.index_select(2, Variable(torch.cuda.LongTensor([1]))).view(
nB, nA, nH, nW))
coordinate_w = output.index_select(
2, Variable(torch.cuda.LongTensor([2]))).view(nB, nA, nH, nW)
coordinate_h = output.index_select(
2, Variable(torch.cuda.LongTensor([3]))).view(nB, nA, nH, nW)
confidence = F.sigmoid(
output.index_select(2, Variable(torch.cuda.LongTensor([4]))).view(
nB, nA, nH, nW))
cls = output.index_select(
2,
Variable(torch.linspace(5, 5 + nC - 1), nC).long().cuda())
cls = cls.view(nB * nA, nC, nH * nW).transpose(1, 2).contiguous().view(
nB * nA * nH * nW, nC)
t1 = time.time()
pred_boxes = torch.cuda.FloatTensor(4, nB * nA * nH * nW)
grid_x = torch.linspace(0, nW - 1,
nW).repeat(nB * nA, 1,
1).view(nB * nA * nH * nW).cuda()
grid_y = torch.linspace(0, nH - 1, nH).repeat(nW, 1).t().repeat(
nB * nA, 1, 1).view(nB * nA * nH * nW).cuda()
anchor_w = torch.Tensor(self.anchors).view(
nA, self.anchor_step).index_select(1,
torch.LongTensor([0])).cuda()
anchor_h = torch.Tensor(self.anchors).view(
nA, self.anchor_step).index_select(1,
torch.LongTensor([1])).cuda()
anchor_w = anchor_w.repeat(nB,
1).repeat(1, 1,
nH * nW).view(nB * nA * nH * nW)
anchor_h = anchor_h.repeat(nB,
1).repeat(1, 1,
nH * nW).view(nB * nA * nH * nW)
pred_boxes[0] = coordinate_x.data + grid_x
pred_boxes[1] = coordinate_y.data + grid_y
pred_boxes[2] = torch.exp(coordinate_w.data) * anchor_w
pred_boxes[3] = torch.exp(coordinate_h.data) * anchor_h
pred_boxes = convert2cpu(
pred_boxes.transpose(0, 1).contiguous().view(-1, 4))
t2 = time.time()
nGT, nCorrect, coord_mask, conf_mask, cls_mask, tx, ty, tw, th, tconf, tcls = build_targets(
pred_boxes, target.data, self.anchors, nA, nC, nH, nW,
self.noobject_scale, self.object_scale, self.thresh, self.seen)
def residue_forward(self, input, conv_sigmoid, conv_tanh, skip_scale,
residue_scale):
output = input
output_sigmoid, output_tanh = conv_sigmoid(output), conv_tanh(output)
output = F.sigmoid(output_sigmoid) * F.tanh(output_tanh)
skip = skip_scale(output)
output = residue_scale(output)
output = output + input[:, :, -output.size(2):]
return output, skip
def forward(self, x):
#x = self.embedding(x)
# x = self.one_hot_to_emb(x)
#import pdb; pdb.set_trace()
#x = x.permute(0,2,1)
#x_conv_list = [F.relu(conv1d(x)) for conv1d in self.conv1_list]
#x_pool_list = [F.max_pool1d(x_conv, kernel_size=x_conv.shape[2])
# for x_conv in x_conv_list]
#x_fc = torch.cat([x_pool.squeeze(dim=2) for x_pool in x_pool_list], dim=1)
#logits = self.fc(self.dropout(x_fc))
#if self.num_classes == 1:
# logits = logits.squeeze()
#x = self.conv1(x)
#x = F.leaky_relu(x, negative_slope=self.lrelu_neg_slope)
#x = self.conv2(x)
#x = self.batch_norm2(x)
#x = F.leaky_relu(x, negative_slope=self.lrelu_neg_slope)
#x = self.conv3(x)
#x = self.batch_norm3(x)
#x = F.leaky_relu(x, negative_slope=self.lrelu_neg_slope)
#x = torch.flatten(x)
x = x.unsqueeze(3)
import pdb
pdb.set_trace()
# Encoding
x = self.conv1(x)
x = self.relu(x)
x = self.pool(x)
x = self.conv2(x)
x = self.relu(x)
x = self.pool(x)
# Decoding
x = self.t_conv1(x)
x = self.relu(x)
x = self.t_conv2(x)
#x = F.relu(x)
x = F.sigmoid(x)
return x
def forward(self, x):
x = F.leaky_relu(self.conv1(x), 0.2)
x = F.leaky_relu(self.bn1(self.conv2(x)), 0.2)
x = F.leaky_relu(self.bn2(self.conv3(x)), 0.2)
x = F.leaky_relu(self.bn3(self.conv4(x)), 0.2)
x = F.leaky_relu(self.bn4(self.conv5(x)), 0.2)
x = F.leaky_relu(self.bn5(self.conv6(x)), 0.2)
x = F.leaky_relu(self.bn6(self.conv7(x)), 0.2)
x = F.leaky_relu(self.bn7(self.conv8(x)), 0.2)
x = F.leaky_relu(self.conv9(self.flatten(x)))
x = F.sigmoid(self.conv10(x))
return x
def forward(self, x):
if self.upsample:
new_features = []
for layer in self.layers:
out = layer(x)
x = torch.cat([x, out], 1)
new_features.append(out)
out = torch.cat(new_features, 1)
fm_size = out.size()[2]
scale_weight = F.avg_pool2d(out, fm_size)
scale_weight = F.relu(self.SE_upsample1(scale_weight))
scale_weight = F.sigmoid(self.SE_upsample2(scale_weight))
out = out * scale_weight.expand_as(out)
return out
else:
for layer in self.layers:
out = layer(x)
x = torch.cat([x, out], 1) # 1 = channel axis
fm_size = x.size()[2]
scale_weight = F.avg_pool2d(x, fm_size)
scale_weight = F.relu(self.SE1(scale_weight))
scale_weight = F.sigmoid(self.SE2(scale_weight))
x = x * scale_weight.expand_as(x)
return x
def dec_act(self, inputs):
if self.args.dec_act == 'tanh':
return F.tanh(inputs)
elif self.args.dec_act == 'elu':
return F.elu(inputs)
elif self.args.dec_act == 'relu':
return F.relu(inputs)
elif self.args.dec_act == 'selu':
return F.selu(inputs)
elif self.args.dec_act == 'sigmoid':
return F.sigmoid(inputs)
elif self.args.dec_act == 'linear':
return inputs
else:
return F.elu(inputs)
def choose_action(self, state): #here state is simply the current f_map
state_tensor = torch.tensor([state]).to(self.ActorCritic.device)
(mu, sigma), _ = self.ActorCritic.forward(state_tensor)
actions = np.zeros(self.cell_nb, self.cell_nb)
log_probs = np.zeros_like(actions)
for ir, (mu_r, sig_r) in enumerate(zip(mu, sigma)):
for ic, (mu_c, sig_c) in enumerate(zip(mu_r, sig_r)):
#mu_c and sig_c are the mu and sigma parameter for the gaussian distribution of the current cell
sig_c = torch.exp(sig_c)
dist = torch.distributions.Normal(mu_c, sig_c)
action = dist.sample()
log_prob = dist.log_prob(action).to(self.ActorCritic.device)
actions[ir, ic] = F.sigmoid(action.item(
)) #bound the normalized transmit power between 0 and 1
log_probs[
ir, ic] = log_prob #for later, to calculate the actor loss
self.log_probs = log_probs
return actions
def softwhere(input, x=0.0, y=1.0, width=1.0):
"""Soft version of `torch.where(input > 0, x, y)`
The operation is defined as:
.. math::
out = p * x + (1 - p) * y
p = sigmoid(input / width)
Args:
- input : Tensor
- threshold : float | Tensor
- x : float | Tensor
- y : float | Tensor
- width : float | Tensor
Returns:
TODO(simaki)
Shape:
- input : :math:`(*)`
"""
p = fn.sigmoid(input / width)
return p * x + (1 - p) * y
def bernoulli(mean, temp):
g1 = -torch.log(1e-10 - torch.log(1e-10+Variable(mean.data.new(mean.shape).uniform_())))
g2 = -torch.log(1e-10 - torch.log(1e-10+Variable(mean.data.new(mean.shape).uniform_())))
return F.sigmoid((g1 + torch.log(1e-10+mean) - g2 - torch.log(1e-10+1-mean)) / temp)
def forward(self, usr_emb):
y = F.sigmoid(self.layer1(usr_emb))
return y
def eval_metrics(output, target):
output = (F.sigmoid(output) > 0.5)
target = target
return torch.norm(output - target)
def forward(self, x):
x = F.elu(self.map1(x))
x = F.elu(self.map2(x))
return F.sigmoid(self.map3(x))
def eval_metrics(output, target):
output = (F.sigmoid(output) > 0.5).cpu().data.numpy()
target = target.cpu().data.numpy()
return np.linalg.norm(output - target)
