上节，我们介绍了TencentOS tiny，参考官方给出的移植教程亲自动手做了一遍，文章如下：
 
 
天啊！鹅厂都开始做开发板了？网红腾讯物联网开发板终极开箱评测,让我们一睹为快!
 
 
趁着最近有时间，这节，我撸了几个例程作为后面做项目参考的基本框架，当然也有一些是直接拿了官方文档的例程：
 
 
 
 
一般来说，学习任何一个RTOS，本质是没有什么太大的区别的，通常在最简版nano上进行开发，关于TencentOS tiny，我个人认为，掌握以下基础组件的用法足矣，

      最近我国自研的操作系统接连开源，先是MiniGui（Github地址：https://github.com/VincentWei/minigui），可能现在提起MiniGui大家已经比较陌生了，不过对于笔者-曾经的CSDN嵌入式论坛版主而言，MiniGui是个如雷贯耳的名字，在十几年前MiniGui和WINCE是各个各种开发板的标配，当时论坛上也有各种关于MiniGui移植及开发的帖子。但是由于当时的嵌入式系统多用来制作手持式PDA，车载导航仪等设备，所以安卓出现后迅速占领了上述市场，MiniGUI等嵌入式操作系统逐渐没落。
 
     但是我们整理互联网发展的脉络可以看到，内容的不断丰富与终端的不断扩展是两条主线，随着网上数据量的持续爆炸性增长，今后新增的流量肯定主要来自于对于万物互联的红利，而与传统互联网内容+用户的模式不同，物联网则是场景+用户的模式，谁能整合场景谁能笑到最后。所以之后的嵌入式系统又迎来了生命中的第二个春天。
 
         巨头们的布局
 
       腾讯在三天前正式发布了其物联网终端的操作系统TinyOS(Github地址：https://github.com/Tencent/TencentOS-tiny),其系统架构图如下：    
 
​
 
 
 
目前看其内核部分已经开发完成，并已经完全开源。虽然从其从tinyos内核的代码来看（详见https://blog.csdn.net/BEYONDMA/article/details/101355221），还是为物联终端做了一定优化与裁减的，不过从下面的场景图来看，腾讯其实醉翁之意不在酒，以操作系统为契机入局物联网的相关链条已经规划完整，
 
 ​
 
而且从比操作系统发布还早几天就挂在淘宝上的开发板来看，更是说明腾讯对于旗下云平台能够整合物联场景的巨大野心。
 
 ​   
 
 
 
 
 
    AliOS Thing3.0发布 
 
     云栖大会第三天，阿里不出意外的拿出了AliOS Things 3.0（Github地址https://github.com/alibaba/AliOS-Things/tree/rel_3.0.0），与TencentOS Tiny一样这款OS也是与阿里云平台无缝对接的，而且它的内核还直接支持了自家的AI芯片，提前布局AI+物联网。由于AliOS Things已经开源两年有余，所以其开发者体验相对较好，他们的IDE是基于VSCODE的，笔者已经下单他们的开发板了，后续亲测OS后再发体验。
 
    可见巨头的逻辑就是要整合物联网时代的场景，他们的OS都是免费的，而且技术支持也强，不过巨头就是要做物联时代的ANDROID,最终一统天下。
 
     老牌嵌入式操作系统的选择
 
    MiniGui做为已经存在了20多年的嵌入式操作系统，其架构图如下：
 
​
 
 
 
    
 
从底至上，MiniGUI 由如下几个模块组成：
 
图形抽象层（Graphics Abstraction Layer，GAL）。图形抽象层将来自不同操作系统或设备的图形接口进行抽象，为 MiniGUI 上层提供统一的图形接口。在图形抽象层内，包含有针对 Linux FB 设备、eCos LCD 设备等的软件组成部分。这些软件组成部分通过调用底层设备的接口来实现具体的图形抽象层操作，如打开设备、设置分辨率及显示模式、关闭设备等。我们将这些用于适配图形抽象层接口的软件组成部分称为“引擎（engine）”，其概念和操作系统中的设备驱动程序类似。
输入抽象层（Input Abstraction Layer，IAL）。和 GAL 类似，输入抽象层将 MiniGUI 涉及的所有输入设备，如键盘（keyboard）、小键盘（keypad）、鼠标（mouse）、触摸屏（touch screen）等抽象了出来，为上层提供一致的接口。要支持不同的键盘、触摸屏或者鼠标接口，则通过为 IAL 编写不同的输入引擎实现。MiniGUI 通过 IAL 及其输入引擎，提供对 Linux 控制台（键盘及鼠标）、触摸屏、遥控器、小键盘等输入设备的支持。
图形设备接口（Graphics Device Interfaces，GDI）。该模块基于图形抽象层为上层应用程序提供图形相关的接口，如绘制曲线、输出文本、填充矩形等等。图形设备接口中含包含其他比较独立的子模块，如字体字符集（font and charset）支持、图像（image）支持等。
消息处理模块（Messaging Module）。该模块在输入抽象层基础上，实现了 MiniGUI 的消息处理机制，为上层提供了完备的消息管理接口。众所周知，几乎所有的GUI 系统本质上都是事件驱动的，系统自身的运行，以及GUI 应用程序的运行，都依赖于消息处理模块。
多窗口处理模块（Windowing Module）和控件（Control 或 Widget）。基于图形设备接口和消息处理模块，MiniGUI 实现了多窗口处理模块。该模块为上层应用程序提供了创建主窗口和控件的基本接口，并负责维护控件类。控件类是用来实现控件代码重用的重要概念，利用控件类（control class），我们可以创建属于某个控件类的多个控件实例（instance），从而让这些控件实例使用同一个控件类的代码，这样，我们就实现了类似 C++ 那样的类和实例概念，从而可以最大程度上重复利用已有代码，并提高软件的可维护性。MiniGUI 的控件模块实现了常见的 GUI 控件，如静态框、按钮、编辑框、列表框、下拉框等等。
外观支持（Look and Feel）。这个模块是 MiniGUI V3.0 提供给上层应用程序的接口，可用来定制 MiniGUI 窗口、控件的绘制。在 MiniGUI V3.0 之前的版本中，对主窗口和控件的定制能力，还没有被抽离出来形成独立的模块，但我们仍然可以通过配置选项让 MiniGUI 的主窗口、控件具有三种显示风格，分别是：类似 PC 的三维风格（PC3D）、平板风格（FLAT）、流行风格（FASHION）。在 MiniGUI 3.0 中，主窗口和控件的外观可完全由应用程序自行定制，在创建主窗口或者控件时，指定外观渲染器（renderer）的名称，就可以让主窗口或者控件具有各自不同的外观。
       可以看到MiniGUI从创立伊始就放弃了对于RTOS内核的编写，直接基于linux等内核来做封装。简单聊两句基于MiniGUI的图形应用开发。
 
typedef struct _MSG
 {
  HWND             hwnd;
     int              message;
     WPARAM           wParam;
     LPARAM           lParam;
 #ifdef _LITE_VERSION
    unsigned int     time;
 #else
      struct timeval   time;
 #endif
      POINT            pt;
  #ifndef _LITE_VERSION
      void*            pAdd;
  #endif
  }MSG;
typedef MSG* PMSG;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        可以看到其对于消息的定义几乎与WINDOWS一致，其建立窗体等操作也几乎与WINDOWS一样。所以MiniGUI的设计有很大程序是为降低嵌入式系统图形界面开发难度而产生的。
 
国产实时操作系统内核的先驱RTthread
 
  提到咱们国产的lot操作系统RTthread也是一个无论如何也绕不过去的标志，如果RTthread在06年初就发布了第一版，而且经过了这十几年的上亿台设备装机的技术沉淀，RTthread的社区也已经俨然发展成为国内最强的嵌入式社区了，笔者刚刚到他们的论坛上逛了一圈，真的是强手如云，大咖云集。具体内核相关知识后续会再发文介绍这里也就不再赘述了。而且最新的消息显示MiniGUI开始支持RTthread的内核了，可见传统的嵌入式操作系统厂商的策略是要尽量保持生态的多元化，抱团取暖。
 
  HybridOS的开源计划
 
最近MiniGUI的飞漫软件又官宣了他们的HybridOS开源计划，而根据目前的材料看HybridOS最大的看点是要用HTML来统一UI的开发，这与之前使用WIN32的设计来统一UI开发的逻辑如出一辙。我们知道由于物联网终端真的是不一而足，与手机终端完全不同，其不同终端的碎片化需求太多太复杂，比如，有的智能灯泡要蓝牙即可，而智能空调可能就要有 WiFi了，而我们金融行业要做智能合约可能对于终端的算力又有一定的要求，这样碎片化的场景，由于Android硬件设备的要求门槛较高，就不太适合了， 而直接用 Linux裁减，这对于人才的要求又太高。所以与腾讯等巨头整合全场景的目标不同，MiniGUI的背后其是保持生态多样性的逻辑，他的目标是降低开发门槛，避免初创公司必须选择鸿蒙或者TinyOS这种大厂的操作系统，让场景的提供方可以通过较低成本验证自身的想法，而避免从一开始就走上巨头们早已画好的圆圈。
 
      在他们的官宣当中对于其后续要发布的HybridOS物联网操作系统有如目标：
 
HybridOS 的设备端系统基于 Linux 内核，充分利用 Linux 内核生态，降低各种驱动程序的开发难度以及各种协议栈的支持难度，从而降低开发成本。
和基于 RTOS（实时操作系统）技术发展而来的物联网操作系统（如RT-Thread、LiteOS）相比，HybridOS 更倾向于运行在具有更高硬件配置的智能物联网设备上，而不是小型的单功能物联网设备上，后者的硬件配置往往有限。
HybridOS 不仅仅运行在智能物联网设备中，它同时还提供了针对云端以及客户端的标准框架和编程接口，为开发者提供了从设备到云再到客户端的完整软件栈和协议栈。在未来，HybridOS 还计划统一客户端和设备端上的 App 开发接口。
HybridOS 将基于区块链技术为物与物之间的通讯提供一个全新的实现方法。在 HybridOS定义的实现方法下，所有的数据都带有不可篡改的数字签名以及时间戳，而所有数据的传输和存储都可加密。这将从根本上提高物联网的安全性。
    后记
 
    我们可以看到巨头的逻辑是要让其它公司免费使用其OS上车，然后接入其loT云平台成者直接收购无缝整合，败者自生自灭，从而将自己立于不败之地，而传统的嵌入式公司逻辑则是降低OS的使用开发门槛，让物联网生态链上的企业能有自主选择。也让我们拭目以待，物联网时代能否产生新的巨头。
 
 
 
 

 
Tiny Core Linux 保存配置
 
前言
一. Tiny Core Linux 版本介绍
二. 命令行版本（无GUI）
三. 图形界面版本
补充说明

 
 
前言
 
Tiny Core Linux是一款极体积极小且高度可扩展的微型 Linux 发行版，它将一个 Linux 操作系统精简到仅有 10 多 MB 左右的大小。它的体积仅有十几MB左右，却依然提供了图形化的界面。而且得益于体积小，Tiny Core Linux 采用了将系统内核完全装载在内存中运行的方式，因此无论是启动还是运行速度都极快！
 
因为TinyCoreLinux是内存闪存系统，为保证系统的快速启动运行，所有数据都保存在内存中，所以当重启系统之后对系统的所有修改将被删除。
 
那么如何保存系统修改呢？需要指定一个tce目录，这样就会保存一个包含home和opt目录的压缩文档mydata.tgz。mydata.tgz保存在/tce目录，所以当你设定了tce目录，修改将可以保存到目录中，在下一次开机时可以加载数据。
 
默认情况下，关机的时候会调用backup utility保存你的文档和设置。backup utility会创建一个包含home和opt目录的压缩文档mydata.tgz。mydata.tgz保存在/tce目录，所以你只要你设定了tce目录，所有修改都将会自动保存。
 
一. Tiny Core Linux 版本介绍
 
Tiny Core Linux 其实提供了三个不同版本供用户下载，分别是 Core (11MB)、TinyCore (16MB) 以及 CorePlus (106MB)，其中 Core 版只包含命令行，没有图形界面，适用于高级用户或用来定制应用；TinyCore 版则是提供了图形界面、网络连接等功能，比较适合大众用户；而 CorePlus 版则内置了更多的安装工具，安装时可以在7种窗口管理器中自由选择，支持非美国键盘等。
 
所以总体上可以将Tiny Core Linux 系统分为两种，也就是命令行版本（无GUI）和图形界面版本。下面将分别介绍这两种版本如何实现配置保存。
 
二. 命令行版本（无GUI）
 
/opt/.filetool.lst文件是用户可以设定永久保存的文件或文件夹的系统文件。所以如果有想设定保存的文件或者文件夹，可以通过以下命令编辑文件，添加需要保存的文件或者路径，并保存。
 
vi /opt/.filetool.lst
 
再进行存盘操作（系统命令）
 
sudo filetool.sh -b
 
输入命令后会出现backup成功，保存为mydata.tgz的提示。再关机重启就能发现这个文件没有删除，被成功的保存并且加载。
 
三. 图形界面版本
 
相对来说，有图形界面的保存配置文件会更加容易，关机的时候系统会提供选择，包含直接关机或者备份关机等操作，只要选择备份关机即可。
 
 
补充说明
 
/opt/bootlocal.sh文件用于系统启动后自动运行的命令

 
这里写自定义目录标题
 
1. yolov3-tiny简介
2 安装darknet
3.下载预训练模型yolov3-tiny.weights
4. 简单地测试
4.1 测试图片
4.2 测试实时视频
  
5. 制作自己的数据集
5.1 准备数据集
5.2 打乱顺序并重命名
5.3 数据标注
第一种方法:
第二种方法:
   
   
5.4 指定训练集和测试集
5.5 指定训练集和测试集的实际路径和标签文件
5.6 修改一些必要文件
5.6.1 修改data目录下的voc.names
5.6.2 修改 cfg目录下的voc.data文件
5.6.3 修改 cfg目录下的yolov3-tiny.cfg文件
5.6.4 生成预训练模型
  
  
6.训练
7.测试
7.1 使用c进行图片检测
7.2 使用c进行实时检测
7.2 使用python进行图片检测
7.3 使用python进行实时检测
 

 
1. yolov3-tiny简介
 
2 安装darknet
 
首先下载darknet,执行如下命令:
 
git clone https://github.com/pjreddie/darknet
 
下载完成后,进入darknet目录,并打开Makefile文件,因为Jetson Nano支持GPU,且已预安装了OPENCV和CUDNN.所以在编译的时候我们需要修改下Makefile文件,如下:将
 
GPU=0
CUDNN=0
OPENCV=1
OPENMP=0
DEBUG=1
 
修改为
 
GPU=1
CUDNN=1
OPENCV=1
OPENMP=0
DEBUG=1
 
然后执行如下命令进行编译:
 
$ cd darknet
$ make
 
此时darkent安装完成.
 
3.下载预训练模型yolov3-tiny.weights
 
执行如下命令下载预训练模型:
 
wget https://pjreddie.com/media/files/yolov3-tiny.weights
 
等待其下载完成后,会在darknet根目录下看到该预训练模型.
 
4. 简单地测试
 
4.1 测试图片
 
./darknet detect cfg/yolov3-tiny.cfg yolov3-tiny.weights data/dog.jpg
 
4.2 测试实时视频
 
./darknet detector demo cfg/voc.data cfg/yolov3-tiny.cfg yolov3-tiny.weights
 
5. 制作自己的数据集
 
本次训练的目标是为了能够检测出四类不同的物体,即西瓜,手套,电池和鞋,如图所示:
 
每种物体采集700张,命名方式以数字形式进行命名.
 
5.1 准备数据集
 
然后切换到darkent根目录,依次建立如下几个文件夹:
 
$ cd scripts
$ mkdir -p VOCdevkit && cd VOCdevkit
$ mkdir -p VOC2019  && cd VOC2019
$ mkdir -p Annotations && mkdir -p ImageSets && mkdir -p  JPEGImages && mkdir -p labels
 
建立完之后的目录为:
 ├── VOCdevkit
 │ └── VOC2019
 │ ├──── Annotations
 │ ├──-── ImageSets
 │ ├──-──JPEGImages
 │ └─────labels
 将采集到的图像全部放入JPEGImages文件夹下.
 
5.2 打乱顺序并重命名
 
将JPEGImages文件夹下的图像文件打乱顺序并重新命名.方法是执行如下的python脚本文件:
 
# -*- coding:utf-8 -*-
import os
import random
class ImageRename():
    def __init__(self):
        self.path = '/home/jetbot/darknet-master/scripts/VOCdevkit/VOC2019/JPEGImages'#图片所在文件夹
 
    def rename(self):
        filelist = os.listdir(self.path)
        random.shuffle(filelist)
        total_num = len(filelist)
        i = 0
        for item in filelist:
            if item.endswith('.jpg'):
                src = os.path.join(os.path.abspath(self.path), item)
                dst = os.path.join(os.path.abspath(self.path), '0000' + format(str(i), '0>3s') + '.jpg')
                os.rename(src, dst)
                print ('converting %s to %s ...' % (src, dst))
                i = i + 1
        print ('total %d to rename & converted %d jpgs' % (total_num, i))
 
if __name__ == '__main__':
    newname = ImageRename()
    newname.rename()
 
5.3 数据标注
 
该步骤用于对每张图片生成描述文件,我们需要认为指定图片里哪一块区域是我们要检测的物体.每张图片都要以一个xml文件进行描述.数据标注的工具很多,在这里我们选择labelImg.首先安装,在这里该插件对python版本有要求,python2和python3的安装方式不同,选择任意一种即可,区别在于最后执行过程.
 若为python3,安装过程如下:
 
$ sudo apt-get install pyqt5-dev-tools
$ sudo pip3 install lxml
$ cd darknet &&  mkdir -p software && cd software
$ git clone https://github.com/tzutalin/labelImg.git
$ cd labelImg
$ make all
 
若为python2,安装过程如下:
 
$ sudo apt-get install pyqt4-dev-tools
$ sudo pip install lxml
$ cd darknet &&  mkdir -p software && cd software
$ git clone https://github.com/tzutalin/labelImg.git
$ cd labelImg
$ make all
 
至此,安装已完成,下面可以运行如下命令打开该软件进行标注了:
 若为python3安装,则打开软件的方式为:
 
$ python3 labelImg.py  #打开labelImg
 
若为python2安装,则打开软件的方式为:
 
$ python labelImg.py  #打开labelImg
 
软件界面如下:
 
 然后点击左侧的"Open Dir"按键,选择我们存放数据图片的文件夹JPEGImages,如下:
 然后点击"Open",之后会出现第一张图片,对于一张图片的标注,一般分如下几个步骤:
 1)点击左侧的"Create \n RectBox"按键,然后找准我们要识别的物体,从左上角到右下角拖一个矩形,
 2) 在弹出的窗口种创建标签,如下图所示,我们需要选择"watermenlon",如果不出现,要手动敲一个,添加进去,并选择,如果图片中有多个待识别的物体,则再此拉矩形框,并选择类别.
 
 3) 选择完成后,点击保存或者键盘按"ctrl+s",则会在JPEGImages文件夹下生成对应00001.jpg的xml文件00001.xml.
 4)按键盘"n"来进入下一张图片.
 按照上述步骤依次进行,直到标注完毕.
 注: 若在标注过程中,有些图片比较模糊,我们可以不进行标注,直接进入下一张图片.
 标注全部完成后,我们会在JPEGImages文件夹中看到jpg文件和xml文件共存,在这这里还需要删除我们之前没有标注的图片,它们不具备任何作用.所以就需要我们进行排查和清除,方法有两个,对于样本较少的,建议第一种:
 
