【Tensoflow2】Unet实现CityScapes语义分割及resize插值问题

最新推荐文章于 2024-05-05 12:16:16 发布
最新推荐文章于 2024-05-05 12:16:16 发布
阅读量2.2k 收藏 31
点赞数 4
分类专栏： 深度学习 文章标签： 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38565839/article/details/106296479
版权

文章目录

1.数据介绍

  • 本文主要使用Tensorflow2实现Unet模型在城市景观数据场景下的语义分割实现。使用数据为CityScapes,数据主页：https://www.cityscapes-dataset.com/。数据分为原图，分割图，并包含训练集及测试集。
    原图
    分割图像
  • 语义分割后数据输出共34类。每一类为单独的物体，不同物体标注不同的颜色。
物体名称输出类型ID颜色
unlabeled0( 0, 0, 0)
ego vehicle1( 0, 0, 0)
rectification border2( 0, 0, 0)
out of roi3( 0, 0, 0)
static4( 0, 0, 0)
dynamic5(111, 74, 0)
ground6( 81, 0, 81)
road7(128, 64,128)
sidewalk8(244, 35,232)
parking9(250,170,160)
rail track10(230,150,140)
building11( 70, 70, 70)
wall12(102,102,156)
fence13(190,153,153)
guard rail14(180,165,180)
bridge15(150,100,100)
tunnel16(150,120, 90)
pole17(153,153,153)
polegroup18(153,153,153)
traffic light19(250,170, 30)
traffic sign20(220,220, 0)
vegetation21(107,142, 35)
terrain22(152,251,152)
sky23( 70,130,180)
person24(220, 20, 60)
rider25(255, 0, 0)
car26( 0, 0,142)
truck27( 0, 0, 70)
bus28( 0, 60,100)
caravan29( 0, 0, 90)
trailer30( 0, 0,110)
train31( 0, 80,100)
motorcycle32( 0, 0,230)
bicycle33(119, 11, 32)

2.Unet模型

  • Unet模型是广泛用于无人驾驶，医学影像语义分割场景的基础模型。Unet使用编码器-解码器的U型结构，左半部分下采样进行特征工程，右半部分上采样结合skip connection融合特征。最后输出每个像素的分类(此处共34类)。
    在这里插入图片描述

3.开发流程

1).读取数据及数据预处理

  • 导包
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
import glob
import matplotlib.pyplot as plt
  • 加载数据，乱序
    注意：如果使用Kaggle NoteBook进行训练，图片及语义分割图像不一一对应
# 训练集
train_path_raw = glob.glob(r'D:\tensorflowDataSet\cityUNET\image2\images\train\*\*.png')
train_label_path_raw = glob.glob(r'D:\tensorflowDataSet\cityUNET\gtFine\train\*\*gtFine_labelIds.png')
# 测试集
test_path_raw = glob.glob(r'D:\tensorflowDataSet\cityUNET\image2\images\val\*\*.png')
test_label_path_raw = glob.glob(r'D:\tensorflowDataSet\cityUNET\gtFine\val\*\*gtFine_labelIds.png')

train_total_num = len(train_path_raw) #2975
test_total_num = len(test_path_raw)   #500
# 打乱数据集
index = np.random.permutation(train_total_num)
train_path = np.array(train_path)[index]
train_label_path = np.array(train_label_path)[index]
  • 图片预处理，原始图片像素为(2048,1024)，考虑到显存，统一resize到(256,256)，并使用图像增强。
def read_image(path): # 加载原始图像
    image = tf.io.read_file(path)
    image = tf.image.decode_png(image,channels=3)
    return image

def read_label(path): # 加载语义分割图像
    image = tf.io.read_file(path)
    image = tf.image.decode_png(image,channels=1)
    return image

