Bài báo này đã được xuất bản như một phần của Blogathon Khoa học Dữ liệu.

Phát hiện tư thế là một tập hợp con của kỹ thuật Thị giác máy tính (CV) dự đoán dấu vết và vị trí của một người hoặc vật thể. Điều này được thực hiện bằng cách nhìn vào sự kết hợp của các tư thế và hướng của người hoặc vật nhất định.

Bài báo này là một phần đang diễn ra của một blog mà tôi đã viết rồi.

Vui lòng xem liên kết dưới đây để hiểu rõ hơn về Pose Detection.

Liên kết Blog: Cộng đồng Analytics | Thảo luận về Analytics | Thảo luận về Dữ liệu lớn (analyticsvidhya.com)

nhiều ứng dụng thú vị và các trường hợp sử dụng phát hiện tư thế. Bây giờ, trong bài viết này, chúng ta sẽ thảo luận về một ứng dụng thú vị như vậy và xây dựng một mô hình để giải quyết vấn đề đó.

Mục tiêu của bài viết này là xây dựng một mô hình có thể phân loại các cú đánh cricket bằng cách sử dụng tư thế của một người chơi. Đối với điều này, một hình ảnh sẽ được nhập vào mô hình. Nó sẽ phát hiện tư thế của người trong ảnh và sau đó sử dụng tư thế đã được phát hiện, chúng tôi sẽ phân loại đó là kiểu chụp nào.

Mục lục

1. Cài đặt Phụ thuộc
2. Tải và xử lý trước dữ liệu
3. Tăng cường dữ liệu
4. Phát hiện tư thế bằng Detron2
5. Phân loại cú đánh cricket bằng cách sử dụng tư thế của một người chơi
6. Đánh giá hiệu suất mô hình

! pip cài đặt pyyaml ​​== 5.1

# install detector2:! pip install detector2 == 0.1.3 -f https://dl.fbaipublicfiles.com/detectron2/wheels/cu101/torch1.5/index.html

Tải và xử lý trước dữ liệu để phân loại trận đấu cricket

Chúng tôi sẽ tải tập dữ liệu được lưu trên ổ đĩa. Vì vậy, trước tiên, chúng tôi sẽ mount ổ đĩa, sau đó chúng tôi sẽ giải nén tệp zip ngắn.

Liên kết tập dữ liệu: - https://courses.analyticsvidhya.com/courses/take/Applied-Computer-Vision-using-Deep-Learning/downloads/14568149-dataset-cricket-shot-classification

# mount drive từ google.colab import drive drive.mount ('drive /')

Tệp zip ngắn chứa các hình ảnh cho các loại ảnh khác nhau. Tiếp theo, chúng ta sẽ lấy tên của các thư mục là các lớp hoặc các loại ảnh khác nhau.

# giải nén tệp! giải nén 'drive / My Drive / shot.zip'

Tiếp theo, chúng tôi đang thực hiện việc này bằng cách sử dụng chức năng ERR danh sách của thư viện OS. Ở đây chúng tôi đang in tên thư mục mà chúng tôi có để chúng tôi có bốn thư mục là kéo, cắt, ổ đĩa và quét.

nhập os # chỉ định đường dẫn đường dẫn = 'shot /' # danh sách các thư mục xuống các thư mục thư mục = os.listdir (đường dẫn) print (các thư mục)

Đầu ra: - ['pull', 'cut', 'drive', 'scan']

Tiếp theo, chúng tôi đang đọc tất cả các hình ảnh và lưu trữ chúng trong một danh sách có tên các hình ảnh. WWe cũng sẽ lưu trữ các nhãn trong một danh sách về cơ bản là lớp cho mỗi hình ảnh. Lớp này sẽ không có gì khác ngoài tên của thư mục mà hình ảnh đã được lưu trữ. Bạn đã quen thuộc với quy trình mà chúng ta sẽ đi qua từng thư mục và đọc từng hình ảnh một và thêm chúng vào danh sách đã tạo.

