Environment friendly Human Posture Estimation

Introduction

Throughout the area of laptop imaginative and prescient, Human Posture Estimation stands as a fascinating area with purposes extending from elevated actuality and gaming to mechanical autonomy and healthcare. This text sheds gentle on the complexities of human posture estimation, its significance, basic advances, and putting purposes.

Posture estimation, an intriguing area inside laptop imaginative and prescient, contains recognizing key focuses on an individual’s physique to get it and analyze their pose. Our goal is to carry this innovation into the area of yoga, allowing us to consequently acknowledge and classify yoga postures from footage.

Studying Goal

• Achieve a deep understanding of human pose estimation rules and their significance in laptop imaginative and prescient.
• Comprehend how human pose estimation expertise enhances yoga observe with personalised steering and real-time suggestions.
• Develop sensible abilities in implementing human pose estimation algorithms for yoga purposes utilizing Python and related libraries.

This text was printed as part of the Information Science Blogathon.

Understanding Human Pose Estimation

Human Pose Estimation is a pc imaginative and prescient activity that includes representing the orientation of an individual graphically. This method, leveraging model-based approaches, identifies and classifies poses of human physique elements and joints in pictures or movies. The important thing lies in capturing a set of coordinates defining joints like wrists, shoulders, and knees, which collectively describe an individual’s pose.

Significance of Human Pose Estimation

The detection of individuals has advanced with machine studying algorithms, enabling computer systems to grasp human physique language by way of pose detection and monitoring. This expertise has turn out to be commercially viable, impacting varied industries corresponding to safety, enterprise intelligence, well being and security, and leisure. Notably, within the period of the coronavirus pandemic, real-time pose detection aids in implementing social distancing measures.

Distinction Between 2D and 3D Human Posture Estimation

Two main strategies exist are 2D Posture Estimation and 3D Posture Estimation. The earlier gauges physique joint areas in 2D area, whereas the final talked about adjustments a 2D image right into a 3D protest by anticipating an additional Z-dimension. 3D pose estimation, although difficult, permits for correct spatial positioning in representations.

Varieties of Human Pose Estimation Fashions

Human Pose Estimation fashions fall into three essential varieties:

• Skeleton-based Mannequin: Represents the skeletal construction, used for each 3D and 2D pose estimation.
• Contour-based Mannequin: Focuses on 2D pose estimation, emphasizing the physique’s look and form.
• Quantity-based Mannequin: Employed for 3D pose estimation, makes use of 3D human physique fashions and poses.

Backside-Up vs. Prime-Down Strategies of Pose Estimation

Strategies for human pose estimation are broadly categorized into two approaches: bottom-up and top-down. Backside-up evaluates every physique joint individually, whereas top-down employs a physique detector first and determines joints inside found bounding containers.

Understanding the workings of human pose estimation includes delving into the essential construction, mannequin structure overview, and varied approaches for pose estimation. The method encompasses absolute pose estimation, relative pose estimation, and their mixture.

A number of open-source libraries facilitate human pose estimation:

• OpenPose: A multi-person system supporting 2D and 3D pose estimation.
• PoseDetection: Constructed on TensorFlow.js, providing real-time pose estimation fashions.
• DensePose: Maps human pixels from 2D RGB pictures to a 3D surface-based mannequin.
• AlphaPose: An actual-time multi-person pose estimation library utilizing a top-down strategy.
• HRNet (Excessive-Decision Internet): Appropriate for high-accuracy key level heatmap prediction.

Enhanced Human Pose Estimation: A Easy and Environment friendly Strategy

Allow us to now start with easy human pose estimation code by following sure steps.

Step 1: Setting the Stage

To kick off our journey, we have to arrange the environment by putting in the required libraries. OpenCV, NumPy, and MediaPipe are important for our undertaking. Execute the next command to put in them:

!pip set up opencv-python mediapipe

We have now introduce MediaPipe on this article, an open-source framework developed by Google for constructing machine studying pipelines centered on laptop imaginative and prescient duties. MediaPipe simplifies the implementation of advanced visible purposes, providing pre-trained fashions for human pose estimation that may be built-in with minimal effort. Its cross-platform functionality ensures constant efficiency on cell gadgets, net purposes, and desktops, whereas its design for real-time processing permits for fast video enter evaluation.

