从零开始，带你用Nanodet目标检测模型完成自动捡球机器人

前言

• 本项目涉及到的所有代码见github：项目代码
• 一些叽里呱啦的碎碎念：

       说来惭愧，自上一次更新博客以来已经有半年多没更新了，中间其实积累了几个项目想要分享的，可惜太懒，日后慢慢补上吧。
       这次想要分享的是刚刚结束不久的大创项目，这个令我又爱又恨的项目，值得来记录一下。
       2020年5月27号那天，跟组员胡编乱造乱开脑洞地写了个大创项目申请书，谁知道整个实验室只有我们进省赛了，本来完全想水过去的项目，随着时间慢慢逼近又不得不做，记得中期答辩的时候我们拿着一个随意到不能再随意的ppt被评委怼得无话可说，就觉得肯定是做不出来的，看看后面能不能放弃吧。
       当后面得知省赛队伍不可以放弃的时候，整个人都是绝望的，因为申请书上面写的强化学习，深度学习对我来说有点天花乱坠，更何况考研才是当前的主线。
       时间来到一个月前，看到我的队友们已经把车子都造出来了，觉得我也应该花点时间来弄一下了，不然也浪费了队友这么大的功夫。
       谁知道弄着弄着，在最后十天的时候，阴差阳错地弄出了一个模型，然后顺理成章地结合到了机器人上面，最后答辩还拿了个为数不多的优秀，现在想想那种体验就amazing。
       在考研期间花十天时间弄这么一个项目，值也不值，值的是确实有点意思，也做出了点东西，跟以前的队友一起合作的感觉也很难得，跟实验室的小伙伴一起讨论着有意思的技术问题也很有趣，大家一起通宵调车到五点累了就躺下睡着，看到最后小车能够完成预期的效果也开心到不行；不值的是考研的朋友在这段时间已经在高数上面远超我的进度，而我最近却丢失了那种先在脑子里算出答案再落笔写过程的感觉，英语单词也前功尽弃只能从头开始。怎么说呢？既然都这样了那就好好结束这个项目，然后好好地准备考研，也算是给自己一个交代吧。

---

• 好了，说了那么多屁话，来介绍一下这个项目是什么东西。
• 项目名字叫做《多场景下的球体回收分类机器人》，简单理解就是做一个机器人，这个机器人能够通过自带的摄像头来动态规划当前的最优捡球路径进而完成自动捡球和自动避障，同时也可以在各种场景下同时检测多种球体，通过机械结构自动将大小球进行分类。
• 要完成上面所说的东西，单凭我一个人显然是不够的，但是我有超级厉害的队友，各自负责不同的部分，最后再合成这台机器人。
• 我们将项目分成三大部分，分别为机械，电控，视觉，由于我主要负责的是视觉部分，因此本文主要介绍的也是该部分，但为了让大家更加了解整个机器人的运作流程，下面先让我简单介绍一下其他两部分。

---

机械结构

• 强力队友毓正哥主要负责设计机械结构，将整台机器人组装起来，同时该机械机构可以根据重力筛自动将大小球进行分离。下面是整体的效果，整体机械结构由两部分组成，第一部分是前面的旋转扫板，另一部分是后面的收集滤板以及收集仓。
  

• 大小球在前部旋转扫板的推动下被扫上后部的收集滤板。滤板的滤孔可将大小球进行上下分离。

• 当需要分类的大小球尺寸不同时，我们可以通过更换不同滤孔大小的滤板来实现大小球分离。

• 而当仅收集一种球类时，我们可以将滤板拆除，使收集到的球类全部落入收集仓中。

• 下面是整个机器人的运作视频。

---

电控设计思路

• 男神马哥则负责电路部分的设计，让机器人能够动起来。下面简单说一下视觉算法得到的决策数据是怎么控制机器人动起来的。
• 机器人分为手动遥控跟自动控制两个模式。显然要实现自动控制，则需要我这边的算法做路径规划然后告诉机器人怎么动（转多少度和向前走多少米）。
• 该部分需要注意的点有几个：
  • 1.视觉这边的处理速度（大约是100ms）是要慢于机器人更新信息的速度的，但是我们可以沟通好两边传输数据的规则，电控那边每50ms发送一下它那边的情况。同时我们约定好我这边发送数据的有两个，分别表示当前情况机器人最优的旋转方向和前进距离。而电控方发送给我的数据主要是前一个决策动作做完没有，如果做完了，我这边就做一次新的决策并且发送新的数据，如果没做完，我这边就可以发送前一次的数据，防止前一次发送的数据中途丢失。
  • 2.具体的数据传输则需要借助串口通信来完成，可以理解为是tcp中的端口连接通信。我们可以将数据发送到串口，而电控方可以通过串口接受数据。
