Python 如何从输出分类器创建分段掩码？

我是ML的新手，我正在尝试对我的灰度tif图像进行图像分割。这些图像包含值为NaN的区域（表示海洋），以及值为0到2（表示陆地）的区域。我为训练制作了一些真正的面具。遮罩的面积为NaN表示海，0表示陆地，1表示云。我想创建一个分割面具，它有3个代表海洋、陆地和云的类

我参考了下面的代码。输出分类器确实显示了一些东西，但是分割掩码总体上变为0。请帮忙，谢谢你

从全局导入全局
从PIL导入图像
从sklearn.model\u选择导入列车\u测试\u拆分
将matplotlib.pyplot作为plt导入
将numpy作为np导入
导入tensorflow作为tf
从tensorflow.python.keras导入图层
来自tensorflow.python.keras导入损失
从tensorflow.python.keras导入模型
#加载图像
img=已排序（glob（'/content/drive/My drive/train_sub_5/*.tif'））
掩码=已排序（全局（'/content/drive/My drive/train_mask_sub_5/*.tif'））
#分为训练和测试数据集
img、img\u val、mask、mask\u val=train\u test\u split（img、mask、test\u size=0.2、random\u state=42）
#以数组形式读取图像并制作其形状（512、512、1）
列车图像=[]
对于img中的m[：]：
image=image.open（m）
img\u arr=np.nan\u to\u num（np.array（图像），nan=0）
堆栈=np。堆栈（（img\u arr，）*1，轴=-1）
列车图像追加（叠加图像）
列车屏蔽=[]
对于掩码[：]中的n：
image\u mask=image.open（n）
掩码arr=np.nan-to-num（np.array（图像掩码），nan=2）
堆叠的屏蔽=np。堆栈（（屏蔽阵列，）*1，轴=-1）
序列掩码。附加（堆叠掩码）
test_img=[]
对于img_val[：]中的o：
图像=图像。打开（o）
img\u arr=np.nan\u to\u num（np.array（图像），nan=0）
堆栈=np。堆栈（（img\u arr，）*1，轴=-1）
测试\u img.追加（堆叠\u img）
测试屏蔽=[]
对于掩码中的p_val[：]：
image\u mask=image.open（p）
掩码arr=np.nan-to-num（np.array（图像掩码），nan=2）
堆叠的屏蔽=np。堆栈（（屏蔽阵列，）*1，轴=-1）
测试屏蔽。附加（堆叠屏蔽）
#创建tensorflow数据集
train=tf.data.Dataset.from_tensor_切片（（train_图像，train_掩码））
test=tf.data.Dataset.from_tensor_切片（（test_img，test_mask））
#设置参数
列车长度=长度（列车图像）
img_形状=（512512,1）
批量大小=16
纪元=20
#洗牌、批处理和重复
train\u数据集=train.cache（）.shuffle（train\u长度）.批处理（批处理大小）.重复（）
列车数据集=列车数据集.预取（缓冲区大小=tf.data.experimental.AUTOTUNE）
test\u dataset=test.batch（batch\u size）.repeat（）
#建立模型
def conv_块（输入张量、数字过滤器）：
编码器=layers.Conv2D（num_filters，（3,3），padding='same'）（输入张量）
编码器=层。BatchNormalization（）（编码器）
编码器=层。激活（'relu'）（编码器）
编码器=layers.Conv2D（num_过滤器，（3,3），padding='same'）（编码器）
编码器=层。BatchNormalization（）（编码器）
编码器=层。激活（'relu'）（编码器）
返回编码器
def编码器块（输入张量、数字过滤器）：
编码器=转换块（输入张量、数值过滤器）
编码器_pool=layers.MaxPooling2D（（2,2），步长=（2,2））（编码器）
返回编码器\u池，编码器
def解码器块（输入张量、concat张量、num滤波器）：
解码器=层。Conv2DTranspose（num_filters，（2，2），跨步=（2，2），padding='same'）（输入张量）
解码器=层。连接（[concat_张量，解码器]，轴=-1）
解码器=层。BatchNormalization（）（解码器）
解码器=层。激活（'relu'）（解码器）
解码器=layers.Conv2D（num_过滤器，（3,3），padding='same'）（解码器）
解码器=层。BatchNormalization（）（解码器）
解码器=层。激活（'relu'）（解码器）
解码器=layers.Conv2D（num_过滤器，（3,3），padding='same'）（解码器）
解码器=层。BatchNormalization（）（解码器）
解码器=层。激活（'relu'）（解码器）
返回解码器
输入=层。输入（形状=img_形状）
编码器0_池，编码器0=编码器_块（输入，32）
编码器1\u池，编码器1=编码器块（编码器0\u池，64）
编码器2_池，编码器2=编码器块（编码器1_池，128）
encoder3_池，encoder3=编码器_块（encoder2_池，256）
编码器4_池，编码器4=编码器块（编码器3_池，512）
中心=转换块（编码器4池，1024）
decoder4=解码器×块（中心，编码器4，512）
decoder3=解码器块（decoder4，encoder3，256）
decoder2=解码器块（decoder3，编码器r2，128）
decoder1=解码器块（decoder2，编码器1，64）
decoder0=解码器块（decoder1，编码器0，32）
输出=layers.Conv2D（1，（1，1），activation='sigmoid'）（解码器0）
#定义模型
模型=模型。模型（输入=[输入]，输出=[输出]）
#定义损失函数
def dice_coeff（y_true，y_pred）：
平滑=1。
y_-true\u-f=tf.重塑（y_-true，[-1]）
y_pred_f=tf.重塑（y_pred，[-1]）
交集=tf.减少总和（y\u真f*y\u pred\f）
分数=（2.*交集+平滑）/（tf.减少求和（y\u-true\u-f）+tf.减少求和（y\u-pred\u-f）+平滑）
回击得分
def dice_损失（y_真，y_pred）：
损失=1-骰子系数（y_真，y_pred）
回波损耗
def bce_dice_loss（y_true，y_pred）：
损失=损失。二进制交叉熵（y_真，y_pred）+骰子损失（y_真，y_pred）
回波损耗
#编译模型
compile（优化器='adam'，loss=bce\u dice\u loss，metrics=[dice\u loss]）
model.summary（）
保存_model_path='/content/drive/My drive/tmp/weights.hdf5'
cp=tf.keras.callbacks.ModelCheckpoint（filepath=save\u model\u path，monitor='val\u dice\u loss'，mode='max'，save\u best\u only=True）
#训练模型
history=model.fit（train\u数据集，步长/epoch=int（np.ceil（train\u length/float（batch\u size））），epoch=epoch，validation\u data=test\u数据集，validation\u步长=int（np.ceil（len（test\u img）/float（batch\u size）），回调=[cp]）
#可视化培训过程
骰子=历史。历史['dice\u loss']
val_dice=历史。历史['val_dice_loss']
损失=历史。历史['loss']
val_loss=历史。历史['val_loss']
纪元