第一种方法:
 
打开文件夹,将文件夹水平方向缩小为只能包含两列,即左侧为jpg图片,右侧为xml文件,若某一行出现有两个jpg图片,则删除左边那个,不断向下拖动滑动条,直到尾断即完成了排查和删除.
 
第二种方法:
 
执行如下脚本进行排查:
 
import os
import os.path

h = 0
a = ''
b = ''
dele = []
pathh = "/home/jetbot/darknet-master/scripts/VOCdevkit/VOC2019/JPEGImages"
#dele.remove(1)
for filenames in os.walk(pathh):
    filenames = list(filenames)
    filenames = filenames[2]
    for filename in filenames:

        print(filename)
        if h==0:
            a = filename
            h = 1
        elif h==1:
            #print(filename)
            b = filename
            if a[0:a.rfind('.', 1)]==b[0:b.rfind('.', 1)]:
                h = 0
                #print(filename)
            else:
                h = 1
                dele.append(a)
                a = b
        else:
            print("wa1")
print(dele)
for file in dele:
    os.remove(pathh+file)
    print("remove"+file+" is OK!")

#再循环一次看看有没有遗漏的单身文件
for filenames in os.walk(pathh):
    filenames = list(filenames)
    filenames = filenames[2]
    for filename in filenames:

        print(filename)
        if h==0:
            a = filename
            h = 1
        elif h==1:
            #print(filename)
            b = filename
            if a[0:a.rfind('.', 1)]==b[0:b.rfind('.', 1)]:
                h = 0
                #print(filename)
            else:
                h = 1
                dele.append(a)
                a = b
        else:
            print("wa1")
