首先，基于图像和数值数据作为共同输入，自己创建一个CNN回归模型，其中图像和数值数据在全连接层进行拼接；然后，对CNN模型进行训练和测试；最后，基于最后一个卷积层，实现Grad-Cam可视化。PyTorch代码实现

好的，以下是一个基于PyTorch的CNN回归模型实现。假设我们的输入图像为224x224，数值数据为一个1x10的向量。我们将使用3个卷积层和2个全连接层。
import torch
import torch.nn as nn

class CNNRegression(nn.Module):
def __init__(self):
super(CNNRegression, self).__init__()
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.bn1 = nn.BatchNorm2d(16)
self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
self.bn2 = nn.BatchNorm2d(32)
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
self.bn3 = nn.BatchNorm2d(64)
self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)
self.fc1 = nn.Linear(64 * 28 * 28 + 10, 512)
self.fc2 = nn.Linear(512, 1)

def forward(self, x, y):
x = self.pool1(torch.relu(self.bn1(self.conv1(x))))
x = self.pool2(torch.relu(self.bn2(self.conv2(x))))
x = self.pool3(torch.relu(self.bn3(self.conv3(x))))
x = torch.flatten(x, start_dim=1)
x = torch.cat((x, y), dim=1)
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x

我们将使用Mean Squared Error作为我们的损失函数，并使用Adam优化器进行模型训练。
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters())

for epoch in range(num_epochs):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data['image'], data['value']
inputs, labels = inputs.to(device), labels.to(device)

optimizer.zero_grad()

outputs = model(inputs, labels)
loss = criterion(outputs, labels.view(-1, 1).float())
loss.backward()
optimizer.step()

running_loss += loss.item()
if i % 100 == 99:
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 100))
running_loss = 0.0

print('Finished Training')

接下来，我们将实现Grad-Cam可视化，以可视化CNN模型中每个类别的重要性区域。Grad-Cam基于梯度的可视化方法，因此我们需要保存CNN模型中最后一个卷积层的梯度。
class GradCam:
def __init__(self, model, last_conv_layer):
self.model = model
self.last_conv_layer = last_conv_layer
self.gradient = None
self.activations = None

self.last_conv_layer.register_backward_hook(self.save_gradient)

def save_gradient(self, module, grad_input, grad_output):
self.gradient = grad_output[0]

def forward(self, x, y):
x = x.to(device)
y = y.to(device)

output = self.model(x, y)
output.backward()

activations = self.last_conv_layer(x).detach()

weight = self.gradient.mean(dim=(2, 3)).unsqueeze(2).unsqueeze(3)
cam = (weight * activations).sum(dim=1, keepdim=True)
cam = torch.relu(cam)
cam = nn.functional.interpolate(cam, size=x.shape[2:], mode='bilinear', align_corners=False)
cam = cam.squeeze()

return cam.cpu().numpy()

最后，我们可以使用Grad-Cam可视化模型中每个类别的重要性区域。假设我们要可视化的图像和数值数据为test_image和test_value。
grad_cam = GradCam(model, model.conv3)
cam = grad_cam.forward(test_image, test_value)

plt.imshow(test_image.numpy().transpose((1, 2, 0)))
plt.imshow(cam, alpha=0.5, cmap='jet')

我们可以将alpha值设置为0.5，以使Grad-Cam的重要性区域更清晰可见。 cmap='jet'参数可以使Grad-Cam的颜色更加明亮。