Step 2: Import Needed Library

import math
import cv2
import numpy as np
from time import time
import mediapipe as mp
import matplotlib.pyplot as plt
from IPython.show import HTML

•  `math`: Supplies mathematical features for calculations.
• `cv2`: OpenCV library for laptop imaginative and prescient duties like picture manipulation and processing.
• `numpy as np`: NumPy library for numerical computing with assist for arrays and matrices.
• `time`: Module for working with time, used right here to measure execution time.
• `mediapipe as mp`: MediaPipe framework for constructing notion pipelines for varied media varieties.
• `matplotlib.pyplot as plt`: Matplotlib library for creating plots and visualizations.
• `IPython.show import HTML`: IPython module for displaying HTML content material inside the pocket book.

Step 3: Initialze MediaPipe Package deal

Arrange MediaPipe’s Pose and Drawing utilities for pose detection and visualization.

# Initializing mediapipe pose class.
mp_pose = mp.options.pose

# Establishing the Pose perform.
pose = mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.3, model_complexity=2)

# Initializing mediapipe drawing class, helpful for annotation.
mp_drawing = mp.options.drawing_utils 

• These traces initialize the required parts from the MediaPipe framework for performing pose estimation duties.
• mp_pose = mp.options.pose initializes the MediaPipe Pose class, enabling pose estimation performance.
• pose = mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.3, model_complexity=2) units up the Pose perform with particular parameters, corresponding to static picture mode, minimal detection confidence, and mannequin complexity.
• mp_drawing = mp.options.drawing_utils initializes the MediaPipe drawing utilities class, which gives features for annotating pictures with pose landmarks and connections, facilitating visualization of pose estimation outcomes.

Step 4: Load and Show Picture

Use OpenCV to load a picture and Matplotlib to show it.

sample_img  = cv2.imread('/content material/istockphoto-664637378-612x612.jpg')
plt.determine(figsize = [10,10])
plt.title("sample_Image")
plt.axis('off')
plt.imshow(sample_img[:,:,::-1]);plt.present()

• This code phase masses a pattern picture from a specified file path utilizing the OpenCV library (cv2.imread()).
• It then makes use of Matplotlib to show the loaded picture in a determine with a specified measurement (plt.determine(figsize=[10, 10])), title (plt.title(“Pattern Picture”)), and with out axis ticks (plt.axis(‘off’)).
• The picture is lastly proven utilizing plt.imshow() perform, which takes care of displaying the picture within the specified determine. The [:, :, ::-1] indexing is used to transform the picture from BGR to RGB format, as Matplotlib expects RGB pictures for show.

Step5: Detect and Print Landmarks

Convert the picture to RGB and use MediaPipe to detect pose landmarks. Print the primary two detected landmarks (e.g., NOSE, LEFT_EYE_INNER).

Keypoint_Identification

keypoint_Landmark

# Carry out pose detection after changing the picture into RGB format.
outcomes = pose.course of(cv2.cvtColor(sample_img, cv2.COLOR_BGR2RGB))

# Verify if any landmarks are discovered.
if outcomes.pose_landmarks:
    
    # Iterate two instances as we solely need to show first two landmarks.
    for i in vary(2):
        
        # Show the discovered normalized landmarks.
        print(f'{mp_pose.PoseLandmark(i).title}:n{outcomes.pose_landmarks.landmark[mp_pose.PoseLandmark(i).value]}') 

• This code phase performs pose detection on the pattern picture after changing it into RGB format utilizing OpenCV’s cv2.cvtColor() perform.
• It then checks if any pose landmarks are discovered within the picture utilizing the outcomes.pose_landmarks attribute.
• If landmarks are discovered, it iterates over the primary two landmarks and prints their names and coordinates.
• The landmark title is obtained utilizing mp_pose.PoseLandmark(i).title, and the coordinates are accessed utilizing outcomes.pose_landmarks.landmark[mp_pose.PoseLandmark(i).value].

