一.安装

库：

安装numpy、matplotlib、sklearn、scipy、PIL、opencv、pickle、pytorch（高于等于0.4）
代码在CycleGAN and pix2pix in PyTorch基础上编写。
Python版本为3.6(使用3.5和3.7也能运行），在Windows和Ubuntu下都能运行，windows下可能会报Lambda表达式打包的错误。

文件目录结构：

C:\CODE_P
├─alexnet 中间层特征可视化
├─Checkpoints 保存训练模型
├─Cluster 聚类相关程序
│ │ cluster_img.py 对图像聚类
│ │ gen_cell.py 生成Cell，主要为Cell后处理程序
├─Data 数据准备模块
│ │ base_dataset.py 基类，在送入网络前进行处理
│ │ base_data_loader.py 基类
│ │ Dataset_gather.py 根据不同参数调用不同的数据的具体实现
│ │ data_loader.py 数据下载类，根据不同参数调用不同的数据
│ │ Data_manage.py 数据管理， 读取、生成路径等
├─figure 保存图表
├─label 保存所有label
├─Models 网络模型相关
│ │ base_model.py 基类
│ │ double_threads.py 双线程示例
│ │ layers_trans.py 替换字符串string中指定位置p的字符为c，用于批量转换模型各层的名字
│ │ models.py 根据参数进行模型选择
│ │ model_set.py 网络调用、优化函数定义、前向和反向传播及损失值计算
│ │ networks.py 网络模型定义
│ │ resnet_layer_trans.txt
│
├─Options
│ │ options_set.py 参数定义
├─pre_model_state_dict
│ resnet18-5c106cde.pth 预训练模型
├─Result 结果
├─runs
│ │ 无视这个文件夹 │
├─util 计算图像中值
│ compute_image_mean.py│
├─Visualization 可视化相关程序
│ ├─test
└─

二.总体流程

下图是总体流程，三个部分分别为 特征提取、构建Cell和训练定位网络并定位三个部分

程序流程图

主程序

opt = BaseOptions().parse()#导入配置参数
clu = clusterdata()#实例化clusterdata类
datareader = dataread(opt)#实例化数据读取类
[gps_x,gps_y] = datareader.get_gps()#读取数据的GPS信息
c = dataset.num_img#各个车道的图像数量，左中右对应c[0]、c[1]、c[2]
ll2 = clu.cluster_sequence(length,200)#根据图像序列平均划分200个cell
ll3 = clu.cluster_sequence(length,600)
ll4 = clu.cluster_sequence(length,900)

#标注三个车道的图像为0、1、2
three_cla = numpy.zeros(length,dtype=int)
three_cla[0:c[0]] = 0
three_cla[c[0]:c[0]+c[1]] = 1
three_cla[c[0]+c[1]:c[0]+c[1]+c[2]] = 2
three_l = numpy.array(three_cla)
#numpy.savetxt('3.txt',three_l,fmt='%d')

#平均划分的CELL标号写入txt
f =open('label/seq200.txt','w')  
for j in range(len(img_dir)):
    text = str(img_dir[j][37:]) + ' ' + str(int(ll2[j]))                                
    f.write(text)
    f.write('\n')
f.close()
f =open('label/seq600.txt','w')  
for j in range(len(img_dir)):
    text = str(img_dir[j][37:]) + ' ' + str(int(ll3[j]))                                
    f.write(text)
    f.write('\n')
f.close()
f =open('label/seq900.txt','w')  
for j in range(len(img_dir)):
    text = str(img_dir[j][37:]) + ' ' + str(int(ll4[j]))                                
    f.write(text)
    f.write('\n')
f.close()
#将数据随机划分为无序的训练集和测试集
split(opt,'seq200')
split(opt,'seq600')
split(opt,'seq900')

train_extract_features(opt.num_outputs)#训练特提取网络
extract_features(opt.num_outputs)#使用训练好的网络提取图像特征
label = clu.clu_features(900)#根据新特征聚类
numpy.save('clu_900.npy',label)#保存聚类结果#label = numpy.load('clu_900.npy')#下载聚类结果
#显示聚类结果的柱形图
plt.figure(2)
plt.bar(numpy.arange(len(label)),label,width = 1)
plt.show()
#实例化生成Cell的类
cell_gen = CELL(label,900,100,0.16,0.5,opt)  #the third para should < 0.25,else all cells will be 0
[cells_num,lane_cells_count] = cell_gen.gen_cell()#生成Cell，即对聚类结果进行后处理

#cells_num = 631

train_clustered_cell(cells_num)#训练定位网络
single_localization(cells_num)#单张图片定位

train_cells(cells_num)#分层定位网络训练
localization(cells_num)#分层定位网络单张图片定位

Data模块

CreateDataLoader函数准备数据

    train_str = 'train'
    test_str = 'test'
    dataset_train = CreateDataLoader(opt,train_str,isTrain = True)
    dataset_test = CreateDataLoader(opt,test_str,isTrain = False)

CreateDataLoader，实例化CustomDatasetDataLoader类并进行初始化

def CreateDataLoader(opt,phase,isTrain):
    data_loader = CustomDatasetDataLoader()
    print(data_loader.name())
    data_loader.initialize(opt,phase,isTrain)
    return data_loader

CustomDatasetDataLoader类实现如下：重写BaseDataLoader类，并在初始化时通过调用CreateDataset函数选择数据集，再定义torch.utils.data.DataLoader中的参数，如batch大小，是否给顺序等

class CustomDatasetDataLoader(BaseDataLoader):
    def name(self):
        return 'CustomDatasetDataLoader'

    def initialize(self, opt,phase,isTrain):
        BaseDataLoader.initialize(self, opt)
        self.dataset = CreateDataset(opt,phase,isTrain)
        self.dataloader = torch.utils.data.DataLoader(
            self.dataset,
            batch_size=opt.batchSize,
            #shuffle = opt.shuffle if isTrain else not opt.shuffle,
            #shuffle = False, 
            shuffle= isTrain,
            num_workers=int(opt.nThreads))
        print('-----------------dataloader------------------')
        #print(self.dataset)
    def load_data(self):
        return self

    def __len__(self):
        return min(len(self.dataset), self.opt.max_dataset_size)

    def __iter__(self):
        for i, data in enumerate(self.dataloader):
            if i >= self.opt.max_dataset_size:
                break
            yield data

CreateDataset函数实现如下：通过opt.dataset_mode参数选择数据集

def CreateDataset(opt,phase,isTrain):
    dataset = None
    if opt.dataset_mode == 'c3_Dataset':
        from Data.Dataset_gather import c3_Dataset
        dataset = c3_Dataset()
    elif opt.dataset_mode == 'seq_Dataset':
        from Data.Dataset_gather import seq_Dataset
        dataset = seq_Dataset()
    elif opt.dataset_mode == 'cells_Dataset':
        from Data.Dataset_gather import cells_Dataset
        dataset = cells_Dataset()
    elif opt.dataset_mode == 'clustered_cells_Dataset':
        from Data.Dataset_gather import clustered_cells_Dataset
        dataset = clustered_cells_Dataset()
    elif opt.dataset_mode == 'other_test_dataset':
        from Data.Dataset_gather import other_test_dataset
        dataset = other_test_dataset()
    else:
        raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)

    print("dataset [%s] was created" % (dataset.name()))
    dataset.initialize(opt,phase,isTrain)
    return dataset