# để xử lý hình ảnh nhập cv2 # tạo danh sách hình ảnh = [] nhãn = [] # cho mỗi thư mục cho thư mục trong thư mục: # liệt kê xuống tên hình ảnh tên = os.listdir (đường dẫn + thư mục) # cho mỗi hình ảnh cho tên trong tên : # đọc hình ảnh img = cv2.imread (đường dẫn + thư mục + '/' + tên) # nối hình ảnh vào danh sách images.append (img) # nối tên thư mục (loại ảnh) vào danh sách nhãn.append (thư mục)

Hãy nhanh chóng kiểm tra số lượng hình ảnh bằng cách sử dụng hàm độ dài. Chúng ta có thể quan sát thấy có 290 hình ảnh.

# số hình ảnh len (hình ảnh)

Đầu ra: - 290

Bây giờ ở đây chúng ta đang hình dung một vài hình ảnh từ tập dữ liệu. Vì vậy, đối với mỗi kiểu bắn. Chúng tôi đang vẽ ngẫu nhiên năm hình ảnh. Chúng tôi sẽ sử dụng matplotlib để hình dung các hình ảnh. Chức năng ngẫu nhiên sẽ được sử dụng để chọn ngẫu nhiên các hình ảnh.

Chúng ta sẽ tạo một subplot với bốn hàng cho bốn lớp khác nhau và năm cột cho năm ví dụ. Tiếp theo cho mỗi lớp, chúng tôi sẽ chọn ngẫu nhiên năm hình ảnh và đọc các hình ảnh đó bằng hàm cv2.imread. Sau khi bạn đọc hình ảnh, bạn có thể chuyển đổi những hình ảnh này sang định dạng RGB và trực quan hóa những hình ảnh này.

# thư viện trực quan nhập matplotlib.pyplot dưới dạng plt # cho tính ngẫu nhiên nhập ngẫu nhiên # tạo các ô con có 4 hàng và 5 cột hình, ax = plt.subplots (nrows = 4, ncols = 5, figsize = (15,15))

# hiển thị ngẫu nhiên 5 hình ảnh cho mỗi lần chụp cho mỗi thư mục đối với tôi trong phạm vi (len (thư mục)): # đọc tên các tên hình ảnh = os.listdir (đường dẫn + thư mục [i]) # chọn ngẫu nhiên 5 tên hình ảnh tên = random.sample (tên, 5) # cho mỗi hình ảnh cho j trong phạm vi (len (tên)): # đọc hình ảnh img = cv2.imread (đường dẫn + thư mục [i] + '/' + tên [j]) # chuyển đổi BGR thành RGB img = cv2.cvtColor (img, cv2.COLOR_BGR2RGB) # display image ax [i, j] .imshow (img) # đặt tên thư mục làm tiêu đề ax [i, j] .set_title (thư mục [i]) # Tắt trục ax [i, j] .axis ('tắt')

                                    Nguồn: - Tác giả

Vì vậy, ở đây bạn có thể thấy một vài ví dụ về hình ảnh mà chúng tôi đã lấy từ tập dữ liệu. Bây giờ vì chúng ta có ít hình ảnh hơn trong tập huấn luyện. Chúng tôi sẽ sử dụng các kỹ thuật tăng dữ liệu để tăng quy mô đào tạo của chúng tôi.

Tăng cường dữ liệu

# image boost aug_images = [] aug_labels = [] # cho mỗi hình ảnh trong dữ liệu đào tạo cho idx trong dải (len (images)): # tìm nạp một hình ảnh và nhãn img = images [idx] label = label [idx] # flip an image img_flip = cv2.flip (img, 1) # append image to list aug_images.append (img_flip) # append label to list aug_labels.append (label)

Tiếp theo, chúng ta sẽ hình dung một vài hình ảnh tăng cường cùng với các hình ảnh gốc.

Vì vậy, chúng tôi sẽ chọn ngẫu nhiên năm hình ảnh. Ngoài ra, chúng tôi đang tạo một subplot để hình dung như trước đây chúng tôi đã làm. Đầu tiên chúng tôi vẽ hình ảnh thực tế và sau đó là phiên bản tăng cường của nó.

Vì vậy, ở đây chúng ta có thể thấy rằng sử dụng tăng cường dữ liệu để lật các hình ảnh, loại ảnh không thay đổi. Một bức ảnh kéo sẽ là một bức ảnh kéo ngay cả khi chúng ta xoay hình ảnh theo chiều ngang.

