打通图像增强tensorflow版Unet_v2代码

已于 2022-04-13 21:01:17 修改
阅读量3.5k 收藏 4
点赞数 2
分类专栏： 图像分割 文章标签： 图像处理 tensorflow
于 2022-04-12 16:35:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WRStop/article/details/124124147
版权

目录

数据path结构

代码调试

构建数据生成器对象

Augmentation函数

doAugmentate函数

 splitMerge函数

保存到.npy模型文件

完整代码

data.py

unet.py

实验结果

基础v1版：打通tensorflow版Unet_v1代码_WRStop的博客-CSDN博客

代码来源&参考，改动都是在此基础上改动：U-net：运行你的第一个U-net进行图像分割_decouples的博客-CSDN博客

数据path结构

代码调试

只更改了data.py，增加图像增强

构建数据生成器对象

# 数据生成器对象
		self.datagen = ImageDataGenerator(
							        rotation_range=0.2, # 随机旋转度数
							        width_shift_range=0.05, # 随机水平平移
							        height_shift_range=0.05, # 随机竖直平移
							        shear_range=0.05, # 随机错切变换
							        zoom_range=0.05,  # 随机放大
							        horizontal_flip=True, # 水平翻转
							        fill_mode='nearest') # 填充方式

Augmentation函数

合并train与label图片，save到merge路径下

 (0.tif)

doAugmentate函数

增强一张图片，其中imgnum为一张图片增强后的结果图片有几张，保存到aug_merge中

（这里的图片是Augmentation函数后的merge图片，所以也是对merge图片进行增强，输出的结果图片也是merge的）

以下都以增强两次即imgnum=2为例

        

                                             0_0_3144.tif                                  0_0_5058.tif

 splitMerge函数

将aug_merge中增强过的merge图片分开为aug_train与aug_label

        ​​​​​​​

0_0_3144_train.tif                           0_0_5058_train.tif 

         

                                       0_0_3144_label.tif                         0_0_5058_label.tif        

保存到.npy模型文件

与v1版的文件路径、文件名和加载方式有较大区别，

文件路径：aug_train和aug_label下分0-29文件夹分别存储增强后的图像

create_train_data中

imgs = glob.glob(self.data_path+"/*/*."+self.img_type) # 添加/*
imgs.sort(key=lambda x: int(x.split('/')[4][:-10])) #3，-4更改为4，-10

文件名：从单纯的0.tif变成0_0_3144_label.tif，所以在匹配上花了些时间

create_train_data中

		for imgname in imgs:
			midname = imgname[23:imgname.rindex("_")] #[imgname.rindex("/")+1:]更改为[23:32]
			img = load_img(self.data_path + "/" + midname + "_train.tif",grayscale = True)
			label = load_img(self.label_path + "/" + midname + "_label.tif",grayscale = True)
			img = img_to_array(img)
			label = img_to_array(label)
			
			imgdatas[i] = img
			imglabels[i] = label
			if i % 100 == 0:
				print('Done: {0}/{1} train'.format(i, len(imgs)))
			i += 1

完整代码

data.py

from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img
import numpy as np 
import os
import glob
import cv2
#from libtiff import TIFF

