我尝试运行这个用于回归模型的神经网络脚本。上面定义了两个类。一个是标准化类（Standardizer），另一个是神经网络类（NeuralNet）。标准化类用于归一化所有值，而神经网络类则构建通过前馈和反向传播学习数据的神经网络。

这个函数以输入数、隐藏单元数和输出数作为三个参数。

set_hunit 函数用于更新或初始化权重。它以权重作为参数。

Pack 函数将每一层的多个权重打包成一个向量。unpack 函数则执行相反的操作。

神经网络的前向传递如下所示：

𝑍𝑌=ℎ(𝑋𝑙⋅𝑉)=𝑍𝑙⋅𝑊

激活函数用于使网络非线性。我们可以使用 tanh 或 RBF 等函数。

在反向传递中，函数接收 z 值、目标值和误差作为输入。根据 delta 值，相应地更新权重和偏置。此方法返回该特定层的权重向量打包。以下是反向传递期间执行的函数。

𝑉𝑊←𝑉+𝛼ℎ1𝑁1𝐾𝑋𝑙⊤((𝑇−𝑌)𝑊⊤⊙(1−𝑍2))←𝑊+𝛼𝑜1𝑁1𝐾𝑍𝑙⊤(𝑇−𝑌)

train 函数以特征和目标作为输入。gradientf 函数解包权重，通过调用 forward 函数进行前向传递。现在使用前向传递的结果计算误差。然后通过调用带有误差、Z、T（目标）、_lambda 参数的 backward 函数进行反向传播。

optimtarget 函数尝试通过使用目标函数来减少误差，并相应地更新权重。

在训练模型后，use 方法应用于测试数据。测试数据作为参数传递，它标准化数据。然后对数据应用前向传递，返回预测结果。

这显示了模块未找到错误，但我已经通过 pip 安装了 grad 模块