# hiển thị hình ảnh thực tế và hình ảnh tăng cường cho hình ảnh mẫu # tạo các chỉ số ind = range (len (aug_images)) # các chỉ số mẫu ngẫu nhiên ind = random.sample (ind, 5) # tạo các ô con có 5 hàng và 2 cột hình, ax = plt. subplots (nrows = 5, ncols = 2, figsize = (15,15)) # cho mỗi hàng cho hàng trong phạm vi (5): # cho mỗi cột cho col trong phạm vi (2): # cột đầu tiên cho hình ảnh thực tế nếu col == 0: # hiển thị hình ảnh thực ax [row, col] .imshow (images [ind [row]]) # set title ax [row, col] .set_title ('Thực tế') # Tắt trục ax [row, col ] .axis ('off') # cột thứ hai cho hình ảnh tăng cường khác: # hiển thị hình ảnh tăng cường ax [row, col] .imshow (aug_images [ind [row]]) # set title ax [row, col] .set_title (' Tăng cường ') # Tắt trục ax [hàng, cột] .axis (' tắt ')

                                                 Nguồn: - Tác giả

Bây giờ chúng tôi đang kết hợp hình ảnh thực tế và hình ảnh tăng cường và kiểm tra số lượng hình ảnh.

# kết hợp hình ảnh thực tế và hình ảnh tăng cường & nhãn images = hình ảnh + aug_images label = label + aug_labels

# số hình ảnh len (hình ảnh)

Đầu ra: - 580

# nhập một số tiện ích detron2 phổ biến # để có được các mô hình được đào tạo trước từ exploreron2 import model_zoo # thiết lập bộ dự đoán từ detector2.engine import DefaultPredictor # set config từ detron2.config import get_cfg # xác định cấu hình instance cfg = get_cfg () # lấy một mô hình được chỉ định bởi tương đối trong thư mục configs / chính thức của Detectron2. cfg.merge_from_file (model_zoo.get_config_file ("COCO-Keypoints / keypoint_rcnn_R_101_FPN_3x.yaml")) # tải xuống mô hình đào tạo trước cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url ("COCO-KeynnlPN_101x.yampoints / keypoint)

# đặt ngưỡng cho mô hình này cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.8

# tạo công cụ dự đoán = DefaultPredictor (cfg)

Hãy hình dung một vài dự đoán từ mô hình. Ở đây, chúng tôi sẽ chọn ngẫu nhiên năm hình ảnh và sau đó đối với mỗi hình ảnh, chúng tôi sẽ lấy các dự đoán xác định trình hiển thị và vẽ các dự đoán trên hình ảnh, và cuối cùng vẽ các dự đoán.

# để vẽ dự đoán trên hình ảnh từ Detron2.utils.visualizer nhập Visualizer # để lấy siêu dữ liệu từ Detron2.data import MetadataCatalog # để hiển thị hình ảnh từ google.colab.patches import cv2_imshow # chọn ngẫu nhiên hình ảnh cho img trong random.sample (hình ảnh, 5): # thực hiện các kết quả dự đoán = dự đoán (img) # sử dụng `Visualizer` để vẽ các dự đoán trên hình ảnh. v = Visualizer (img [:,:, :: - 1], MetadataCatalog.get (cfg.DATASETS.TRAIN [0]), scale = 1) # vẽ dự đoán trên hình ảnh v = v.draw_instance_predictions (đầu ra ["instance" ] .to ("cpu")) # display image cv2_imshow (v.get_image () [:,:, :: - 1])

Nguồn: - Tác giả

Vì vậy, đây là những dự đoán từ mô hình. Bạn có thể thấy rằng chúng tôi có các hộp giới hạn cùng với các điểm chính được dự đoán cho mỗi người chơi này. Bạn có thể thấy rằng mô hình thậm chí còn dự đoán một số hình ảnh trong nền. Vì vậy, đây là một vài dự đoán từ mô hình.

Tiếp theo, chúng ta sẽ xác định một chức năng sẽ được sử dụng để trích xuất và phát hiện các tư thế cho hình ảnh. Vì vậy, chức năng này sẽ lấy một hình ảnh làm đầu vào thực hiện các dự đoán này cho hình ảnh bằng cách sử dụng mô hình được đào tạo trước và sau đó chuyển đổi các điểm chính được trích xuất thành cục mịch mảng cho một hình ảnh duy nhất.