class myAugmentation(object):
	
	"""
	一个用于图像增强的类：
	首先：分别读取训练的图片和标签，然后将图片和标签合并用于下一个阶段使用
	然后：使用Keras的预处理来增强图像
	最后：将增强后的图片分解开，分为训练图片和训练标签
	"""
	def __init__(self, train_path="deform/train/train", label_path="deform/train/label", merge_path="deform/train/merge", aug_merge_path="deform/train/aug_merge", aug_train_path="deform/train/aug_train", aug_label_path="deform/train/aug_label", img_type="tif"):
		"""
		使用glob从路径中得到所有的“.img_type”文件，初始化类：__init__()
		"""
		self.train_imgs = glob.glob(train_path+"/*."+img_type)
		self.train_imgs.sort(key=lambda x: int(x.split('/')[3][:-4]))
		self.label_imgs = glob.glob(label_path+"/*."+img_type)
		self.label_imgs.sort(key=lambda x: int(x.split('/')[3][:-4]))
		self.train_path = train_path
		self.label_path = label_path
		self.merge_path = merge_path
		self.img_type = img_type
		self.aug_merge_path = aug_merge_path
		self.aug_train_path = aug_train_path
		self.aug_label_path = aug_label_path
		self.slices = len(self.train_imgs)
		# 数据生成器对象
		self.datagen = ImageDataGenerator(
							        rotation_range=0.2, # 随机旋转度数
							        width_shift_range=0.05, # 随机水平平移
							        height_shift_range=0.05, # 随机竖直平移
							        shear_range=0.05, # 随机错切变换
							        zoom_range=0.05,  # 随机放大
							        horizontal_flip=True, # 水平翻转
							        fill_mode='nearest') # 填充方式

	def Augmentation(self):

		"""
		Start augmentation.....
		"""
		trains = self.train_imgs
		labels = self.label_imgs
		path_train = self.train_path
		path_label = self.label_path
		path_merge = self.merge_path
		imgtype = self.img_type
		path_aug_merge = self.aug_merge_path
		if len(trains) != len(labels) or len(trains) == 0 or len(trains) == 0:
			print ("trains can't match labels")
			return 0
		for i in range(len(trains)):
			# keras.preprocessing中load_img + img_to_array 形成numpy数组；与cv2.imread()效果相同
			img_t = load_img(path_train+"/"+str(i)+"."+imgtype)
			img_l = load_img(path_label+"/"+str(i)+"."+imgtype)
			x_t = img_to_array(img_t)
			x_l = img_to_array(img_l)
			x_t[:,:,2] = x_l[:,:,0]
			img_tmp = array_to_img(x_t)
			# 合并train与label，save到merge路径下
			img_tmp.save(path_merge+"/"+str(i)+"."+imgtype)
			img = x_t
			img = img.reshape((1,) + img.shape)
			# 建立aug_merge下的0-29路径
			savedir = path_aug_merge + "/" + str(i)
			if not os.path.lexists(savedir):
				os.mkdir(savedir)
			self.doAugmentate(img, savedir, str(i))

	def doAugmentate(self, img, save_to_dir, save_prefix, batch_size=1, save_format='tif', imgnum=2):
        # 增强一张图片的方法
		"""
		augmentate one image
		"""
		datagen = self.datagen
		i = 0
		for batch in datagen.flow(img,
                          batch_size=batch_size,
                          save_to_dir=save_to_dir,
                          save_prefix=save_prefix,
                          save_format=save_format):
		    i += 1
			# 原代码中>改成==
		    if i == imgnum:
		        break

	def splitMerge(self):
        # 将合在一起的图片分开
		"""
		split merged image apart
		"""
		path_merge = self.aug_merge_path
		path_train = self.aug_train_path
		path_label = self.aug_label_path

		for i in range(self.slices):
			path = path_merge + "/" + str(i)
			train_imgs = glob.glob(path+"/*."+self.img_type)
			savedir = path_train + "/" + str(i)
			if not os.path.lexists(savedir):
				os.mkdir(savedir)
			savedir = path_label + "/" + str(i)

			if not os.path.lexists(savedir):
				os.mkdir(savedir)
			for imgname in train_imgs:
				midname = imgname[imgname.rindex("/")+1:imgname.rindex("."+self.img_type)]
				img = cv2.imread(imgname)
				img_train = img[:,:,2] #cv2 read image rgb->bgr
				img_label = img[:,:,0]
				cv2.imwrite(path_train+"/"+str(i)+"/"+midname+"_train"+"."+self.img_type,img_train)
				cv2.imwrite(path_label+"/"+str(i)+"/"+midname+"_label"+"."+self.img_type,img_label)

	def splitTransform(self):
        # 拆分透视变换后的图像
		"""
		split perspective transform train
		"""
		#path_merge = "transform"
		#path_train = "transform/data/"
		#path_label = "transform/label/"

		path_merge = "deform/deform_norm2"
		path_train = "deform/train/"
		path_label = "deform/label/"

		train_imgs = glob.glob(path_merge+"/*."+self.img_type)
		for imgname in train_imgs:
			midname = imgname[imgname.rindex("/")+1:imgname.rindex("."+self.img_type)]
			img = cv2.imread(imgname)
			img_train = img[:,:,2]#cv2 read image rgb->bgr
			img_label = img[:,:,0]
			cv2.imwrite(path_train+midname+"."+self.img_type,img_train)
			cv2.imwrite(path_label+midname+"."+self.img_type,img_label)

		print("after splitTransform")

