1.安装labelme，用于标注，对机器学习来说就是选取像素样本，这一步对监督分类来说是没法避免的，你想想深度学习还要画样本呢，只不过这里选取样本比较随意，一点都不麻烦。
pip install labelme
安装好后直接在命令行输入labelme按enter，接着工具就会弹出来了
2.获取样本
放大看：
取任意形状都可以接受，每个类别的范围不包含其它类就行，这里我分了两个类别，请注意在弹出来填写类别的框中务必以0，1，2，3…这样从0开始按顺序给类别，主要是为了方便后面的处理，如果不照做会报错。
样本选取好后，点击那个保存按钮，图像目录下会自动生成一个.json文件。
3.标签转换
参考链接：https://zhuanlan.zhihu.com/p/116023772
import os
json_folder = r"C:\Users\Administrator\Desktop\data\test" #这个路径包含了图像和对应的json文件，就是上面截图的路径
# 获取文件夹内的文件名
FileNameList = os.listdir(json_folder)
# 激活labelme环境
os.system("activate labelme")
for i in range(len(FileNameList)):
# 判断当前文件是否为json文件
if(os.path.splitext(FileNameList[i])[1] == ".json"):
json_file = json_folder + "\\" + FileNameList[i]
# 将该json文件转为png
os.system("labelme_json_to_dataset " + json_file)
运行以后会产生一个文件夹
里面有需要用到的一些图片
这一步是利用了labelme自带的转换工具生成了需要的数据，包括图像、标签等，后面分类也是在转出的基础上做的，如果觉得会有图像质量损失的问题，你们自己把预测图换一下就好了，看完代码应该能明白什么意思，其实效果差不多的，我对比了，不用另外麻烦去改代码了。
4.训练预测代码
这里用到了配置文件的方式读取数据，下面会给出配置文件
# -*- coding: utf-8 -*-
from osgeo import ogr, osr
from osgeo import gdal
from gdalconst import *
import os, sys, time
import copy
from tqdm import tqdm
import numpy as np
import cv2
from PIL import Image
from collections import Counter
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from skimage import morphology, filters
import pickle
# import numba
# from numba import jit
import pydensecrf.densecrf as dcrf
from pydensecrf.utils import unary_from_labels, create_pairwise_bilateral, create_pairwise_gaussian
def getValues(img_path,mask_path):
img = cv2.imread(img_path)
mask = Image.open(mask_path)
mask = mask.convert('P')
mask = np.array(mask)
statis = mask.flatten()
lab_dict = Counter(statis)
del lab_dict[0]
class_list = {
}
for k,v in lab_dict.items():
temp_list = []
mask_temp = mask.copy()
mask_temp[mask_temp<k] = 0
mask_temp[mask_temp>k] = 0
mask_temp[mask_temp==k] = 1
masked = cv2.add(img, np.zeros(np.shape(img), dtype=np.uint8), mask=mask_temp)
masked = cv2.cvtColor(masked, cv2.COLOR_BGR2RGB)
cv2.imwrite(str(k)+'.png',masked)
masked = Image.fromarray(masked.astype('uint8'))
a, b = masked.size
for i in range(a):
for j in range(b):
pixel = masked.getpixel((i,j))
if pixel != ((0,0,0)):
temp_list.append(pixel)
class_list[k] = np.array(temp_list)
return class_list
def svm_train(class_list, img_arr, model_path):
array_num = len(class_list)
RGB_arr = np.array([[0,0,0]])
label= np.array([])
count = 0
class_final = {
}
for i in sorted(class_list):
RGB_arr = np.concatenate((RGB_arr,class_list[i]),axis=0)
array_l = class_list[i].shape[0]
label = np.append(label, count * np.ones(array_l))
class_final[i] = count
count += 1
RGB_arr = np.delete(RGB_arr,0,0)
if os.path.exists(model_path):
pass
else:
rf = RandomForestClassifier(n_estimators=500, max_depth=10, n_jobs=14)
rf.fit(RGB_arr, label)
# svc.fit(RGB_arr,label)
with open(model_path, 'wb') as f:
pickle.dump(rf, f)
return array_num, class_final
def get_model(model_path):
with open(model_path, 'rb') as f:
svc = pickle.load(f)
return svc
def svm_predict(svc, img_arr, array_num, outPath):
temp = copy.copy(img_arr)
img_reshape = img_arr.reshape([img_arr.shape[0]*img_arr.shape[1],img_arr.shape[2]])
predict = svc.predict(img_reshape)
for j in range(array_num):
lake_bool = predict == np.float(j)
lake_bool = lake_bool[:,np.newaxis]
try:
lake_bool_4col = np.concatenate((lake_bool,lake_bool,lake_bool,lake_bool),axis=1)
lake_bool_4d = lake_bool_4col.reshape((img_arr.shape[0],img_arr.shape[1],img_arr.shape[2]))
img_arr[lake_bool_4d] = np.float(j)
except:
lake_bool_4col = np.concatenate((lake_bool,lake_bool,lake_bool),axis=1)
lake_bool_4d = lake_bool_4col.reshape((img_arr.shape[0],img_arr.shape[1],img_arr.shape[2]))
img_arr[lake_bool_4d] = np.float(j)
# crf_deal = crf(temp, img_arr[:,:,0])
# img_arr = crf_deal.transpose((1,0))
img_arr = img_arr.transpose((2,1,0))
img_arr = img_arr[0]
# write_img(outPath, im_proj, im_geotrans, img_arr)
return img_arr
def read_img(filename):
dataset=gdal.Open(filename)
im_width = dataset.RasterXSize
im_height = dataset.RasterYSize
im_geotrans = dataset.GetGeoTransform()
im_proj = dataset.GetProjection()
im_data = dataset.ReadAsArray(0,0,im_width,im_height)
del dataset
return im_proj,im_geotrans,im_width, im_height,im_data
def write_img(filename, im_proj, im_geotrans, im_data):
if 'int8' in im_data.dtype.name:
datatype = gdal.GDT_Byte
elif 'int16' in im_data.dtype.name:
datatype = gdal.GDT_UInt16
else:
datatype = gdal.GDT_Float32
if len(im_data.shape) == 3:
im_bands, im_height, im_width = im_data.shape
else:
im_bands, (im_height, im_width) = 1,im_data.shape
driver = gdal.GetDriverByName("GTiff")
dataset = driver.Create(filename, im_width, im_height, im_bands, datatype)
dataset.SetGeoTransform(im_geotrans)
dataset.SetProjection(im_proj)
if im_bands == 1:
dataset.GetRasterBand(1).WriteArray(im_data)
else:
for i in range(im_bands):
dataset.GetRasterBand(i+1).WriteArray(im_data[i])
del dataset
def write_img_(filename, im_proj, im_geotrans, im_data):
if 'int8' in im_data.dtype.name:
datatype = gdal.GDT_Byte
elif 'int16' in im_data.dtype.name:
datatype = gdal.GDT_UInt16
else:
datatype = gdal.GDT_Float32
if len(im_data.shape) == 3:
im_bands, im_height, im_width = im_data.shape
else:
im_bands, (im_height, im_width) = 1,im_data.shape
driver = gdal.GetDriverByName("GTiff")
dataset = driver.Create(filename, im_width, im_height, im_bands, gdal.GDT_Byte)
dataset.SetGeoTransform(im_geotrans)
dataset.SetProjection(im_proj)
if im_bands == 1:
dataset.GetRasterBand(1).WriteArray(im_data)
else:
for i in range(im_bands):
dataset.GetRasterBand(i+1).WriteArray(im_data[i])
del dataset
def array_change(inlist, outlist):
for i in range(len(inlist[0])):
outlist.append([j[i] for j in inlist])
return outlist
def array_change2(inlist, outlist):
for ele in inlist:
for ele2 in ele:
outlist.append(ele2)
return outlist
def stretch_n(bands, img_min, img_max, lower_percent=0, higher_percent=100):
out = np.zeros_like(bands).astype(np.float32)
# a = 0
# b = 65535
a = img_min
b = img_max
# print(a, b)
c = np.percentile(bands[:, :], lower_percent)
d = np.percentile(bands[:, :], higher_percent)
# x = d-c
# if (x==0).any():
# t = 0
# else:
t = a + (bands[:, :] - c) * (b - a) / (d - c)
t[t < a] = a
t[t > b] = b
out[:, :] = t
return out
def getTifSize(tif):
dataSet = gdal.Open(tif)
width = dataSet.RasterXSize
height = dataSet.RasterYSize
bands = dataSet.RasterCount
geoTrans = dataSet.GetGeoTransform()
proj = dataSet.GetProjection()
return width,height,bands,geoTrans,proj
# @jit(nopython=True)
def partDivisionForBoundary(model,array_num,tif1,divisionSize,tempPath):
width,height,bands,geoTrans,proj = getTifSize(tif1)
partWidth = partHeight = divisionSize
if width % partWidth > 0 :
widthNum = width // partWidth + 1
else:
widthNum = width // partWidth
if height % partHeight > 0:
heightNum = height // partHeight +1
else:
heightNum = height // partHeight
realName = os.path.split(tif1)[1].split(".")[0]
tif1 = gdal.Open(tif1)
# for i in range(heightNum):
for i in tqdm(range(heightNum), desc='Processing'):
for j in range(widthNum):
startX = partWidth * j
startY = partHeight * i
if startX+partWidth<= width and startY+partHeight<=height:
realPartWidth = partWidth
realPartHeight = partHeight
elif startX + partWidth > width and startY+partHeight<=height:
realPartWidth = width - startX
realPartHeight = partHeight
elif startX+partWidth <= width and startY+partHeight > height:
realPartWidth = partWidth
realPartHeight = height - startY
elif startX + partWidth > width and startY+partHeight > height:
realPartWidth = width - startX
realPartHeight = height - startY
outName = realName + str(i)+str(j)+".tif"
outPath = os.path.join(tempPath,outName)
if not os.path.exists(outPath):
driver = gdal.GetDriverByName("GTiff")
outTif = driver.Create(outPath,realPartWidth,realPartHeight,1,gdal.GDT_Float32)
outTif.SetGeoTransform(geoTrans)
outTif.SetProjection(proj)
data1 = tif1.ReadAsArray(startX,startY,realPartWidth,realPartHeight)
data1 = data1.transpose((2,1,0))
svmData = svm_predict(model, data1, array_num, outPath)
outTif.GetRasterBand(1).WriteArray(svmData)
return 1
# @jit(nopython=True)
def partStretch(tif1,divisionSize,outStratchPath,tempPath):
width,height,bands,geoTrans,proj = getTifSize(tif1)
# bands = 1
partWidth = partHeight = divisionSize
if width % partWidth > 0 :
widthNum = width // partWidth + 1
else:
widthNum = width // partWidth
if height % partHeight > 0:
heightNum = height // partHeight +1
else:
heightNum = height // partHeight
realName = os.path.split(tif1)[1].split(".")[0]
driver = gdal.GetDriverByName("GTiff")
outTif = driver.Create(outStratchPath,width,height,1,gdal.GDT_Byte)
if outTif!= None:
outTif.SetGeoTransform(geoTrans)
outTif.SetProjection(proj)
for i in range(heightNum):
for j in range(widthNum):
startX = partWidth * j
startY = partHeight * i
if startX+partWidth<= width and startY+partHeight<=height:
realPartWidth = partWidth
realPartHeight = partHeight
elif startX + partWidth > width and startY+partHeight<=height:
realPartWidth = width - startX
realPartHeight = partHeight
elif startX+partWidth <= width and startY+partHeight > height:
realPartWidth = partWidth
realPartHeight = height - startY
elif startX + partWidth > width and startY+partHeight > height:
realPartWidth = width - startX
realPartHeight = height - startY
partTifName = realName+str(i)+str(j)+".tif"
partTifPath = os.path.join(tempPath,partTifName)
divisionImg = gdal.Open(partTifPath)
for k in range(1):
data1 = divisionImg.GetRasterBand(k+1).ReadAsArray(0,0,realPartWidth,realPartHeight)
outPartBand = outTif.GetRasterBand(k+1)
outPartBand.WriteArray(data1,startX,startY)
def DoesDriverHandleExtension(drv, ext):
exts = drv.GetMetadataItem(gdal.DMD_EXTENSIONS)
return exts is not None and exts.lower().find(ext.lower()) >= 0
def GetExtension(filename):
ext = os.path.splitext(filename)[1]
if ext.startswith('.'):
ext = ext[1:]
return ext
def GetOutputDriversFor(filename):
drv_list = []
ext = GetExtension(filename)
for i in range(gdal.GetDriverCount()):
drv = gdal.GetDriver(i)
if (drv.GetMetadataItem(gdal.DCAP_CREATE) is not None or
drv.GetMetadataItem(gdal.DCAP_CREATECOPY) is not None) and \
drv.GetMetadataItem(gdal.DCAP_VECTOR) is not None:
if ext and DoesDriverHandleExtension(drv, ext):
drv_list.append(drv.ShortName)
else:
prefix = drv.GetMetadataItem(gdal.DMD_CONNECTION_PREFIX)
if prefix is not None and filename.lower().startswith(prefix.lower()):
drv_list.append(drv.ShortName)
return drv_list
def GetOutputDriverFor(filename):
drv_list = GetOutputDriversFor(filename)
ext = GetExtension(filename)
if not drv_list:
if not ext:
return 'ESRI Shapefile'
else:
raise Exception("Cannot guess driver for %s" % filename)
elif len(drv_list) > 1:
print("Several drivers matching %s extension. Using %s" % (ext if ext else '', drv_list[0]))
return drv_list[0]
def crf(inimage,img_anno): # inimage为原图 img_anno为预测结果，我的预测结果是0，1，2，3这样，每个数字代表一个类别
fn_im = inimage
fn_anno = img_anno
img = inimage
anno_rgb = img_anno
rgb = anno_rgb
# print("=========>>", anno_rgb.shape)
#rgb= np.argmax(anno_rgb[0],axis=0)
# print("=======>>",rgb.shape)
# print(np.max(rgb), np.min(rgb))
anno_lbl=rgb
# img = img[0]
# img = img.transpose(1, 2, 0)
colors, labels = np.unique(anno_lbl, return_inverse=True)
colors = colors[1:]
colorize = np.empty((len(colors), 3), np.uint8)
colorize[:,0] = (colors & 0x0000FF)
colorize[:,1] = (colors & 0x00FF00) >> 8
colorize[:,2] = (colors & 0xFF0000) >> 16
# n_labels = len(set(labels.flat))-1
n_labels = len(set(labels.flat)) #这里我把减1去掉了，因为我的所有数字都代表一个类别，没有背景
if n_labels <= 1:
return rgb
use_2d = False
if use_2d:
img = img.astype(int)
d = dcrf.DenseCRF2D(img.shape[1], img.shape[0], n_labels)
U = unary_from_labels(labels, n_labels, gt_prob=0.7, zero_unsure=False)
d.setUnaryEnergy(U)
d.addPairwiseGaussian(sxy=(3, 3), compat=3, kernel=dcrf.DIAG_KERNEL, #1.CONST_KERNEL 2.DIAG_KERNEL (the default) 3.FULL_KERNEL
normalization=dcrf.NORMALIZE_SYMMETRIC) #1.NO_NORMALIZATION 2.NORMALIZE_BEFORE 3.NORMALIZE_AFTER 4.NORMALIZE_SYMMETRIC (the default)
img = counts = np.copy(np.array(img,dtype = np.uint8),order='C')
d.addPairwiseBilateral(sxy=(80,80), srgb=(13, 13, 13), rgbim=img,
compat=10,
kernel=dcrf.CONST_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
else:
#这部分比上面的效果好点，建议用这个
# Example using the DenseCRF class and the util functions
d = dcrf.DenseCRF(img.shape[1] * img.shape[0], n_labels)
# get unary potentials (neg log probability)
U = unary_from_labels(labels, n_labels, gt_prob=0.7, zero_unsure=False) #zero_unsure=False 0不是背景而是一个类别，所以False
d.setUnaryEnergy(U)
# This creates the color-independent features and then add them to the CRF
feats = create_pairwise_gaussian(sdims=(3, 3), shape=img.shape[:2])
d.addPairwiseEnergy(feats, compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This creates the color-dependent features and then add them to the CRF
feats = create_pairwise_bilateral(sdims=(80, 80), schan=(13, 13, 13),
img=img, chdim=2)
d.addPairwiseEnergy(feats, compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(20)
# Find out the most probable class for each pixel.
MAP = np.argmax(Q, axis=0)
return MAP.reshape(img.shape[:2])
def remove_and_deal(img_array, hole, obj):
# ret, binary = cv2.threshold(img_array, 0, 1, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
binary = img_array
binary = binary.astype(bool)
binary = morphology.remove_small_holes(binary, min_size=hole, connectivity=8)
binary = morphology.remove_small_objects(binary, min_size=obj, connectivity=8)
binary = binary + 0
binary = np.uint8(binary)
return binary
def cls_deal(class_path):
im_proj,im_geotrans,im_width, im_height,im_data = read_img(class_path)
binary_0 = copy.copy(im_data)
binary_0[binary_0==0] = 100
binary_0[binary_0 < 10] = 0
binary_0[binary_0==100] = 1
binary_0 = remove_and_deal(binary_0, 2000, 500)
temp0 = os.path.join(temp_path, '0.tif')
write_img(temp0, im_proj, im_geotrans, binary_0)
binary_1 = copy.copy(im_data)
binary_1[binary_1 == 1] = 100
binary_1[binary_1 < 10] = 0
binary_1[binary_1 == 100] = 1
binary_1 = remove_and_deal(binary_1, 2000, 500)
temp1 = os.path.join(temp_path, '1.tif')
write_img(temp1, im_proj, im_geotrans, binary_1)
binary_2 = copy.copy(im_data)
binary_2[binary_2 == 2] = 100
binary_2[binary_2 < 10] = 0
binary_2[binary_2 == 100] = 1
binary_2 = remove_and_deal(binary_2, 2000, 500)
temp2 = os.path.join(temp_path, '2.tif')
write_img(temp2, im_proj, im_geotrans, binary_2)
binary_3 = copy.copy(im_data)
binary_3[binary_3 == 3] = 100
binary_3[binary_3 < 10] = 0
binary_3[binary_3 == 100] = 1
binary_3 = remove_and_deal(binary_3, 2000, 500)
temp3 = os.path.join(temp_path, '3.tif')
write_img(temp3, im_proj, im_geotrans, binary_3)
if __name__ == '__main__':
config_file='config_order.txt'
dirs=[]
for line in open(config_file):
dirs.append(line.split()[0])
data_image = dirs[0]
data_image = data_image.replace('\\','/')
mask_path = dirs[1]
mask_path = mask_path.replace('\\','/')
task_image = dirs[2]
task_image = task_image.replace('\\','/')
result_path = dirs[3]
result_path = result_path.replace('\\','/')
temp_path = dirs[4]
temp_path = temp_path.replace('\\','/')
time1 = time.time()
print('Start ...')
class_list = getValues(data_image,mask_path)
print('Train model ...')
model_path = os.path.join(temp_path, 'model.pickle')
num, class_final = svm_train(class_list,data_image,model_path)
svm = get_model(model_path)
slice_path = os.path.join(temp_path, 'slice_temp')
if os.path.exists(slice_path):
pass
else:
os.mkdir(slice_path)
print('Predict task area ...')
partDivisionForBoundary(svm,num,task_image,1000,slice_path)
raster_path = os.path.join(temp_path, 'class_raster.tif')
partStretch(task_image,1000,raster_path,slice_path)
im_proj, im_geotrans, im_width, im_height, im_data = read_img(raster_path)
im_proj, im_geotrans, im_width, im_height, im_data2 = read_img(task_image)
im_data = im_data.transpose((1,0))
im_data2 = im_data2.transpose((2,1,0))
crf_deal = crf(im_data2, im_data)
crf_deal = crf_deal.transpose((1,0))
raster_path = os.path.join(temp_path, 'class_raster2.tif')
write_img_(raster_path, im_proj, im_geotrans, crf_deal)
time2 = time.time()
print((time2-time1)/3600)
配置文件名字config_order.txt，内容如下：
C:\Users\Administrator\Desktop\data\test2\fixed_json\img.png #样本图
C:\Users\Administrator\Desktop\data\test2\fixed_json\label.png #样本图上选取的标签，上面已经生成了
C:\Users\Administrator\Desktop\data\test2\fixed_json\img.png #需要预测的图，考虑到可能图很大，所以选取样本的图可以是从大图上裁剪下来的，而预测的图可以是别的，反正模型是根据样本图训练生成的，这个要注意
C:\Users\Administrator\Desktop\data\test2\temp/t.png # 这个路径本来是用来放结果的，现在没有用到，但是要有，代码自己改吧
C:\Users\Administrator\Desktop\data\test2\temp #新建一个中间文件，里面放结果
运行结果：
注：这里用的是随机森林的方法，开头import还导入了SVM需要的话自己替换就行了