为什么神经网络转移到Gpu运算后变慢

Question

为什么神经网络转移到Gpu运算后，没有加速反而变慢了

import numpy as np
import torch
import torch.nn as nn
np.random.seed(234198)
import time
import scipy.stats
 
torch.cuda.is_available()
torch.cuda.device_count()
torch.cuda.get_device_name(0)
torch.cuda.current_device()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
start_time = time.time()
class stock:
    def __init__(self, T, K, sigma, delta, So, r, N, M, d):
        self.T = T 
        self.K=K 
        self.sigma=sigma *np.ones(d) 
        self.delta=delta 
        self.So=So*np.ones(d) 
        self.r=r 
        self.N=N 
        self.M=M 
        self.d=d 
    
    def GBM(self):
        
        dt=self.T/self.N
        So_vec=self.So*np.ones((1,S.M, S.d))
        
        Z=np.random.standard_normal((self.N,self.M, self.d))
        s=self.So*np.exp(np.cumsum((self.r-self.delta-0.5*self.sigma**2)*dt+self.sigma*np.sqrt(dt)*Z, axis=0))
        
        s=np.append(So_vec, s, axis=0)
        return s
    
    
    def g(self,n,m,X):
        max1=torch.max(X[int(n),m,:].float()-self.K).to(device)
       ## input_tensor = torch.tensor(self.r * (self.T / self.N) * n)
        return torch.exp((self.r * (self.T / self.N) * n) * torch.max(max1.to(device), torch.tensor([0.0]).to(device))).to(device) 
       # return np.exp((self.r * (self.T / self.N) * n)*torch.max(max1.to(device),torch.tensor([0.0]).to(device))
       

 #
class NeuralNet(torch.nn.Module):
    def __init__(self, d, q1, q2):
        super(NeuralNet, self).__init__()
        self.a1 = nn.Linear(d, q1) 
        self.relu = nn.ReLU()
        self.a2 = nn.Linear(q1, q2)
        self.a3 = nn.Linear(q2, 1)  
        self.sigmoid=nn.Sigmoid()
    
    def forward(self, x):
        out = self.a1(x)
        out = self.relu(out)
        out = self.a2(out)
        out = self.relu(out)
        out = self.a3(out)
        out = self.sigmoid(out)
        
        return out
    
def loss(y_pred,s, x, n, tau):
    r_n=torch.zeros(s.M,device=device)
    for m in range(0,s.M):
        
        r_n[m]=-s.g(n,m,x)*y_pred[m] - s.g(tau[m],m,x)*(1-y_pred[m])
    
    return(r_n.mean().to(device))
    
#%%
##def __init__(self, T, K, sigma, delta, So, r, N, M, d):
S=stock(T=3,K=100,sigma=0.4,delta=0.1,So=90,r=0.05,N=9,M=50000,d=4)

X=torch.from_numpy(S.GBM()).float().to(device) 
#%%

def NN(n,x,s, tau_n_plus_1):
    epochs=50
    model=NeuralNet(s.d,s.d+40,s.d+40).to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr = 0.0001)

    for epoch in range(epochs):
        F = model.forward(X[n].to(device))
        optimizer.zero_grad()
        criterion = loss(F,S,X,n,tau_n_plus_1).to(device)
        criterion.backward()
        optimizer.step()
    
    return F,model

mods=[None]*S.N
tau_mat=torch.zeros((S.N+1,S.M)) 
tau_mat[S.N,:]=S.N

f_mat=torch.zeros((S.N+1,S.M))
f_mat[S.N,:]=1

#%%
for n in range(S.N-1,-1,-1):
    probs, mod_temp = NN(n, X, S, torch.from_numpy(np.array(tau_mat[n+1])).float().to(device))
    #probs, mod_temp=NN(n, X, S,torch.from_numpy(tau_mat[n+1]).float().to(device)) 
    mods[n]=mod_temp
    np_probs=probs.detach().reshape(S.M)
    print(n, ":", min(np_probs)," , ", max(np_probs))

    f_mat[n,:]=(np_probs > 0.5)*1.0

    tau_mat[n,:]=torch.argmax(f_mat, axis=0)