class dataProcess(object):
	def __init__(self, out_rows, out_cols, data_path = "deform/train/aug_train", label_path = "deform/train/aug_label", test_path = "test/test", npy_path = "npydata", img_type = "tif"):
        # 数据处理类，初始化
		self.out_rows = out_rows
		self.out_cols = out_cols
		self.data_path = data_path
		self.label_path = label_path
		self.img_type = img_type
		self.test_path = test_path
		self.npy_path = npy_path

# 创建训练数据
	def create_train_data(self):
		i = 0
		print('-'*30)
		print('Creating training train...')
		print('-'*30)
		imgs = glob.glob(self.data_path+"/*/*."+self.img_type) # 添加/*
		imgs.sort(key=lambda x: int(x.split('/')[4][:-10])) #3，-4更改为4，-10
		print(len(imgs))

		imgdatas = np.ndarray((len(imgs),self.out_rows,self.out_cols,1), dtype=np.uint8)
		imglabels = np.ndarray((len(imgs),self.out_rows,self.out_cols,1), dtype=np.uint8)
		for imgname in imgs:
			midname = imgname[23:imgname.rindex("_")] #[imgname.rindex("/")+1:]更改为[23:32]
			img = load_img(self.data_path + "/" + midname + "_train.tif",grayscale = True)
			label = load_img(self.label_path + "/" + midname + "_label.tif",grayscale = True)
			img = img_to_array(img)
			label = img_to_array(label)
			#img = cv2.imread(self.data_path + "/" + midname,cv2.IMREAD_GRAYSCALE)
			#label = cv2.imread(self.label_path + "/" + midname,cv2.IMREAD_GRAYSCALE)
			#img = np.array([img])
			#label = np.array([label])
			imgdatas[i] = img
			imglabels[i] = label
			if i % 100 == 0:
				print('Done: {0}/{1} train'.format(i, len(imgs)))
			i += 1
		print('loading done')
		np.save(self.npy_path + '/imgs_train.npy', imgdatas)
		np.save(self.npy_path + '/imgs_mask_train.npy', imglabels)
		print('Saving to .npy files done.')

# 创建测试数据
	def create_test_data(self):
		i = 0
		print('-'*30)
		print('Creating test train...')
		print('-'*30)
		imgs = glob.glob(self.test_path+"/*."+self.img_type)
		imgs.sort(key=lambda x: int(x.split('/')[2][:-4]))
		print(len(imgs))
		imgdatas = np.ndarray((len(imgs),self.out_rows,self.out_cols,1), dtype=np.uint8)
		for imgname in imgs:
			midname = imgname[imgname.rindex("/")+1:]
			img = load_img(self.test_path + "/" + midname,grayscale = True)
			img = img_to_array(img)
			#img = cv2.imread(self.test_path + "/" + midname,cv2.IMREAD_GRAYSCALE)
			#img = np.array([img])
			imgdatas[i] = img
			i += 1
		print('loading done')
		np.save(self.npy_path + '/imgs_test.npy', imgdatas)
		print('Saving to imgs_test.npy files done.')

# 加载训练图片与mask
	def load_train_data(self):
		print('-'*30)
		print('load train train...')
		print('-'*30)
		imgs_train = np.load(self.npy_path+"/imgs_train.npy")
		imgs_mask_train = np.load(self.npy_path+"/imgs_mask_train.npy")
		imgs_train = imgs_train.astype('float32')
		imgs_mask_train = imgs_mask_train.astype('float32')
		imgs_train /= 255
		mean = imgs_train.mean(axis = 0)
		imgs_train -= mean
		imgs_mask_train /= 255
        # 做一个阈值处理，输出的概率值大于0.5的就认为是对象，否则认为是背景
		imgs_mask_train[imgs_mask_train > 0.5] = 1
		imgs_mask_train[imgs_mask_train <= 0.5] = 0
		return imgs_train,imgs_mask_train