Output:

NOSE:
x: 0.7144814729690552
y: 0.3049055337905884
z: -0.1483774036169052
visibility: 0.9999918937683105
LEFT_EYE_INNER:
x: 0.7115224599838257
y: 0.2835153341293335
z: -0.13594578206539154
visibility: 0.9999727010726929

Step6: Draw Landmarks on Picture

Create a duplicate of the picture, draw detected landmarks utilizing MediaPipe utilities, and show it.

# Create a duplicate of the pattern picture to attract landmarks on.
img_copy = sample_img.copy()

# Verify if any landmarks are discovered.
if outcomes.pose_landmarks:
    
    # Draw Pose landmarks on the pattern picture.
    mp_drawing.draw_landmarks(picture=img_copy, landmark_list=outcomes.pose_landmarks, connections=mp_pose.POSE_CONNECTIONS)
       
    # Specify a measurement of the determine.
    fig = plt.determine(figsize = [10, 10])

    # Show the output picture with the landmarks drawn, additionally convert BGR to RGB for show. 
    plt.title("Output")
    plt.axis('off')
    plt.imshow(img_copy[:,:,::-1])
    plt.present()

• This code phase creates a duplicate of the pattern picture to protect the unique picture whereas drawing landmarks on a separate picture.
• It checks if any pose landmarks are discovered within the outcomes.
• If landmarks are discovered, it attracts the landmarks on the copied picture utilizing mp_drawing.draw_landmarks().
• The dimensions of the determine for displaying the output picture is specified utilizing plt.determine(figsize=[10, 10]).
• Lastly, it shows the output picture with landmarks drawn utilizing plt.imshow(). The [:,:,::-1] indexing is used to transform the picture from BGR to RGB format for correct show with Matplotlib.

Step 7: 3D Pose Visualization

Use MediaPipe’s plot_landmarks() to visualise the detected landmarks in 3D.

# Plot Pose landmarks in 3D.
mp_drawing.plot_landmarks(outcomes.pose_world_landmarks, mp_pose.POSE_CONNECTIONS)

• This code phase plots the pose landmarks in 3D area utilizing MediaPipe’s plot_landmarks() perform.
• It takes outcomes.pose_world_landmarks as enter, which represents the pose landmarks in world coordinates.
• mp_pose.POSE_CONNECTIONS specifies the connections between completely different landmarks, serving to to visualise the skeletal construction.

Step 8: Customized Pose Detection Operate

For customized pose detection we are going to use detectpose(). This perform performs pose detection, shows outcomes, and optionally returns landmarks.

def detectPose(picture, pose, show=True):
    '''
    This perform performs pose detection on a picture.
    Args:
        picture: The enter picture with a outstanding particular person whose pose landmarks must be detected.
        pose: The pose setup perform required to carry out the pose detection.
        show: A boolean worth that's if set to true the perform shows the unique enter picture, the resultant picture, 
                 and the pose landmarks in 3D plot and returns nothing.
    Returns:
        output_image: The enter picture with the detected pose landmarks drawn.
        landmarks: A listing of detected landmarks transformed into their unique scale.
    '''
    
    # Create a duplicate of the enter picture.
    output_image = picture.copy()
    
    # Convert the picture from BGR into RGB format.
    imageRGB = cv2.cvtColor(picture, cv2.COLOR_BGR2RGB)
    
    # Carry out the Pose Detection.
    outcomes = pose.course of(imageRGB)
    
    # Retrieve the peak and width of the enter picture.
    peak, width, _ = picture.form
    
    # Initialize an inventory to retailer the detected landmarks.
    landmarks = []
    
    # Verify if any landmarks are detected.
    if outcomes.pose_landmarks:
    
        # Draw Pose landmarks on the output picture.
        mp_drawing.draw_landmarks(picture=output_image, landmark_list=outcomes.pose_landmarks,
                                  connections=mp_pose.POSE_CONNECTIONS)
        
        # Iterate over the detected landmarks.
        for landmark in outcomes.pose_landmarks.landmark:
            
            # Append the landmark into the listing.
            landmarks.append((int(landmark.x * width), int(landmark.y * peak),
                                  (landmark.z * width)))
    
    # Verify if the unique enter picture and the resultant picture are specified to be displayed.
    if show:
    
        # Show the unique enter picture and the resultant picture.
        plt.determine(figsize=[22,22])
        plt.subplot(121);plt.imshow(picture[:,:,::-1]);plt.title("Authentic Picture");plt.axis('off');
        plt.subplot(122);plt.imshow(output_image[:,:,::-1]);plt.title("Output Picture");plt.axis('off');
        
        # Additionally Plot the Pose landmarks in 3D.
        mp_drawing.plot_landmarks(outcomes.pose_world_landmarks, mp_pose.POSE_CONNECTIONS)
        
    # In any other case
    else:
        
        # Return the output picture and the discovered landmarks.
        return output_image, landmarks