以cells_Dataset数据为例，先下载对应的train.txt和test.txt以及单张图片定位的txt。调用get_transform_函数，定义数据处理过程，这个函数中的处理过程在自动调用__getitem__函数时会自动进行，如对图片进行剪裁、缩放等。__getitem__函数在

for i, data in enumerate(dataset_train):

循环中会在每一次迭代时自动调用，返回的data即为return的数据
for i, data in enumerate(dataset_train):

class cells_Dataset(BaseDataset):
    def initialize(self, opt ,phase ,isTrain):
        self.opt = opt
        self.root = opt.coderoot
        self.transform_flag = True
        str_train = '/label/cell_'+ str(opt.num_outputs) +'_train.txt'
        str_test = '/label/cell_'+ str(opt.num_outputs) +'_test.txt'
        str_localiza = '/label/cell_'+ str(opt.num_outputs) +'.txt'
        if(phase == 'train'):
            split_file = self.root + str_train
#            split_file.replace(''\'',''/'')
            isTrain = True
        elif(phase == 'test'):
            split_file = self.root + str_test
            isTrain = False
        else:
            #isTrain = True
            self.transform_flag = False
            split_file = self.root + str_localiza
        self.path = numpy.loadtxt(split_file, dtype=str, delimiter=' ', skiprows=0, usecols=(0))
        #self.path = [os.path.join(self.opt.dataroot, path) for path in self.path]
        self.path = [(self.opt.dataroot + path) for path in self.path]
        self.lane= numpy.loadtxt(split_file, dtype=float, delimiter=' ', skiprows=0, usecols=(1))
        self.cell= numpy.loadtxt(split_file, dtype=float, delimiter=' ', skiprows=0, usecols=(2))
        self.mean_image = numpy.load(os.path.join(self.opt.dataroot , 'mean_image.npy'))#下载中值文件
        self.size = len(self.path)
        print('len(self.path):{:}'.format(self.size))
        self.transform = get_transform_(opt,self.mean_image,self.transform_flag)#定义数据处理过程
        #self.num_outputs = opt.num_outputs
    def __getitem__(self, index):
        path = self.path[index % self.size]
        A_img = Image.open(path).convert('RGB')
        #A_img.save('pic/'+path[-9:])
        #print('************')
        cell = self.cell[index % self.size]
        lane = self.lane[index % self.size]
        img = self.transform(A_img)
        return {'img': img, 'cell': cell,
                'path': path,'lane':lane}

    def __len__(self):
        return self.size

    def name(self):
        return 'cells_Dataset'