print (dele)
 
至此数据标注工作完毕,我们还需要一个小工作,就是将xml文件全部从JPEGImages移出到Annotations文件夹下,方法为:
 
$ cd JPEGImages
$ mv *.xml ../Annotations/
 
至此,JPEGImages为全部的图像数据,Annotations中为对应的xml描述文件.
 
5.4 指定训练集和测试集
 
我们做好的数据集要一部分作为训练集来训练模型,需要另一部分作为测试集来帮助我们验证模型的可靠性.因此首先要将所有的图像文件随机分配为训练集和测试集.
 首先切换到ImageSets目录中,新建Main目录,然后在Main目录中新建两个文本文档train.txt和val.txt.分别用于存放训练集的文件名列表和测试集的文件名列表.
 
$ cd ImageSets 
$ mkdir -p Main && cd Main
$ touch train.txt test.txt 
 
然后执行如下脚本文件来生成训练集和测试集,注意该文件中的2400为我选择的训练集的个数.400默认为测试集.
 
import os
from os import listdir, getcwd
from os.path import join
if __name__ == '__main__':
    source_folder='/home/jetbot/darknet-master/scripts/VOCdevkit/VOC2019/JPEGImages/'     # 修改为自己的路径
    dest='/home/jetbot/darknet-master/scripts/VOCdevkit/VOC2019/ImageSets/Main/train.txt' # 修改为自己的路径
    dest2='/home/jetbot/darknet-master/scripts/VOCdevkit/VOC2019/ImageSets/Main/val.txt'  # 修改为自己的路径
    file_list=os.listdir(source_folder)       
    train_file=open(dest,'a')                 
    val_file=open(dest2,'a')   
    count = 0               
    for file_obj in file_list:
        count += 1                
       
        file_name,file_extend=os.path.splitext(file_obj)
        
        if(count<2400):  # 可以修改这个数字，这个数字用来控制训练集合验证集的分割情况                   
            
            train_file.write(file_name+'\n')  
        else :
            val_file.write(file_name+'\n')    
    train_file.close()
    val_file.close()
 