• This perform detectPose() performs pose detection on an enter picture utilizing MediaPipe’s Pose mannequin.
• It takes three parameters: picture (the enter picture), pose (the pose setup perform), and show (a boolean indicating whether or not to show the outcomes).
• It copies the enter picture to protect the unique and converts the picture from BGR to RGB format, as required by MediaPipe.
• It detects poses on the transformed picture and attracts the detected landmarks on the output picture utilizing mp_drawing.draw_landmarks().
• The perform additionally retrieves the peak and width of the enter picture and initializes an empty listing to retailer the detected landmarks.
• If the show parameter is ready to True, it shows the unique enter picture, the output picture with landmarks drawn, and plots the landmarks in 3D area utilizing mp_drawing.plot_landmarks().
• If show is False, it returns the output picture with landmarks drawn and the detected landmarks listing.

Step 9: Pattern Execution

Run pose detection on a brand new pattern picture utilizing the detectPose() perform.

# Learn one other pattern picture and carry out pose detection on it.
picture = cv2.imread('/content material/HD-wallpaper-yoga-training-gym-pose-woman-yoga-exercises.jpg')
detectPose(picture, pose, show=True)

• This code phase reads one other pattern picture from the required file path.
• It then calls the detectPose() perform to carry out pose detection on the picture utilizing the beforehand initialized pose setup.
• Setting the show parameter to True directs the perform to point out the unique enter picture, the resultant picture with drawn landmarks, and the 3D plot of landmarks.

Step 10: Pose Classification (Non-compulsory)

The subsequent step includes defining a perform to categorise poses like Warrior, Tree, and so on., primarily based on joint angles.

Warrior-Pose, T-Pose, Tree-Pose, Unknown