• 传输流程图如下：
  
  • 执行流程图如下：
• 申请书中提到了自动避障，但是从视觉方面实现避障功能感觉需要用到激光雷达等高端的东西，在短期内很难做出来，能力也有限，故可通过避障模块进行检测来实现该功能。细节如下：
  • 机器人的前方布置了三个光电开关（通过激光检测前方某个距离内是否有障碍物），形成了八种状态，对于每种状态我们采用不同的避障动作即可。
  • 下面为整体流程图和效果视频：
    

---

视觉思路

• 终于到了本文的主要内容了，视觉部分主要的目标有两个，对小球做目标检测，对小车做路径规划。下面一个个来说。

小球的目标检测

传统方法OR深度学习

• 实际上，刚开始思考的时候是想着能不能用传统的视觉方法来做，因为自己对深度学习这一块确实不熟悉，而且深度学习往往比较慢，不能满足实时的路径规划。

• 但是在思考过后，发现传统的方法有下面的缺点：
  

• 因此硬是要用传统方法做是做不出来的。于是思考目标检测算法。

• 最主流也最先想到的当然是Yolo-V4算法，毕竟实验室也有朋友之前用过，可以请教一下，于是就先试一试，效果如下图，可见整体来说其准确率还是非常高的，但是却有一个致命的缺点，在我们的电脑上处理一张图片需要30秒，这意味着我们的机器人每做一个动作要等30秒才能做另一个动作，显然不可行。（考虑过神经网络棒加速，但加速后依然满足不了实时的需求）。
  

Nanodet目标检测算法训练与部署

• 一次实验室的另一位朋友也在研究目标检测，提到用Nanodet模型可以达到10ms每张图片的速度，兴奋起来了！
• 在前面的方法都走不通的情况下，也只能硬着头皮试一试了。
• 然而对这个网络一无所知，也没有任何的数据集的情况下，确实难顶，于是开始了为期四天的训练模型之路。

1.手动创建数据集

• 深度学习的前提是有数据集，然而我们什么都没有，于是一天晚上我去实验室场地上面用手机拍了快一个钟，得到了近两百张小球的图片。
  
• 实际上还有一种获取图片的方法，就是用手机拍一个小球的视频，可以绕着小球转几圈，让手机摄像头从俯视到平视（尽可能获取多个视角），然后用下面的程序把这个视频导出很多帧图片，即可完成图片的收集。
  • 使用的时候只需要修改三个参数即可。
    1.DATA_DIR ：视频的路径（注意如果粘贴的路径是’‘一定要改成’/‘或者’\’,否则python读取不了）
    2.SAVE_DIR ：图片保存的文件夹
    3.GAP ：每个多少帧截取一张图片
  • 这里重点说一下GAP的作用，因为拍的视频中两帧之间的间隔是很短的，因此我们看起来图片其实差不多，对于深度学习来说可能前后两帧能提取到的特征都差不多，所以我们可以取10帧截取一张图片的方式，让导出的数据集尽可能不太一样，即让我们的数据集质量更高。
  • 需要注意的是，拍视频的时候最好不要走得太快（手机不要晃动得太厉害），不然拍出来的视频中小球会有拖影，这对数据集的质量会降低，训练出来的效果也会下降（毕竟小车最终的视角中球是没拖影的）。

#将视频导出为若干帧图片
DATA_DIR = "E:/大三上/大创/视频素材/ball_video_1.mp4" #视频数据主目录
SAVE_DIR = "E:/大三上/大创/第二次训练图片" #帧文件保存目录
GAP = 10	#每隔多少帧导出一张图片

import cv2  #OpenCV库
import os 

