Python 我的tensorflow卷积神经网络没有训练

我尝试使用tensorflow在kaggle上为人脸表情识别数据实现一个基于类的卷积神经网络。然而，由于某些原因，我的网络没有训练，每次迭代我都会得到相同的成本和错误率

我尝试使用一个热向量作为标签，更改超参数，但它们对结果没有任何影响

将熊猫作为pd导入
将numpy作为np导入
将matplotlib.pyplot作为plt导入
导入tensorflow作为tf
从sklearn.utils导入shuffle
def get_data（）：
df=pd.read_csv（“../large_files/fer2013/fer2013.csv”）
Y=df.emotion.to_numpy（）
XX=df像素
X=[]
对于范围内的i（len（XX））：
X.append（XX[i].split（））
X=np.array（X）.astype（np.float）
Z=df.用法
训练=（Z=‘训练’）。到_列表（）
测试=[列车中非i代表i]
Xtrain=X[train].aType（np.32）
Xtrain=Xtrain.reformate（（Xtrain.shape[0]，int（np.sqrt（Xtrain.shape[1]）），int（np.sqrt（Xtrain.shape[1]）），1））
Xtest=X[test].astype（np.float32）
Xtest=Xtest.REFORMATE（（Xtest.shape[0]，int（np.sqrt（Xtest.shape[1]）），int（np.sqrt（Xtest.shape[1]）），1））
Ytrain=Y[列车].aType（np.int32）
Ytest=Y[test].astype（np.int32）
返回Xtrain/255、Xtest/255、Ytrain、Ytest
def convpool（X、W、b、poolsz）：
conv_out=tf.nn.conv2d（X，W，步幅=[1,1,1,1]，填充='SAME'）
conv_out=tf.nn.bias_add（conv_out，b）
pool_out=tf.nn.max_pool（conv_out，ksize=[1，poolsz，poolsz，1]，步长=[1，poolsz，poolsz，1]，填充='SAME'）
返回tf.nn.relu（池外）
def初始过滤器（形状）：
w=np.random.rand（*形状）*np.sqrt（2/np.prod（形状[：-1]））
返回w.astype（np.float32）
def错误率（Y，T）：
返回np.平均值（Y！=T）
类FullyConnectedLayer（）：
定义初始化（self，M1，M2，activation=tf.nn.relu）：
W=np.随机随机随机数n（M1，M2）/np.平方比（M1+M2）
self.W=tf.Variable（W.astype（np.float32））
b=np.零（M2）
self.b=tf.Variable（b.astype（np.float32））
自我激活
def前进（自身，X）：
如果self.activation==无：
返回tf.matmul（X，self.W）+self.b
其他：
返回自激活（tf.matmul（X，self.W）+self.b）
类卷积层（）：
def uuu init uuuu（自，过滤器形状，b，池sz=2）：
W=初始过滤器（过滤器形状）
self.W=tf.Variable（W）
self.b=tf.Variable（b.astype（np.float32））
self.poolsize=poolsz
def前进（自身，X）：
返回convpool（X，self.W，self.b，self.poolsize）
类CNN（）：
定义初始（自、过滤器形状、密集层大小）：
self.filter_shapes=filter_shapes#形状列表
self.densite_layer_size=densite_layer_size#密集层的隐藏单元列表
def配合（自身、列车组、测试集、学习率=0.001、动量=0.9、衰减=0.99、批次=200、池大小=2）：
学习率=np.32（学习率）
动量=np.32（动量）
衰变=np.32（衰变）
Xtrain=列车组[0]
Y列车=列车组[1]
Xtest=testset[0]
Ytest=testset[1]
K=透镜（组（Y）
#作物序列和批次大小可分性测试集
Ntrain=len（Ytrain）
Ntrain=Ntrain//batch_sz*batch_sz
Xtrain=Xtrain[：Ntrain，]
Ytrain=Ytrain[：Ntrain]
Ntest=len（Ytest）
Ntest=Ntest//batch_sz*batch_sz
Xtest=Xtest[：Ntest，]
Y测试=Y测试
X_shape=Xtrain.shape
宽度=X_形[1]
高度=X_形[2]
#创建卷积层并存储它们
self.convolutionlayers=[]
对于self.filter_形状中的形状：
b=np.zero（形状[-1]，数据类型=np.float32）
conv=卷积层（形状，b，池sz=池大小）
self.convolutionlayers.append（conv）
#在每个最大池中，宽度和高度的大小都减半，所以第一个完全连接层的输入大小如下所示
最终过滤形状=自过滤形状[-1]
num_convs=len（自卷积层）
M1=int（（宽度/（2**num\u convs））*（高度/（2**num\u convs））*最终过滤器形状[-1]）
#创建完全连接的层并存储它们
self.vanillayers=[]
对于自密实层尺寸的M2：
层=完全连接层（M1，M2）
self.vanillayers.append（层）
M1=M2
最终_层=完全连接层（M1，K，激活=无）
self.vanillayers.append（最后一层）
self.AllLayers=self.volculationlayers+self.vanillayers
tfX=tf.placeholder（dtype=tf.float32，shape=（batch_sz，width，height，1））
tfT=tf.placeholder（dtype=tf.int32，shape=（batch_sz，）
Yish=自转发（tfX）
成本=tf.reduce\u和（tf.nn.sparse\u softmax\u cross\u entropy\u和\u logits（logits=Yish，labels=tfT））
训练op=tf.train.RMSPropOptimizer（学习速率=学习速率，衰减=衰减，动量=动量）。最小化（成本）
predict\u op=self.predict（tfX）
最大历元=10
打印周期=20
num_batches=Ntrain//batch_sz
测试成本=[]
init=tf.global_variables_initializer（）
使用tf.Session（）作为sess：
sess.run（初始化）
对于范围内的i（最大历元）：
Xtrain，Ytrain=shuffle（Xtrain，Ytrain）
对于范围内的j（数量批次）：
Xbatch=Xtrain[j*批次号：（j+1）*批次号，]
Ybatch=Ytrain[j*批次号：（j+1）*批次号，]
sess.run（train_op，feed_dict={tfX:Xbatch，tfT:Ybatch}）
如果j%打印周期==0：
测试成本=0
预测=np.0（Ntest）
对于范围内的k（Ntest//batch_sz）：
XTESTBACH=Xtest[k*批次号：（k*批次号+批次号），]