get_transform_函数的定义如下：使用lambda表达式将函数打包到transforms，在每次执行上面的__getitem__函数时，这些lambda表达式封装的函数都会对每张图片进行处理。

def get_transform_(opt, mean_image,isTrain = True):
    transform_list = []
    transform_list.append(transforms.Resize(opt.loadSize, Image.BICUBIC))
    transform_list.append(transforms.Lambda(lambda img: __subtract_mean(img, mean_image)))
    transform_list.append(transforms.Lambda(lambda img: __crop_image(img, opt.fineSize, isTrain)))
    transform_list.append(transforms.Lambda(lambda img: __to_tensor(img)))
    return transforms.Compose(transform_list)

def __scale_width(img, target_width):
    ow, oh = img.size
    if (ow == target_width):
        return img
    w = target_width
    h = int(target_width * oh / ow)
    return img.resize((w, h), Image.BICUBIC)

def __subtract_mean(img, mean_image):
    if mean_image is None:
        return numpy.array(img).astype('float')
    return numpy.array(img).astype('float') - mean_image.astype('float')

def __crop_image(img, size, isTrain):
    h, w = img.shape[0:2]
    # w, h = img.size
    if isTrain:
        if w == size and h == size:
            return img
        x = numpy.random.randint(0, w - size)
        y = numpy.random.randint(0, h - size)
    else:
        x = int(round((w - size) / 2.))
        y = int(round((h - size) / 2.))
    return img[y:y+size, x:x+size, :]
    # return img.crop((x, y, x + size, y + size))

def __to_tensor(img):
    return torch.from_numpy(img.transpose((2, 0, 1)))

Model模块

model = create_model(opt)

create_model创建model，根据 opt.model参数创建用于特征训练、定位训练和车道分类的网络

def create_model(opt,istest = False):
    model = None
    print(opt.model)
    if opt.model == 'RESNET18'
        from .model_set import RESNET18Model
        model = RESNET18Model():  #训练特征提取网络、定位网络
    elif opt.model == 'RESNET18_CELL':   
        from .model_set import RESNET18Model_CELL
        model = RESNET18Model_CELL() :#训练分层定位网络
    elif opt.model == 'RESNET18_3':   
        from .model_set import RESNET18Model_3
        model = RESNET18Model_3() #训练车道分类网络
    else:
        raise ValueError("Model [%s] not recognized." % opt.model)
    model.initialize(opt, istest)
    #print("model [%s] was created" % (model.name()))
    return model

    def save_network(self, network, network_label, epoch):
        save_filename = '%s_net_%s.pth' % (network_label, epoch)
        save_path = os.path.join(self.save_dir, '%s_%s'%(self.opt.dataset_mode,self.opt.num_outputs))
        if not os.path.exists(save_path):
            os.makedirs(save_path)
        save_path = os.path.join(save_path,save_filename)
        torch.save(network.state_dict(), save_path)

以RESNET18Model类为例，讲解Model类的功能。RESNET18Model类重写了BaseModel类，BaseModel类中有个重要的函数实现，即save_network函数，在base_model文件中。