def getphoto(video_in, video_save):
    number = 0
    cap = cv2.VideoCapture(video_in)  # 打开视频文件
    n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))  # 视频的帧数
    fps = cap.get(cv2.CAP_PROP_FPS)  # 视频的帧率
    dur = n_frames / fps  # 视频的时间
    num_frame = 0
    judge = cap.isOpened()
    while judge:
        flag, frame = cap.read()  # flag是读取状态，frame下一帧
        if cv2.waitKey(0) == 27:
            break
        if flag:
            num_frame += 1
            if num_frame % GAP == 0: 
                print("正在保存第%d张照片" % number)
                cv2.imwrite(video_save + '/' + str(number) + '.jpg', frame)  # cv2.imwrite(‘路径’ + ‘名字’ + ‘后缀’， 要存的帧)
                number += 1
        else:
            break

    print("视频时长: %d 秒" % dur)
    print("视频共有帧数: %d 保存帧数为: %d" % (n_frames, number))
    print("每秒的帧数(FPS): %.1lf" % fps)
def main_1(path):
    video_in = path
    video_save = SAVE_DIR
    getphoto(video_in, video_save)
    
if __name__=='__main__':
     paht= DATA_DIR#视频路径
     main_1(paht)

---

2.数据标注

• 目标检测跟图片的分类最大的不同在于其需要将每张图片进行标注，怎么说，体力活，花时间，没有捷径，就硬标。
• 因为Nanodet用的是Coco数据集，因此我们需要先从每张图片中导出一个个xml文件，再将若干个xml文件转换为json文件。
• 我采用的是labelimg软件进行标注的，怎么说呢…每一张图片都要像下面那样子进行标注，就一个下午加晚上标到直接泪目的程度。
  
• 标完之后就会得到若干个xml文件：

---

• 我们打开其中一个xml文件看看其中的格式：要是通过自瞄等方式自动生成xml则需要注意里面的字段是否有缺失或者不一样。
  

---

• 同时，如果我们发现想批量修改所有xml文件的某些字段，比如我们想要将类别为“small ball”或者是“big ball”改为“ball”，则可以用到下面的脚本：
  • 该脚本还能删除某个类别名的框，比如我们想删掉类别名字为“middle ball”的框，即可把下面代码注释的部分加上。
  • 最后还能检查xml文件中的类别是否正确，比如下面两行代码中，我们查看是否有一个框的类别名不为ball，如果有，则输出错误信息。
    • 如果你的数据集是有多个类别，则把[‘ball’]改成[‘category_A’,‘category_B’,’ category_C’],表示如果有一个类别名不属于这三个名字之一，则输出错误

		 if not (name in ["ball"]):
          		  print(filename + "------------->label is error--->" + name)

• 同理，该脚本还需要修改两个路径：
  • 原始xml文件夹路径(origin_xml_dir)
  • 新生成的xml文件路径(new_xml_dir)

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
import os
import xml.etree.ElementTree as ET
 
origin_xml_dir = './第二次标注/'# 设置原始标签路径为 Annos
new_xml_dir = './数据集准备/xml/'# 设置新标签路径 Annotations
for dirpaths, dirnames, filenames in os.walk(origin_xml_dir):   # os.walk游走遍历目录名
  for filename in filenames:
    print("process...")
    if os.path.isfile(r'%s%s' %(origin_xml_dir, filename)):   # 获取原始xml文件绝对路径，isfile()检测是否为文件 isdir检测是否为目录
      origin_ann_path = os.path.join(r'%s%s' %(origin_xml_dir, filename))   # 如果是，获取绝对路径（重复代码）
      new_ann_path = os.path.join(r'%s%s' %(new_xml_dir, filename))
      tree = ET.parse(origin_ann_path)  # ET是一个xml文件解析库，ET.parse（）打开xml文件。parse--"解析"
      root = tree.getroot()   # 获取根节点
      for object in root.findall('object'):   # 找到根节点下所有“object”节点
        name = str(object.find('name').text)  # 找到object节点下name子节点的值（字符串）
    # 如果name等于str，则删除该节点
# =============================================================================
#         if (name in ["middle ball"]):
#           root.remove(object)
# =============================================================================
 
    # 如果name等于str，则修改name
        if(name in ["small ball","big ball"]):
          object.find('name').text = "ball"
 
    # 检查是否存在labelmap中没有的类别
      for object in root.findall('object'):
        name = str(object.find('name').text)
        if not (name in ["ball"]):
            print(filename + "------------->label is error--->" + name)
      tree.write(new_ann_path)#tree为文件，write写入新的文件中。

