你好，我有两个张量：
a = torch.randn(125, 128) # Shape: (125, 128)
b = torch.randn(128, 8, 64) # Shape: (128, 8, 64)
我希望结果的形状为（125，8，64）
我的第一个观察是：a 的最后一个维度与 b 的第一个维度匹配，然后我这样做：
result = torch.matmul(a,b)
它给了我错误：
batch2 张量的前两个维度的预期大小为：[128, 128]，但得到的结果是：[128, 8]。
我怎样才能做到这一点。
编辑：我也不想重塑为 2D，然后再将结果重塑为 3D。
我有一个简单的神经网络 - 一些线性层，层与层之间以及网络末端之后有 tanh。例如，我有一个形状为 (100, 2) 的输入张量，我希望输出的大小为 (100, 5)。但第一列中的值在 [0, 1] 范围内，也就是说，在末端使用 S 形激活函数是合适的。其他列中的值在 [-1, 1] 范围内，也就是说可以使用“tanh”激活函数。但我不明白如何为第一个输出列设置 S 形，为其他输出设置“tanh”？可能吗？或者，我应该对输出中的第一列应用 abs()，并在最后一个线性层之后设置“tanh”？
现在我有以下模型：
nn.Sequential(nn.Linear(input_size, hidden_size),
nn.Tanh(),
nn.Linear(hidden_size, output_size),
nn.Tanh())
y = model(x)
y[:,0] = torch.abs(y[:,0])
但我想要：
model = nn.Sequential(nn.Linear(input_size, hidden_size),
nn.Tanh(),
nn.Linear(hidden_size, output_size))
并对第一个输出应用 nn.Sigmoid()，对其他输出应用 nn.Tanh()：
y = model(x)
act_1 = nn.Sequential(nn.Sigmoid())
act_2 = nn.Sequential(nn.Tanh())
y[:,0] = act_1(y[:,0])
y[:,1:] = act_2(y[:,1:])
我手动计算 R^2，并将结果与没有多输出的 torcheval.metrics.regression.r2_score 进行比较，但我没有绑定总和平方计算，因此手动 R^2 与 torcheval 不同：
手动方法：
#Manual approach code
ss_total = torch.sum((var1 - torch.mean(var1)) ** 2)
ss_residual = torch.sum((var1 - var2) ** 2)
r2 = 1 - (ss_residual / ss_total)
print("R^2 manual",r2, "my ss_total", ss_total, "ss_residual", ss_residual)
#R^2 manual tensor(-1.4128, device='cuda:0') my ss_total tensor(3.7081, device='cuda:0') ss_residual tensor(8.9471, device='cuda:0')
Torcheval.metrics 方法tss 公式文档无需多输出：
sum_squared_obs = torch.sum((actual - torch.mean(actual)) ** 2)
tss sum squared calculation = sum_squared_obs - torch.square(sum_obs) / num_obs
r_squared = 1 - (rss / tss)
#torcheval.metrics.regression.r2_score tested in script
metric = R2Score(device=device)
update = metric.update(var1, var2)
print("sum_squared_residual",update.sum_squared_residual)
print("sum_obs",update.sum_obs)
print("torch.square(sum_obs)",torch.square(update.sum_obs))
print("num_obs",len(var1))
print("sum_squared_obs",update.sum_squared_obs)
r2_py = metric.compute()
print("R^2 pytorch",r2_py)
#sum_squared_residual tensor(8.9471, device='cuda:0')
#sum_obs tensor(-29.9617, device='cuda:0')
#torch.square(sum_obs) tensor(897.7044, device='cuda:0')
#num_obs 64
#sum_squared_obs tensor(22.2245, device='cuda:0')
#R^2 pytorch tensor(-0.0914, device='cuda:0')
#R^2 var_weight pytorch tensor(-0.0914, device='cuda:0')
我无法解开 tss。
有人能解释一下这两种方法有什么区别吗？
我已经在 Excel 中保存了实际值和预测值，并使用这两种方法计算 R^2。
我是 PyTorch 的新手，所以我的问题可能很微不足道。
我正在尝试最小化一个可以在片段中恢复的函数
def target_function(params):
vector = torch.zeros(10)
μr = torch.zeros(2, requires_grad=True)
θ = torch.zeros(2, requires_grad=True)
μr = torch.tensor([params[0], params[4]], requires_grad=True)
θ = torch.tensor([params[3], params[7]], requires_grad=True)
for i in range(2):
vector[i] += (μr[i]**2 - θ[i] ).sum()
return torch.norm(vector)
我尝试通过执行优化
import matplotlib.pyplot as plt
# Initialize parameters with random values between 0 and 1
params = torch.rand(10, requires_grad=True)
# Choose an optimizer (e.g., SGD) and specify the learning rate
optimizer = SGD([params], lr=0.01)
num_steps = 100
# Lists to store the values of the target function during optimization
target_values = []
# Optimization loop
for i in range(num_steps):
# Zero gradients
optimizer.zero_grad()
# Compute the function value
output = target_function(params)
# Store the function value
target_values.append(output.item())
# Compute gradients
output.backward()
# Update parameters
optimizer.step()
# Plot the values of the target function during optimization
plt.plot(target_values)
plt.xlabel('Iteration')
plt.ylabel('Target Function Value')
plt.title('Optimization Progress')
plt.show()
但函数的值似乎在循环期间不会变化。调试我发现它可能取决于使用变量μr 和θ代码中。也许我正在做一些不应该做的事情，但我不明白如何解决这个问题，保持变量μr 和θ。
感谢您的任何帮助或解释
我有一个张量
import torch
a = torch.randn(1, 3, requires_grad=True)
print('a: ', a)
>>> a: tensor([[0.0200, 1.00200, -4.2000]], requires_grad=True)
还有一个面具
mask = torch.zeros_like(a)
mask[0][0] = 1
我想屏蔽我的张量a而不将梯度传播到我的掩模张量（在我的实际情况中它有一个梯度）。我尝试了以下操作
with torch.no_grad():
b = a * mask
print('b: ', b)
>>> b: tensor([[0.0200, 0.0000, -0.0000]])
但它完全从我的张量中删除了梯度。正确的做法是什么？
如果标题中的术语奇怪或不正确，我深表歉意，我尝试参考以下场景：
作为一个最小的例子，我定义一个网络如下：
class Convolution_Layers(nn.Module):
def __init__(self, in, out, kernel):
super(Convolution_Layers, self).__init__()
self.conv2d = nn.Conv2d(in_channels=in, out_channels=out, kernel_size=kernel)
self.conv2d_layers = nn.Sequential(
self.conv2d,
nn.ReLU,
)
forward(self,x):
return self.conv2d_layers(x)
class Network_Model(nn.Module):
def __init__(self):
super(Network_Model, self).__init__()
self.basic_conv = Convolution_layers(1,1,3)
self.subnetwk_1 = nn.ModuleList().append([self.basic_conv])
self.subnetwk_2 = nn.ModuleList().append([self.basic_conv])
def forward(self,x1,x2):
out1, out2 = x1, x2
for l in self.subnetwk_1:
out1 = l(x1)
for l in self.subnetwk_2:
out2 = l(x2)
return out1,out2
我想知道这是否会导致子网 1 和 2 中的权重被共享，因为它们来自同一卷积层实例。
理想情况下，我希望权重是分开的，但只能创建一次基本卷积块，然后在其他地方重复使用它。可能有更好的方法来实现这一点。
这是我对内部培训流程如何运作的理解nn.MultiheadAttention。让我们忽略位置编码，只关注Q大小写。
batch = 1,num_heads = 2, seq_len = 5, problem_dim = 4.
word_embedding = [5,4]
q_weight = [4x4]
Q = word_embedding*q_weight
认为，
class MultiHeadAttentionModel(nn.Module):
def __init__(self, problem_dim, num_heads):
super().__init__()
self.multihead_attn = nn.MultiheadAttention(embed_dim=problem_dim,num_heads=num_heads,batch_first=True)
def forward(self, query, key, value):
attn_output, attn_output_weights = self.multihead_attn(query, key, value)
return attn_output, attn_output_weights
model = MultiHeadAttentionModel(problem_dim=problem_dim, num_heads=num_heads)
model.eval() <---------------- forward pass
attn_output, attn_output_weights = model(Q, K, V)
attn_output.backward() <--------------- training (backward pass)
final_linear_weight = model.multihead_attn.out_proj.weight
现在有最终的线性变换忽略缩放output = (softmax(Q.dot(K_trans).dot(V))*final_linear_weight
我的问题是，final_linear_weight训练阶段学习的唯一权重是吗？
在我的 Ubuntu 18.04 机器上，我有一个包含pytorch=1.10.0=cuda110py38hf84197b_0. 我的 CUDA 版本是 11.0，我通过运行nvidia-smi. 我想安装 torchaudio。
我已经尝试过使用mamba install torchaudio=0.10.0 -c pytorch. 然而，这试图将我的 pytorch 的 cuda 版本从 11.0 升级到 11.2。同样，如果我尝试安装 torchaudio=0.9.1，mamba 想要将我的 pytorch 版本从 1.10.0 降级到 1.9.1。
这是一台旧机器，具有几年前的代码，依赖于这些旧软件包。理想情况下，我能够通过修改尽可能少的包/cuda 驱动程序来安装 torchaudio。有没有办法为 pytorch 1.10.0 cuda build 11.0 安装 torchaudio？我已经检查了官方 pytorch 发布页面，似乎这个选项甚至没有列出（所以也许我已经回答了我自己的问题，但我也在尝试在这里）。
作为参考，这里是一个包含我的 pytorch 必需包的基本环境。谢谢。
name: torchbase
channels:
- pytorch
- conda-forge
- defaults
dependencies:
- _libgcc_mutex=0.1=conda_forge
- _openmp_mutex=4.5=1_llvm
- bzip2=1.0.8=h7f98852_4
- ca-certificates=2023.11.17=hbcca054_0
- cffi=1.15.0=py38h3931269_0
- cudatoolkit=11.0.3=h15472ef_9
- cudnn=8.2.1.32=h86fa8c9_0
- future=0.18.2=py38h578d9bd_4
- icu=68.2=h9c3ff4c_0
- ld_impl_linux-64=2.36.1=hea4e1c9_2
- libblas=3.9.0=12_linux64_mkl
- libcblas=3.9.0=12_linux64_mkl
- libffi=3.4.2=h7f98852_5
- libgcc-ng=11.2.0=h1d223b6_11
- libiconv=1.16=h516909a_0
- liblapack=3.9.0=12_linux64_mkl
- libnsl=2.0.0=h7f98852_0
- libprotobuf=3.18.1=h780b84a_0
- libstdcxx-ng=11.2.0=he4da1e4_11
- libuuid=2.32.1=h7f98852_1000
- libxml2=2.9.12=h72842e0_0
- libzlib=1.2.11=h36c2ea0_1013
- llvm-openmp=12.0.1=h4bd325d_1
- magma=2.5.4=h4a2bb80_2
- mkl=2021.4.0=h8d4b97c_729
- nccl=2.11.4.1=h96e36e3_0
- ncurses=6.2=h58526e2_4
- ninja=1.10.2=h4bd325d_1
- numpy=1.22.3=py38h99721a1_2
- openssl=1.1.1o=h166bdaf_0
- pip=23.3.2=pyhd8ed1ab_0
- pycparser=2.21=pyhd8ed1ab_0
- python=3.8.12=hb7a2778_2_cpython
- python_abi=3.8=2_cp38
- pytorch=1.10.0=cuda110py38hf84197b_0
- pytorch-gpu=1.10.0=cuda110py38h5b0ac8e_0
- readline=8.1=h46c0cb4_0
- setuptools=60.1.1=py38h578d9bd_0
- sleef=3.5.1=h9b69904_2
- tbb=2021.5.0=h4bd325d_0
- tk=8.6.11=h27826a3_1
- typing_extensions=4.0.1=pyha770c72_0
- wheel=0.37.1=pyhd8ed1ab_0
- xz=5.2.5=h516909a_1
- zlib=1.2.11=h36c2ea0_1013
- zstd=1.5.1=ha95c52a_0
我在将鉴别器包含到SRGAN. 在 Flickr 数据集上进行训练时，我发现鉴别器无法尽早学习任何内容（显示BCELoss值为 100）并且永远无法恢复。我尝试了一下并删除了 sigmoid，希望用作BCEWithLogits损失。这导致损失一开始变化很大，最后趋于零。
调试鉴别器实现的好方法是什么？我怀疑我在训练中打电话给鉴别器的方式有问题。
class DiscriminatorConvBlock(nn.Module):
def __init__(self, in_channels, out_channels, stride):
super(DiscriminatorConvBlock, self).__init__()
num_groups = 8
self.conv1 = nn.Sequential(nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
nn.GroupNorm(num_groups, out_channels),
nn.LeakyReLU(0.2, False),
)
def forward(self, x):
out = self.conv1(x)
return out
class Discriminator(nn.Module):
def __init__(self, low_res_dim):
super(Discriminator, self).__init__()
img_d = int(low_res_dim / 4)
self.conv1 = nn.Sequential(nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1, bias=False),
nn.LeakyReLU(0.2, False),
)
self.conv2 = DiscriminatorConvBlock(64, 64, 2)
self.conv3 = DiscriminatorConvBlock(64, 128, 1)
self.conv4 = DiscriminatorConvBlock(128, 128, 2)
self.conv5 = DiscriminatorConvBlock(128, 256, 1)
self.conv6 = DiscriminatorConvBlock(256, 256, 2)
self.conv7 = DiscriminatorConvBlock(256, 512, 1)
self.conv8 = DiscriminatorConvBlock(512, 512, 2)
self.dense1 = nn.Linear(512 * img_d * img_d , 1024)
self.leakyRelu = nn.LeakyReLU(0.2, False)
self.dense2 = nn.Linear(1024 , 1)
self.drop = nn.Dropout(0.3)
def forward(self, x):
out = self.conv1(x)
out = self.conv2(out)
out = self.conv3(out)
out = self.conv4(out)
out = self.conv5(out)
out = self.conv6(out)
out = self.conv7(out)
out = self.conv8(out)
out = out.view(-1, out.size(1) * out.size(2) * out.size(3))
out = self.leakyRelu(self.dense1(out))
out = self.dense2(out)
out = torch.clamp_(out, 0.0, 1.0)
return out
gen_model = Generator().to(device)
disc_model = Discriminator(low_res).to(device)
# VGG terms
vgg = models.vgg19(pretrained=True).to(device)
feature_nodes = ["features.35"]
feature_extractor = create_feature_extractor(vgg, feature_nodes)
feature_extractor_nodes = feature_nodes
normalizeT = transforms.Normalize([ 0.5, 0.5, 0.5 ], [ 0.5, 0.5, 0.5 ])
for model_parameters in feature_extractor.parameters():
model_parameters.requires_grad = False
feature_extractor.eval()
gen_optimizer = optim.Adam(gen_model.parameters(),lr=1e-4)
disc_optimizer = optim.Adam(disc_model.parameters(),lr=1e-5)
gen_scheduler = CosineAnnealingWarmRestarts(gen_optimizer,
T_0 = 8,# Number of iterations for the first restart
T_mult = 1, # A factor increases TiTi after a restart
eta_min = 1e-5) # Minimum learning rate
disc_scheduler = CosineAnnealingWarmRestarts(disc_optimizer,
T_0 = 8,# Number of iterations for the first restart
T_mult = 1, # A factor increases TiTi after a restart
eta_min = 1e-6) # Minimum learning rate
mse_loss = nn.MSELoss()
vgg_loss = nn.MSELoss()
disc_loss = nn.BCEWithLogitsLoss()
disc_loss_generator = nn.BCEWithLogitsLoss()
gen_optimizer.zero_grad()
for epoch in range(num_epochs):
gen_scheduler.step()
disc_scheduler.step()
for i, data in enumerate(tqdm.tqdm(dataloader)):
input_images, labels = data
# forward pass
input_images = input_images.to(device)
lowres_images = transforms.Resize(low_res)(input_images)
gen_highres_images = gen_model(lowres_images.to(device))
for model_parameters in disc_model.parameters():
model_parameters.requires_grad = True
# Discriminator
disc_model.zero_grad()
actual_label = disc_model(input_images.to(device))
# Adversarial loss
d2_loss = (disc_loss(actual_label, torch.ones_like(actual_label,dtype=torch.float)))
d2_loss.backward()
generated_label = disc_model(gen_highres_images.to(device))
d1_loss = (disc_loss(generated_label, torch.zeros_like(generated_label,dtype=torch.float)))
d1_loss.backward(retain_graph=True)
errD = d2_loss + d1_loss
disc_optimizer.step()
gen_model.zero_grad()
# Perceptual loss
mse = mse_loss(normalizeT(gen_highres_images), normalizeT(input_images))
vgg_losses = []
sr_feature = feature_extractor(normalizeT(input_images))
gt_feature = feature_extractor(normalizeT(gen_highres_images))
for i in range(len(feature_extractor_nodes)):
vgg_losses.append(vgg_loss(sr_feature[feature_extractor_nodes[i]],
gt_feature[feature_extractor_nodes[i]]))
for model_parameters in disc_model.parameters():
model_parameters.requires_grad = False
actual_generated_label = disc_model(gen_highres_images.to(device))
gen_disc_loss = disc_loss_generator(actual_generated_label, torch.ones_like(actual_label,dtype=torch.float))
generator_loss = vgg_losses[0] + mse + gen_disc_loss
generator_loss.backward()
gen_optimizer.step()
gen_optimizer.zero_grad()
torch.cuda.empty_cache()
一段时间以来一直试图解决这个问题。我发现了这个类似的问题，但我认为提议的答案实际上并没有解决这个问题。
在编码器/解码器 Transformer 的推理模式下，我的理解是我们不会预先填充解码器输入序列以匹配编码器序列长度（即传入[start_id,]而不传入[start_id, pad_id, pad_id, ...]）
我可能会遗漏一些东西，但是当我不预填充时，注意机制无法正确计算矩阵乘法，因为解码器输入的 seq_length = 1，而编码器 seq_length > 1 ( T)。作为参考（参见附图），我在每个步骤中识别了张量形状，您可以看到在给定不兼容的张量形状的情况下无法执行最后一个 matmul 步骤的位置。
我缺少什么？我应该预填充解码器输入吗？或者我是否截断编码器输出以匹配解码器长度？还有别的事吗？