class RESNET18Model(BaseModel):
    def name(self):
        return 'RESNET18'
    def initialize(self, opt,isTest = False):#调用resnet网络结构；定义优化方法为SGD；定义训练策略lr_scheduler.StepLR
        self.opt = opt
        BaseModel.initialize(self, opt)
        self.isTrain = not isTest
        self.net = networks.RESNET18(opt.num_outputs,isTest)#调用net为networks模块下的RESNET18网络
        if self.isTrain:
            self.old_lr = opt.lr
            self.criterion = torch.nn.CrossEntropyLoss()    #定义损失函数为交叉熵函数       
            self.optimizers = []
            self.optimizer_A = torch.optim.SGD(self.net.parameters() , lr = opt.lr , momentum = 0.9)#定义优化方法为SGD
            self.optimizers.append(self.optimizer_A)
            self.schedulers = lr_scheduler.StepLR(self.optimizer_A, step_size=10, gamma=0.9)#定义训练策略，每10个epoch学习率×0.9
    def set_input(self, input):#设置输出图像
        self.input_img = input['img']
        self.cell = input['cell']
        self.image_paths = input['path']        
    def forward(self):#推理函数
        self.input_img = Variable(self.input_img.float().cuda())
        [self.features,self.pred] = self.net(self.input_img)
        Z = F.softmax(self.pred,dim=1)#获得softmax输出
        _ , self.preds_= torch.max(Z, 1)#获得softmax输出中概率最大的类
    def extract_features(self):
        f = deepcopy(self.features.data.cpu().numpy())#提取特征
        return f
    def testnet(self):#测试，只推理不backward
        self.forward()
        
    def trainnet(self):#训练
        self.optimize_parameters()
    def get_pred_result(self):
        return self.preds_
    def get_image_paths(self):
        return self.image_paths
    def backward(self):#反向传播
        self.loss = self.criterion(self.pred,self.cell.long().cuda())
        self.loss.backward()
    def optimize_parameters(self):#训练优化
        self.forward()
        self.optimizer_A.zero_grad()
        self.backward()
        self.optimizer_A.step()
    def get_current_acc(self,opt):#得到每个batch的正确率
        self.cell = self.cell.long().cuda()
        self.running_corrects = int(torch.sum(self.preds_ == self.cell.data))
        return self.running_corrects    
    def get_current_loss(self,opt):#得到损失值
        self.loss = self.criterion(self.pred,self.cell.long().cuda())
        return float(self.loss)
    def save(self, epoch):
        self.save_network(self.net, 'RESNET18', epoch)
    def forward_singlepic(self):#单张图片推理
        self.input_img = Variable(self.input_img.float().cuda())
        [self.features,self.pred] = self.net(self.input_img)
        Z = F.softmax(self.pred,dim=1)
        _ , self.preds_= torch.max(Z, 1)
        return self.preds_

networks模块定义了各个网络的结构，其中class RESNET18(torch.nn.Module):是继承了torch.nn.Module类，重写了初始化函数 init和前向传播函数forward，在网络喂入图片数据后自动调用forward函数。 torch.load 返回的是一个 OrderedDict。关于模型和权重下载以及权重保存格式等，可以阅读这个博客。self.model.eval()将网络调到测试模式，测试模式时对ropout和batch normalization层的操作在训练和测试的时候是不一样的，具体讲解看这个博客。

class RESNET18(torch.nn.Module):
    """Constructs a ResNet-18 model.
    """
    def __init__(self, num_output, isTest=False,  gpu_ids=[]):
        super(RESNET18, self).__init__()        
        self.model_name = 'resnet18'
        self.gpu_ids = gpu_ids
        state_dict = (torch.load('C:/code_p/Checkpoints/RESNET18/clustered_cells_Dataset_631/RESNET18_net_068.pth'))#预训练权重，其数据结构是每个键对应一个层
        self.model = ResNet(BasicBlock, [2, 2, 2, 2], num_output)#定义ResNet的具体网络结构
        pretrained = True
        if pretrained:
            new_state_dict = OrderedDict()
            for k, v in state_dict.items():
                name = k[6:] # remove `module.`
                new_state_dict[name] = v
                #print(v.size())
            self.model.load_state_dict(new_state_dict,strict = True) #将权重下载到模型中，以模型各层的名字为准，名字不对应则报错，如果strict = False，名字不对应则直接略过。
        if isTest:
            self.model.eval()#在测试模式下
        self.model.eval()
        self.model = self.model.cuda()
        print(self.model)
    def forward(self, x):#前向传播函数
        out = self.model(x)
        return out 