---

3.数据增强

• 开始还在想带有xml的数据集怎么做数据增强，结果发现已经有人做过了，于是直接拿来用，解放双手。（代码来自：https://github.com/mickkky/XML-Augment.git）
• 我们需要修改的参数有5个（在最底下的main函数里面）（使用前需要先确认原始的图片和xml文件夹内的文件是不是一一对应的，比如图片文件夹有一张abc.jpg,则xml文件夹一定有一个abc.xml文件）：
  • IMG_DIR ：原始数据集图片的文件夹路径
  • XML_DIR： 原始xml文件的文件夹路径
  • AUG_XML_DIR ：数据增强后的图片的文件夹路径
  • AUG_IMG_DIR：数据增强后的xml文件的文件夹路径
  • AUGLOOP ：每张图片增强多少次（我设的是20）

import xml.etree.ElementTree as ET
import pickle
import os
from os import getcwd
import numpy as np
from PIL import Image
import shutil
import matplotlib.pyplot as plt

import imgaug as ia
from imgaug import augmenters as iaa


ia.seed(1)


def read_xml_annotation(root, image_id):
    in_file = open(os.path.join(root, image_id))
    tree = ET.parse(in_file)
    root = tree.getroot()
    bndboxlist = []

    for object in root.findall('object'):  # 找到root节点下的所有country节点
        bndbox = object.find('bndbox')  # 子节点下节点rank的值

        xmin = int(bndbox.find('xmin').text)
        xmax = int(bndbox.find('xmax').text)
        ymin = int(bndbox.find('ymin').text)
        ymax = int(bndbox.find('ymax').text)
        # print(xmin,ymin,xmax,ymax)
        bndboxlist.append([xmin, ymin, xmax, ymax])
        # print(bndboxlist)

    bndbox = root.find('object').find('bndbox')
    return bndboxlist


# (506.0000, 330.0000, 528.0000, 348.0000) -> (520.4747, 381.5080, 540.5596, 398.6603)
def change_xml_annotation(root, image_id, new_target):
    new_xmin = new_target[0]
    new_ymin = new_target[1]
    new_xmax = new_target[2]
    new_ymax = new_target[3]

    in_file = open(os.path.join(root, str(image_id) + '.xml'))  # 这里root分别由两个意思
    tree = ET.parse(in_file)
    xmlroot = tree.getroot()
    object = xmlroot.find('object')
    bndbox = object.find('bndbox')
    xmin = bndbox.find('xmin')
    xmin.text = str(new_xmin)
    ymin = bndbox.find('ymin')
    ymin.text = str(new_ymin)
    xmax = bndbox.find('xmax')
    xmax.text = str(new_xmax)
    ymax = bndbox.find('ymax')
    ymax.text = str(new_ymax)
    tree.write(os.path.join(root, str("%06d" % (str(id) + '.xml'))))


def change_xml_list_annotation(root, image_id, new_target, saveroot, id,img_name):
    in_file = open(os.path.join(root, str(image_id) + '.xml'))  # 这里root分别由两个意思
    tree = ET.parse(in_file)
    elem = tree.find('filename')
    elem.text = (img_name + str("_%06d" % int(id)) + '.jpg')
    xmlroot = tree.getroot()
    index = 0

    for object in xmlroot.findall('object'):  # 找到root节点下的所有country节点
        bndbox = object.find('bndbox')  # 子节点下节点rank的值

        # xmin = int(bndbox.find('xmin').text)
        # xmax = int(bndbox.find('xmax').text)
        # ymin = int(bndbox.find('ymin').text)
        # ymax = int(bndbox.find('ymax').text)

        new_xmin = new_target[index][0]
        new_ymin = new_target[index][1]
        new_xmax = new_target[index][2]
        new_ymax = new_target[index][3]

        xmin = bndbox.find('xmin')
        xmin.text = str(new_xmin)
        ymin = bndbox.find('ymin')
        ymin.text = str(new_ymin)
        xmax = bndbox.find('xmax')
        xmax.text = str(new_xmax)
        ymax = bndbox.find('ymax')
        ymax.text = str(new_ymax)

        index = index + 1

    tree.write(os.path.join(saveroot, img_name + str("_%06d" % int(id)) + '.xml'))