def classifyPose(landmarks, output_image, show=False):
    '''
    This perform classifies yoga poses relying upon the angles of assorted physique joints.
    Args:
        landmarks: A listing of detected landmarks of the particular person whose pose must be categorized.
        output_image: A picture of the particular person with the detected pose landmarks drawn.
        show: A boolean worth that's if set to true the perform shows the resultant picture with the pose label 
        written on it and returns nothing.
    Returns:
        output_image: The picture with the detected pose landmarks drawn and pose label written.
        label: The categorized pose label of the particular person within the output_image.

    '''
    
    # Initialize the label of the pose. It isn't identified at this stage.
    label="Unknown Pose"

    # Specify the colour (Crimson) with which the label might be written on the picture.
    colour = (0, 0, 255)
    
    # Calculate the required angles.
    #----------------------------------------------------------------------------------------------------------------
    
    # Get the angle between the left shoulder, elbow and wrist factors. 
    left_elbow_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value],
                                      landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value],
                                      landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value])
    
    # Get the angle between the best shoulder, elbow and wrist factors. 
    right_elbow_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value],
                                       landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value],
                                       landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value])   
    
    # Get the angle between the left elbow, shoulder and hip factors. 
    left_shoulder_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value],
                                         landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value],
                                         landmarks[mp_pose.PoseLandmark.LEFT_HIP.value])

    # Get the angle between the best hip, shoulder and elbow factors. 
    right_shoulder_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value],
                                          landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value],
                                          landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value])

    # Get the angle between the left hip, knee and ankle factors. 
    left_knee_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.LEFT_HIP.value],
                                     landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value],
                                     landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value])

    # Get the angle between the best hip, knee and ankle factors 
    right_knee_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value],
                                      landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value],
                                      landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value])
    
    #----------------------------------------------------------------------------------------------------------------
    
    # Verify if it's the warrior II pose or the T pose.
    # As for each of them, each arms needs to be straight and shoulders needs to be on the particular angle.
    #----------------------------------------------------------------------------------------------------------------
    
    # Verify if the each arms are straight.
    if left_elbow_angle > 165 and left_elbow_angle < 195 and right_elbow_angle > 165 and right_elbow_angle < 195:

        # Verify if shoulders are on the required angle.
        if left_shoulder_angle > 80 and left_shoulder_angle < 110 and right_shoulder_angle > 80 and right_shoulder_angle < 110:

    # Verify if it's the warrior II pose.
    #----------------------------------------------------------------------------------------------------------------

            # Verify if one leg is straight.
            if left_knee_angle > 165 and left_knee_angle < 195 or right_knee_angle > 165 and right_knee_angle < 195:

                # Verify if the opposite leg is bended on the required angle.
                if left_knee_angle > 90 and left_knee_angle < 120 or right_knee_angle > 90 and right_knee_angle < 120:

                    # Specify the label of the pose that's Warrior II pose.
                    label="Warrior II Pose" 
                        
    #----------------------------------------------------------------------------------------------------------------
    
    # Verify if it's the T pose.
    #----------------------------------------------------------------------------------------------------------------
    
            # Verify if each legs are straight
            if left_knee_angle > 160 and left_knee_angle < 195 and right_knee_angle > 160 and right_knee_angle < 195:

                # Specify the label of the pose that's tree pose.
                label="T Pose"

    #----------------------------------------------------------------------------------------------------------------
    
    # Verify if it's the tree pose.
    #----------------------------------------------------------------------------------------------------------------
    
    # Verify if one leg is straight
    if left_knee_angle > 165 and left_knee_angle < 195 or right_knee_angle > 165 and right_knee_angle < 195:

        # Verify if the opposite leg is bended on the required angle.
        if left_knee_angle > 315 and left_knee_angle < 335 or right_knee_angle > 25 and right_knee_angle < 45:

            # Specify the label of the pose that's tree pose.
            label="Tree Pose"
                
    #----------------------------------------------------------------------------------------------------------------
    
    # Verify if the pose is assessed efficiently
    if label != 'Unknown Pose':
        
        # Replace the colour (to inexperienced) with which the label might be written on the picture.
        colour = (0,0,255)  
    
    # Write the label on the output picture. 
    cv2.putText(output_image, label, (10, 30),cv2.FONT_HERSHEY_PLAIN, 2, colour, 5)
    
    # Verify if the resultant picture is specified to be displayed.
    if show:
    
        # Show the resultant picture.
        plt.determine(figsize=[10,10])
        plt.imshow(output_image[:,:,::-1]);plt.title("Output Picture");plt.axis('off');
        
    else:
        
        # Return the output picture and the categorized label.
        return output_image, label

# Learn a pattern picture and carry out pose classification on it.
picture = cv2.imread('/content material/amp-1575527028-- triangle pose.jpg')
output_image, landmarks = detectPose(picture, pose, show=False)
if landmarks:
    classifyPose(landmarks, output_image, show=True)

• This code phase reads a pattern picture from the required file path.
• It then calls the detectPose() perform to carry out pose detection on the picture utilizing the beforehand initialized pose setup.
• If the show parameter is False, the perform skips displaying the outcomes.
• If the picture incorporates detected landmarks, the perform calls classifyPose() to categorise the pose primarily based on these landmarks and show the end result.

# Learn a pattern picture and carry out pose classification on it.
picture = cv2.imread('/content material/warrior2.jpg')
output_image, landmarks = detectPose(picture, pose, show=False)
if landmarks:
    classifyPose(landmarks, output_image, show=True)