还有网络结构的具体实现，这部分为官方对resnet18的实现源码。这里不讲解，可以去网上搜一下资料。

训练函数

以训练特征提取网络为例，先创建数据，然后创建模型，在每次epoch中进行一次训练和一次测试。

def train_extract_features(num_outputs):
    opt = BaseOptions().parse()
    train_str = 'train'
    test_str = 'test'
    dataset_train = CreateDataLoader(opt,train_str,isTrain = True)#创建训练数据
    dataset_test = CreateDataLoader(opt,test_str,isTrain = False)#创建测试数据
    dataset_size_train = len(dataset_train)
    dataset_size_test = len(dataset_test)
    model = create_model(opt)
    Loss_list_train = []
    Loss_list_test = []
    Accuracy_list_train = []
    Accuracy_list_test = []
    for epoch in range(opt.num_epochs):#epoch 
        epoch_acc_train = 0
        epoch_acc_test = 0
        epoch_loss_train = 0
        epoch_loss_test = 0
        print('Training...')
        for i, data in enumerate(dataset_train): #iter
            #print('[%04d/%04d] ' % (i, len(dataset_train)/opt.batchSize), end='\r')
            model.set_input(data)#输入数据
            model.trainnet()#训练网络
            running_corrects = model.get_current_acc(opt)
            running_loss = model.get_current_loss(opt)
            epoch_acc_train = running_corrects + epoch_acc_train
            epoch_loss_train = running_loss + epoch_loss_train
            Loss_list_train.append(running_loss)
            data_batch_size = len(data['cell'])
            Accuracy_list_train.append(running_corrects/data_batch_size)
            #print(running_loss)
            #print(running_corrects)
            print('[%04d/%04d] ------------------  corrects: %04f-------------------' % (i, len(dataset_train)/opt.batchSize,epoch_acc_train/(i+1)/data_batch_size), end='\r')
        epoch_loss_train = epoch_loss_train/(i+1)
        epoch_acc_train = epoch_acc_train*100/dataset_size_train
        print(' Train epoch {:}:---- lr:{:} ----Acc: {:.4f}%  loss:{:.4f}' .format(epoch,opt.lr,epoch_acc_train,epoch_loss_train))
        print('Test...')
        for i, data in enumerate(dataset_test):
            model.set_input(data)
            istest = True
            model.testnet()
            running_corrects = model.get_current_acc(opt)
            running_loss = model.get_current_loss(opt)
            epoch_acc_test = running_corrects + epoch_acc_test
            epoch_loss_test = running_loss + epoch_loss_test
            Loss_list_test.append(running_loss)
            data_batch_size = len(data['cell'])
            Accuracy_list_test.append(running_corrects/data_batch_size)
            print('[%04d/%04d] ------------------  corrects: %04f-------------------' % (i, len(dataset_test)/opt.batchSize,epoch_acc_test/(i+1)/data_batch_size), end='\r')
        epoch_loss_test = epoch_loss_test/(i+1)
        epoch_acc_test = epoch_acc_test*100/dataset_size_test
        print(' Test epoch {:}:---- lr:{:} ----Acc: {:.4f}%  loss:{:.4f}' .format(epoch,opt.lr,epoch_acc_test,epoch_loss_test))
        model.save(epoch)
        if(epoch%1 == 0):
            numpy.save('D:/figure/Loss_list_train_600_.npy',Loss_list_train)#保存loss
            numpy.save('D:/figure/Loss_list_test_600_.npy',Loss_list_test)
            numpy.save('D:/figure/Accuracy_list_train_600_.npy',Accuracy_list_train)
            numpy.save('D:/figure/Accuracy_list_test_600_.npy',Accuracy_list_test)
        if((epoch_acc_train>99.9)&(epoch_acc_test>99.9)):
            break

GEN_CELL模块

GEN_CELL模块是对聚类后的cell进行后处理生成最终cell的模块

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 28 10:19:06 2018

