Python 为什么Skorch在每个时代都展示NAN？

我想基于Skorch的dataset类创建自己的dataset类，因为我想区分分类列和连续列。这些分类列将通过模型中的嵌入层传递。结果很奇怪，因为它显示了NAN 像这样：

  epoch    train_loss    valid_loss     dur
-------  ------------  ------------  ------
      1           nan           nan  0.2187
      2           nan           nan  0.1719
      3           nan           nan  0.1719
      4           nan           nan  0.1562
      5           nan           nan  0.1406

你能帮我修一下吗？我使用的数据来自于此kaggle：

从skorch导入神经网络回归器
从skorch.dataset导入数据集
进口火炬
导入torch.nn作为nn
导入torch.nn.功能为F
作为pd进口熊猫
将numpy作为np导入
从sklearn.preprocessing导入标签编码器
类tablerDataSet（数据集）：
定义初始值（自身、数据、类别=无、输出列=无）：
self.n=data.shape[0]
如果输出_col：
self.y=data[output\u col].astype（np.float32）.values.reformate（-1，1）
其他：
self.y=np.zero（（self.n，1））
self.cat\u cols=如果cat\u cols为else，则为cat\u cols[]
self.cont_cols=[col for col in data.columns
如果列不在self.cat_cols+[output_col]]
如果self.cont\u cols：
self.cont_X=数据[self.cont_cols].astype（np.float32）.值
其他：
self.cont_X=np.zero（（self.n，1））
如果self.cat_cols：
self.cat\u X=数据[self.cat\u cols].astype（np.int64）.值
其他：
self.cat_X=np.zero（（self.n，1））
定义（自我）：
#表示SAMPOE的总数
返回自我
def uu getitem uu（self，idx）：
#生成一个数据样本
返回[self.cont_X[idx]，self.cat_X[idx]]，self.y[idx]
类前馈nn（nn.模块）：
定义初始（自、emb dims、无连续、林层大小、，
输出\u大小、emb\u辍学、lin\u层\u辍学）：
"""
参数
----------
emb_dims：两个元素元组的列表
此列表将包含每个元素的两个元素元组
分类特征。元组的第一个元素将
表示类别的唯一值的数目
第二个元素将表示嵌入
用于该特征的尺寸。
否\u of \u cont:整数
数据中连续要素的数量。
林层大小：整数列表。
每个线性层的大小。长度将相等
总数
网络中线性层的数量。
输出大小：整数
最终输出的大小。
emb_辍学：浮动
嵌入层后要使用的下拉列表。
lin_layer_辍学：浮动列表
在每个线性层之后使用的辍学。
"""
super（）。\uuuu init\uuuuu（）
#嵌入层
self.emb_layers=nn.ModuleList（[nn.Embedding（x，y））
对于x，y，在emb_dims中]）
无emb=总和（y代表x，y代表emb）
self.no_of_embs=no_of_embs
self.no_of_cont=no_of_cont
#线性层
第一层=nn.线性（EMB的自编号+cont的自编号，
林_层_大小[0]）
self.lin_层=\
nn.模块列表（[第一层]+\
[nn.线性（lin_层大小[i]，lin_层大小[i+1]）
适用于范围内的i（透镜（lin_层尺寸）-1）]）
对于self.linu层中的linu层：
nn.init.kaiming\u normal\u（lin\u layer.weight.data）
#输出层
self.output\u layer=nn.Linear（lin\u layer\u大小[-1]，
输出（单位大小）
nn.init.kaiming\u normal\u（self.output\u layer.weight.data）
#批量标准层
self.first\u bn\u layer=nn.BatchNorm1d（self.no\u of\u cont）
self.bn_layers=nn.ModuleList（[nn.BatchNorm1d（大小）
对于lin中的大小（图层大小]）
#辍学层
self.emb\u dropout\u layer=nn.dropout（emb\u dropout）
self.droput_layers=nn.ModuleList（[nn.Dropout（大小））
对于lin_层中的大小（辍学）]）
def前进（自身，X）：
cont_data=X[0]
cat_数据=X[1]
如果没有EMB！=0:
x=[emb_层（cat_数据[：，i]）
对于i，枚举中的emb_层（self.emb_层）]
x=火炬类别（x，1）
x=自emb\u脱落层（x）
如果self.no\u of\u cont！=0:
标准化的连续数据=自身第一层（连续数据）
如果没有EMB！=0:
x=火炬.cat（[x，标准化控制数据]，1）
其他：
x=标准化的连续数据
对于lin_层、dropout_层、bn_层\
zip（self.lin\u层、self.droput\u层、self.bn\u层）：
x=F.relu（林_层（x））
x=bn_层（x）
x=脱落层（x）
x=自输出层（x）
返回x
#读取数据
data=pd.read\u csv（“data/train.csv”，usecols=[“SalePrice”，“MSSubClass”，“MSZoning”，“LotFrontage”，“LotArea”，
“街道”、“年建”、“莲花形”、“1stFlrSF”、“2ndFlrSF”]）。dropna（）
分类特征=[“MSSubClass”、“MSZoning”、“Street”、“LotusShape”、“YearBuild”]
输出功能=“销售价格”
#标签编码分类特征
标签_编码器={}
对于分类功能中的类别：
标签编码器[cat\U col]=标签编码器（）
数据[cat\U col]=标签编码器[cat\U col]。拟合变换（数据[cat\U col]）
#前馈神经网络
cat_dims=[int（数据[col].nunique（））表示分类_要素中的col]
emb_dims=[（x，min（50，（x+1）//2]）对于cat_dims中的x]
net=前馈nn（emb\u dims，无控制=4，lin\u层大小=[50100]，
输出大小=1，emb\U辍学=0.04，
lin_层_辍学率=[0.001,0.01]）
#合身
ds=表格数据集（数据=数据，类别=分类特征，
输出列=输出列（特征）
X=数据。下降（['SalePrice'，]，轴
from sklearn.preprocessing import StandardScaler

class TabularDataset(Dataset):
    def __init__(self, data, cat_cols=None, output_col=None):
        self.n = data.shape[0]
        # [...]
        if output_col:
            scaler_y = StandardScaler()
            self.y = data[output_col].astype(np.float32).values.reshape(-1, 1)

            scaler_y.fit(self.y)
            self.y = scaler_y.transform(self.y)
        # [...]
        if self.cont_cols:
            scaler_X_cont = StandardScaler()
            self.cont_X = data[self.cont_cols].astype(np.float32).values
            scaler_X_cont.fit(self.cont_X)
            self.cont_X = scaler_X_cont.transform(self.cont_X)
        # [...]

net = NeuralNetRegressor(
    net,
    max_epochs=5,
    lr=0.00001,
)
net.fit(ds, y=None)