# 加载测试图片
	def load_test_data(self):
		print('-'*30)
		print('load test train...')
		print('-'*30)
		imgs_test = np.load(self.npy_path+"/imgs_test.npy")
		imgs_test = imgs_test.astype('float32')
		imgs_test /= 255
		mean = imgs_test.mean(axis = 0)
		imgs_test -= mean
		return imgs_test


if __name__ == "__main__":
# 以下注释掉的部分为数据增强代码，通过他们可以将数据进行增强

	aug = myAugmentation()
	aug.Augmentation()
	aug.splitMerge()
	aug.splitTransform()

	mydata = dataProcess(512,512)
	mydata.create_train_data()
	mydata.create_test_data()

	imgs_train,imgs_mask_train = mydata.load_train_data()
	print (imgs_train.shape,imgs_mask_train.shape)

unet.py

import os 
#os.environ["CUDA_VISIBLE_DEVICES"] = "0"
import numpy as np
from keras.models import *
from keras.layers import Input, merge, Conv2D, MaxPooling2D, UpSampling2D, Dropout, Cropping2D
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, LearningRateScheduler
from keras import backend as keras
from data import *


class myUnet(object):
	def __init__(self, img_rows = 512, img_cols = 512):
		self.img_rows = img_rows
		self.img_cols = img_cols
# 参数初始化定义
	def load_data(self):
		mydata = dataProcess(self.img_rows, self.img_cols)
		imgs_train, imgs_mask_train = mydata.load_train_data()
		imgs_test = mydata.load_test_data()
		return imgs_train, imgs_mask_train, imgs_test
# 载入数据
	def get_unet(self):
		inputs = Input((self.img_rows, self.img_cols,1))
		# 网络结构定义
		'''
		#unet with crop(because padding = valid) 

		conv1 = Conv2D(64, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(inputs)
		print "conv1 shape:",conv1.shape
		conv1 = Conv2D(64, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv1)
		print "conv1 shape:",conv1.shape
		crop1 = Cropping2D(cropping=((90,90),(90,90)))(conv1)
		print "crop1 shape:",crop1.shape
		pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
		print "pool1 shape:",pool1.shape

		conv2 = Conv2D(128, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(pool1)
		print "conv2 shape:",conv2.shape
		conv2 = Conv2D(128, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv2)
		print "conv2 shape:",conv2.shape
		crop2 = Cropping2D(cropping=((41,41),(41,41)))(conv2)
		print "crop2 shape:",crop2.shape
		pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
		print "pool2 shape:",pool2.shape

		conv3 = Conv2D(256, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(pool2)
		print "conv3 shape:",conv3.shape
		conv3 = Conv2D(256, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv3)
		print "conv3 shape:",conv3.shape
		crop3 = Cropping2D(cropping=((16,17),(16,17)))(conv3)
		print "crop3 shape:",crop3.shape
		pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
		print "pool3 shape:",pool3.shape

		conv4 = Conv2D(512, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(pool3)
		conv4 = Conv2D(512, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv4)
		drop4 = Dropout(0.5)(conv4)
		crop4 = Cropping2D(cropping=((4,4),(4,4)))(drop4)
		pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)

		conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(pool4)
		conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv5)
		drop5 = Dropout(0.5)(conv5)

		up6 = Conv2D(512, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(drop5))
		merge6 = merge([crop4,up6], mode = 'concat', concat_axis = 3)
		conv6 = Conv2D(512, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(merge6)
		conv6 = Conv2D(512, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv6)

		up7 = Conv2D(256, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv6))
		merge7 = merge([crop3,up7], mode = 'concat', concat_axis = 3)
		conv7 = Conv2D(256, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(merge7)
		conv7 = Conv2D(256, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv7)

		up8 = Conv2D(128, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv7))
		merge8 = merge([crop2,up8], mode = 'concat', concat_axis = 3)
		conv8 = Conv2D(128, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(merge8)
		conv8 = Conv2D(128, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv8)

		up9 = Conv2D(64, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv8))
		merge9 = merge([crop1,up9], mode = 'concat', concat_axis = 3)
		conv9 = Conv2D(64, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(merge9)
		conv9 = Conv2D(64, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv9)
		conv9 = Conv2D(2, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv9)
		'''

		conv1 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(inputs)
		print ("conv1 shape:",conv1.shape)
		conv1 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv1)
		print ("conv1 shape:",conv1.shape)
		pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
		print ("pool1 shape:",pool1.shape)

		conv2 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool1)
		print ("conv2 shape:",conv2.shape)
		conv2 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv2)
		print ("conv2 shape:",conv2.shape)
		pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
		print ("pool2 shape:",pool2.shape)

		conv3 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool2)
		print ("conv3 shape:",conv3.shape)
		conv3 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv3)
		print ("conv3 shape:",conv3.shape)
		pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
		print ("pool3 shape:",pool3.shape)

		conv4 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool3)
		conv4 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv4)
		drop4 = Dropout(0.5)(conv4)
		pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)

		conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool4)
		conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv5)
		drop5 = Dropout(0.5)(conv5)

		up6 = Conv2D(512, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(drop5))
		merge6 = merge.concatenate([drop4,up6], axis = 3)
		conv6 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge6)
		conv6 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv6)

		up7 = Conv2D(256, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv6))
		merge7 = merge.concatenate([conv3,up7], axis = 3)
		conv7 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge7)
		conv7 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv7)

		up8 = Conv2D(128, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv7))
		merge8 = merge.concatenate([conv2,up8], axis = 3)
		conv8 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge8)
		conv8 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv8)

		up9 = Conv2D(64, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv8))
		merge9 = merge.concatenate([conv1,up9], axis = 3)
		conv9 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge9)
		conv9 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv9)
		conv9 = Conv2D(2, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv9)
		conv10 = Conv2D(1, 1, activation = 'sigmoid')(conv9)

		model = Model(inputs = inputs, outputs = conv10)
		model.compile(optimizer = adam_v2.Adam(lr = 1e-4), loss = 'binary_crossentropy', metrics = ['accuracy'])
		return model

