Merge pull request '修改源码' (#50) from develop into master

# Conflicts:
#	doc/无人机的路径生成及绘制环境图-软件设计规格说明书.doc

Arc.py

@@ -1,14 +0,0 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-
-class Arc:
-    def __init__(self, argv):
-        self.id = int(argv[0])
-        self.from_node = int(argv[1])
-        self.to_node = int(argv[2])
-        self.len = float(argv[3])
-        self.road_class = argv[4]
-        self.geometry_list = [float(ele) for ele in argv[5:9]]
-        self.direction = float(argv[9])
-
-

ArcMany.py

@@ -1,10 +0,0 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-
-class ArcMany:
-    def __init__(self, argv2):
-        self.geometry_list2 =  [float(ele) for ele in argv2[0:2]]
-        self.id = int(argv2[2])
-
-
-

CarPath.py

@@ -1,11 +0,0 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-
-class CarPath:
-    def __init__(self, argv4):
-        self.path =  int(argv4[0])
-        self.id =  int(argv4[1])
-        self.time_stage = int(argv4[2])
-
-
-

CarQuery.py

@@ -1,3 +0,0 @@
-class CarQuery:
-    def __init__(self, argv):
-        self.geo = [float(ele) for ele in argv[0:2]]

CarRecord.py

@@ -1,10 +0,0 @@
-class CarRecord:
-    def __init__(self, argv):
-        self.car = int(argv[0])
-        self.car_id = int(argv[10])
-        self.time = argv[1]
-        self.geo = [float(ele) for ele in argv[2:4]]
-        self.hight = float(argv[4])
-        self.speed = float(argv[5])
-        self.direction = float(argv[6])
-        self.id = int(argv[8])

Query.py

@@ -1,88 +0,0 @@
-from idlelib import tooltip
-from math import *
-import queue
-import sys
-import time
-import os
-from datetime import datetime
-import pymssql
-import pandas as pd
-import numpy as np
-import datetime
-import math
-from folium import plugins
-import folium
-import os
-
-sys.path.append(r'C:\Users\Wayson\Desktop')
-from CarQuery import *
-from Arc import *
-from ArcMany import *
-
-arc_objects=[]
-Arc_many_count=[]
-Arc_many_objects=[]
-Arc_data2=[]
-# 返回两个gps点的实际距离，x,y与米的换算约为1:111000。不同的比例尺换算不一样
-def DistanceActual(geo1, geo2):
-    return pow(pow(float(geo1[0]) - float(geo2[0]), 2) + pow(float(geo1[1]) - float(geo2[1]), 2), 0.5) * 111000
-
-
-# 如果起点定位数据跟道路的相差很远，则没有必要取该条arc
-def CheckNecessary(arc, car_record):
-    if DistanceActual(arc.geometry_list[0], car_record.geo) > 1000:
-        if DistanceActual(arc.geometry_list[-1], car_record.geo) > 1000:
-            return False
-    else:
-        return True
-
-
-def CalCost(arc, car_record):
-    cost = float("inf")
-    # CheckNecessary函数首先排除与起点定位点距离相差远的路段。/LOU
-    if CheckNecessary(arc, car_record):
-        # 下面if是计算这条道路上所有点跟目标点的最短距离小于10m才返回True。我们认为起点定位精度为10m
-        min_dist = float("inf")
-        for geo1 in arc.geometry_list:
-            tmp = DistanceActual(geo1, car_record.geo)
-            if tmp < min_dist:
-                min_dist = tmp
-        cost = min_dist
-    return cost
-
-
-# 给定car_geo和car_direction，根据最短距离，计算在所有道路的Cost，返回Cost最小的道路id
-def CalMinCostArcID(car_record):
-    min_cost = float("inf")
-    id = 0
-    # arc_objects存储着所有边的Arc对象实例，即所有路段信息。/LOU
-    for arc in arc_objects:
-        cost = CalCost(arc, car_record)
-        if cost < min_cost:
-            min_cost = cost
-            id = arc.id
-    return id
-
-
-# 得到id为i的路段的密集点集合
-def ArcmanyRecordsDivide(Arcmany_i):
-    Arcmany_index_start = sum(Arc_many_count[:Arcmany_i])  # 第i路段的起始索引位置
-    Arcmany_index_end = sum(Arc_many_count[:Arcmany_i + 1])  # 第i路段的终止索引位置
-    Arcmany_record_list = Arc_many_objects[Arcmany_index_start: Arcmany_index_end]  # 每个路段的点集合
-    Arcmany_geo_list = [Arcmany_record.geometry_list2 for Arcmany_record in Arcmany_record_list]  # 每个路段的点的(x,y)集合
-    return Arcmany_geo_list
-
-def swap_loc(list):
-    temp = 0
-    for i in range(0,len(list)):
-        temp = list[i][1]
-        list[i][1] = list[i][0]
-        list[i][0] = temp
-# arc_objects里的路段经纬度更新为点集合
-for i in range(0, len(Arc_data2)):  # 对每条路段循环
-    del arc_objects[i].geometry_list[0:4]  # 删除第i条路段原有的(x,y)信息
-    Arcmany_record_list_i = ArcmanyRecordsDivide(i)  # 提取第i条路段新的密集点(x,y)信息
-    for j in range(0, len(Arcmany_record_list_i)):  # 对第i条路段新的密集点(x,y)信息循环
-        arc_objects[i].geometry_list.append(Arcmany_record_list_i[j])  # 在第i条路段(x,y)列加上 新的密集点(x,y)第j条信息
-
-

ShortestPath.py

@@ -1,313 +0,0 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-
-from math import *
-import queue
-import sys
-import time
-import os
-from datetime import datetime
-import pymssql
-import pandas as pd
-import numpy as np
-import datetime
-import math
-sys.path.append(r'C:\Users\Administrator\Desktop')
-from CarRecord import *
-from Arc import *
-from ArcMany import *
-from CarPath import *
-
-
-arc_objects=[]
-map_graph=[]
-car_id_count=[]
-#通过经纬度计算两点之间的距离
-def DistanceBetween(geo1, geo2):
-    return pow(pow(float(geo1[0]) - float(geo2[0]), 2) + pow(float(geo1[1]) - float(geo2[1]), 2), 0.5)
-
-# 知道三个顶点坐标ABC，看角ACB是否是锐角三角形
-def CheckOxygon(A, C, B):
-    a = DistanceBetween(C, B)
-    b = DistanceBetween(A, C)
-    c = DistanceBetween(A, B)
-    if a ** 2 + b ** 2 < c ** 2:
-        return False
-    else:
-        return True
-
-# 计算起点到终点线段方向与x轴的夹角 逆时针
-# geo_list 第一个参数-1终点 0起点 第二个参数 0--y 1--x
-def CalDirection(geo_list):
-    if geo_list[-1][0] == geo_list[0][0]:
-        if geo_list[-1][1] > geo_list[0][1]:
-            return float(0)
-        else:
-            return float(180)
-    else:
-        # tan=slope
-        # arctan(tan x)=x
-        slope = (geo_list[-1][1] - geo_list[0][1]) / (geo_list[-1][0] - geo_list[0][0])
-        if geo_list[-1][0] >  geo_list[0][0]: # 如果射线在第1,2象限
-            return 90 - (atan(slope) / pi * 180) # 由于角度是跟x轴的夹角，所以需要90-
-        else: # 如果射线在第3,4象限
-            return 90 - (atan(slope) / pi * 180) + 180
-
-# 传入geo1, geo2为直线y = kx + d上两点，求geo3在直线上的射影（即作垂直后与直线的交点）
-# 如果形成钝角三角形，则垂点取geo1，geo2中靠近geo3的那个  就是直接过去
-def CalProjection(geo1, geo2, geo3):
-    geo1 = [float(ele) for ele in geo1]
-    geo2 = [float(ele) for ele in geo2]
-    geo3 = [float(ele) for ele in geo3]
-    a = DistanceBetween(geo2, geo3)
-    b = DistanceBetween(geo1, geo3)
-    c = DistanceBetween(geo1, geo2)
-    if (a**2 + c**2) <= b**2: #钝角三角形，且geo3靠近geo2，包括点在线段延长线上的情况
-        return geo2
-    elif b**2 + c**2 <= a**2: #钝角三角形，且geo3靠近geo1，包括点在线段延长线上的情况
-        return geo1
-    elif a + b == c: # 说明点在线段上
-        return geo3
-    else:
-        if geo1[0] == geo2[0]: # 如果直线竖直（0---x;1---y)
-            return [geo1[0], geo3[1]]
-        elif geo1[1] == geo2[1]: # 如果直线水平
-            return [geo3[0], geo1[1]]
-        else:
-            k = (geo1[1] - geo2[1]) / (geo1[0] - geo2[0]) # y = kx+d中的k
-            d = geo1[1] - k * geo1[0] # y = kx+d中的d
-            x4 = (k * geo3[1] - k * d + geo3[0]) / (1 + k**2) #先求交点经度
-            y4 = k * x4 + d #再求交点纬度
-            return [x4, y4]
-
-
-#逐个计算路段的点、与路段延长点、出发点的的夹角
-def CalProjectionOfArc(arc, geo):
-    length = len(arc.geometry_list)
-    # 先找一个虚拟点，其为点arc.geometry_list[-2]到arc.geometry_list[-1]连线延长线上延长相等距离的点virtual_p
-    virtual_p = [(2 * arc.geometry_list[-1][i] - arc.geometry_list[-2][i]) for i in range(2)]
-    # 找从哪个i开始，三角形ACB变成钝角，其中点A为car_record.geo（出发点）,点C为arc.geometry_list[i]（路段的点），点B为virtual_p（路段延长点）
-    i = 0
-    while i < length - 1 and CheckOxygon(geo, arc.geometry_list[i], virtual_p):  # 判断是否是锐角
-        i += 1
-    # 如果最小的i为0或者len() - 1，则取最靠近目标点的两个点计算垂点
-    # 即使第一个点就出现钝角三角形的情况，calProjection函数中会处理
-    if i == 0:  # 如果垂点不在线段上
-        projection = CalProjection(arc.geometry_list[i], arc.geometry_list[i + 1], geo)
-    else:  # 如果垂点在线段上
-        projection = CalProjection(arc.geometry_list[i - 1], arc.geometry_list[i], geo)
-    return projection
-
-
-# 传入geo1, geo2为直线y = kx + d上两点，求geo3到直线的距离
-# 如果形成钝角三角形，则垂点取geo1，geo2中靠近geo3的那个点与geo3的距离
-def CalDistance(geo1, geo2, geo3):
-    geo1 = [float(ele) for ele in geo1]
-    geo2 = [float(ele) for ele in geo2]
-    geo3 = [float(ele) for ele in geo3]
-    a = DistanceBetween(geo2, geo3)
-    b = DistanceBetween(geo1, geo3)
-    c = DistanceBetween(geo1, geo2)
-    if (a ** 2 + c ** 2) <= b ** 2:  # 钝角三角形，且geo3靠近geo2，包括点在线段延长线上的情况
-        return DistanceBetween(geo2, geo3) * 5  # *5是geo点跑到外面去的panelty
-    elif b ** 2 + c ** 2 <= a ** 2:  # 钝角三角形，且geo3靠近geo1，包括点在线段延长线上的情况
-        return DistanceBetween(geo1, geo3) * 5
-    elif a + b == c:  # 说明点在线段上
-        return 0
-    else:
-        if geo1[0] == geo2[0]:  # 如果直线竖直
-            return abs(geo3[0] - geo1[0])
-        elif geo1[1] == geo2[1]:  # 如果直线水平
-            return abs(geo3[1] - geo1[1])
-        else:
-            k = (geo1[1] - geo2[1]) / (geo1[0] - geo2[0])  # y = kx+d中的k
-            d = geo1[1] - k * geo1[0]  # y = kx+d中的d
-            dist = abs(k * geo3[0] + d - geo3[1]) / sqrt(1 + k ** 2)  # 点到直线距离公式
-            return dist
-
-# 如果起点定位跟路线的相差很远或者方向不对，则没有必要取该条arc
-def CheckNecessary(arc, car_record):
-    # 计算该地图中最长的路，取一半的大一点，即1000，防止出现漏判的情况，因为下面这个if是只取每段道路的坐标的起点和终点来跟目标点计算距离
-    if DistanceActual(arc.geometry_list[0], car_record.geo) > 1000:
-        if DistanceActual(arc.geometry_list[-1], car_record.geo) > 1000:
-            return False
-    # 下面if是计算这条线路上有一gps点跟目标点的最短距离小于100m才返回True。
-    min_dist = float("inf")
-    for geo1 in arc.geometry_list:
-        tmp = DistanceActual(geo1, car_record.geo)
-        if tmp < min_dist:
-            min_dist = tmp
-    if min_dist < 10:#起点与路线距离的判断
-        return True
-    else:
-        return False
-
-# 计算GPS匹配到该路段的成本系数cost
-def CalCost(arc, car_record):
-    cost = float("inf")#正无穷
-    # CheckNecessary函数首先排除与起点定位点距离相差远的路段。
-    if CheckNecessary(arc, car_record):
-        # arc.geometry_list为路段点集合，length记录点个数。
-        length = len(arc.geometry_list)
-        # 先找一个虚拟点，其为点arc.geometry_list[-2]到arc.geometry_list[-1]连线延长线上延长相等距离的点
-        # 虚拟点virtual_p在道路最后一个点之后。
-        virtual_p = [(2 * arc.geometry_list[-1][i] - arc.geometry_list[-2][i]) for i in range(2)]
-        # 找从哪个i开始，三角形ACB变成钝角，其中点A为car_record.geo,点C为arc.geometry_list[i]，点B为virtual_p
-        i = 0
-        # CheckOxygon检查起点与线路第i点的连线，与线路的夹角是否为锐角，是锐角继续循环。/LOU
-        while i < length - 1 and CheckOxygon(car_record.geo, arc.geometry_list[i], virtual_p):
-            i += 1
-        # 如果最小的i为0或者len() - 1，则取最靠近目标点的两个点计算垂点
-        # 即使出现钝角三角形的情况，calProjection函数中会处理
-        if i == 0:
-            # dist为起点定位点与道路的距离，direction_road为线路方向，作为之后计算cost的直接、间接的参数。/LOU
-            dist = CalDistance(arc.geometry_list[i], arc.geometry_list[i + 1], car_record.geo)
-
-            direction_road = arc.direction
-        else:  # 如果垂点在线段上
-            dist = CalDistance(arc.geometry_list[i - 1], arc.geometry_list[i], car_record.geo)
-            direction_road = CalDirection(arc.geometry_list[i - 1: i + 1])
-        # 综合考虑起点与道路距离，得出起点定位点与路段匹配的cost。
-        cost = dist
-    return cost
-
-# 给定car_geo和car_direction，根据最短距离，计算在所有道路的Cost，返回Cost最小的道路id
-def CalMinCostArcID(car_record):
-    min_cost = float("inf")
-    id = 0
-    # arc_objects存储着所有边的Arc对象实例，即所有路段信息。
-    for arc in arc_objects:
-        cost = CalCost(arc, car_record)
-        if cost < min_cost:
-            min_cost = cost
-            id = arc.id
-    return id
-
-# 计算时长
-def SecondsBetween(t1, t2):
-    big = datetime.datetime.strptime(str(t2), "%Y-%m-%d %H:%M:%S")#例：print(now.strftime('%a, %b %d %H:%M'))输出Mon, May 08 20:22
-    small = datetime.datetime.strptime(str(t1), "%Y-%m-%d %H:%M:%S")
-    return (big - small).total_seconds()#用秒统计
-
-# 返回两个点的实际距离，x,y与米的换算约为1:111000。（不同的比例尺数值不同）
-def DistanceActual(geo1, geo2):
-    return pow(pow(float(geo1[0]) - float(geo2[0]), 2) + pow(float(geo1[1]) - float(geo2[1]), 2), 0.5)*111000
-
-# 输入arc_cover是arc_id和cover的列表，该函数输出这个arc_cover包含的道路总长
-def CalLenCover(arc_cover):
-    travel_distance = 0
-    for k in range(len(arc_cover)):
-        # arc_objects存储着所有边的Arc对象实例，即所有路段信息。
-        travel_distance += arc_objects[arc_cover[k][0] - 1].len * arc_cover[k][1]
-    return round(travel_distance,1)
-
-# 输入arc_list是arc_id的列表，该函数输出这个arc_list包含的道路总长
-def CalLen(arc_list):
-    travel_distance = 0
-    for k in range(len(arc_list)):
-        travel_distance += arc_objects[arc_list[k] - 1].len
-    return round(travel_distance,1)
-
-# 拿着集合找最短的
-def findMinDist(dist, collected):
-    min_dist = float("inf")
-    min_key = -1
-    for key in dist:
-        if dist[key] < min_dist and (key not in collected.keys()):
-            min_dist = dist[key]
-            min_key = key
-    return min_key
-
-# 用单源最短路径算法，求两条边的最短距离的arc_list
-# graph：邻近路网关系图；start_arc_id：起点路段；end_arc_id：终点路段
-def dijkstra(graph, start_arc_id, end_arc_id):
-    if start_arc_id == end_arc_id:  # 当前一路段与后匹配路段一样
-        return [start_arc_id]
-    dist = {}
-    path = {}
-    collected = {}
-    # 初始化距离为无穷大
-    for key in graph:
-        dist[key] = float("inf")
-        for arc in graph[key]:
-            if not arc.to_node in dist.keys():  # 如果邻近路网关系图中没有路段的起点等于arc的终点，则距离设为无穷
-                dist[arc.to_node] = float("inf")
-    from_node = arc_objects[start_arc_id - 1].to_node  # 起始路段起点
-    to_node = arc_objects[end_arc_id - 1].from_node  # 终止路段终点
-    if from_node in graph.keys():  # 如果graph中有路段起点与from_node一致
-        for arc in graph[from_node]:  # 遍历路段起点与from_node一致的路段
-            dist[arc.to_node] = arc.len  # 更新始路段起点到该点的距离
-            path[arc.to_node] = from_node  # 更新始路段起点到该点的路径
-    dist[from_node] = 0  # 起始路段起点到起始路段起点距离为0
-    collected[from_node] = True
-    while True:
-        node = findMinDist(dist, collected)
-        if node == -1:
-            break
-        collected[node] = True
-        if node in graph.keys():
-            for arc in graph[node]:
-                if arc.to_node not in collected.keys():
-                    if dist[arc.to_node] > dist[node] + arc.len:
-                        dist[arc.to_node] = dist[node] + arc.len
-                        path[arc.to_node] = node
-    arc_list = [end_arc_id]# 先放入终点
-    while to_node in path.keys():
-        for arc in graph[path[to_node]]:
-            if arc.to_node == to_node:
-                arc_list.append(arc.id)
-        to_node = path[to_node]
-    arc_list.append(start_arc_id) #最后放入起点
-    arc_list = arc_list[::-1] #两级反转
-    return arc_list
-
-#arc：上一个点所匹配的路径，car_record：点对象，dist：arc终点到点的距离
-def BFSFindPathArc(arc, car_record, dist):
-    min_cost = 60  # min_cost初始值为60近似为无限大
-    arc_list = []  # arc_list是点从上一个点走过的路径集合
-    min_arc_id = 0  # min_arc_id是得到最小cost的路段
-    visited = {}  # visited 里面记录着已经搜索过计算过cost的路段
-    graph_around = {}  # graph_around是连接着上一匹配路段的临近路段集合。
-    q = queue.Queue()  # q是一个队列，里面存放需要计算cost的备选路段
-    q.put(arc)  # 将arc放入队列
-    visited[arc.id] = True  # 表示arc已经搜索过
-    while not q.empty():  # 当q里还有需要计算cost的路段，则继续循环
-        arc1 = q.get()  # 将q里最后放进去的路段拿出并从q里删除
-        # 生成arc附近连通的道路的图，后面用来找最短路径
-        if arc1.from_node in graph_around.keys():
-            graph_around[arc1.from_node].append(arc1)  # 将起点ID相同的路段放入同一个索引
-        else:
-            graph_around[arc1.from_node] = [arc1]
-        cost = CalCost(arc1, car_record)  # 计算arc1的cost
-        if cost < min_cost:
-            min_cost = cost  # 更新最小cost
-            min_arc_id = arc1.id   # 更新最小cost的路段
-        if arc1.to_node in map_graph.keys():  # 如果arc1路段的终点在地图临近关系表map_graph里
-            for arc2 in map_graph[arc1.to_node]:  # 在以arc1路段终点为起点的路段集合里做循环，以arc2变量表示
-                if arc2.id not in visited.keys():  # 如果arc2不在visited集合中
-                    if DistanceBetween(arc.geometry_list[-1], arc2.geometry_list[0]) < dist*1.5:
-                        # 如果arc1终点到arc2的起点的距离 小于 arc终点到GPS点的距离
-                        q.put(arc2)  # 将arc2放进队列
-                        visited[arc2.id] = True  # 将arc2标记已搜索
-    if min_arc_id != 0:
-        arc_list = dijkstra(graph_around, arc.id, min_arc_id)   # 计算前一匹配路段到现匹配路段的最短路径
-    return arc_list
-
-# 计算car_i经过的路径，将路段index记录在car_i_start_end_inde_list中，路径以j表示
-def CarRecordsDivide(car_i):
-    # car_id_count存储着从1到100每一条OD的定位数量 /LOU
-    index_start = sum(car_id_count[:car_i-1])  # 第i条OD数据的起始索引位置
-    index_end = sum(car_id_count[:car_i])  # 第i条OD数据的终止索引位置
-    car_i_start_end_index_list = []
-    car_i_start_end_index_list.append([index_start, index_end])
-    return car_i_start_end_index_list
-
-#计算属于一天中的第几个小时
-def Time_stage(gps_time):
-    today_time=datetime.datetime(2022, 7, 9, 0, 0, 0)
-    return math.ceil(SecondsBetween(today_time, gps_time)/3600)
-
-
-
-
-

src/PaddleClas/MANIFEST.in

@@ -0,0 +1,7 @@
+include LICENSE.txt
+include README.md
+include docs/en/whl_en.md
+recursive-include deploy/python predict_cls.py preprocess.py postprocess.py det_preprocess.py
+recursive-include deploy/utils get_image_list.py config.py logger.py predictor.py
+
+recursive-include ppcls/ *.py *.txt

src/PaddleClas/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__all__ = ['PaddleClas']
+from .paddleclas import PaddleClas
+from ppcls.arch.backbone import *

src/PaddleClas/benchmark/README.md

@@ -0,0 +1,27 @@
+# benchmark使用说明
+
+此目录所有shell脚本是为了测试PaddleClas中不同模型的速度指标，如单卡训练速度指标、多卡训练速度指标等。
+
+## 相关脚本说明
+
+一共有3个脚本：
+
+- `prepare_data.sh`: 下载相应的测试数据，并配置好数据路径
+- `run_benchmark.sh`: 执行单独一个训练测试的脚本，具体调用方式，可查看脚本注释
+- `run_all.sh`: 执行所有训练测试的入口脚本
+
+## 使用说明
+
+**注意**：为了跟PaddleClas中其他的模块的执行目录保持一致，此模块的执行目录为`PaddleClas`的根目录。
+
+### 1.准备数据
+
+```shell
+bash benchmark/prepare_data.sh
+```
+
+### 2.执行所有模型的测试
+
+```shell
+bash benchmark/run_all.sh
+```

src/PaddleClas/benchmark/prepare_data.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+dataset_url=$1
+
+package_check_list=(imageio tqdm Cython pycocotools tb_paddle scipy pandas wget h5py sklearn opencv-python visualdl)
+for package in ${package_check_list[@]}; do
+    if python -c "import ${package}" >/dev/null 2>&1; then
+        echo "${package} have already installed"
+    else
+        echo "${package} NOT FOUND"
+        pip install ${package}
+        echo "${package} installed"
+    fi
+done
+
+cd dataset
+rm -rf ILSVRC2012
+wget -nc ${dataset_url}
+tar xf ILSVRC2012_val.tar
+ln -s ILSVRC2012_val ILSVRC2012
+cd ILSVRC2012
+ln -s val_list.txt train_list.txt
+cd ../../

src/PaddleClas/benchmark/run_all.sh

@@ -0,0 +1,31 @@
+# 提供可稳定复现性能的脚本，默认在标准docker环境内py37执行： paddlepaddle/paddle:latest-gpu-cuda10.1-cudnn7  paddle=2.1.2  py=37
+# 执行目录：需说明
+# cd **
+# 1 安装该模型需要的依赖 (如需开启优化策略请注明)
+# pip install ...
+# 2 拷贝该模型需要数据、预训练模型
+# 3 批量运行（如不方便批量，1，2需放到单个模型中）
+log_path=${LOG_PATH_INDEX_DIR:-$(pwd)}  # LOG_PATH_INDEX_DIR 后续QA设置参数
+model_mode_list=(MobileNetV1 MobileNetV2 MobileNetV3_large_x1_0 ShuffleNetV2_x1_0 HRNet_W48_C SwinTransformer_tiny_patch4_window7_224 alt_gvt_base)    # benchmark 监控模型列表
+#model_mode_list=(MobileNetV1 MobileNetV2 MobileNetV3_large_x1_0 EfficientNetB0 ShuffleNetV2_x1_0 DenseNet121 HRNet_W48_C SwinTransformer_tiny_patch4_window7_224 alt_gvt_base)   # 该脚本支持列表
+fp_item_list=(fp32)
+#bs_list=(32 64 96 128)
+for model_mode in ${model_mode_list[@]}; do
+      for fp_item in ${fp_item_list[@]}; do
+          if [ ${model_mode} = MobileNetV3_large_x1_0 ] || [ ${model_mode} = ShuffleNetV2_x1_0 ]; then
+              bs_list=(256)
+          else
+              bs_list=(64)
+          fi
+          for bs_item in ${bs_list[@]};do
+	    echo "index is speed, 1gpus, begin, ${model_name}"
+	    run_mode=sp
+	    CUDA_VISIBLE_DEVICES=0 bash benchmark/run_benchmark.sh ${run_mode} ${bs_item} ${fp_item} 1 ${model_mode} | tee ${log_path}/clas_${model_mode}_${run_mode}_bs${bs_item}_${fp_item}_1gpus 2>&1    #  (5min)
+	    sleep 10
+            echo "index is speed, 8gpus, run_mode is multi_process, begin, ${model_name}"
+            run_mode=mp
+            CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 bash benchmark/run_benchmark.sh ${run_mode} ${bs_item} ${fp_item} 1 ${model_mode}| tee ${log_path}/clas_${model_mode}_${run_mode}_bs${bs_item}_${fp_item}_8gpus8p 2>&1
+            sleep 10
+            done
+      done
+done

src/PaddleClas/benchmark/run_benchmark.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+set -xe
+# 运行示例：CUDA_VISIBLE_DEVICES=0 bash run_benchmark.sh ${run_mode} ${bs_item} ${fp_item} 500 ${model_mode}
+# 参数说明
+function _set_params(){
+    run_mode=${1:-"sp"}          # 单卡sp|多卡mp
+    batch_size=${2:-"64"}
+    fp_item=${3:-"fp32"}        # fp32|fp16
+    epochs=${4:-"2"}       # 可选，如果需要修改代码提前中断
+    model_item=${5:-"model_item"}
+    run_log_path=${TRAIN_LOG_DIR:-$(pwd)}  # TRAIN_LOG_DIR 后续QA设置该参数
+
+    index=1
+    mission_name="图像分类"           # 模型所属任务名称，具体可参考scripts/config.ini                                （必填）
+    direction_id=0                    # 任务所属方向，0：CV，1：NLP，2：Rec。                                          (必填)
+    skip_steps=8                      # 解析日志，有些模型前几个step耗时长，需要跳过                                  (必填)
+    keyword="ips:"              # 解析日志，筛选出数据所在行的关键字                                            (必填)
+    keyword_loss="loss:"       #选填
+    model_mode=-1                      # 解析日志，具体参考scripts/analysis.py.                                        (必填)
+    ips_unit="images/s"
+    base_batch_size=$batch_size
+#   以下不用修改   
+    device=${CUDA_VISIBLE_DEVICES//,/ }
+    arr=(${device})
+    num_gpu_devices=${#arr[*]}
+    log_file=${run_log_path}/clas_${model_item}_${run_mode}_bs${batch_size}_${fp_item}_${num_gpu_devices}
+    model_name=${model_item}_bs${batch_size}_${fp_item}    # model_item 用于yml匹配，model_name用于入库
+}
+function _train(){
+    echo "Train on ${num_gpu_devices} GPUs"
+    echo "current CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES, gpus=$num_gpu_devices, batch_size=$batch_size"
+
+    if [ ${fp_item} = "fp32" ];then
+        model_config=`find ppcls/configs/ImageNet -name ${model_item}.yaml`
+    else
+        model_config=`find ppcls/configs/ImageNet -name ${model_item}_fp16.yaml`
+    fi
+
+    train_cmd="-c ${model_config} -o DataLoader.Train.sampler.batch_size=${batch_size} -o Global.epochs=${epochs}  -o Global.eval_during_train=False -o Global.print_batch_step=2"
+    case ${run_mode} in
+    sp) train_cmd="python -u tools/train.py ${train_cmd}" ;;
+    mp)
+        train_cmd="python -m paddle.distributed.launch --log_dir=./mylog --gpus=$CUDA_VISIBLE_DEVICES tools/train.py ${train_cmd}"
+        log_parse_file="mylog/workerlog.0" ;;
+    *) echo "choose run_mode(sp or mp)"; exit 1;
+    esac
+    rm -rf mylog
+# 以下不用修改
+    timeout 5m ${train_cmd} > ${log_file} 2>&1
+    if [ $? -ne 0 ];then
+        echo -e "${model_name}, FAIL"
+        export job_fail_flag=1
+    else
+        echo -e "${model_name}, SUCCESS"
+        export job_fail_flag=0
+    fi
+    kill -9 `ps -ef|grep 'python'|awk '{print $2}'`
+ 
+    if [ $run_mode = "mp" -a -d mylog ]; then
+        rm ${log_file}
+        cp mylog/workerlog.0 ${log_file}
+    fi
+}
+
+source ${BENCHMARK_ROOT}/scripts/run_model.sh # 在该脚本中会对符合benchmark规范的log使用analysis.py 脚本进行性能数据解析;该脚本在连调时可从benchmark repo中下载https://github.com/PaddlePaddle/benchmark/blob/master/scripts/run_model.sh;如果不联调只想要产出训练log可以注掉本行,提交时需打开
+_set_params $@
+_run
+#_train

src/PaddleClas/deploy/.idea/.gitignore

@@ -0,0 +1,3 @@
+# 默认忽略的文件
+/shelf/
+/workspace.xml

src/PaddleClas/deploy/.idea/deploy.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="GOOGLE" />
+    <option name="myDocStringFormat" value="Google" />
+  </component>
+</module>

src/PaddleClas/deploy/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

src/PaddleClas/deploy/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9" project-jdk-type="Python SDK" />
+</project>

src/PaddleClas/deploy/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/deploy.iml" filepath="$PROJECT_DIR$/.idea/deploy.iml" />
+    </modules>
+  </component>
+</project>

src/PaddleClas/deploy/.scannerwork/report-task.txt

@@ -0,0 +1,6 @@
+projectKey=deploy
+serverUrl=http://localhost:9000
+serverVersion=8.1.0.31237
+dashboardUrl=http://localhost:9000/dashboard?id=deploy
+ceTaskId=AYA_xvBwrgFtfprwzYuQ
+ceTaskUrl=http://localhost:9000/api/ce/task?id=AYA_xvBwrgFtfprwzYuQ