运行完成后可以在train.txt和val.txt文件如下所示:
 
 
5.5 指定训练集和测试集的实际路径和标签文件
 
修改script文件夹根目录下的voc_label.py文件,需要修改几处:
 
sets=[ (‘2019’, ‘train’), (‘2019’, ‘val’)] ,2019为我们设置的文件夹标识 ,"train"和"val"指代训练集和测试集
 2)classes = [“shose”, “glove”, “battery”, “watermenlon”] ,修改为我们要识别的四类物体名称
 如下:
 
import xml.etree.ElementTree as ET
import pickle
import os
from os import listdir, getcwd
from os.path import join

sets=[ ('2019', 'train'), ('2019', 'val')]

classes = ["shose", "glove", "battery", "watermenlon"]


def convert(size, box):
    dw = 1./(size[0])
    dh = 1./(size[1])
    x = (box[0] + box[1])/2.0 - 1
    y = (box[2] + box[3])/2.0 - 1
    w = box[1] - box[0]
    h = box[3] - box[2]
    x = x*dw
    w = w*dw
    y = y*dh
    h = h*dh
    return (x,y,w,h)

def convert_annotation(year, image_id):
    in_file = open('VOCdevkit/VOC%s/Annotations/%s.xml'%(year, image_id))
    out_file = open('VOCdevkit/VOC%s/labels/%s.txt'%(year, image_id), 'w')
    tree=ET.parse(in_file)
    root = tree.getroot()
    size = root.find('size')
    w = int(size.find('width').text)
    h = int(size.find('height').text)

    for obj in root.iter('object'):
        difficult = obj.find('difficult').text
        cls = obj.find('name').text
        if cls not in classes or int(difficult)==1:
            continue
        cls_id = classes.index(cls)
        xmlbox = obj.find('bndbox')
        b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text), float(xmlbox.find('ymax').text))
        bb = convert((w,h), b)
        out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')