# 如果需要修改输入的格式，那么可以从以下开始修改，上面的结构部分不需要修改
	def train(self):
		print("loading data")
		imgs_train, imgs_mask_train, imgs_test = self.load_data()
		print("loading data done")
		model = self.get_unet()
		print("got unet")
		model_checkpoint = ModelCheckpoint('my_unet.hdf5', monitor='loss',verbose=1, save_best_only=True)
		print('Fitting model...')
		model.fit(imgs_train, imgs_mask_train, batch_size=2, epochs=10, verbose=1,validation_split=0.2, shuffle=True, callbacks=[model_checkpoint])

		print('predict test data')
		imgs_mask_test = model.predict(imgs_test, batch_size=1, verbose=1)
		np.save('/Users/fengyuting/Documents/pycharm/CV/Unet/unet-master2/results/imgs_mask_test.npy', imgs_mask_test)

	def save_img(self):
		print("array to image")
		imgs = np.load('/Users/fengyuting/Documents/pycharm/CV/Unet/unet-master2/results/imgs_mask_test.npy')
		# 二值化
		# imgs[imgs > 0.5] = 1
		# imgs[imgs <= 0.5] = 0
		for i in range(imgs.shape[0]):
			img = imgs[i]
			img = array_to_img(img)
			img.save("/Users/fengyuting/Documents/pycharm/CV/Unet/unet-master2/results/results_jpg/%d.jpg"%(i))

if __name__ == '__main__':
	myunet = myUnet()
	myunet.train()
	myunet.save_img()

实验结果

      

                                增强前                                                                 增强后 (x2)

         