Có thể có nhiều đối tượng. Vì vậy, chúng tôi sẽ chọn đối tượng có điểm cao nhất và chỉ giữ lại những điểm chính đó và cuối cùng chúng tôi chuyển đổi các điểm chính thành một mảng 1d.

Vì chúng tôi muốn xây dựng một mô hình mạng nơ-ron trên đó và mạng nơ-ron nhận đầu vào đơn chiều.

Vì vậy, ở đây chúng tôi đang chuyển đổi nó thành một chiều duy nhất, bây giờ chúng tôi sẽ sử dụng hàm đã xác định và trích xuất các điểm chính cho tất cả các hình ảnh và lưu trữ chúng trong một điểm chính danh sách.

Bây giờ chúng ta có các điểm chính cho tất cả các hình ảnh. Tiếp theo, chúng ta sẽ xây dựng một mạng lưới thần kinh sẽ phân loại các điểm chính này thành loại ảnh.

# định nghĩa hàm trích xuất các điểm chính cho một hình ảnh def extract_keypoints (img): # thực hiện dự đoán outputs = Predctor (img) # tìm nạp các điểm chính keypoints = outputs ['instance']. pred_keypoints # chuyển đổi thành mảng numpy kp = keypoints.cpu () .numpy () # if keypoints được phát hiện if (len (keypoints)> 0): # tìm nạp keypoint của một người có điểm tin cậy tối đa kp = kp [0] kp = np.delete (kp, 2,1) # convert mảng 2D đến mảng 1D kp = kp.flatten () # return keypoints return kp

# thanh tiến trình từ tqdm import tqdm import numpy as np # create list keypoints = [] # for every image for i in tqdm (range (len (images))): # extract keypoints kp = extract_keypoints (images [i]) # append keypoints keypoints.append (kp) 

5. Phân loại cú đánh cricket bằng cách sử dụng tư thế của một người chơi

# để chuẩn hóa từ sklearn.preprocessing import StandardScaler # xác định chuẩn scaleer = StandardScaler () # normalize keypoints keypoints = scaler.fit_transform (keypoints) # convert to an array keypoints = np.array (keypoints)

Vì vậy, ở đây chúng tôi đã chuẩn hóa các giá trị của các điểm chính của chúng tôi. Chúng tôi đang chuyển đổi mục tiêu hiện đang ở dạng văn bản thành số bằng cách sử dụng mã hóa nhãn.

# chuyển đổi danh mục mục tiêu thành số từ sklearn.preprocessing import LabelEncoder le = LabelEncoder () y = le.fit_transform (nhãn)

Sau đó, chúng tôi đang tách tập dữ liệu của mình thành tập huấn luyện và tập xác nhận bằng cách sử dụng chức năng phân chia thử nghiệm huấn luyện. Vì vậy, chúng tôi đã giữ kích thước thử nghiệm là 0.2 có nghĩa là 80 (%) dữ liệu sẽ được sử dụng để đào tạo và 20 (%) sẽ nằm trong tập xác thực.

# để tạo bộ đào tạo và xác thực từ sklearn.model_selection nhập train_test_split # phân tách các điểm chính và nhãn trong 80:20 x_tr, x_val, y_tr, y_val = train_test_split (keypoints, y, test_size = 0.2, stratify = label, random_state = 120)

Bây giờ để sử dụng các điểm chính và mục tiêu, chúng ta phải chuyển đổi chúng thành tensor. Do đó, ở đây chúng tôi đang chuyển đổi các điểm chính cũng như các mục tiêu thành các bộ căng của python cho cả tập huấn luyện và xác nhận.

# chuyển đổi các điểm chính và giá trị mục tiêu thành tensor import torch x_tr = torch.Tensor (x_tr) x_val = torch.Tensor (x_val) y_tr = torch.Tensor (y_tr) y_tr = y_tr.type (torch.long) y_val = torch.Tensor (y_val) y_val = y_val.type (torch.long)

Đây là hình dạng của khóa đào tạo và tập hợp xác thực có 464 hình ảnh để đào tạo và 116 hình ảnh để xác nhận.

