from paddlex.cls import transforms
import paddlex
import cv2
base = './data'
train_transforms = transforms.Compose([
transforms.ResizeByShort(256),
transforms.RandomCrop(crop_size=224),
transforms.RandomRotate(rotate_range=30, prob=0.5),
transforms.RandomDistort(),
transforms.Normalize()
])
train_dataset = paddlex.datasets.ImageNet(data_dir=base,
file_list='train_list.txt',
label_list='labels.txt',
transforms=train_transforms,
shuffle=True)
model = paddlex.load_model('weights/final')
im = cv2.imread('test.jpg')
print(model.evaluate(eval_dataset=train_dataset))
def garbage_test():
cap = cv2.VideoCapture(0) # 打开摄像头
# #形态学操作需要使用,获取一个3x3的卷积核
# kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3))
# #创建混合高斯模型用于背景建模
# fgbg = cv2.createBackgroundSubtractorMOG2(detectShadows = False)
# img_back=cv2.imread('/home/thomas/下载/QQ图片20201211233654.png')
while (1):
# get a frame
ret, frame = cap.read()
frame = cv2.flip(frame, 1) # 摄像头是和人对立的，将图像左右调换回来正常显示
# # fgmask= fgbg.apply(frame)
# rows, cols, channels = frame.shape
# lower_color = np.array([95, 95, 95])
# # lower_color = np.array([254, 254, 254])
# # upper_color = np.array([255, 255, 255])
# upper_color = np.array([150, 165, 165])
# # 创建掩图
# fgmask = cv2.inRange(frame, lower_color, upper_color)
# # cv2.imshow('Mask', fgmask)
# # 腐蚀膨胀
# erode = cv2.erode(fgmask, None, iterations=1)
# # cv2.imshow('erode', erode)
# dilate = cv2.dilate(erode, None, iterations=1)
# # cv2.imshow('dilate', dilate)
# rows, cols = dilate.shape
# img_back=img_back[0:rows,0:cols]
# # print(img_back)
# # #根据掩图和原图进行抠图
# img2_fg = cv2.bitwise_and(img_back, img_back, mask=dilate)
# Mask_inv = cv2.bitwise_not(dilate)
# img3_fg = cv2.bitwise_and(frame, frame, mask=Mask_inv)
# finalImg=img2_fg+img3_fg
# cv2.imshow('res', finalImg)
# show a frame
cv2.imshow("capture", frame) # 生成摄像头窗口
if cv2.waitKey(1) & 0xFF == ord('q'): # 如果按下q 就截图保存并退出dd
# cv2.imwrite("test.jpg", finalImg) # 保存路径
cv2.imwrite("test.jpg", frame) # 保存路径
break
cap.release()
model = pdx.load_model(
'/home/thomas/python/paddle/PaddleDetection/output/ResNet50_vd_ssld/best_model'
)
image_name = '/home/thomas/python/test.jpg'
result = model.predict(image_name)
return result
base = './data/'
import paddlex as pdx
from paddlex.det import transforms
INTERACTIVE = True
WRITE_CSV = True
USE_YOLO = False
if USE_YOLO:
eval_transforms = transforms.Compose([
transforms.Resize(
target_size=608, interp='CUBIC'), transforms.Normalize()
])
model = pdx.load_model('./PPYOLO/best_model')
else:
eval_transforms = transforms.Compose([
transforms.Normalize(),
transforms.ResizeByShort(short_size=800, max_size=1333),
transforms.Padding(coarsest_stride=32), ])
model = pdx.load_model('./models/det/FasterRCNN/epoch_48')
evaluator = CsvEvalWriter()
loop_gen = ((pdx.datasets.VOCDetection(
data_dir=base,
file_list=k,
transforms=eval_transforms,
label_list='./data/labels.txt'), v) for k, v in [
('data/MOT20/train/MOT20-03/manifest.txt', 'MOT20-03.txt'),
('data/MOT20/train/MOT20-01/manifest.txt', 'MOT20-01.txt'),
('data/MOT20/train/MOT20-02/manifest.txt', 'MOT20-02.txt'),
def toPic():
model = pdx.load_model(os.path.join(log, 'best_model'))
for x, y in test_dataset.file_list:
result = model.predict(x)
pdx.seg.visualize(x, result, weight=0.4, save_dir=log)
break
help="视频存放路径")
parser.add_argument("-o",
"--output",
type=str,
default="/home/aistudio/test/frame",
help="结果帧存放路径")
parser.add_argument("-m",
"--model",
type=str,
default="/home/aistudio/plane/gear/output/yolov3/epoch_20",
help="起落架检测模型路径")
parser.add_argument("--itv", type=int, default=8, help="人进入起落架区域，抽帧间隔")
args = parser.parse_args()
people_det = hub.Module(name="yolov3_resnet50_vd_coco2017")
flg_det = pdx.load_model(args.model)
transforms = transforms.Compose([transforms.Resize(), transforms.Normalize()])
# 坐标的顺序是按照crop时下标的顺序，坐标第一个就是下标第一维，cv2里面的应该和这个是反的
def toint(l):
return [int(x) for x in l]
def crop(img, p, mode="max"):
if mode == "max":
return img[p[0]:p[2], p[1]:p[3], :]
elif mode == "length":
p = toint([p[0], p[1], p[0] + p[2], p[1] + p[3]])
return crop(img, p)
def main():
import os
os.environ['CUDA_VISIBLE_DEVICES'] = ""
import paddlex as pdx
if len(sys.argv) < 2:
print("Use command 'paddlex -h` to print the help information\n")
return
parser = arg_parser()
args = parser.parse_args()
if args.version:
print("PaddleX-{}".format(pdx.__version__))
print("Repo: https://github.com/PaddlePaddle/PaddleX.git")
print("Email: [email protected]")
return
if args.export_inference:
assert args.model_dir is not None, "--model_dir should be defined while exporting Model model"
assert args.save_dir is not None, "--save_dir should be defined to save Model model"
fixed_input_shape = None
if args.fixed_input_shape is not None:
fixed_input_shape = eval(args.fixed_input_shape)
assert len(
fixed_input_shape
) == 2, "len of fixed input shape must == 2, such as [224,224]"
else:
fixed_input_shape = None
model = pdx.load_model(args.model_dir, fixed_input_shape)
model.export_inference_model(args.save_dir)
if args.export_onnx:
assert args.model_dir is not None, "--model_dir should be defined while exporting onnx model"
assert args.save_dir is not None, "--save_dir should be defined to create onnx model"
model = pdx.load_model(args.model_dir)
if model.status == "Normal" or model.status == "Prune":
logging.error(
"Only support Model model, try to export model first as below,",
exit=False)
logging.error(
"paddlex --export_inference --model_dir model_path --save_dir infer_model"
)
save_file = os.path.join(args.save_dir, 'paddle2onnx_model.onnx')
pdx.converter.export_onnx_model(model, save_file, args.onnx_opset)
if args.data_conversion:
assert args.source is not None, "--source should be defined while converting dataset"
assert args.to is not None, "--to should be defined to confirm the taregt dataset format"
assert args.pics is not None, "--pics should be defined to confirm the pictures path"
assert args.annotations is not None, "--annotations should be defined to confirm the annotations path"
assert args.save_dir is not None, "--save_dir should be defined to store taregt dataset"
if args.source not in ['labelme', 'jingling', 'easydata']:
logging.error(
"The source format {} is not one of labelme/jingling/easydata".
format(args.source),
exit=False)
if args.to not in ['PascalVOC', 'MSCOCO', 'SEG', 'ImageNet']:
logging.error(
"The to format {} is not one of PascalVOC/MSCOCO/SEG/ImageNet".
format(args.to),
exit=False)
if args.source == 'labelme' and args.to == 'ImageNet':
logging.error(
"The labelme dataset can not convert to the ImageNet dataset.",
exit=False)
if args.source == 'jingling' and args.to == 'PascalVOC':
logging.error(
"The jingling dataset can not convert to the PascalVOC dataset.",
exit=False)
if not osp.exists(args.save_dir):
os.makedirs(args.save_dir)
pdx.tools.convert.dataset_conversion(args.source, args.to, args.pics,
args.annotations, args.save_dir)
if args.split_dataset:
assert args.dataset_dir is not None, "--dataset_dir should be defined while spliting dataset"
assert args.format is not None, "--format should be defined while spliting dataset"
assert args.val_value is not None, "--val_value should be defined while spliting dataset"
dataset_dir = args.dataset_dir
dataset_format = args.format.lower()
val_value = float(args.val_value)
test_value = float(args.test_value
if args.test_value is not None else 0)
save_dir = dataset_dir
if not dataset_format in ["coco", "imagenet", "voc", "seg"]:
logging.error(
"The dataset format is not correct defined.(support COCO/ImageNet/VOC/Seg)"
)
if not osp.exists(dataset_dir):
logging.error("The path of dataset to be splited doesn't exist.")
if val_value <= 0 or val_value >= 1 or test_value < 0 or test_value >= 1 or val_value + test_value >= 1:
logging.error("The value of split is not correct.")
pdx.tools.split.dataset_split(dataset_dir, dataset_format, val_value,
test_value, save_dir)
def test():
import paddlex as pdx
model = pdx.load_model(f'{output_dir}/mobilenetv2/best_model')
image_name = f'{data_dir}/vegetables_cls/bocai/100.jpg'
result = model.predict(image_name)
print("Predict Result:", result)
import paddlex as pdx
import os
import cv2
pic_index = 25
# 获取测试文件名
test_path = 'steel/test_list.txt'
f = open(test_path)
lines = f.readlines()
imgname = os.path.basename(lines[pic_index].split(' ')[0])
labelname = os.path.basename(lines[pic_index].split(' ')[1])
labelname = labelname.replace('\n', '')
f.close()
# 加载模型并预测
image_path = os.path.join('steel/JPEGImages', imgname)
model = pdx.load_model('output/hrnet/best_model')
result = model.predict(image_path)
pdx.seg.visualize(image_path, result, weight=0.4, save_dir='output/predict')
# 输出ground truth
label_path = os.path.join('steel/Annotations', labelname)
mask = cv2.imread(label_path, cv2.IMREAD_GRAYSCALE)
gt = {'label_map': mask}
pdx.seg.visualize(image_path, gt, weight=0.4, save_dir='output/gt')
import paddlex as pdx
import cv2
gige2modelPath = "./yolov3_mobilenetv1_coco"
model_gige2 = pdx.load_model(gige2modelPath)
img = cv2.imread("./Image_20201206195514944.bmp")
print(img.shape)
# gige1Img = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR)
results1 = model_gige2.predict(img)
pdx.det.visualize(img, results1, threshold=0.1, save_dir='./')
print(results1)
from paddlex.det import transforms
import paddlex as pdx
from deep_sort import DeepSort
yolov3 = {'transforms': None, 'model': None, 'data_source': None}
faster_rcnn = {
'transforms':
transforms.Compose([
transforms.Normalize(),
transforms.ResizeByShort(short_size=800, max_size=1333),
transforms.Padding(coarsest_stride=32),
]),
'model':
pdx.load_model('./models/det/FasterRCNN/best_model'),
'data_source':
pdx.datasets.VOCDetection(
data_dir='./data/',
file_list='data/MOT20/train/MOT20-01/manifest.txt',
label_list='./data/labels.txt',
transforms=transforms.Compose([
transforms.Normalize(),
transforms.ResizeByShort(short_size=800, max_size=1333),
transforms.Padding(coarsest_stride=32),
])).file_list,
'tracker':
DeepSort('models/deep_sort/checkpoint_static/net', n_init=2)
}
import paddlex as pdx
from paddlex.det import transforms
model = pdx.load_model('output/yolov3/epoch_40')
image_name = '/home/aistudio/data/data67498/DatasetId_152881_1610856374/Images/1.png'
transforms = transforms.Compose([transforms.Resize(), transforms.Normalize()])
# transforms = transforms.Compose([transforms.ComposedYOLOv3Transforms()])
# result = model.predict(image_name, transforms=transforms)
result = model.batch_predict([], transforms=transforms)
print(result)
pdx.det.visualize(image_name,
result,
threshold=0.001,
save_dir='./output/plane_lg')
'''
Transforms:
- Resize:
interp: CUBIC
target_size: 608
- Normalize:
mean:
- 0.485
- 0.456
- 0.406
std:
- 0.229
- 0.224
import os
import paddlex as pdx
from paddlex.det import transforms
rcnn_eval_transforms = transforms.Compose([
transforms.Normalize(),
transforms.ResizeByShort(short_size=800, max_size=1333),
transforms.Padding(coarsest_stride=32),
])
rcnn_model = pdx.load_model('./FasterRCNN/best_model')
yolo_eval_transforms = transforms.Compose([
transforms.Resize(target_size=512, interp='CUBIC'),
transforms.Normalize(),
])
yolo_model = pdx.load_model('./YOLOv3/best_model')
print(
rcnn_model.evaluate(
pdx.datasets.VOCDetection(data_dir='./data',
file_list=os.path.join(
'./data', 'valid.txt'),
transforms=rcnn_eval_transforms,
label_list='./data/labels.txt'), 16))
print(
yolo_model.evaluate(
pdx.datasets.VOCDetection(data_dir='./data',
file_list=os.path.join(
'./data', 'valid.txt'),
transforms=yolo_eval_transforms,
label_list='./data/labels.txt'), 16))
import paddlex as pdx
from paddlex.det import transforms
INTERACTIVE = False
WRITE_CSV = True
eval_transforms = transforms.Compose([
transforms.Resize(target_size=512, interp='CUBIC'),
transforms.Normalize(),
])
eval_dataset = pdx.datasets.VOCDetection(
data_dir=base,
file_list=os.path.join(base, 'valid_all_1.txt'),
label_list='./data/labels.txt')
model = pdx.load_model('./YOLOv3/best_model')
evaluator = CsvEvalWriter()
for i in tqdm(eval_dataset.file_list):
image_name = i[0]
start = time.time()
result = model.predict(image_name)
# print('infer time:{:.6f}s'.format(time.time()-start))
# print('detected num:', len(result))
# paddle.disable_static()
im = cv2.imread(image_name)
font = cv2.FONT_HERSHEY_SIMPLEX
threshold = 0.2
result = list(filter(lambda x: x['score'] > threshold, result))
bboxes = np.array(list(map(lambda v: np.array(v['bbox']), result)))
confidence = list(map(lambda v: v['score'], result))
track = sort.update(bboxes, confidence, im)
print(cap.get(4))
print("success to save: " + str(num) + ".jpg")
print("-------------------------")
num += 1
elif k == ord('q'): #若检测到按键 ‘q’，退出
break
cap.release() #释放摄像头
cv2.destroyAllWindows() #删除建立的全部窗口
return num - 1
##def freshness_predict(image_num):
## model = pdx.load_model('banana_export_model/inference_model')
## result = model.predict(workpath + str(image_num) + ".jpg", topk=3)
## print("Predict Result:", result)
##
##
##
##if __name__ == '__main__':
## image_num = make_photo()
## freshness_predict(image_num)
print("---------------------------------------")
photo_num = make_photo()
print("photo_num: ", photo_num)
model = pdx.load_model('banana_export_model/inference_model')
result = model.predict(workpath + str(photo_num) + ".jpg", topk=3)
print("Predict Result:", result)
def export_onnx(model_dir, save_dir, fixed_input_shape):
assert len(fixed_input_shape) == 2, "len of fixed input shape must == 2"
model = pdx.load_model(model_dir, fixed_input_shape)
model_name = os.path.basename(model_dir.strip('/')).split('/')[-1]
export_onnx_model(model, save_dir)
def dbb(img, b, color="R"):
ymin, xmin, ymax, xmax = b
lines = [[(xmin, ymin), (xmin, ymax)], [(xmax, ymin), (xmax, ymax)],
[(xmin, ymin), (xmax, ymin)], [(xmin, ymax), (xmax, ymax)]]
if color == "R":
color = (0, 0, 255)
elif color == "G":
color = (0, 255, 0)
elif color == "B":
color = (255, 0, 0)
for l in lines:
cv2.line(img, l[0], l[1], color, 2)
flg_det = pdx.load_model("./model/new_flg/")
flg_trans = transforms.Compose([transforms.Resize(), transforms.Normalize()])
people_det = pdx.load_model("./model/person/50")
people_trans = transforms.Compose(
[transforms.Resize(), transforms.Normalize()])
def sort_key(p):
return (int(p['bbox'][0]), int(p['bbox'][1]))
for vid_name in tqdm(os.listdir(vid_dir)):
print(vid_name)
vidcap = cv2.VideoCapture(osp.join(vid_dir, vid_name))
def drawText(img, addText, x1, y1):
color = (20, 255, 20)
# img = Image.fromarray(image)
draw = ImageDraw.Draw(img)
draw.text((x1, y1),
addText.encode("utf-8").decode("utf-8"),
color,
font=fontC)
imagex = np.array(img)
return imagex
save_dir = './best_model'
model = pdx.load_model(save_dir)
classes = {
'c0': 'normal driving',
'c1': 'texting-right',
'c2': 'talking on the phone-right',
'c3': 'texting-left',
'c4': 'talking on the phone-left',
'c5': 'operating the radio',
'c6': 'drinking',
'c7': 'reaching behind',
'c8': 'hair and makeup',
'c9': 'talking to passenger'
}
base = './test_images'
import paddlex as pdx
import os
from tqdm import tqdm
import json
JSONFILE = './RCNN101.json'
results = []
#读取训练文件并且排序
test_file = './dataset/test'
img_list = os.listdir(test_file)
img_list.sort(key = lambda x : x.split('.')[0])
#加载模型
model = pdx.load_model('./output/best_model')
#训练
for i ,data in enumerate(tqdm(img_list)):
buffer_result = []
targets = []
buffer_result.append(int(data.split('.')[0])) #图片序号
img_path = os.path.join(test_file,data)
result = model.predict(img_path)
if len(result) != 0:#如果有结果
for j,data in enumerate(result):
target = []
if data['category'] == 'green':
target.append(0)
else:
target.append(1)
target.append(data['score'])
target.append(data['bbox'][0]),target.append(data['bbox'][1])
target.append(data['bbox'][2]+data['bbox'][0])
target.append(data['bbox'][3]+data['bbox'][1])
targets.append(target)
import glob
import numpy as np
import threading
import time
import random
import os
import base64
import cv2
import json
import paddlex as pdx
# 待预测图片路径
image_name = 'work/dataset_reinforcing_steel_bar_counting/JPEGImages/4B145787.jpg'
# 预测模型加载
model = pdx.load_model('output/yolov3_mobilnetv1/best_model')
# 读取图片与获取预测结果
img = cv2.imread(image_name)
result = model.predict(img)
# 解析预测结果，并保存到txt中
keep_results = []
areas = []
f = open('result.txt', 'a')
count = 0
for dt in np.array(result):
cname, bbox, score = dt['category'], dt['bbox'], dt['score']
if score < 0.5:
continue
keep_results.append(dt)
import argparse
from tqdm import tqdm
import cv2
import paddlex as pdx
from paddlex.det import transforms
parser = argparse.ArgumentParser(description="")
parser.add_argument("-m", "--model", type=str, help="模型路径")
parser.add_argument("-i", "--input", type=str, help="视频存放路径")
parser.add_argument("-o", "--output", type=str, help="结果视频存放路径")
parser.add_argument("--interval", type=int, default=10, help="间隔多少帧推理一次")
parser.add_argument("--bs", type=int, default=10, help="推理batchsize")
args = parser.parse_args()
model = pdx.load_model(args.model)
transforms = transforms.Compose([transforms.Resize(), transforms.Normalize()])
# TODO: 结果保存VOC格式
def predict(img_data, names, folder):
results = model.batch_predict(img_data, transforms=transforms)
for idx in range(len(results)):
vis = pdx.det.visualize(img_data[idx],
results[idx],
threshold=0.8,
save_dir=None)
cv2.imwrite(osp.join(folder, names[idx]), vis)
print(idx)
[(xmin, ymin), (xmax, ymin)],
[(xmin, ymax), (xmax, ymax)]
]
if color == "R":
color = (0, 0, 255)
elif color == "G":
color = (0, 255, 0)
elif color == "B":
color = (255, 0, 0)
for l in lines:
cv2.line(img, l[0], l[1], color, 2)
flg_det = pdx.load_model("../model/new_flg/")
flg_trans = transforms.Compose([
transforms.Resize(), transforms.Normalize()
])
def sort_key(p):
return (int(p['bbox'][0]), int(p['bbox'][1]))
for vid_name in tqdm(os.listdir(vid_dir)):
print(vid_name)
vidcap = cv2.VideoCapture(osp.join(vid_dir, vid_name))
frame_count = vidcap.get(cv2.CAP_PROP_FRAME_COUNT)
print(frame_count)
# coding:utf-8
# 环境变量配置，用于控制是否使用GPU
# 说明文档：https://paddlex.readthedocs.io/zh_CN/develop/appendix/parameters.html#gpu
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import os.path as osp
import paddlex as pdx
img_file = 'images/000001.jpg'
model_dir = 'output/ppyolov2_r50vd_dcn/best_model/'
save_dir = './visualize/predict'
# 设置置信度阈值
score_threshold = 0.4
if not os.path.exists(save_dir):
os.makedirs(save_dir)
model = pdx.load_model(model_dir)
res = model.predict(img_file)
pdx.det.visualize(img_file, res, threshold=score_threshold, save_dir=save_dir)