def crop_img(image,mask):      # 图像增强，随机剪裁为(256,256)
    
    img = tf.concat([image,mask],axis=-1)#将原图和语义图合并剪裁 
    # resize成(256,256)，插值方法用邻近插值(为啥要用临近插值？后续会讲)
    img = tf.image.resize(img,(280, 280),method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
    img = tf.image.random_crop(img,size=[256,256,4])
    
    return img[:,:,:3],img[:,:,3:]

def normalize(image,mask):    #归一化到[-1,1]，加速训练
    image = tf.cast(image,tf.float32) /127.5 - 1
    mask = tf.cast(mask,tf.int32)
    return image,mask

def image_handler_train(image_path,label_path): #训练集加载
    train_img = read_image(image_path)
    label_img = read_label(label_path)
    
    image,mask = crop_img(train_img,label_img)
    
    if tf.random.uniform(()) > 0.5: #图像增强-随机左右翻转
        image = tf.image.flip_left_right(image)
        mask = tf.image.flip_left_right(mask)
        
    if tf.random.uniform(()) > 0.5: #图像增强-明暗度
        image = tf.image.adjust_brightness(image,0.5)
        mask = tf.image.adjust_brightness(mask,0.5)
        
    image,mask = normalize(image,mask)
    return image,mask

def image_handler_test(image_path,label_path):  #测试集加载(不需要进行增强)
    train_img = read_image(image_path)
    label_img = read_label(label_path)
    
    train_img = tf.image.resize(train_img,size=(256,256),method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
    label_img = tf.image.resize(label_img,size=(256,256),method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
        
    image,mask = normalize(train_img,label_img)
    return image,mask
  • 构建数据集
BUFFERSIZE = 100 
BATCHSIZE = 20
AUTO = tf.data.experimental.AUTOTUNE #自动加载
#构建训练集
train_path_dataset = tf.data.Dataset.from_tensor_slices((train_path,train_label_path))
train_dataset = train_path_dataset.map(image_handler_train,num_parallel_calls=AUTO)
train_dataset = train_dataset.repeat().shuffle(BUFFERSIZE).batch(BATCHSIZE).prefetch(AUTO)
#构建测试集
test_path_dataset = tf.data.Dataset.from_tensor_slices((test_path,test_label_path))
test_dataset = test_path_dataset.map(image_handler_test,num_parallel_calls=AUTO)
test_dataset = test_dataset.batch(BATCHSIZE)

2).函数式模型构建

  • 模型构建的时候可以根据Unet一层一层的写，也可以使用模型组合的方式。
# 按照Unet模型一层一层写
def make_unet_model():
    input = keras.Input(shape=(256,256,3))
    x1 = layers.Conv2D(64,3,strides=1,padding='same')(input)
    x1 = layers.BatchNormalization()(x1)
    x1 = layers.ReLU()(x1)
    x1 = layers.Conv2D(64,3,strides=1,padding='same')(x1)
    x1 = layers.BatchNormalization()(x1)
    x1 = layers.ReLU()(x1)  #(256,256,64)

    x2 = layers.MaxPooling2D()(x1) #(128,128,64)

    x2 = layers.Conv2D(128,3,strides=1,padding='same')(x2)
    x2 = layers.BatchNormalization()(x2)
    x2 = layers.ReLU()(x2)
    x2 = layers.Conv2D(128,3,strides=1,padding='same')(x2)
    x2 = layers.BatchNormalization()(x2)
    x2 = layers.ReLU()(x2)  #(128,128,128)

    x3 = layers.MaxPooling2D()(x2) #(64,64,128)

    x3 = layers.Conv2D(256,3,strides=1,padding='same')(x3)
    x3 = layers.BatchNormalization()(x3)
    x3 = layers.ReLU()(x3)
    x3 = layers.Conv2D(256,3,strides=1,padding='same')(x3)
    x3 = layers.BatchNormalization()(x3)
    x3 = layers.ReLU()(x3) #(64,64,256)

    x4 = layers.MaxPooling2D()(x3) #(32,32,256)

    x4 = layers.Conv2D(512,3,padding='same',strides=1)(x4)
    x4 = layers.BatchNormalization()(x4)
    x4 = layers.ReLU()(x4)
    x4 = layers.Conv2D(512,3,padding='same',strides=1)(x4)
    x4 = layers.BatchNormalization()(x4)
    x4 = layers.ReLU()(x4) #(32,32,512)

    x5 = layers.MaxPooling2D()(x4) #(16,16,512)

    x5 = layers.Conv2D(1024,3,padding='same',strides=1)(x5)
    x5 = layers.BatchNormalization()(x5)
    x5 = layers.ReLU()(x5)
    x5 = layers.Conv2D(1024,3,padding='same',strides=1)(x5)
    x5 = layers.BatchNormalization()(x5)
    x5 = layers.ReLU()(x5) #(16,16,1024)

    x4_ = layers.Conv2DTranspose(512,2,padding='same',strides=2)(x5)
    x4_ = layers.BatchNormalization()(x4_)
    x4_ = layers.ReLU()(x4_) #(32,32,512)

    x3_ = tf.concat([x4,x4_],axis=-1) #(32,32,1024)
    x3_ = layers.Conv2D(512,3,padding='same',strides=1)(x3_)
    x3_ = layers.BatchNormalization()(x3_)
    x3_ = layers.ReLU()(x3_)
    x3_ = layers.Conv2D(512,3,padding='same',strides=1)(x3_)
    x3_ = layers.BatchNormalization()(x3_)
    x3_ = layers.ReLU()(x3_) #(32,32,512)

    x3_= layers.Conv2DTranspose(256,2,padding='same',strides=2)(x3_)
    x3_ = layers.BatchNormalization()(x3_)
    x3_ = layers.ReLU()(x3_) #(64,64,256)

    x2_ = tf.concat([x3,x3_],axis=-1) #(64,64,512)
    x2_ = layers.Conv2D(256,3,padding='same',strides=1)(x2_)
    x2_ = layers.BatchNormalization()(x2_)
    x2_ = layers.ReLU()(x2_)
    x2_ = layers.Conv2D(256,3,padding='same',strides=1)(x2_)
    x2_ = layers.BatchNormalization()(x2_)
    x2_ = layers.ReLU()(x2_) #(64,64,256)

    x2_ = layers.Conv2DTranspose(128,2,padding='same',strides=2)(x2_)
    x2_ = layers.BatchNormalization()(x2_)
    x2_ = layers.ReLU()(x2_) #(128,128,128)

    x1_ = tf.concat([x2,x2_],axis=-1) #(128,128,256)
    x1_ = layers.Conv2D(128,3,padding='same',strides=1)(x1_)
    x1_ = layers.BatchNormalization()(x1_)
    x1_ = layers.ReLU()(x1_)
    x1_ = layers.Conv2D(128,3,padding='same',strides=1)(x1_)
    x1_ = layers.BatchNormalization()(x1_)
    x1_ = layers.ReLU()(x1_) #(128,128,128)

    x1_= layers.Conv2DTranspose(64,2,padding='same',strides=2)(x1_) 
    x1_ = layers.BatchNormalization()(x1_)
    x1_ = layers.ReLU()(x1_) #(256,256,64)

    x_ = tf.concat([x1,x1_],axis=-1) #(256,256,128)
    x_ = layers.Conv2D(64,3,padding='same',strides=1)(x_)
    x_ = layers.BatchNormalization()(x_)
    x_ = layers.ReLU()(x_)
    x_ = layers.Conv2D(64,3,padding='same',strides=1)(x_)
    x_ = layers.BatchNormalization()(x_)
    x_ = layers.ReLU()(x_) #(256,256,64)
	#输出层，共34类
    output = layers.Conv2D(34,1,padding='same',strides=1,activation='softmax')(x_) #(256,256,34)

    return keras.Model(inputs=input,outputs=output)
  • 使用模型组合构建模型
# 构建基础模型
def down_sample(filters,kernel):  #下采样卷积层
   model = keras.Sequential()
   model.add(layers.Conv2D(filters,kernel,strides=1,padding='same'))
   model.add(layers.BatchNormalization())
   model.add(layers.ReLU())
   return model

def max_pooling():                #下采样池化层
   model = keras.Sequential()
   model.add(layers.MaxPooling2D())
   return model

def up_sample(filters,kernel):    #上采样卷积层
   model = keras.Sequential()
   model.add(layers.Conv2DTranspose(filters,kernel,padding='same',strides=2))
   model.add(layers.BatchNormalization())
   model.add(layers.ReLU())
   return model

def get_unet_model():
    input = keras.Input(shape=(256,256,3)) #(256,256,3)
    
    down_models = [
        down_sample(64,3), #(256,256,64)
        down_sample(64,3),  
        max_pooling(),     #(128,128,64)
        down_sample(128,3),#(128,128,128)
        down_sample(128,3), 
        max_pooling(),     #(64,64,128)
        down_sample(256,3),#(64,64,256)
        down_sample(256,3), 
        max_pooling(),     #(32,32,256)
        down_sample(512,3),#(32,32,512)
        down_sample(512,3),
        max_pooling(),     #(16,16,512)
        down_sample(1024,3),#(16,16,1024)
        down_sample(1024,3)#(16,16,1024)
    ]
    
    down_output = []
    x = input
    for i,down in enumerate(down_models):
        x = down(x)
        if i % 3 == 1:
            down_output.append(x)
            
    down_output = reversed(down_output[:-1])
    
    up_models = [
        up_sample(512,2),
        up_sample(256,2),
        up_sample(128,2),
        up_sample(64,2)
    ]
    
    up_conv2_model_1 = [
        down_sample(512,3),
        down_sample(256,3),
        down_sample(128,3),
        down_sample(64,3)
    ]
    
    up_conv2_model_2 = [
        down_sample(512,3),
        down_sample(256,3),
        down_sample(128,3),
        down_sample(64,3)
    ]
    
    for d_out,up,conv2_1,conv2_2 in zip(down_output,up_models,up_conv2_model_1,up_conv2_model_2):
        x = up(x)
        x = tf.concat([d_out,x],axis=-1)
        x = conv2_1(x)
        x = conv2_2(x)
    #输出层，共34类
    x = layers.Conv2D(34,1,padding='same',strides=1,activation='softmax')(x)
    
    return keras.Model(inputs=input,outputs=x)

#构建模型
model = get_unet_model()

3).模型编译及训练

  • 模型评估指标
    i) acc:分类正确率。
    ii) MeanIou:交集与并集之比，越大拟合效果越好。