# hình dạng của tập hợp đào tạo và xác thực (x_tr.shape, y_tr.shape), (x_val.shape, y_val.shape)

Bây giờ chúng ta sẽ xác định kiến ​​trúc cho mô hình của chúng ta. Vì vậy, ở đây chúng tôi đang nhập một vài hàm từ PyTorch sẽ giúp ích cho chúng tôi. Ở đây chúng ta đang định nghĩa một kiến ​​trúc mạng nơ-ron đơn giản chỉ với một lớp ẩn với 64 nơ-ron.
Lớp đầu ra có bốn tế bào thần kinh vì chúng ta có bốn lớp khác nhau và chức năng kích hoạt của lớp đầu ra sẽ trả về xác suất. Do đó, chúng tôi có một chức năng kích hoạt softmax.

# import thư viện để xác định kiến ​​trúc của mô hình từ torch.autograd import Biến từ torch.optim import Adam từ torch.nn import Linear, ReLU, Sequential, Softmax, CrossEntropyLoss # xác định mô hình kiến ​​trúc model = Sequential (Linear (34, 64) , ReLU (), Tuyến tính (64, 4), Softmax ())

Tiếp theo, chúng tôi đang xác định trình tối ưu hóa là adam và mất mát là entropy chéo. Đó là một vấn đề phân loại nhiều lớp và sau đó chúng tôi đang chuyển mô hình sang GPU.

# xác định trình tối ưu hóa và trình tối ưu hóa chức năng mất mát = Adam (model.parameters (), lr = 0.01) tiêu chí = CrossEntropyLoss () # kiểm tra xem GPU có khả dụng không nếu torch.cuda.is_available (): model = model.cuda () tiêu chí = tiêu chí .cuda ()

Tiếp theo, chúng tôi đang xác định một hàm sẽ được sử dụng để đào tạo mô hình của chúng tôi. Vì vậy, hàm này sẽ lấy số lượng kỷ nguyên làm đầu vào. Chúng tôi sẽ thiết lập mô hình để đào tạo. Đầu tiên, chúng tôi đang khởi tạo khoản lỗ bằng XNUMX, sau đó chúng tôi đang tải tập huấn luyện và tập xác nhận bằng cách sử dụng biến Pytorch.

Chuyển mô hình và xác thực của chúng tôi sang GPU sau đó chúng tôi đang xóa các độ dốc của thông số mô hình. Tiếp theo, chúng tôi sẽ lấy các dự đoán từ mô hình cho cả quá trình đào tạo cũng như các bộ xác nhận và sắp xếp chúng thành các biến riêng biệt.

Chúng tôi đã tính toán sự mất mát của chuyến tàu và xác thực và cuối cùng, chúng tôi đang truyền lại các gradient và cập nhật các tham số.

Ngoài ra, chúng tôi cũng đang in mất xác thực sau mỗi kỷ nguyên thứ 10.

def train (epoch): model.train () tr_loss = 0 # nhận tập huấn luyện x_train, y_train = Variable (x_tr), Variable (y_tr) # nhận tập xác thực x_valid, y_valid = Variable (x_val), Variable (y_val) # chuyển đổi dữ liệu sang định dạng GPU nếu torch.cuda.is_available (): x_train = x_train.cuda () y_train = y_train.cuda () x_valid = x_valid.cuda () y_valid = y_valid.cuda ()

 # xóa Điểm trọng lượng của trình tối ưu hóa thông số mô hình.zero_grad () # dự đoán cho tập hợp đào tạo và xác thực output_train = model (x_train) output_val = model (x_valid) # tính toán việc đào tạo và xác thực mất loss_train = tiêu chí (đầu ra_train, y_train) loss_val = tiêu chí (output_val, y_valid) # tính toán trọng số được cập nhật của tất cả các tham số mô hình loss_train.backward () Optimizer.step () if epoch% 10 == 0: # in bản in mất xác thực ('Epoch:', epoch + 1, ' t ',' loss: ', loss_val.item ())