def mkdir(path):
    # 去除首位空格
    path = path.strip()
    # 去除尾部 \ 符号
    path = path.rstrip("\\")
    # 判断路径是否存在
    # 存在     True
    # 不存在   False
    isExists = os.path.exists(path)
    # 判断结果
    if not isExists:
        # 如果不存在则创建目录
        # 创建目录操作函数
        os.makedirs(path)
        print(path + ' 创建成功')
        return True
    else:
        # 如果目录存在则不创建，并提示目录已存在
        print(path + ' 目录已存在')
        return False


if __name__ == "__main__":

    IMG_DIR = "./img_val"
    XML_DIR = "./temp_valxml"

# =============================================================================
#     AUG_XML_DIR = "./Annotations"  # 存储增强后的XML文件夹路径
# =============================================================================
    AUG_XML_DIR = "./val2017"  # 存储增强后的XML文件夹路径
    try:
        shutil.rmtree(AUG_XML_DIR)
    except FileNotFoundError as e:
        a = 1
    mkdir(AUG_XML_DIR)

# =============================================================================
#     AUG_IMG_DIR = "./JPEGImages"  # 存储增强后的影像文件夹路径
# =============================================================================
    AUG_IMG_DIR = "./valxml"  # 存储增强后的影像文件夹路径
    try:
        shutil.rmtree(AUG_IMG_DIR)
    except FileNotFoundError as e:
        a = 1
    mkdir(AUG_IMG_DIR)

    AUGLOOP = 20  # 每张影像增强的数量

    boxes_img_aug_list = []
    new_bndbox = []
    new_bndbox_list = []

    # 影像增强
    seq = iaa.Sequential([
        iaa.Flipud(0.5),  # vertically flip 20% of all images
        iaa.Fliplr(0.5),  # 镜像
        iaa.Multiply((1.2, 1.5)),  # change brightness, doesn't affect BBs
        iaa.GaussianBlur(sigma=(0, 3.0)),  # iaa.GaussianBlur(0.5),
        iaa.Affine(
            translate_px={
     "x": 15, "y": 15},
            scale=(0.8, 0.95),
            rotate=(-30, 30)
        )  # translate by 40/60px on x/y axis, and scale to 50-70%, affects BBs
    ])

    for root, sub_folders, files in os.walk(XML_DIR):

        for name in files:
            print(name)
            bndbox = read_xml_annotation(XML_DIR, name)
            shutil.copy(os.path.join(XML_DIR, name), AUG_XML_DIR)
            shutil.copy(os.path.join(IMG_DIR, name[:-4] + '.jpg'), AUG_IMG_DIR)

            for epoch in range(AUGLOOP):
                seq_det = seq.to_deterministic()  # 保持坐标和图像同步改变，而不是随机
                # 读取图片
                img = Image.open(os.path.join(IMG_DIR, name[:-4] + '.jpg'))
                # sp = img.size
                img = np.asarray(img)
                # bndbox 坐标增强
                for i in range(len(bndbox)):
                    bbs = ia.BoundingBoxesOnImage([
                        ia.BoundingBox(x1=bndbox[i][0], y1=bndbox[i][1], x2=bndbox[i][2], y2=bndbox[i][3]),
                    ], shape=img.shape)

                    bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]
                    boxes_img_aug_list.append(bbs_aug)

                    # new_bndbox_list:[[x1,y1,x2,y2],...[],[]]
                    n_x1 = int(max(1, min(img.shape[1], bbs_aug.bounding_boxes[0].x1)))
                    n_y1 = int(max(1, min(img.shape[0], bbs_aug.bounding_boxes[0].y1)))
                    n_x2 = int(max(1, min(img.shape[1], bbs_aug.bounding_boxes[0].x2)))
                    n_y2 = int(max(1, min(img.shape[0], bbs_aug.bounding_boxes[0].y2)))
                    if n_x1 == 1 and n_x1 == n_x2:
                        n_x2 += 1
                    if n_y1 == 1 and n_y2 == n_y1:
                        n_y2 += 1
                    if n_x1 >= n_x2 or n_y1 >= n_y2:
                        print('error', name)
                    new_bndbox_list.append([n_x1, n_y1, n_x2, n_y2])
                # 存储变化后的图片
                image_aug = seq_det.augment_images([img])[0]
                path = os.path.join(AUG_IMG_DIR,
                                    name[:-4] + str( "_%06d" % (epoch + 1)) + '.jpg')
                image_auged = bbs.draw_on_image(image_aug, thickness=0)
                Image.fromarray(image_auged).save(path)

                # 存储变化后的XML
                change_xml_list_annotation(XML_DIR, name[:-4], new_bndbox_list, AUG_XML_DIR,
                                           epoch + 1,name[:-4])
                print( name[:-4] + str( "_%06d" % (epoch + 1)) + '.jpg')
                new_bndbox_list = []