#重写__call__方法，MeanIou默认按照OneHot进行计算。
class MeanIoU(tf.keras.metrics.MeanIoU):
   def __call__(self, y_true, y_pred, sample_weight=None):
       y_pred = tf.argmax(y_pred, axis=-1)
       return super().__call__(y_true, y_pred, sample_weight=sample_weight)
  • 模型编译
model.compile(optimizer='adam',
               loss='sparse_categorical_crossentropy',
               metrics=['acc',MeanIoU(num_classes=34)])
  • 模型训练
EPOCHS = 80
train_step = train_total_num // BATCHSIZE
val_step = test_total_num // BATCHSIZE

history = model.fit(train_dataset,
           epochs=EPOCHS,
           steps_per_epoch= train_step,
           validation_data=test_dataset,
           validation_steps=val_step)

  • 指标可视化
    损失曲线
    正确率曲线
    MeanIou

  • 结论
    由图像可以看出，训练严重过拟合，建议使用Dropout抑制过拟合。测试集表现不佳，建议增加训练数据集，使用图像增强。

  • 模型预测
    第一列为原始图像，第二列为标签分割图，第三列为预测图像。
    在这里插入图片描述

4).Resize插值问题

  • 在对图像进行resize时，使用了tf.image.ResizeMethod.NEAREST_NEIGHBOR邻近插值法，其实不仅有这种插值法，如图：
