मुद्रा के वर्गीकरण के विकल्प

ML Kit के पोज़ डिटेक्शन एपीआई की मदद से, शरीर के अलग-अलग हिस्सों की स्थिति की जांच करके, किसी पोज़ के बारे में अहम जानकारी हासिल की जा सकती है. इस पेज पर कुछ उदाहरण दिए गए हैं.

k-NN एल्गोरिदम की मदद से, चीज़ों को कैटगरी में बांटने और उन्हें दोहराने की गिनती करें

आसन का पता लगाने का सबसे सामान्य उपयोग फ़िटनेस ट्रैकिंग है. डेवलपर के लिए, ऐसा पोज़ क्लासिफ़ायर बनाना चुनौती भरा हो सकता है जो फ़िटनेस के खास पोज़ को पहचानता हो और दोहराए जाने की संख्या की गिनती करता हो.

इस सेक्शन में हमने बताया है कि हमने कस्टम पोज़ कैसे बनाया MediaPipe Colab का इस्तेमाल करके क्लासिफ़ायर और हमारे ML किट सैंपल ऐप्लिकेशन में काम करने वाले क्लासिफ़ायर को दिखाने के लिए.

अगर आपको Google Colaboratory के बारे में जानकारी नहीं है, तो कृपया इसके बारे में जानकारी देने वाली गाइड देखें.

आसन की पहचान करने के लिए, हम k-पास के पड़ोसी एल्गोरिदम (k-NN) का इस्तेमाल करते हैं, क्योंकि यह आसान है और इसे शुरू करना आसान है. एल्गोरिदम, ऑब्जेक्ट की क्लास इनके आधार पर तय करता है: सबसे करीब से लिए गए सैंपल को ट्रेनिंग सेट में शामिल कर सकते हैं.

आइडेंटिफ़ायर बनाने और उसे ट्रेनिंग देने के लिए, यह तरीका अपनाएं:

1. इमेज के सैंपल इकट्ठा करें

हमने अलग-अलग सोर्स से, टारगेट किए गए व्यायाम की इमेज के सैंपल इकट्ठा किए हैं. हमने हर कसरत के लिए कुछ हज़ार इमेज चुनी हैं. जैसे, पुश-अप के लिए "अप" और "डाउन" पोज़िशन. अलग-अलग कैमरे को कवर करने वाले सैंपल इकट्ठा करना ज़रूरी है कोण, पर्यावरण की स्थितियां, शरीर के आकार, और कसरत के वैरिएशन.

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

2. सैंपल इमेज पर पोज़ की पहचान करने की सुविधा चलाना

इससे पोज़ के लैंडमार्क का एक सेट बनता है, जिसका इस्तेमाल ट्रेनिंग के लिए किया जाता है. हम खुद से पोज़ का पता लगाने में दिलचस्पी नहीं रखते, क्योंकि अगले चरण में हम अपने मॉडल को ट्रेनिंग देंगे.

पसंद के मुताबिक पोज़ की कैटगरी तय करने के लिए, हमने k-NN एल्गोरिदम चुना है हर सैंपल के लिए फ़ीचर वेक्टर प्रज़ेंटेशन और कैलकुलेट करने के लिए मेट्रिक पोज़ सैंपल के सबसे नज़दीकी टारगेट को खोजने के लिए, दो वेक्टर के बीच की दूरी. इसका मतलब है कि हमें अभी जो पोज़ लैंडमार्क मिले हैं उन्हें बदलना होगा.

पोज़ के लैंडमार्क को फ़ीचर वेक्टर में बदलने के लिए, हम पोज़ के जोड़ों की पहले से तय सूचियों के बीच की दूरियों का इस्तेमाल करते हैं. जैसे, कलाई और कंधे, एड़ी और कूल्हे, और बाईं और दाईं कलाई के बीच की दूरी. इमेज के स्केल से में अंतर हो सकता है. हम पोज़ को सामान्य बनाकर रखने और शरीर का साइज़ एक जैसा और वर्टिकल रखने का फ़ैसला लेते हैं ओरिएंटेशन बदलने से पहले करें.

3. मॉडल को ट्रेनिंग देना और दोहरावों की गिनती करना

हमने क्लासिफ़ायर का कोड ऐक्सेस करने के लिए, MediaPipe Colab का इस्तेमाल किया है और मॉडल को ट्रेनिंग दो.

दोहराव की गिनती करने के लिए, हमने दूसरे Colab एल्गोरिदम का इस्तेमाल किया है, ताकि गड़बड़ियों को मॉनिटर किया जा सके टारगेट पोज़ पोज़िशन का थ्रेशोल्ड. उदाहरण के लिए:

• जब "डाउन" पोज़ क्लास की संभावना पहली बार तय थ्रेशोल्ड से ज़्यादा हो जाती है, तो एल्गोरिदम यह मार्क करता है कि "डाउन" पोज़ क्लास दर्ज की गई है.
• जब प्रॉबबिलिटी थ्रेशोल्ड से कम हो जाती है, तो एल्गोरिदम यह बताता है कि "नीचे" पोज़ क्लास को छोड़ दिया गया है और इससे काउंटर बढ़ जाता है.

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

4. ML Kit के क्विकस्टार्ट ऐप्लिकेशन के साथ इंटिग्रेट करना

ऊपर दिया गया Colab, एक CSV फ़ाइल बनाता है. इसमें अपने सभी पोज़ (हाव-भाव) इस्तेमाल किए जा सकते हैं सैंपल. इस सेक्शन में, आपको CSV फ़ाइल को ML Kit Android क्विकस्टार्ट ऐप्लिकेशन, ताकि रीयल टाइम में अपनी पसंद के हिसाब से पोज़ की कैटगरी तय की जा सके.

क्विकस्टार्ट ऐप्लिकेशन में, सैंपल के साथ पोज़ देने की सुविधा आज़माएं

• GitHub से ML Kit का Android क्विकस्टार्ट ऐप्लिकेशन प्रोजेक्ट पाएं और पक्का करें कि यह सही तरीके से बन रहा हो और चल रहा हो.
• LivePreviewActivity पर जाएं और पोज़ डिटेक्शन Run classification को चालू करें सेटिंग' पेज पर जाएं करें. अब आपको पुशअप और स्क्वैट को अलग-अलग कैटगरी में बांटने की सुविधा मिल जाएगी.

अपनी CSV फ़ाइल जोड़ना

• अपनी CSV फ़ाइल को ऐप्लिकेशन के एसेट फ़ोल्डर में जोड़ें.
• PoseClassifierProcessor में, अपनी CSV फ़ाइल और पोज़ के सैंपल से मैच करने के लिए, POSE_SAMPLES_FILE और POSE_CLASSES वैरिएबल अपडेट करें.
• ऐप्लिकेशन बनाएं और चलाएं.

ध्यान दें कि ज़रूरत के मुताबिक सैंपल न होने पर, हो सकता है कि डेटा को अलग-अलग कैटगरी में बांटने की सुविधा ठीक से काम न करे. आम तौर पर, आपको हर पोज़ क्लास के लिए करीब 100 सैंपल की ज़रूरत होती है.

ज़्यादा जानने और इसे खुद आज़माने के लिए, MediaPipe Colab पर जाएं और MediaPipe के क्लासिफ़िकेशन की गाइड पढ़ें.

लैंडमार्क की दूरी का हिसाब लगाकर, आसान जेस्चर को पहचानना

जब दो या दो से ज़्यादा लैंडमार्क एक-दूसरे के पास हों, तो उनका इस्तेमाल इन कामों के लिए किया जा सकता है जेस्चर को पहचानता है. उदाहरण के लिए, जब हाथ की एक या उससे ज़्यादा उंगलियों का लैंडमार्क, नाक के लैंडमार्क के करीब हो, तो यह अनुमान लगाया जा सकता है कि उपयोगकर्ता अपने चेहरे को छू रहा है.

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

अलग-अलग ऐंगल की कसरत के साथ योग के पोज़ की पहचान करना

अलग-अलग जोड़ों के कोणों का हिसाब लगाकर, योग के आसन की पहचान की जा सकती है. इसके लिए उदाहरण के लिए, नीचे दी गई इमेज में योद्धा II की योग मुद्रा दिखाई गई है. इस पोज़ की पहचान करने वाले अनुमानित ऐंगल इनमें लिखे गए हैं:

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

इस पोज़ को शरीर की अनुमानित बनावट के इस तरह के मेल के तौर पर बताया जा सकता है पार्ट के कोण:

• दोनों कंधों पर 90 डिग्री का कोण
• दोनों कोहनी पर 180 डिग्री
• आगे के पैर और कमर पर 90 डिग्री का कोण
• घुटने के पिछले हिस्से पर 180 डिग्री का कोण
• कमर पर 135 डिग्री का कोण

इन कोणों का पता लगाने के लिए, पोज़ लैंडमार्क का इस्तेमाल किया जा सकता है. उदाहरण के लिए, कोण आपके सामने के दाएं पैर और कमर पर, दाईं ओर से लाइन के बीच का ऐंगल है कंधे से दाएं कूल्हे तक और दाएं कूल्हे से दाएं घुटने तक.

पोज़ की पहचान करने के लिए ज़रूरी सभी ऐंगल का हिसाब लगाने के बाद, यह देखा जा सकता है कि कोई मैच है या नहीं. अगर मैच है, तो इसका मतलब है कि पोज़ की पहचान हो गई है.

