Yolov5 Deepsort

La reproduction de cet article est interdite!

Cet article Adresse: https://blog.csdn.net/weixin_44936889/article/details/112002152

Introduction du projet:

Utilisez Yolov5 + DeepSort pour mettre en œuvre le suivi et le comptage des piétons des véhicules, et le code est encapsulé dans une classe de détecteur, qui est plus facile à intégrer dans vos propres projets.

Adresse du code (Star Welcome):

https://github.com/sharpilesess/yolov5-deepsort/

Effet final:

Détecteur Yolov5:

 class Detector ( baseDet ):

    def __init__ ( self ):
        super ( Detector , self ). __init__ ()
        self . init_model ()
        self . build_config ()

    def init_model ( self ):

        self . weights = 'weights/yolov5m.pt'
        self . device = '0' if torch . cuda . is_available () else 'cpu'
        self . device = select_device ( self . device )
        model = attempt_load ( self . weights , map_location = self . device )
        model . to ( self . device ). eval ()
        model . half ()
        # torch.save(model, 'test.pt')
        self . m = model
        self . names = model . module . names if hasattr (
            model , 'module' ) else model . names

    def preprocess ( self , img ):

        img0 = img . copy ()
        img = letterbox ( img , new_shape = self . img_size )[ 0 ]
        img = img [:, :, :: - 1 ]. transpose ( 2 , 0 , 1 )
        img = np . ascontiguousarray ( img )
        img = torch . from_numpy ( img ). to ( self . device )
        img = img . half ()  # 半精度
        img /= 255.0  # 图像归一化
        if img . ndimension () == 3 :
            img = img . unsqueeze ( 0 )

        return img0 , img

    def detect ( self , im ):

        im0 , img = self . preprocess ( im )

        pred = self . m ( img , augment = False )[ 0 ]
        pred = pred . float ()
        pred = non_max_suppression ( pred , self . threshold , 0.4 )

        pred_boxes = []
        for det in pred :

            if det is not None and len ( det ):
                det [:, : 4 ] = scale_coords (
                    img . shape [ 2 :], det [:, : 4 ], im0 . shape ). round ()

                for * x , conf , cls_id in det :
                    lbl = self . names [ int ( cls_id )]
                    if not lbl in [ 'person' , 'car' , 'truck' ]:
                        continue
                    x1 , y1 = int ( x [ 0 ]), int ( x [ 1 ])
                    x2 , y2 = int ( x [ 2 ]), int ( x [ 3 ])
                    pred_boxes . append (
                        ( x1 , y1 , x2 , y2 , lbl , conf ))

        return im , pred_boxes

Appelez la méthode self.detect pour renvoyer les résultats de l'image et de la prédiction

Deepsort Tracker:

 deepsort = DeepSort ( cfg . DEEPSORT . REID_CKPT ,
                    max_dist = cfg . DEEPSORT . MAX_DIST , min_confidence = cfg . DEEPSORT . MIN_CONFIDENCE ,
                    nms_max_overlap = cfg . DEEPSORT . NMS_MAX_OVERLAP , max_iou_distance = cfg . DEEPSORT . MAX_IOU_DISTANCE ,
                    max_age = cfg . DEEPSORT . MAX_AGE , n_init = cfg . DEEPSORT . N_INIT , nn_budget = cfg . DEEPSORT . NN_BUDGET ,
                    use_cuda = True )

Appelez la méthode Self.update pour mettre à jour les résultats de suivi

Exécutez la démo:

python demo.py

Formation de votre propre modèle:

Reportez-vous à un autre blog:

[Xiaobai cv] vous apprenez étape par étape avec Yolov5 pour former votre propre ensemble de données (de la configuration de l'environnement Windows au déploiement de modèle)

Après l'entraînement, mettez-le dans le dossier des poids

Appel à l'interface:

Créer un détecteur:

 from AIDetector_pytorch import Detector

det = Detector ()

Appel à l'interface de détection:

 result = det . feedCap ( im )

où je suis une image BGR

Le résultat renvoyé est un dictionnaire, le résultat [«cadre»] renvoie l'image visuelle

Contactez l'auteur:

Station B: https://space.bilibili.com/470550823

CSDN: https://blog.csdn.net/weixin_44936889

AI Studio: https://aistudio.baidu.com/aistudio/personalcenter/thirdview/67156

Github: https://github.com/sharpilsless

Suivez le protocole GNU General Public License v3.0 et indiquez la source de la partie de détection cible: https://github.com/ultralytique/yolov5/