#%% 
Y=torch.from_numpy(S.GBM()).float().to(device) 

tau_mat_test=torch.zeros((S.N+1,S.M)) 
tau_mat_test[S.N,:]=S.N

f_mat_test=torch.zeros((S.N+1,S.M)) 
f_mat_test[S.N,:]=1

V_mat_test=torch.zeros((S.N+1,S.M)) 
V_est_test=torch.zeros(S.N+1)

for m in range(0,S.M):
    V_mat_test[S.N,m]=S.g(S.N,m,Y)
    
V_est_test[S.N]=torch.mean(V_mat_test[S.N,:])



for n in range(S.N-1,-1,-1):
    mod_curr=mods[n]
    probs=mod_curr(Y[n])
    np_probs=probs.detach().reshape(S.M)

    f_mat_test[n,:]=(np_probs > 0.5)*1.0

    tau_mat_test[n,:]=torch.argmax(f_mat_test, axis=0)
    
    
    for m in range(0,S.M):
        V_mat_test[n,m]=torch.exp((n-tau_mat_test[n,m])*(-S.r*S.T/S.N))*S.g(tau_mat_test[n,m],m,X) 
        
end_time = time.time()
#%%
V_est_test=torch.mean(V_mat_test, axis=1)
V_std_test=torch.std(V_mat_test, axis=1)
V_se_test=V_std_test/(np.sqrt(S.M))

z=scipy.stats.norm.ppf(0.975)
lower=V_est_test[0] - z*V_se_test[0]
upper=V_est_test[0] + z*V_se_test[0]
# 计算训练时间
training_time = end_time - start_time
print("模型训练时间：", training_time, "秒")
print(V_est_test[0])
print(V_se_test[0])
print(lower)
print(upper)

Answer 1

晚上好🌙🌙🌙
本答案参考ChatGPT-3.5

神经网络转移到GPU运算后，性能可能会有所下降的原因有很多，以下是一些可能的原因和对应的解决方案：

原因一：GPU计算资源有限 如果训练数据集非常大或者计算量很大，那么CPU的运行速度可能会赶不上GPU的运算能力。此时，可以考虑使用分布式计算框架（如Spark、Hadoop等）来分批处理数据。

解决方案：将数据分割成多个部分，并分配到不同的GPU上进行处理；同时，可以使用GPU的并行计算能力，如OpenMP或CUDA编程。

原因二：GPU内存不足 如果GPU的内存不足以存放所有的数据，那么计算的速度也会受到影响。此时，可以考虑使用更小规模的数据进行训练，或者在硬件上优化硬件配置以提高内存利用率。

解决方案：使用较小规模的数据进行训练；或者在硬件上优化硬件配置，如增加内存条、使用SSD硬盘代替HDD硬盘等。

原因三：训练时间过长 如果训练的时间过长，那么CPU的运算速度也无法跟上GPU的运算速度。此时，可以通过减少数据的批次大小、优化模型结构、增加学习率等方式来缩短训练时间。

解决方案：减少数据的批次大小；优化模型结构；增加学习率等。

问题四：GPU版本不兼容 不同版本的GPU可能无法完美地配合特定的深度学习框架（如TensorFlow、PyTorch等）。此时，需要确保GPU版本与深度学习框架相匹配。

解决方案：升级到最新版本的深度学习框架；选择支持GPU的深度学习框架。

问题五：训练参数设置不合理 在训练神经网络时，某些参数设置不当也可能导致性能下降。例如，学习率、权重初始化方式、正则化参数等都可能影响到训练效果。

解决方案：根据实际需求调整这些参数的值。

以上就是一些可能导致神经网络转移到GPU运算后性能下降的因素及其解决方案。希望对你有所帮助。