wd = getcwd()

for year, image_set in sets:
    if not os.path.exists('VOCdevkit/VOC%s/labels/'%(year)):
        os.makedirs('VOCdevkit/VOC%s/labels/'%(year))
    image_ids = open('VOCdevkit/VOC%s/ImageSets/Main/%s.txt'%(year, image_set)).read().strip().split()
    list_file = open('%s_%s.txt'%(year, image_set), 'w')
    for image_id in image_ids:
        list_file.write('%s/VOCdevkit/VOC%s/JPEGImages/%s.jpg\n'%(wd, year, image_id))
        convert_annotation(year, image_id)
    list_file.close()

os.system("cat 2019_train.txt 2019_val.txt > train.txt")
 
修改完成后,执行如下命令,即可在labels文件夹下生成标签文件.如下:
 
 在scripts根目录下,也会生成2019_train.txt和2019_var.txt文件,与之前Main中的train.txt和var.txt文件不同,其内容全部为训练图片或测试图片的实际路径.
 
 
5.6 修改一些必要文件
 
5.6.1 修改data目录下的voc.names
 
将文件中coco数据集的标签,修改为我们需要的四类标签,如下:
 
 
5.6.2 修改 cfg目录下的voc.data文件
 
主要修改的点为:
 1)classes 因为,我们是4类,所以,classes = 4;
 2) 修改训练集:train = /home/jetbot/darknet-master/scripts/2019_train.txt
 3) 修改测试集valid = /home/jetbot/darknet-master/scripts/2019_var.txt
 4) 修改标签名: names = data/voc.names
 5) 修改训练过程中生成的过程结果存放地址
 修改后,如下:
 
 