• 最终我使用了 300 张原始样本来增强到了 6000 张图片（6G大小），下面是数据增强后的图片文件夹的样子，可看到原本的一张图片经过各自旋转，光线变化形成了一个新的数据集。
  

---

4.xml转json

• 因为nanodet需要json格式的文件，因此我们需要将xml文件转成json文件。
  • 训练集的所有xml文件会得到一个大的json文件，验证集同理。
• 使用前需要修改两个参数（在最下面）：
  • xml_path ：xml文件夹的路径（注意！是文件夹，不是文件）
  • json_file ：要导出的json文件的路径

import xml.etree.ElementTree as ET
import os
import json
 
coco = dict()
coco['images'] = []
coco['type'] = 'instances'
coco['annotations'] = []
coco['categories'] = []
 
category_set = dict()
image_set = set()
 
category_item_id = 0
image_id = 'ball-'
id_num = 0
annotation_id = 0
 
def addCatItem(name):
    global category_item_id
    category_item = dict()
    category_item['supercategory'] = 'none'
    category_item_id += 1
    category_item['id'] = category_item_id
    category_item['name'] = name
    coco['categories'].append(category_item)
    category_set[name] = category_item_id
    return category_item_id
 

def addImgItem(file_name, size):
    global image_id,id_num
    if file_name is None:
        raise Exception('Could not find filename tag in xml file.')
    if size['width'] is None:
        raise Exception('Could not find width tag in xml file.')
    if size['height'] is None:
        raise Exception('Could not find height tag in xml file.')
   
    image_item = dict()
    temp = str(id_num)
    image_item['id'] = image_id + temp
    id_num += 1
    image_item['file_name'] = file_name
    image_item['width'] = size['width']
    image_item['height'] = size['height']
    coco['images'].append(image_item)
    image_set.add(file_name)
    return image_item['id']
 
def addAnnoItem(object_name, image_id, category_id, bbox):
    global annotation_id
    annotation_item = dict()
    annotation_item['segmentation'] = []
    seg = []
    #bbox[] is x,y,w,h
    #left_top
    seg.append(bbox[0])
    seg.append(bbox[1])
    #left_bottom
    seg.append(bbox[0])
    seg.append(bbox[1] + bbox[3])
    #right_bottom
    seg.append(bbox[0] + bbox[2])
    seg.append(bbox[1] + bbox[3])
    #right_top
    seg.append(bbox[0] + bbox[2])
    seg.append(bbox[1])
 
    annotation_item['segmentation'].append(seg)
 
    annotation_item['area'] = bbox[2] * bbox[3]
    annotation_item['iscrowd'] = 0
    annotation_item['ignore'] = 0
    annotation_item['image_id'] = image_id
    annotation_item['bbox'] = bbox
    annotation_item['category_id'] = category_id
    annotation_id += 1
    annotation_item['id'] = annotation_id
    coco['annotations'].append(annotation_item)
 
def parseXmlFiles(xml_path): 
    for f in os.listdir(xml_path):
        if not f.endswith('.xml'):
            continue
        
        bndbox = dict()
        size = dict()
        current_image_id = None
        current_category_id = None
        file_name = None
        size['width'] = None
        size['height'] = None
        size['depth'] = None
 
        xml_file = os.path.join(xml_path, f)
        print(xml_file)
 
        tree = ET.parse(xml_file)
        root = tree.getroot()
        if root.tag != 'annotation':
            raise Exception('pascal voc xml root element should be annotation, rather than {}'.format(root.tag))
 
        #elem is , , ,