Bây giờ chúng tôi đã xác định chức năng của chúng tôi. Chúng tôi sẽ sử dụng chức năng đào tạo này và bắt đầu đào tạo cho mô hình của chúng tôi. Ngoài ra, chúng tôi đang đào tạo 400 kỷ nguyên. Bạn có thể thấy rằng mô hình đang bị mất bản in ở mỗi kỷ nguyên thứ 10.

Cuối cùng, chúng tôi bắt đầu với mức lỗ 1.38 và bây giờ chúng tôi lỗ 0.97 khi kết thúc. Vì vậy, chúng ta có thể thấy rằng hiệu suất của mô hình đang được cải thiện khi quá trình đào tạo mô hình diễn ra.

# xác định số kỷ nguyên n_epochs = 100 # đào tạo mô hình cho kỷ nguyên trong phạm vi (n_epochs): train (kỷ nguyên)

Đánh giá hiệu suất mô hình

Hãy đánh giá hiệu suất của mô hình để chúng tôi sẽ kiểm tra độ chính xác của mô hình.

Do đó nhập hàm từ sklearning. chúng tôi đang nhận được tập hợp xác thực bao gồm các điểm chính cũng như các biến mục tiêu. Khi bạn nhận được biến, trước tiên hãy chuyển các giá trị này sang GPU mà chúng tôi đang lấy các dự đoán từ mô hình trên các hình ảnh xác thực bằng cách sử dụng mô hình được đào tạo.

Bây giờ chúng ta đang chuyển đổi các xác suất dự đoán thành các lớp tương ứng bằng cách sử dụng hàm arg max.

# để kiểm tra hiệu suất mô hình từ sklearn.metrics import precision_score # lấy độ chính xác xác thực x, y = Variable (x_val), Variable (y_val) if torch.cuda.is_available (): x_val = x.cuda () y_val = y.cuda () pred = model (x_val) final_pred = np.argmax (pred.cpu (). data.numpy (), axis = 1) precision_score (y_val.cpu (), final_pred)

Cuối cùng, chúng tôi tính toán điểm chính xác để độ chính xác của mô hình này là 0.79, tương đương 80%.

Kết luận

Để cải thiện độ chính xác, bạn có thể sử dụng các siêu tham số khác nhau như tăng số lớp ẩn trong mô hình, thay đổi trình tối ưu hóa, thay đổi chức năng kích hoạt, tăng số kỷ nguyên và hơn thế nữa.

Tôi hy vọng bạn đã quen với việc điều chỉnh siêu tham số cho mạng nơ-ron, hãy thử chúng ở cuối và chia sẻ hiệu suất của bạn trong phần bình luận. Vì vậy, đây là cách chúng ta có thể xây dựng một mô hình để phân loại các bức ảnh bằng cách sử dụng tư thế của một người chơi.

Lưu ý

Xin chào, tôi là Kajal Kumari. đã hoàn thành bằng Thạc sĩ của tôi từ IIT (ISM) Dhanbad về Khoa học và Kỹ thuật Máy tính. Hiện tại, tôi đang làm Kỹ sư Máy học ở Hyderabad. Đây là hồ sơ Linkedin của tôi nếu bạn muốn kết nối với tôi.

Ghi chú kết thúc

Nhờ đọc!

Tôi hy vọng rằng bạn đã thích bài viết. Nếu bạn thích nó, hãy chia sẻ nó với bạn bè của bạn. Xin vui lòng bình luận nếu bạn có bất kỳ suy nghĩ có thể cải thiện bài viết của tôi.

Nếu bạn muốn đọc các blog trước đây của tôi, bạn có thể đọc Các bài đăng trên Blog Khoa học Dữ liệu trước đây từ đây.

Phương tiện hiển thị trong bài viết này không thuộc sở hữu của Analytics Vidhya và được sử dụng theo quyết định riêng của Tác giả.

Sản phẩm liên quan

• Coinsmart. Sàn giao dịch Bitcoin và tiền điện tử tốt nhất Châu Âu.
• Platoblockchain. Web3 Metaverse Intelligence. Khuếch đại kiến ​​thức. TRUY CẬP MIỄN PHÍ.
• CryptoHawk. Radar Altcoin. Dùng thử miễn phí.
• Nguồn: https://www.analyticsvidhya.com/blog/2022/03/cricket-shot-classification-using-pose-of-the-player-image/