• This code phase reads a pattern picture from the required file path.
• It then calls the detectPose() perform to carry out pose detection on the picture utilizing the beforehand initialized pose setup.
• The show parameter is ready to False, indicating that the perform shouldn’t show the outcomes.
• If landmarks are detected within the picture, it calls the classifyPose() perform to categorise the pose primarily based on the detected landmarks and show the end result.

Purposes of Human Pose Estimation

Human pose estimation finds purposes in numerous domains:

Health and Wellness Trade

• Customized Steering: Pose detection purposes information customers by way of yoga classes, providing real-time suggestions on their pose alignment.
• Progress Monitoring: Methods monitor customers’ progress, suggesting modifications or developments tailor-made to particular person talent ranges.

Trade-Stage Purposes

• Company Wellness Applications: Firms can combine yoga pose detection, enhancing worker well being by way of wellness applications and stress discount.

Healthcare

• Posture Correction: Pose detection aids in correcting posture throughout rehabilitation workout routines, making certain appropriate motion execution.
• Distant Monitoring: Healthcare professionals remotely monitor sufferers’ yoga classes, providing digital help and adjusting routines as wanted.

Sports activities Coaching

• Flexibility and Energy Coaching: Pose detection in sports activities coaching applications profit athletes requiring flexibility and power, boosting general efficiency.

Training

• Interactive Studying: Pose detection enhances the interactive and accessible studying of yoga for college students in instructional establishments.
• Talent Evaluation: Lecturers assess college students’ yoga abilities utilizing expertise, providing focused steering for enchancment.

Leisure and Gaming

• Immersive Experiences: VR or AR purposes create immersive yoga experiences with digital instructors guiding customers by way of poses.
• Interactive Gaming: Pose detection in health video games makes train gratifying and motivating for customers.

Ergonomics in Trade

• Desk Yoga Classes: Integrating pose detection into office wellness applications affords brief yoga classes, bettering posture and lowering stress for workers.
• Ergonomic Assessments: Employers use pose detection to evaluate ergonomic points of workstations, selling higher well being amongst workers.

Consumer Advantages

• Right Type: Quick suggestions on the shape reduces the danger of accidents, making certain customers acquire most advantages from yoga practices.
• Comfort: Customers can observe yoga at their comfort, guided by digital instructors or purposes, eliminating the necessity for bodily courses.
• Motivation: Actual-time progress monitoring and suggestions inspire for customers to remain according to their yoga routines.

Conclusion

The mixing of human pose detection with yoga poses transcends numerous sectors, revolutionizing wellness and health. From personalised steering and progress monitoring within the health trade to enhancing rehabilitation and bodily remedy in healthcare, this expertise affords a flexible vary of purposes. In sports activities coaching, it contributes to athletes’ flexibility and power, whereas in schooling, it brings interactive and assessable yoga studying experiences.

The office advantages from desk yoga classes and ergonomic assessments, selling worker well-being. Customers, guided by digital instructors, take pleasure in appropriate kind suggestions, comfort, and motivation, fostering a more healthy and extra environment friendly strategy to yoga practices. This transformative mixture of antiquated practices with cutting-edge innovation clears the best way for an all-encompassing well-being insurgency.

Key Takeaways

• Human Posture Estimation, a area inside laptop imaginative and prescient, contains recognizing key focuses on an individual’s physique to get it and analyze their pose.
• Human posture estimation has assorted purposes, extending from wellness and wellness to healthcare, sports activities preparation, instruction, amusement, and dealing surroundings ergonomics.
• Consolidating posture discovery innovation into Yoga Hone affords shoppers personalised path, real-time enter, superior following, consolation, and inspiration, driving them to maneuver ahead with well-being and more adept exercises.
• The mixing of human pose detection with yoga observe represents a major development in wellness expertise, paving the best way for a complete well-being revolution.

Incessantly Requested Questions

The media proven on this article will not be owned by Analytics Vidhya and is used on the Writer’s discretion.

Whats up there! I am Soumyadarshan Sprint, a passionate and enthusiastic particular person in the case of knowledge science and machine studying. I am continuously exploring new subjects and methods on this area, all the time striving to develop my information and abilities. Actually, upskilling myself is not only a pastime, however a lifestyle for me.