WRStop
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
U-Net深度学习灰度图像的彩色化
weixin_41697507的博客
07-26 1万+
U-Net深度学习灰度图像的彩色化 本文介绍了使用深度学习训练神经网络从单通道灰度图像生成3通道彩色图像的实验。在我看来，虽然它们因主题而异，但结果令人震惊，模型产生了幻觉，原始主题应该是什么颜色。 将灰度1通道图像增强为3通道彩色图像。 Div2k（https://data.vision.ee.ethz.ch/cvl/DIV2K/）训练数据集用于训练，本文中的这些图像基于Div2K验证集。 这...
unet图片数据增强_图像增强 PieNet 学习用户对图片的偏好特征，根据用户喜好增强图像...
weixin_34177886的博客
01-04 1068
PieNetPieNet: Personalized Image Enhancement Network(ECCV 2020) github project (和 GleNet 同个实验室同样的研究者)算法思想：引入用户偏好表示(user preference representation)，训练一个表征网络，提取有区分度的偏好特征，用于辅助增强网络，生成符合特定用户偏好的图片论...
计算机视觉——基于改进UNet图像增强算法实现
最新发布
知来者逆的博客
05-12 1360
在低光照条件下进行成像非常具有挑战性，因为光子计数低且存在噪声。高ISO可以用来增加亮度，但它也会放大噪声。后处理，如缩放或直方图拉伸可以应用，但这并不能解决由于光子计数低导致的低信噪比（SNR）。短曝光图像受到噪声的影响，而长曝光可能会引起模糊，通常也不切实际。已经提出了各种去噪、去模糊和增强技术，但在极端条件下，如夜间视频速率成像，它们的有效性是有限的。有物理手段可以增加低光照下的SNR，包括打开光圈、延长曝光时间以及使用闪光灯。
unet图片数据增强_图像增强 GLeNet Global 加 local图像增强
weixin_39529443的博客
12-15 1464
GLeNetGlobal and Local Enhancement Networks for Paired and Unpaired Image Enhancement(ECCV 2020) github project算法思想：global + local。学习一条增强曲线(3通道图像 3条)，对图像做 global 调整；通过一个 UNet 学习残差图，模拟空间滤波，做 loca...
unet图片数据增强_UNet++整理
weixin_39608063的博客
12-31 1319
原文：UNet++: A Nested U-Net Architecture for Medical Image Segmentation网络结构U-Net++在U-Net的基础上，引入了更多的上采样节点和跳跃连接。如下图所示，除去左边的backbone部分，其他的节点均为上采样节点，由左下方节点上采样后，并与同stage的节点进行skip连接。从横向来看，位于同一个stage上的节点，是一种de...
UNet_unet代码_Unet图像分割_医学图像分割_unet代码_UNet_
10-03
《深入理解UNet：经典神经网络模型在医学图像分割中的应用》 UNet是一种经典的卷积神经网络（Convolutional Neural Network, CNN）架构，尤其在医学图像分割领域展现出强大的性能。该模型由Ronneberger等人于2015年...
TensorFlow-Examples-master.rar_TensorFlow for Unet_tensorflow_te
09-21
**TensorFlow for Unet: 一个深度学习图像分割框架** TensorFlow是一个强大的开源机器学习库，广泛用于构建和训练各种深度学习模型。Unet是一种在图像分割任务中表现优秀的网络结构，尤其在医疗图像分析、遥感图像...
UNet_with_TensorFlow：使用TensorFlow实现UNet
02-16
"UNet_with_TensorFlow：使用TensorFlow实现UNet" 这个标题明确指出了我们讨论的主题是使用TensorFlow框架来实现UNet神经网络模型。UNet是一种深度学习模型，最初由Ronneberger等人在2015年提出，主要用于图像分割...
unet-master 2_Unet图像分割_unet分割_unet源码_UNet_图像分割_源码
10-04
标题"unet-master 2_Unet图像分割_unet分割_unet源码_UNet_图像分割_源码"明确指出这是一个关于UNet图像分割模型的项目，其中包含源代码，且可能已经过了至少一次更新（2表示版本）。这个项目不仅提供了基本的UNet...
unet-master.zip_UNet_tensorflow_u net master_分类UNET教学_基于tensorfl
07-15
基于tensorflow的u_net的实现
基于 Retinex-UNet 算法的低照度图像增强
03-15
基于 Retinex-UNet 算法的低照度图像增强
envi栅格TIF数据进行分割_numpy实现深度学习遥感图像语义分割数据增强(支持多波段)...
weixin_39760065的博客
11-20 1018
前言数据增强是指对训练样本数据进行某种变换操作，从而生成新数据的过程。数据增强的根本目的是得到充足的样本数据量，避免模型训练过程中产生过拟合现象。正文对于遥感影像来说，由于成像过程传感器对同一地物在不同角度拍摄会在影像上展现出不同的位置和形态，所以经过变换的样本可以使模型更好地学习地物的旋转不变的特征，从而更好地适应不同形态的图像。因此我们对训练数据进行几何变换（包括水平翻转、竖直翻转以及对角翻转...
提升图像分割精度：学习UNet++算法
忆~遂愿的博客
01-05 8488
这篇文章将介绍UNet++算法，该算法是对原始UNet网络的改进，可以在图像分割任务中提高精度。UNet++算法通过引入多个级联的编码器和解码器模块，增加了网络的深度和宽度，从而有效地捕捉到不同尺度和语义层次的特征。此外，UNet++算法还增加了一个迭代式上采样模块，使得网络能够更好地处理不同分辨率的特征图。本文将详细介绍UNet++算法的结构和原理，并通过实验验证其在分割任务上的表现。
U-net学习笔记
qq_45813977的博客
07-19 6714
本文只是记录自己的学习过程，并不是面向技术向的硬核文章。U-net首见于这篇论文U-Net，距今7年，算是比较老的模型了，但是它的引用量突破了四万，由此看来，它的重要性不言而喻。U-net初始论文的标题就告诉我们，它是一个用于医学图像分割的卷积神经网络。...
目标检测：EfficientDet（官方开源版）训练自己的数据
北极熊99 的博客
08-14 7420
写在前面： 本教程将介绍从原始标注数据到训练EfficientDet的全部过程，适合入门级选手，你将得到： （1）详细的步骤介绍 （2）数据集处理代码 （3）EfficientDet训练示例代码 （4）EfficientDet官方预训练模型（百度网盘，链接在文末） 大家有任何问题可留言交流，必要时进行远程协助~ 目录 1 说明 2 数据准备 2.1 原始标注数据整理 2.2 数据集预处理 2.3 数据集划分 2.4 tfrecord生成 3 训练 附录 预训练模型下载（.
UNet v2
whaosoft143ai的博客
12-04 2890
在这个框架中，编码器从输入图像中提取分层的和抽象的特征，而解码器则使用编码器生成的特征图，以像素为单位重建分割掩膜或图，并对输入图像中的每个像素分配一个类标签。接下来，对于第i级的特征图，作者通过简单的哈达马乘法操作明确注入包含更多语义信息的高级特征和包含更精细细节的低级特征，从而增强第i级特征的语义和细节。一些在ISIC 2017数据集上的定性示例如图2所示，这些示例证明了作者的U-Net v2能够将语义信息和更精细的细节集成到每个特征图，因此作者的分割模型可以捕捉到物体边界的更细微细节。whaosoft
语义分割模型------unet unet++
m0_47405013的博客
10-20 698
unet unet++
医学图像分割 nnUNetV2 分割自定义2d数据集
今晚看星星的博客
06-05 7322
nnUNetV2使用
from datasets.pyro_dataset import PyroClientDataset from network import Unet from spine_localization_postprocessing import bb, bb_iou from tensorflow.keras.mixed_precision import experimental as mixed_precision from tensorflow_train_v2.dataset.dataset_iterator import DatasetIterator from tensorflow_train_v2.train_loop import MainLoopBase from tensorflow_train_v2.utils.data_format import get_batch_channel_image_size from tensorflow_train_v2.utils.loss_metric_logger import LossMetricLogger from tensorflow_train_v2.utils.output_folder_handler import OutputFolderHandler from tqdm import tqdm
07-09
它导入了一些自定义的模块和库，包括PyroClientDataset、Unet、spine_localization_postprocessing、mixed_precision等。它还使用了一些来自TensorFlow的模块和函数，如DatasetIterator、MainLoopBase、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值