5.6.3 修改 cfg目录下的yolov3-tiny.cfg文件
 
修改地方主要有如下几个:
 
有两处需要修改classes和filters,从下往上有两处,类似如下字样处:
 
[convolutional]
size = 1
stride =1
pad =1
filters = %%%
actication = linear

[yolo]
mask = ...
anchors = ...
classes = %%%
num = ...
 
将classes 修改为4,因为我们只有4类;将卷积层数修改为27 ,计算方式为3*(类别数+5).若为3类,则是3*(3+5) = 24.
 
我们任务是测试,则需要将该文件上方Testing下两行的batch=1,subdivisions=1全部注释掉,将# Training下两行的batch=64,subdivisions=16全部取消注释.
 
至此,训练前的准备工作已全部完成了.
 
5.6.4 生成预训练模型
 
该过程用于生成较小的预训练模型
 
$ ./darknet partial cfg/yolov3-tiny.cfg yolov3-tiny.weights yolov3-tiny.conv.15 15
 
6.训练
 
执行如下命令即可进行训练:
 
$ ./darknet detector train cfg/voc.data cfg/yolov3-tiny.cfg yolov3-tiny.conv.15 | tee person_train_log.txt
 
保存log时会生成两个文件，一个保存的是网络加载信息和checkout点保存信息，另一个保存的是训练信息。
 