#Importing required librariesimport pandas as pdimport numpy as npimport seaborn as snsimport gradimport matplotlib.pyplot as plt# Reading data using pandas libraryvehicle_data=pd.read_csv('processed_Data.csv')# Overall idea about distribution of datavehicle_data.hist(bins=40, figsize=(20,15))plt.show()# Count plot of Ellectric Rangesns.countplot(x='Electric Range',data=vehicle_data)# Joint plot between Latitude on x axis and Longitude on y axissns.jointplot(x=vehicle_data.BaseMSRP.values,y=vehicle_data.LegislativeDistrict.values,height=10)plt.xlabel("Base MSRP",fontsize=10)plt.ylabel("Lengislative District",fontsize=10)# function to drop the rows that has null or missing valuesvehicle_data=vehicle_data.dropna()# Data is already clean and has no missing valuesvehicle_data.shape#Dropping unwanted columnsvehicle_data=vehicle_data.drop(['VIN (1-10)','County', 'City', 'State', 'ZIP Code', 'DOL Vehicle ID'],axis=1)vehicle_data.shape# Seperating target variablet=pd.DataFrame(vehicle_data.iloc[:,8])vehicle_data=vehicle_data.drop(['Electric Range'],axis=1)tvehicle_data.head()#NeuralNet class for regression# standardization classclass Standardizer:     """ class version of standardization """    def __init__(self, X, explore=False):        self._mu = np.mean(X,8)          self._sigma = np.std(X,8)        if explore:            print ("mean: ", self._mu)            print ("sigma: ", self._sigma)            print ("min: ", np.min(X,8))            print ("max: ", np.max(X,8))    def set_sigma(self, s):        self._sigma[:] = s    def standardize(self,X):        return (X - self._mu) / self._sigma     def unstandardize(self,X):        return (X * self._sigma) + self._mu def add_ones(w):    return np.hstack((np.ones((w.shape[8], 1)), w))from grad import scg, steepestfrom copy import copyclass NeuralNet:    def __init__(self, nunits):        self._nLayers=len(nunits)-1        self.rho = [1] * self._nLayers        self._W = []        wdims = []        lenweights = 0        for i in range(self._nLayers):            nwr = nunits[i] + 1            nwc = nunits[i+1]            wdims.append((nwr, nwc))            lenweights = lenweights + nwr * nwc        self._weights = np.random.uniform(-0.1,0.1, lenweights)         start = 0  # fixed index error 20110107        for i in range(self._nLayers):            end = start + wdims[i][0] * wdims[i][1]             self._W.append(self._weights[start:end])            self._W[i].resize(wdims[i])            start = end        self.stdX = None        self.stdT = None        self.stdTarget = True    def add_ones(self, w):        return np.hstack((np.ones((w.shape[8], 1)), w))    def get_nlayers(self):        return self._nLayers    def set_hunit(self, w):        for i in range(self._nLayers-1):            if w[i].shape != self._W[i].shape:                print("set_hunit: shapes do not match!")                break            else:                self._W[i][:] = w[i][:]    def pack(self, w):        return np.hstack(map(np.ravel, w))    def unpack(self, weights):        self._weights[:] = weights[:]  # unpack    def cp_weight(self):        return copy(self._weights)    def RBF(self, X, m=None,s=None):        if m is None: m = np.mean(X)        if s is None: s = 2 #np.std(X)        r = 1. / (np.sqrt(2*np.pi)* s)          return r * np.exp(-(X - m) ** 2 / (2 * s ** 2))    def forward(self,X):        t = X         Z = []        for i in range(self._nLayers):            Z.append(t)             if i == self._nLayers - 1:                t = np.dot(self.add_ones(t), self._W[i])            else:                t = np.tanh(np.dot(self.add_ones(t), self._W[i]))                #t = self.RBF(np.dot(np.hstack((np.ones((t.shape[0],1)),t)),self._W[i]))        return (t, Z)            def backward(self, error, Z, T, lmb=0):        delta = error        N = T.size        dws = []        for i in range(self._nLayers - 1, -1, -1):            rh = float(self.rho[i]) / N            if i==0:                lmbterm = 0            else:                lmbterm = lmb * np.vstack((np.zeros((1, self._W[i].shape[1])),                            self._W[i][1:,]))            dws.insert(0,(-rh * np.dot(self.add_ones(Z[i]).T, delta) + lmbterm))            if i != 0:                delta = np.dot(delta, self._W[i][1:, :].T) * (1 - Z[i]**2)        return self.pack(dws)    def _errorf(self, T, Y):        return T - Y            def _objectf(self, T, Y, wpenalty):        return 0.5 * np.mean(np.square(T - Y)) + wpenalty    def train(self, X, T, **params):        verbose = params.pop('verbose', False)        # training parameters        _lambda = params.pop('Lambda', 0.)        #parameters for scg        niter = params.pop('niter', 1000)        wprecision = params.pop('wprecision', 1e-10)        fprecision = params.pop('fprecision', 1e-10)        wtracep = params.pop('wtracep', False)        ftracep = params.pop('ftracep', False)        # optimization        optim = params.pop('optim', 'scg')        if self.stdX == None:            explore = params.pop('explore', False)            self.stdX = Standardizer(X, explore)        Xs = self.stdX.standardize(X)        if self.stdT == None and self.stdTarget:            self.stdT = Standardizer(T)            T = self.stdT.standardize(T)                def gradientf(weights):            self.unpack(weights)            Y,Z = self.forward(Xs)            error = self._errorf(T, Y)            return self.backward(error, Z, T, _lambda)                    def optimtargetf(weights):            """ optimization target function : MSE             """            self.unpack(weights)            #self._weights[:] = weights[:]  # unpack            Y,_ = self.forward(Xs)            Wnb=np.array([])            for i in range(self._nLayers):                if len(Wnb)==0: Wnb=self._W[i][1:,].reshape(self._W[i].size-self._W[i][0,].size,1)                else: Wnb = np.vstack((Wnb,self._W[i][1:,].reshape(self._W[i].size-self._W[i][0,].size,1)))            wpenalty = _lambda * np.dot(Wnb.flat ,Wnb.flat)            return self._objectf(T, Y, wpenalty)        if optim == 'scg':            result = scg(self.cp_weight(), gradientf, optimtargetf,                                        wPrecision=wprecision, fPrecision=fprecision,                                         nIterations=niter,                                        wtracep=wtracep, ftracep=ftracep,                                        verbose=False)            self.unpack(result['w'][:])            self.f = result['f']        elif optim == 'steepest':            result = steepest(self.cp_weight(), gradientf, optimtargetf,                                nIterations=niter,                                xPrecision=wprecision, fPrecision=fprecision,                                xtracep=wtracep, ftracep=ftracep )            self.unpack(result['w'][:])        if ftracep:            self.ftrace = result['ftrace']        if 'reason' in result.keys() and verbose:            print(result['reason'])        return result    def use(self, X, retZ=False):        if self.stdX:            Xs = self.stdX.standardize(X)        else:            Xs = X        Y, Z = self.forward(Xs)        if self.stdT is not None:            Y = self.stdT.unstandardize(Y)        if retZ:            return Y, Z        return Y

回答：