class ResizeMethod(object):
 BILINEAR = 'bilinear' #双线性
 NEAREST_NEIGHBOR = 'nearest' #最近邻插值法
 BICUBIC = 'bicubic'  #双三次插值
 AREA = 'area' #区域插值
 LANCZOS3 = 'lanczos3' #领域采样插值
 LANCZOS5 = 'lanczos5'
 GAUSSIAN = 'gaussian'
 MITCHELLCUBIC = 'mitchellcubic'
  • 这里为啥要选择邻近插值法，邻近插值法在resize之后不会改变在标签数据的像素类型(目标数据34类)。
label_img = read_image(test_label_path_raw[1])

label_img = tf.image.resize(label_img,size=(256,256),method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
np.unique(label_img.numpy())
# output[ 1,  2,  3,  4,  7,  8,  9, 11, 13, 17, 20, 21, 23, 25, 26, 33]  


#以下插值法可能会影响分类。
label_img = tf.image.resize(label_img,size=(256,256),method=tf.image.ResizeMethod.BILINEAR)
np.unique(label_img.numpy())
# output[ 1.  ,  1.25,  1.5 ,  1.75,  2.  ,  2.5 ,  3.  ,  3.25,  4.  ,4.5 ,  5.5 ,  6.5 ,  6.75,  7.  ,  7.25,  7.5 ,  7.75,  8. ......]


label_img = tf.image.resize(label_img,size=(256,256),method=tf.image.ResizeMethod.AREA)
np.unique(label_img.numpy())
# output[ 1.  ,  1.03125,  1.0625 ,  1.09375,  1.125  ,  1.15625, 1.1875 ,  1.21875,  1.25   ,  1.28125,  1.34375,  1.375  ...]
陌二叔
关注
  • 4
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
Unet：具有城市景观和kitti数据集的Unet
03-02
UNet：使用PyTorch进行语义分割 使用Cityscapes和Kitti数据集 用法 注意：使用Python 3.6或更高版本 预言 训练好模型并将其保存到MODEL.pth后，您可以通过CLI轻松测试图像上的输出蒙版。 要预测单个图像并保存，请执行以下操作： python predict.py -i image.jpg -o output.jpg 要预测多幅图像并显示它们而不保存它们，请执行以下操作： python predict.py -i image1.jpg image2.jpg --viz --no-save > python predict.py -h usage: predict.py [-h] [--model FILE] --input INPUT [INPUT ...] [--output INPUT [INPUT
颜色分类leetcode-pytorch_unet:Cityscapes数据集上的PyTorchU-Net
07-06
颜色分类leetcode Cityscapes 数据集上的 PyTorch U-Net 这个存储库包含我第一次尝试从 . 这最终比我预期的更具挑战性，因为 python 中的数据处理工具并不像我预期的那么简单。 在 PyTorch 框架内，他们为 Cityscapes 数据集提供了一个“数据加载器”，但它并不真正适合任何分割任务。 我建立了那里的初始代码，以允许将相同的随机变换应用于 rgb 图像和标签。 此外，用于训练的类数量已经减少，可以通过更新 dataset.py 加载器中的映射数据类型轻松更改。 网络输出 [N, classes, W, H] 大小的张量，然后需要将其转换为预测。 为了找到给定像素的分类，类响应的 argmax 为每个计算并对应于类。 在保存到磁盘之前，我将此 classid 转换回 rgb 颜色，以便与地面实况标签进行视觉比较。 我发现网络预测在四个 epoch 后给出了不错的视觉结果。 训练模型 请查看script_train.py文件以获取有关可能参数的详细信息。 您首先需要下载 cityscapes 数据集并提取它。 如果您想进行逐像素分割，通常会使用
【数据集】Cityscapes数据集的介绍与使用方法
m0_51579041的博客
03-02 3083
【数据集】Cityscapes数据集的介绍与使用方法，可以用于语义分割，实例分割
基于Pytorch的UNet语义分割模型与代码
12-26
模型在FloodNet数据集上进行了训练，mIOU在0.83左右，可训练自己的数据集 建议在训练网络的时候将输入的训练集其切分为384x384的小图片后，再来进行训练 模型采用标准的UNet，可以采用如下方式训练你自己的模型 数据集地址可以在train.py中修改为你自己的文件夹 python train.py -- --epochs 20 --batch-size 16 --learning-rate 2e-4 --scale 1 --validation 0.1 --classes 10 --amp 其中--amp为半精度训练 --scale是训练的时候对图片进行缩放，已经裁剪为384x384后就不需要再裁剪了
简明代码实现Unet眼底图像血管分割
啊哦的博客
10-14 6337
项目工程文件结构如下： 参考了Retina_Unet项目，决定自己用代码来实现一遍，数据增强不是像Retina_Unet那样随机裁剪，而是将20个训练数据集按顺序裁剪，每张裁剪成48x48大小的144个patch，20张一共裁剪出2880个patch。 Unet模型：模型输入的张量形状为（Npatch,1,48,48），输出为（Npatch,2304,2）。Npatch表示训练集的样本数，本例中...
复现unet(pytorch/keras)
weixin_41619475的博客
05-06 1281
复现unet语义分割模型，共两个版本，keras与pytorch Keras版本 https://github.com/zhixuhao/unet １．讲图像转为灰度图 import os from glob import glob import shutil import cv2 def to_gray(img, outdir): src = cv2.imread(img) try: dst = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
unet开源项目中resize问题踩坑
Christo的博客
12-26 1832
前言 开源项目unet中使用的图像尺寸是固定的256，但是如果要使用resize图片尺寸的话，调用OpenCV中的resize函数不可行，因为源码加载图片的格式是ndarray，所以必须使用与格式对应的resize格式，修改代码如下： img = np.resize(img, (1, 640, 400, 1)) mask = np.resize(img, (1, 640, 400, 1)) ...
语义分割——Unet模型
热门推荐
hallobike的博客
01-11 1万+
语义分割的UNET网络结构 Unet是2015年诞生的模型，它几乎是当前segmentation项目中应用最广的模型。 Unet能从更少的训练图像中进行学习，当它在少于40张图的生物医学数据集上训练时，IOU值仍能达到92%。 Unet网络非常简单，前半部分作用是特征提取，后半部分是上采样。在一些文献中也把这样的结构叫做编码器-解码器结构。由于此网络整体结构类似于大写的英文字母U，故得名U-net。 这里的融合使用的是tf.concat()，FCN中使用的是tf.add()。 Unet实例，城
【Libtorch】语义分割部署踩坑记录（目前包括resize产生新的值、标注不同类别时重叠等问题，后续不断更新）
qq_42944019的博客
08-03 2529
本博客给做语义分割、使用Libtorch的计算机视觉工程师提供相关的经验或者教训，方便更高效开发。
TF2实现语义分割网络UNet
yubaby
02-16 187
""" Created on 2021/1/26 22:01. @Author: anne """ from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Dropout from tensorflow.keras.layers import UpSampling2D, concatenate, Conv2DTrans...
PSPNet ：语义分割
Twilight737的博客
08-07 5000
PSPNet：语义分割 随着卷积神经网络在目标检测任务上的推进，它也开始被用于更精细的图像处理任务：语义分割和实例分割。目标检测只需要预测图像中每个对象的位置和类别，语义分割还要把每个像素都进行分类，而实例分割的任务则更难，要进一步把每个对象的不同实例都区分开。 图像语义分割（semantic segmentation），从字面意思上理解就是让计算机根据图像的语义来进行分割。语义分割是对图像中的每一个像素进行分类，目前广泛应用于医学图像与无人驾驶等。语义在语音识别中指的是语音的意思，在图像领域，语义指的是
tensorflow2.7实现UNet
11-21
基于tensorflow2.7实现UNet并对图像进行语义分割
unet:通用U-Net Tensorflow 2实现的语义分段
05-25
Tensorflow Unet 这是提出的通用U-Net实现 用Tensorflow 2开发。 该项目是对原始的重新实现。 最初，该代码是开发的，并用于。 可以训练网络对任意成像数据执行图像分割。 请查看“部分，随附的或上的玩具问题，...
利用UNet实现语义分割实例
08-22
data:里面存放的数据集，rgb图像时输入，通道数为3，figure_ground为mask,通道数为1 datasets.py loss.py:使用的Dice loss test.py：测试，输入一张图片，输出模型训练的结果 ...Unet.py：Unet模型
Pytorch下实现Unet对自己多类别数据集的语义分割
01-11
Unet通常应用到单类别的语义分割，经过调整后该代码适合于多类别的语义分割。对应博客：https://blog.csdn.net/brf_UCAS/article/details/112383722
深度学习-线性回归+基础优化算法
Einstein·Jun
04-28 1079
1、线性回归是对n维输入的加权，外加偏差。2、使用平方损失来衡量预测值和真实值的差异。3、线性回归有显示解。4、线性回归可以看做是单层神经网络。我们将从零开始实现整个方法，包括数据流水线、模型、损失函数和小批量随机梯度下降优化器。"""生成y=Xw+b+噪声。"""print('features:', features[0], '\nlabel:', labels[0])里插入代码片正态分布函数：normal()
LLM2Vec介绍和将Llama 3转换为嵌入模型代码示例
最新发布
deephub
05-05 639
通过LLM2Vec，我们可以使用LLM作为文本嵌入模型。但是简单地从llm中提取的嵌入模型往往表现不如常规嵌入模型。LLM2Vec的作者提出了新的训练目标MNTP和SimCSE来训练从llm中提取的嵌入模型。这种训练成本很高，但根据作者的说法，可以产生更好的嵌入模型。
基于光伏电站真实数据集的深度学习预测模型（Python代码，深度学习五个模型）
qq_40840797的博客
04-29 553
3.模型（LSTM；LSTM_transform模型）评价指标。前6行的10列数据（黄色部分）作为特征输入，第7行的第10列数据（红色部分）为标签。每一行前9列（黄色部分） 作为特征输入，每一行的第10列值作为标签（红色部分）根据已获取的历史数据预测下一个时间点或者未来多个时间点 更符合实际。5. 对数据集和代码感兴趣的，可以关注最后一行。1min是以1min 间隔采集的数据集。这里分别保存了不同间隔采样时间表格。数据集截图（开始位置截图）4.效果图(测试集)
【PyTorch与深度学习】3、PyTorch张量的运算API（下）
随手写写
04-29 1250
最近做实验发现自己还是基础框架上掌握得不好，于是开始重学一遍PyTorch框架，这个是课程笔记，这个课还是讲的简略，我半小时的课听了一个半小时。
Unet实现多分类语义分割代码
03-25
抱歉，我是AI语言模型，无法提供代码。不过我可以告诉您一般来说实现多分类语义分割的UNet网络结构需要进行以下几个步骤： 1. 准备数据集：含有多个类别的标注数据，如经过标记的图像。需要将数据集分为训练集和测试集。 2. 设计UNet网络结构：这个网络结构是受 U-net: Convolutional Networks for Biomedical Image Segmentation 的启发而来。它具有一个类似于 Autoencoder 网络的结构，包含一个下采样路径用于捕捉模式并将其传递到一个上采样路径，用于生成分割结果。在多分类语义分割中，最后的输出通道数等于类别数。 3. 训练网络：使用训练集和验证集来训练网络，通过反向传播算法来更新权重值 4. 验证与测试：在测试集上验证训练分割网络的性能，并进行准确性评估。 在实现UNet结构的编码与解码函数时，可以使用卷积层、池化层、上采样层和跳跃连接来创建一个具有与输入图像相同尺寸的分割输出的网络。 在实现训练网络时，可以使用损失函数（如交叉熵损失函数），以便在训练中限制输出分割区域与标注区域之间的差异。 总之，最好的方法是找到一个公开的多分类语义分割代码库并对其进行修改，以适应您的数据集和需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值