训练耗时较长,查看log当loss较小,且不再发生变化时,可按"ctrl+c"终止训练.我训练到了90000次就停止了,在这个过程中在backup文件夹下会保存对应迭代次数的中间结果,前1000次内每100次保存一个,超过1000次,每1000保存一次,依次.在这个过程中,我么可以随时拿中间结果进行测试.
 
7.测试
 
7.1 使用c进行图片检测
 
将yolov3-tiny90000.weights拷贝到Nano上即可进行测试,其测试方法同第4节,主要提该模型文件即可.如:
 执行如下命令,即可用于图片检测.
 
$ ./darknet detect cfg/yolov3-tiny.cfg yolov3-tiny90000.weights data/dog.jpg
 
7.2 使用c进行实时检测
 
执行如下命令,即可用于测试实时视频.
 
$ ./darknet detector demo cfg/voc.data cfg/yolov3-tiny.cfg yolov3-tiny90000.weights
 
7.2 使用python进行图片检测
 
若想使用python文件进行测试,可以进入examples目录下,修改detector.py文件,主要修改如下内容:
 
dn.set_gpu(0)
net = dn.load_net("../cfg/yolov3-tiny.cfg", "../backup/yolov3-tiny_70000.weights", 0)
meta = dn.load_meta("../cfg/voc.data")
 