@author: zs
"""
import numpy 
import os
from matplotlib import pyplot as plt
class CELL():
    def __init__(self,label,k,outline_range,outline_range_threshold,kkk,opt):
        ''''
        outline_range、outline_range_threshold分别是统计范围和小Cell的阈值，小于这个阈值则合并，kkk*outline_range是需要处理的范围，kk是个系数。
        ''''
        self.root = opt.coderoot
        self.outline_range = int(outline_range)
        self.outline_range_threshold = outline_range_threshold
        self.num = k
        self.kkk = kkk
        self.new_index = numpy.zeros(k)
        self.index = label
        self.dataset_size = len(label)
        self.new_label = numpy.zeros(label.shape)
        str_path = 'label/seq'+ str(opt.num_outputs) +'.txt'
        split_file = os.path.join(self.root , str_path)
        self.path = numpy.loadtxt(split_file, dtype=str, delimiter=' ', skiprows=0, usecols=(0))
        str_path = 'label/3.txt'
        split_file = os.path.join(self.root , str_path)
        self.lines = numpy.loadtxt(split_file, dtype=int, delimiter=' ', skiprows=0, usecols=(1))
        print(self.new_label.shape)
    def idx_transformation(self):#将聚类形成无序label转换成以图像序列为准的有序label
        n = 0
        for i in range(0,self.dataset_size):
            if(self.new_index[self.index[i]] == 0):
                self.new_index[self.index[i]] = n
                n+=1
        for i in range(0,self.dataset_size):
            self.new_label[i] = int(self.new_index[self.index[i]])-1
            #print(self.new_label[i])
        #self.lll = self.new_label.copy()
        
        save_dir = 'C:/code_p/label/new_label%d.txt'%(self.num)
        numpy.savetxt(save_dir,self.new_label,fmt='%d')
        self.label_removed = self.new_label.copy()
    def check_same_cell_differentlane(self):#检查小的cell和包含不同车道图像的cell
        lane_cells_count = numpy.zeros(3,dtype=numpy.int)
        for j in range(len(self.lines)):
            lane_cells_count[self.lines[j]] += 1
        lane_cells_count[1] = lane_cells_count[1]+lane_cells_count[0]
        print(lane_cells_count)
        save_dir = 'C:/code_p/label/ttt.txt'
        f =open(save_dir,'w')  
        for j in range(len(self.new_label)):
            text =str(self.new_label[j])                                 
            f.write(text)
            f.write('\n')
        f.close
        for i in range(len(lane_cells_count)-1):
            if (self.new_label[lane_cells_count[i]] == self.new_label[lane_cells_count[i]+1]):
                for j in range(lane_cells_count[i]+1,len(self.new_label)):
                    self.new_label[j] += 1        
        
        
    def remove_smallcell(self):#移除小的cell
        print('remove small cell...')
        kkk = self.kkk
        for i in range(0,len(self.new_label)-self.outline_range):
            #print(i)
            global point_sample
            point_sample = numpy.zeros(int(2000),dtype=numpy.int)#保存一定范围内各类cell的数量，因为我们的cell数量这里不超过2000，因此长度设为2000，保证不会超出
            #ll_ = numpy.zeros(int(2000),dtype=numpy.int)
            #print(int(self.outline_range/2))
            #last = self.label_removed[i]
            #nn = 0
            #ll_[0] = self.label_removed[i]
            for j in range(0,self.outline_range):
#                if (self.label_removed[i+j] != last):
#                    nn += 1
#                    ll_[nn] = self.label_removed[i+j]
                    
                point_sample[int(self.label_removed[i+j])] += 1#在[i,i+outline_range]范围内统计每类标签的数量
                #last = self.label_removed[i+j]
            for ii in range(0,2000):
                flag_remove_once = 0
                if(point_sample[ii]<=self.outline_range*self.outline_range_threshold)and(point_sample[ii]>0):   #如果此类cell数量不是0并且小于阈值                 
                    for jj in range(int(self.outline_range/2-self.outline_range*kkk/2),int(self.outline_range/2+self.outline_range*kkk/2)):#对统计处理范围内的小cell进行合并
                        #print(ll.shape())
                        #print(ll_)
                        if (self.label_removed[i+jj] == ii):
                            print('remove%d'%(self.new_label[i+jj]))
                            self.label_removed[i+jj] = self.label_removed[i+jj-1]
                            flag_remove_once = 1
                            print(point_sample)
                            for iii in range(len(point_sample)):
                                if(point_sample[iii] >0):
                                    print(point_sample[iii])
                            #print(ll_)
#                        plt.bar(range(i+0,i+self.outline_range),self.label_removed[i:i+self.outline_range],width = 1)
#                        plt.show()
                if flag_remove_once:
                    i -= 1#保证可以处理交叉的CELL
                    break
        #for i in range(0,len(self.new_label)):
            #print(self.new_label[i],'---',self.lll[i]) 
            #if(abs(self.new_label[i]-self.lll[i])>0.1):
                #print('remove label: %d'%(self.lll[i]))
        save_dir = 'C:/code_p/label/label_removed%d.txt'%(self.num)
        numpy.savetxt(save_dir,self.label_removed,fmt='%d')                  
    def checkandsort_cell(self):#对重复出现的大cell赋予新的标号
#        for i in range(0,len(self.new_label)):
#            #print(self.new_label[i],'---',self.lll[i]) 
#            if(abs(self.new_label[i]-self.lll[i])>0.1):
#                print('remove label')#: %d'%(self.lll[i]))
        print('check and sort cell...')
        cell= numpy.zeros(len(self.label_removed),dtype=numpy.int)
        last = 0
        class_plus = 0
        reco = numpy.zeros(1000,dtype=numpy.int)
        self.count = 0
        for i in range(0,len(self.label_removed)):
            n = int(self.label_removed[i])
            if(reco[n]> 0)and(abs(n - last)>0.1):
                #print('check repeated cell: %d:'%(n))
                self.count += 1
            if(abs(n-last)>0.1):
                class_plus += 1
            #print(class_plus)
            cell[i] = class_plus
            last = n
            reco[n] += 1
        print('check repeated  %d cells'%(self.count))
        return cell
    def cou_cell(self):#统计处理前后的cell数量变化
        nn = int(self.new_label[-1]+1)
        print(nn)
        cm = numpy.zeros(nn,dtype=numpy.int)
        for i in range(0,len(self.new_label)):
            cm[int(self.new_label[i])-1] += 1
        print('before remove max: %d'%(max(cm)))
        print('before remove min: %d'%(min(cm)))
        #print(cm)
        cm = numpy.zeros(nn,dtype=numpy.int)
        for i in range(0,len(self.label_removed)):
            cm[int(self.label_removed[i])-1] += 1
        print('after remove max: %d'%(max(cm)))
        print('after remove min: %d'%(min(cm)))
        #print(cm)
    def gen_cell(self):
        self.idx_transformation()
        #self.check_same_cell_differentlane()
        self.remove_smallcell()
        
        self.cou_cell()
        cell = self.checkandsort_cell()
        save_dir = 'C:/code_p/label/cell_%d.txt'%(cell[-1]+1)
        self.path
        lane_cells_count = numpy.zeros(3,dtype=numpy.int)
        f =open(save_dir,'w')  
        for j in range(len(cell)):
            lane_cells_count[self.lines[j]] += 1
            text = self.path[j]+' '+str(self.lines[j])+' ' +str(cell[j])                                 
            f.write(text)
            f.write('\n')
        f.close
        print(lane_cells_count)
        lane_branch_start_cell = [0,cell[lane_cells_count[0]],cell[lane_cells_count[0]+lane_cells_count[1]]]
        print(lane_branch_start_cell)
        lane_cells_cla = [cell[lane_cells_count[0]-1]+1,cell[lane_cells_count[1]+lane_cells_count[0]-1]-cell[lane_cells_count[0]]+1,cell[lane_cells_count[2]+lane_cells_count[1]+lane_cells_count[0]-1]-cell[lane_cells_count[1]+lane_cells_count[0]]+1]
        #lane_cells_cla = [lane_cells_cla[0],lane_cells_cla[1]-]
        
        numpy.save('C:/code_p/label/lane_cells_cla_900.npy',lane_cells_cla)
        numpy.save('C:/code_p/label/lane_branch_start_cell_900.npy',lane_branch_start_cell)

        return [cell[-1]+1,lane_cells_cla]

论文第四章是分层定位网络相关的内容，主要根据浅层的特征对数据进行预分类，这应该不会是你的下一步重点，如果你想了解，相关程序主要在以下两个类：
model_set 文件内的

class RESNET18Model_CELL(BaseModel):

networks文件内的

class ResNet_redefined_cell(nn.Module):