नीचे दिए गए कोड स्निपेट में, शरीर के दो हिस्सों के बीच के कोण का हिसाब लगाने के लिए, X और Y निर्देशांक का इस्तेमाल करने का तरीका बताया गया है. कैटगरी तय करने के इस तरीके की कुछ सीमाएं हैं. सिर्फ़ X और Y को चुनने पर, आपके दिए गए फ़ॉर्मूला के आधार पर तैयार किए गए कोण बदल सकते हैं ऑब्जेक्ट और कैमरे के बीच के ऐंगल के हिसाब से तय होता है. आपको एक लेवल, सीधे आगे की ओर, हेड-ऑन इमेज के साथ सबसे अच्छे नतीजे मिलते हैं. Z कोऑर्डिनेट का इस्तेमाल करके, इस एल्गोरिदम को बेहतर बनाने की कोशिश की जा सकती है. साथ ही, यह भी देखा जा सकता है कि यह आपके इस्तेमाल के उदाहरण के लिए बेहतर परफ़ॉर्म करता है या नहीं.

fun getAngle(firstPoint: PoseLandmark, midPoint: PoseLandmark, lastPoint: PoseLandmark): Double {
        var result = Math.toDegrees(atan2(lastPoint.getPosition().y - midPoint.getPosition().y,
                lastPoint.getPosition().x - midPoint.getPosition().x)
                - atan2(firstPoint.getPosition().y - midPoint.getPosition().y,
                firstPoint.getPosition().x - midPoint.getPosition().x))
        result = Math.abs(result) // Angle should never be negative
        if (result > 180) {
            result = 360.0 - result // Always get the acute representation of the angle
        }
        return result
    }

static double getAngle(PoseLandmark firstPoint, PoseLandmark midPoint, PoseLandmark lastPoint) {
  double result =
        Math.toDegrees(
            atan2(lastPoint.getPosition().y - midPoint.getPosition().y,
                      lastPoint.getPosition().x - midPoint.getPosition().x)
                - atan2(firstPoint.getPosition().y - midPoint.getPosition().y,
                      firstPoint.getPosition().x - midPoint.getPosition().x));
  result = Math.abs(result); // Angle should never be negative
  if (result > 180) {
      result = (360.0 - result); // Always get the acute representation of the angle
  }
  return result;
}

val rightHipAngle = getAngle(
                pose.getPoseLandmark(PoseLandmark.Type.RIGHT_SHOULDER),
                pose.getPoseLandmark(PoseLandmark.Type.RIGHT_HIP),
                pose.getPoseLandmark(PoseLandmark.Type.RIGHT_KNEE))

double rightHipAngle = getAngle(
                pose.getPoseLandmark(PoseLandmark.Type.RIGHT_SHOULDER),
                pose.getPoseLandmark(PoseLandmark.Type.RIGHT_HIP),
                pose.getPoseLandmark(PoseLandmark.Type.RIGHT_KNEE));

func angle(
      firstLandmark: PoseLandmark,
      midLandmark: PoseLandmark,
      lastLandmark: PoseLandmark
  ) -> CGFloat {
      let radians: CGFloat =
          atan2(lastLandmark.position.y - midLandmark.position.y,
                    lastLandmark.position.x - midLandmark.position.x) -
            atan2(firstLandmark.position.y - midLandmark.position.y,
                    firstLandmark.position.x - midLandmark.position.x)
      var degrees = radians * 180.0 / .pi
      degrees = abs(degrees) // Angle should never be negative
      if degrees > 180.0 {
          degrees = 360.0 - degrees // Always get the acute representation of the angle
      }
      return degrees
  }

(CGFloat)angleFromFirstLandmark:(MLKPoseLandmark *)firstLandmark
                      midLandmark:(MLKPoseLandmark *)midLandmark
                     lastLandmark:(MLKPoseLandmark *)lastLandmark {
    CGFloat radians = atan2(lastLandmark.position.y - midLandmark.position.y,
                            lastLandmark.position.x - midLandmark.position.x) -
                      atan2(firstLandmark.position.y - midLandmark.position.y,
                            firstLandmark.position.x - midLandmark.position.x);
    CGFloat degrees = radians * 180.0 / M_PI;
    degrees = fabs(degrees); // Angle should never be negative
    if (degrees > 180.0) {
        degrees = 360.0 - degrees; // Always get the acute representation of the angle
    }
    return degrees;
}

let rightHipAngle = angle(
      firstLandmark: pose.landmark(ofType: .rightShoulder),
      midLandmark: pose.landmark(ofType: .rightHip),
      lastLandmark: pose.landmark(ofType: .rightKnee))

CGFloat rightHipAngle =
    [self angleFromFirstLandmark:[pose landmarkOfType:MLKPoseLandmarkTypeRightShoulder]
                     midLandmark:[pose landmarkOfType:MLKPoseLandmarkTypeRightHip]
                    lastLandmark:[pose landmarkOfType:MLKPoseLandmarkTypeRightKnee]];