修改完的内容如下:
 
#!/usr/bin/env python
# Stupid python path shit.
# Instead just add darknet.py to somewhere in your python path
# OK actually that might not be a great idea, idk, work in progress
# Use at your own risk. or don't, i don't carefanhui

import sys, os
sys.path.append(os.path.join(os.getcwd(),'python/'))

import darknet as dn
import cv2 as cv
dn.set_gpu(0)
net = dn.load_net("../cfg/yolov3-tiny.cfg", "../backup/yolov3-tiny_70000.weights", 0)
meta = dn.load_meta("../cfg/voc.data")
r = dn.detect(net, meta, "../data/2.jpg")
print r
 
运行如下命令即可对指定的图片进行检测:
 
$ python detector.py
 
7.3 使用python进行实时检测
 
为了对实时视频进行目标检测,我们需要将上述检测图片的代码进行修改,
 
$ cd examples
$ touch detector_real_time.py
 
内容如下:
 
#!/usr/bin/env python
# Stupid python path shit.
# Instead just add darknet.py to somewhere in your python path
# OK actually that might not be a great idea, idk, work in progress
# Use at your own risk. or don't, i don't carefanhui

import sys, os
sys.path.append(os.path.join(os.getcwd(),'python/'))

import darknet as dn
import cv2 as cv
dn.set_gpu(0)
net = dn.load_net("../cfg/yolov3-tiny.cfg", "../backup/yolov3-tiny_70000.weights", 0)
meta = dn.load_meta("../cfg/voc.data")
r = dn.detect(net, meta, "../data/2.jpg")
print r
# And then down here you could detect a lot more images like:

cap = cv.VideoCapture(0)
while True:
   ret,frame = cap.read()
   if ret:
      cv.imwrite("./a.jpg",frame)
      r = dn.detect(net, meta, "./a.jpg")
      print r
      if len(r):
         a= int(r[0][2][0]-(r[0][2][2]/2))
         b= int(r[0][2][1]-(r[0][2][3]/2))
         c= int(r[0][2][0]+(r[0][2][2]/2))
         d= int(r[0][2][1]+(r[0][2][3]/2))
         cv.rectangle(frame,(a,b),(c,d),(255,0,0),thickness=2)
         m= int(r[0][2][0]-(r[0][2][2]/2)-10)
         n= int(r[0][2][1]-(r[0][2][3]/2)-10)
         cv.putText(frame,"%s:%.2f"%(r[0][0],r[0][1]),(m,n),cv.FONT_HERSHEY_SIMPLEX,0.7,(0,0,255),2,0)
         cv.imshow("result",frame)
         c = cv.waitKey(50)
         if c==27:
            break
      else:
         print "nothing"
         continue
   else:
      break
cap.release()
 
运行该python文件,即可看到试试检测的画面,在Nnao上实测帧率为6fps.注意,要用python2来运行,即:
 
$ python detector_real_time.py