Anthropomorphic Grasping of Complex-Shaped Objects Using Imitation Learning

Abstract

This paper presents an autonomous grasping approach for complex-shaped objects using an anthropomorphic robotic hand. Although human-like robotic hands have a number of distinctive advantages, most of the current autonomous robotic pickup systems still use relatively simple gripper setups such as a two-finger gripper or even a suction gripper. The main difficulty of utilizing human-like robotic hands lies in the sheer complexity of the system; it is inherently tough to plan and control the motions of the high degree of freedom (DOF) system. Although data-driven approaches have been successfully used for motion planning of various robotic systems recently, it is hard to directly apply them to high-DOF systems due to the difficulty of acquiring training data. In this paper, we propose a novel approach for grasping complex-shaped objects using a high-DOF robotic manipulation system consisting of a seven-DOF manipulator and a four-fingered robotic hand with 16 DOFs. Human demonstration data are first acquired using a virtual reality controller with 6D pose tracking and individual capacitive finger sensors. Then, the 3D shape of the manipulation target object is reconstructed from multiple depth images recorded using the wrist-mounted RGBD camera. The grasping pose for the object is estimated using a residual neural network (ResNet), K-means clustering (KNN), and a point-set registration algorithm. Then, the manipulator moves to the grasping pose following the trajectory created by dynamic movement primitives (DMPs). Finally, the robot performs one of the object-specific grasping motions learned from human demonstration. The suggested system is evaluated by an official tester using five objects with promising results.

1. Introduction

Although robotic manipulators have been widely used for decades, their roles have been mostly limited to repetitive tasks in industrial environments due to safety reasons. However, with the widespread adoption of cooperative robots that can safely work in human environments, and the growing demand for small-quantity batch productions, we now see an increasing number of smart, flexible robotic manipulation systems used for many different tasks [1,2,3]. Furthermore, with recent advances in machine learning algorithms, with the help of low-cost, high-resolution depth sensors, now many robotic manipulation systems can perceive environments and manipulate objects utilizing sensory information to intelligently handle complex nonrepetitive tasks, such as bin picking [4,5].

In addition to perception, there have been approaches to utilize machine learning to optimize the motions of complex, high-DOF robotic systems. However, as it is often not practical to prepare a large amount of training data using physical robotic systems, they require highly data-efficient machine learning algorithms. One such approach is imitation learning, which uses a small number of demonstration data from human experts to quickly learn the desirable motion policy for the given tasks [6,7,8,9,10,11,12]. Although human-like robotic hands have distinctive advantages in robotic manipulation over simple robotic grippers, such as a large number of grasp types [13] and in-hand manipulation capability [14], there have been few previous works that use anthropomorphic robotic hand for autonomous robotic manipulation due to difficulties coming from the high number of DOFs of the system.

This work presents a robotic platform that autonomously perceives and grasps complex-shaped objects using an anthropomorphic robotic hand. Unlike most of the previous approaches that utilize imitation learning for robotic manipulation, our approach learns how to utilize a high-DOF human-like robotic hand for manipulation using a number of machine learning approaches, which includes ResNet [15], KNN [16], point-set registration [17,18], and dynamical movement primitives (DMPs) [19]. As the direct teaching method cannot be used for such a high-DOF system, we use a VR controller with full finger tracking to acquire each finger motion data as well as the 6D trajectory of the hand. The suggested system can learn the grasp pose, hand trajectory, and finger motions for grasping complex-shaped objects from a limited number of demonstrations and is capable of reliably grasping such objects with arbitrary, previously unknown orientations.

The remainder of the paper proceeds as follows. Section 3 introduces the hardware configuration used for the work, which is shown in Figure 1. Section 4 describes the overall workflow of perception, pose and class estimation, motion planning, and grasping an object. Section 5 presents how the training data are collected, which consists of 3D point clouds, 6D hand trajectory data, and RGB images of the objects. Section 6 explains how the platform estimates the grasping pose for the manipulation object utilizing the learning data collected in Section 5. Section 7 shows the hand trajectory generation process given the grasping pose. Finally, Section 8 presents the experimental results to validate the system’s performance done by an official tester. Finally, we conclude the future direction of this work in Section 9.

2. Related Work

Imitation Learning approaches can use a variety of primary machine learning algorithms, which are systemically surveyed in [6].

In [7], the authors developed a robotic system that played table tennis with a human opponent utilizing a mixture of motor primitives (MoMP). The system used a Barett 7DOF WAM robotic arm attached to a table tennis racket. It learned the ball-hitting motions from human demonstrations, which was provided by the direct teaching method of physically moving the robotic arm. In [8], the authors also developed a similar table tennis playing robotic system using imitation learning, but utilizing different algorithms, a hidden Markov model (HMM) [20] and Gaussian mixture regression (GMR) [21]. Compared to this work, both systems used a manipulator without any gripper, and the demonstration data were acquired by the direct teaching method.

On the other hand, a number of recent imitation learning approaches use deep neural network (DNN) algorithms as the primary technique for imitation learning [9,10]. A 3D convolutional neural network (CNN) [22] is used in [9], where the authors used an imitation learning algorithm to teach a robot to grasp a deformable fish. In that work, the human expert used a six-DOF virtual reality (VR) controller to move the manipulator in a simulation environment using the Unity game engine. The human grasping pose and the point cloud of the manipulation object were logged as the training data. In [10], the authors used a DNN-based algorithm to teach a dual-arm robot to perform various manipulation tasks with objects on a table. The proposed system also used VR controllers to provide grasping poses from a human expert. Compared to our work, these approaches used simple one-DOF grippers and only learned the final grasping poses instead of the full grasping trajectories.

There have been imitation-learning-based robotic manipulation systems that use high-DOF, human-like hands [11,12]. In [11], the authors presented a robotic system that learned to catch flying objects using human demonstrations of grasping and pose estimation algorithm based on the Gaussian mixture model (GMM) [23]. In [12], the authors presented a method for learning hierarchical manipulation skills using a state-based transitions autoregressive hidden Markov model (STARHMM) [24]. The system successfully taught a dual-armed robot with human-like hands to perform a bimanual grasping of a box. However, neither system used human-like robotic hands for fine manipulations, such as grasping complex-shaped objects, which is the main focus of our work.

3. Hardware Configuration

Figure 1 shows the hardware setup used for this work, which consisted of a 7-DOF manipulator arm and a 16-DOF human-like hand. The system had a total number of DOFs of 23 and could replicate complex human manipulation behaviors. In addition to the manipulator setup, a lightweight RealSense RGBD camera was mounted on the back of the hand to perceive the manipulation objects from multiple viewpoints.

3.1. Manipulator Arm

We used a commercial Franka Emika Panda 7-DOF manipulator for this work, as the redundant DOF provides a much larger dexterous workspace compared to 6-DOF ones [25,26,27], which we found to be crucial for grasping objects in arbitrary orientation [28,29]. In addition, the manipulator’s electrically adjustable compliance greatly helped prevent possible damage to the delicate robotic hand.

3.2. Robot Hand

We used the commercial Allegro robotic hand, which has four fingers with 4 DOFs each. The hand consists of multiple smart servomotors that directly actuate the joints and spherical rubber fingertips shown in Figure 2b that are used for precise grasps. We chose the Allegro robotic hand as it was many times more affordable compared to other commercial human-like robotic hands such as Shadow Dexterous Hand [14] or SCHUNK SVH hand [30], and was easily serviceable due to its modular construction. As we wanted the robotic hand to perform delicate manipulation motions such as putting fingers through object holes for grasping, we made a slimmer, low-friction fingertip as shown in Figure 2c to prevent unwanted contact during the manipulation.

3.3. RGBD Camera

As shown in Figure 3b, we mounted an RGBD camera on the back of the hand to perceive the manipulation object from multiple viewpoints. Among the commercially available lightweight RGBD cameras, we chose the RealSense SR305 model as it was lightweight, had a very short minimum sensing distance of 20cm, and had much better depth accuracy compared to stereo-vision-based RGBD cameras according to our test. Figure 4 shows the comparison of the depth data from three different RGBD cameras, where the SR305 model showed distinctively better depth accuracy over others.

4. System Overview

Figure 5 shows the overall system architecture. When the system starts up, the manipulator moves through three capture positions so that the system can get the depth images of the object from three different viewpoints. These images are then converted to 3D point clouds and merged into a single 3D model using a 3D reconstruction algorithm [31,32] described in Section 5. After creating a 3D model, the manipulator captures the RGB image of the manipulation object to determine its object class using ResNet. Candidate data are obtained by selecting the 3D data having a corresponding object class value with the current object class. From these data, the optimal grasping pose is obtained by comparing the 3D model of candidate data and the current model using the KNN and point-set registration, which is described in more detail in Section 6.

After obtaining the grasping pose, the hand trajectory to reach the grasping pose is generated. DMPs, an imitation learning algorithm, are used for this task. It derives the grasping trajectory of the manipulator and robot hand from the movements performed by an operator. The moving data are collected by controlling a manipulator using a VR controller in a simulated environment, and specific DMP weights are generated for each manipulation object. The object class information of the current manipulation object, provided by ResNet, is used to generate the correct weight for the trajectory generation process. Then, the platform moves the manipulator according to the planned trajectory to reach the grasping pose.

5. Collecting Data for Imitation Learning

To estimate the grasping pose and plan the hand trajectory to grasp an object, the system uses three types of data: the 3D point cloud of the manipulation object, the RGB image of the manipulation object, and the hand trajectory data from human demonstration.

5.1. Three-Dimensional Data

As we can see in Figure 5, at the beginning of the process, the platform first captures depth images of the manipulation object from three different viewpoints, and these images are converted to point clouds. By transforming these point clouds according to the captured pose and merging the transformed data into a single point cloud, we can make a 3D model of the object. However, we cannot directly use the result of this process as it may contain points from backgrounds.

In order to remove the background points behind the object, we use the following filtering process. We first capture the depth image of the objects in the up pose, where the camera faces downwards, and first remove the points with z-coordinate lower than the preset threshold. Then, we calculate the minimum and maximum $x,y$ values of the remaining points, which are used to filter out points when the system captures the depth image of the objects sideways. Although this method can remove most of the background points, it is hard to remove the point cloud of the tripod stand the object is placed upon. To solve this problem, as shown in Figure 6, we wrapped the tripod stand with black tape so that it was not detected by the IR-based RealSense sensor.

The 3D data acquisition algorithm is summarized in Algorithm 1, where $T_{up}$, $T_{left}$, and $T_{right}$ are defined as a transform matrix [33] for the up pose, left pose, and right pose, respectively. The output of the above algorithm is shown in Figure 7. After creating a 3D model with this algorithm, it is labeled with the object name, trajectory data, and grasping pose. The following section explains this task.

Algorithm 1 Three-Dimensional Reconstruction Algorithm

1: $capturing\_pose$←$up$  2: while  $capturing$$object$do  3:     $point\_cloud$←$convToPointCloud(depth\_image)$  4:     $point\_cloud$←$removeUnderStand(point\_cloud)$  5:     if $capturing\_pose$ is $up$ then  6:         $3d\_model.setEmpty\left(\right)$  7:         $transform\_mat$←$T_{up}$  8:         $max\_x,max\_y,min\_x,min\_y$←$setXYCond(point\_cloud)$  9:         $xy\_cond$←$[max\_x,max\_y,min\_x,min\_y]$ 10:         $capturing\_pose$←$left$ 11:     else if $capturing\_pose$ is $left$ then 12:         $transform\_mat$←$T_{left}$ 13:         $capturing\_pose$←$right$ 14:     else if $capturing\_pose$ is $right$ then 15:         $transform\_mat$←$T_{right}$ 16:     end if 17:     $point\_cloud$←$filtering(point\_cloud,xy\_cond)$ 18:     $point\_cloud$←$transform(transform\_mat,$$point\_cloud)$ 19:     $3d\_model.append(point\_cloud)$ 20:     if $capturing\_pose$ is $right$ then 21:         $break$ 22:     end if 23: end while

5.2. Trajectory Data

The trajectory data were collected by controlling the platform manually using a VR controller [34]. In this task, Valve’s Index Knuckles VR controller was used to control the platform. As this controller can track the precise 6D pose of the hand, as well as the positions of individual fingers using noncontact sensors, the controller can be used to naturally control both the robotic arm and a human-like robotic hand at the same time.

In controlling the platform with the VR controller, we interconnected SteamVR software with the OpenVR API to read the controller pose. As the base stations decide its pose, we connected its initial pose with the robot hand pose in the up pose and used the relative pose, based on the initial pose, in controlling the manipulator.

Starting from the up pose, we controlled the platform to grasp the captured object properly. In this process, trajectory data were collected by saving all joint angles of the manipulator and the robot hand whenever their states changed. With this method, we could get the trajectory data of the manipulator and robot hand from the up pose to the grasping pose. When the robot hand grasped the captured object, the trajectory, grasping pose, and object’s name were labeled in the 3D model.

We implemented direct teleoperation of both the manipulator and hand using the VR controller, as shown in Figure 8a. Although we could use this setup for training data acquisition, we used the simulation environment shown in Figure 8b extensively to speed up the training process while preventing possible hardware damage.

5.3. RGB Data

Since we recognized an object in a static environment, there was no need to consider changes in the object’s position or the environment. For this reason, we captured RGB data only in the up pose, changing an object’s orientation with a tripod stand. However, some objects should be grasped differently depending on whether the grasping pose is on the left side or right side. For example, when the handle of the brush was on the left, we labeled the image as brush-left, and when the handle was on the right, we labeled the image as brush-right. Figure 9 shows objects which should be labeled differently according to their direction, and Figure 10 shows different grasping strategies based on the object orientation.

6. Grasping Pose Prediction

Before grasping an object, we need to predict the grasping pose on the 3D model. Predicting the grasping pose proceeded in three steps: candidate data selection, transform matrix creation, and grasping pose prediction. As we can see in the process, this task was implemented by matching the current 3D model with candidate data using the following techniques: ResNet, KNN, and point-set registration. This section describes how these techniques were applied in each step.

6.1. Candidate Data Selection

In predicting the grasping pose, selecting candidate data is the first step to match them with the current 3D model. To choose candidate data from the 3D data, the manipulator captured the RGB image in the up pose and recognized its name with ResNet. Selecting candidate data was executed by matching the recognized name with the object information labeled in 3D data. If the information had the same object name as the recognized name, these data were selected as candidate data, and the selected data were used to get the transform matrix.

6.2. Transformation Matrix Creation

Although we can derive spatial transformation matrices between the current model and candidate models by matching them directly, this method has a high failure rate because of the partial difference, indicated in Figure 11. To solve this problem, we matched the current and candidate models’ divided clusters instead of matching the models themselves. The KNN was used for dividing the models. After dividing, as shown in Figure 12, we derived transformation matrices by matching clusters of the current model and candidate models using a point-set registration, and match rates between them by transforming the current model with the matrices and comparing it with the candidate model. Out of these matrices, the matrix with the best match rate was a transformation matrix. By matching divided clusters, they were analyzed several times with various parts. For example, when an object had one candidate data, the matching was done 25 times for different parts. As a result, matching failures were likely to be corrected in the process of matching, which could prevent failures caused by partial differences. To determine the optimal K value for the KNN, we performed several tests with varying K values and used a K-value of 5 that showed the lowest failure rate.

6.3. Grasping Pose Prediction

We needed to select the appropriate one to use for predicting the grasping pose from the candidate data. When selecting the appropriate data, we chose one that had a minimum error rate derived in Section 6.2. After finding the appropriate data, the object’s grasping pose was predicted using the labeled grasping pose and transform matrix. As we can see in Algorithm 2, the predicted grasping pose was derived by transforming the labeled grasping pose with a selected matrix. Figure 13 shows the result of Algorithm 2.

Algorithm 2 Predict_grasping_pose(rgb_image, 3d_data)

1: $object\_class$←$ResNet(rgb\_image)$                ▹ candidate data selection  2: $candidate\_data$←$findPointCloudData(object\_class)$  3: $clusters$←$KNN(3d\_data)$                        ▹ transform matrix creation  4: $transform\_matrices$←$\left[\right]$  5: $sync\_rates$←$\left[\right]$  6: $trajectories$←$\left[\right]$  7: fori←$0;$$i<candidate\_data.length$do  8:     $clusters$←$KNN(candidate\_data[i].3d\_data)$  9:     for j←$0;$$j<clusters.length$ do 10:         for k←$0;$$k<clusters.length$ do 11:            T←$PointSetRegisration\left(clusters\right[j],clusters[k\left]\right)$ 12:            $transformed\_data$←$transform(3d\_data,T)$ 13:            $error\_rate$←$getSyncRate(transformed\_data,candidate\_data[i\left]\right)$ 14:            $transform\_matrices.append\left(T\right)$ 15:            $error\_rates.append(error\_rate)$ 16:            $trajectories.append(candidate\_data[i].grasping\_trajectory)$ 17:         end for 18:     end for 19: end for 20: $index$←$getMinElementIndex(error\_rates)$          ▹ grasping pose prediction 21: $grasping\_trajectory$←$trajectories\left[index\right]$ 22: $grasping\_point$←$FK(grasping\_trajectory[last].state)$ 23: $selected\_matrix$←$transform\_matrix\_list\left[index\right]$ 24: $predicted\_grasping\_point$←$transform(grasping\_point,selected\_matrix)$

7. Manipulation

Although we discovered the grasping pose in Section 6, grasping an object would fail if the manipulator was controlled by the wrong trajectory. The platform’s grasping trajectory can be derived from the simulation’s trajectory data collected with the VR controller. DMPs, the imitation learning algorithm, were used in this process. As the trajectory data from the up pose to a grasping pose were presented in joint space, we could obtain the positions, orientations, and hand motions data when grasping an object. From these data, the positions were used as learning data to get the weights of DMPs and to derive the position trajectory of the manipulator.

7.1. Extraction

As we can see in Algorithm 2, we have trajectory data included in candidate data when we predicted the grasping pose. As the manipulator’s states in the trajectory were presented in joint space, they could be transformed into a list of homogeneous matrices using FK [33,35,36], and we could get the positions and orientations of the end effector from them. The manipulator’s state data were used after transformation, but the robot hand’s state data were used without any transformation.

7.2. Position Trajectory

For planning the trajectory of the end effector’s position, we used the Pydmp, an open-source package that makes DMPs easy to use. In the source code of this package, the methodology is described as follows.

$$\tau \dot{\mathit{V}}=K({\mathit{X}}_g-\mathit{X})-D\mathit{V}+({\mathit{X}}_g-{\mathit{X}}_0)f$$

(1)

$$\tau \dot{\mathit{X}}=\dot{\mathit{V}}$$

(2)

where vectors $\mathit{V},\mathit{X},{\mathit{X}}_g,$ and ${\mathit{X}}_0$ indicate the current velocity, current position, goal position, and initial position, and constants $\tau ,K,$ and D indicate the timescale, spring, and damping terms. Function f indicates the forcing function that determines the nonlinear behavior learned from trajectory data, and it is defined as follows:

$$f\left(s\right)=\frac{{\sum }_{i=1}^L{\mathsf{\omega }}_i{\mathsf{\psi }}_i\left(s\right)s}{{\sum }_{i=1}^L{\mathsf{\psi }}_i\left(s\right)}$$

(3)

where ${\mathsf{\psi }}_i\left(s\right)=exp(-h_i{(s-c_i)}^2)$ is a Gaussian basis function, with center $c_i$ and width $h_i$, and ${\mathsf{\omega }}_i$ are adjustable weights. Parameter L represents the number of Gaussian basis functions. The function f does not directly depend on time. Instead, it depends on a phase variable s, which monotonically changes from 1 towards 0 during a movement and is obtained by the equation

$$\tau \dot{s}=-\mathsf{\alpha }s,$$

(4)

where $\mathsf{\alpha }$ is a predefined constant. Using these equations, $f_{target}\left(s\right)$ is computed as follows.

$$f_{target}\left(s\right)=\frac{-K({\mathit{X}}_g-\mathit{X})+D\mathit{V}+\tau \dot{\mathit{V}}}{{\mathit{X}}_g-{\mathit{X}}_0}$$

(5)

Thus, finding the weights ${\mathsf{\omega }}_i$ that minimize the error criterion $J={\sum }_s{(f_{target}\left(s\right)-f\left(s\right))}^2$ is a linear regression problem, which can be solved efficiently.

7.3. Orientation and Hand Shape Trajectory

In planning the trajectory of the orientation and shape of the robot hand, similar to planning the positions, learning the trajectory using DMPs seemed to be the intuitively right way. However, when these data were learned with DMPs, the results showed poor performance. For this reason, we used another strategy in this work.

Before moving the position, the robot hand adjusted its orientation identically to the grasping pose. While adjusting the orientation, the robot hand shifted the hand shape to a grasping-ready pose, stored in the first element in the hand motion trajectory. The orientation and hand motion were not changed while moving the position, but there was no problem grasping an object. When the robot hand arrived at the grasping pose, it changed its pose to the grasping pose. After grasping an object, the robot hand bent all its joints to prevent slipping.

8. Experiment

8.1. Simulation Results

Before performing the test in the real world, we used the Webots [37] open-source robotic simulator to validate its accuracy and safety. As shown in Figure 14, the simulated model was a simplified version of the actual robot with the same specifications as the real platform. In the simulation environment, we used ten objects that we can see in Figure 15: a screwdriver, a cup, a carafe, a telephone, a valve, a hammer, a wrench, a skillet, scissors, and a lamp. For each object, ten trials were performed, where the orientation of the object was randomly determined for each trial. We automatically scored the trial result by checking the pose of the objects, and we considered the trial a success if the robot could hold the object for more than 10 s as Figure 16.

Table 1. Simulation results.

Object	Trial Num	Success Num	Failure Num	Success Rate	Failure Rate
Screwdriver	10	10	0	100%	0%
Cup	10	9	1	90%	10%
Carafe	10	10	0	100%	0%
Telephone	10	10	0	100%	0%
Valve	10	10	0	100%	0%
Hammer	10	10	0	100%	0%
Wrench	10	10	0	100%	0%
Skillet	10	10	0	100%	0%
Scissors	10	8	2	80%	20%
Lamp	10	10	0	100%	0%
Average	10	9.7	0.3	97%	3%

shows the result of the experiment, where the suggested algorithm autonomously picked up the 10 test objects with an average success rate of 97%.

8.2. Experimental Results

8.2.1. Official Test

The suggested system was validated through an accredited certification evaluation conducted by KTR (Korea Testing and Research Institute). The test was performed with five complex-shaped tools that we can see in Figure 17: scissors, spray bottle, brush, cup, and clamp.

8.2.2. Success Conditions

To formally clarify the success or failure of object grasping, we defined success conditions in the test as follows. Firstly, when grasping scissors, the thumb should pass through one side of the handle, and the index and middle fingers should pass through the other. In holding a brush, the robot hand’s thumb should touch one side of the handle, and the other fingers should wrap the other side simultaneously. In the case of a cup, the index and middle fingers should pass through the front of the handle. In addition, the thumb should contact these fingers at the back of the handle. Grasping a clamp is similar to grasping a brush. The thumb should touch one side of the handle, and the other fingers wrap the other side simultaneously. However, in the case of the brush, the thumb should be in the orange area of the clamp handle. Finally, a spray bottle should be gripped with the thumb on the back and the other fingers on the front. In addition, the index finger should be positioned on the trigger. Unlike other objects, the spray bottle cannot be grasped on the left side.

8.2.3. Results

Table 2. Experiment results.

Object	Trial Num	Success Num	Failure Num	Success Rate	Failure Rate
Scissors	10	8	2	80%	20%
Spray bottle	10	9	1	90%	10%
Clamp	10	9	1	90%	10%
Cup	10	8	2	80%	20%
Brush	10	9	1	90%	10%
Average	10	8.6	1.4	86%	14%

shows the result of the experiment performed in an accredited certification evaluation. Each of these objects was tested ten times by changing its orientation. The average success rate was 86%, and the success rates for all objects were more than 80%.

8.3. Discussions

Experimental results from the official test proved that the suggested robotic framework could perceive and grasp complex-shaped objects using an anthropomorphic robot hand with high accuracy. Compared to other studies that conducted similar work either using a low-DOF hand with soft fingers [38] or only in a simulated environment [39], our work had the main distinction of fully utilizing a high-DOF human-like robotic hand for delicate manipulation in reality, while having a comparable success rate as others. Although the motion generation itself took a very short time, less than 1 s, at the stage of writing this paper, we were using a very conservative and slow arm motion that made the whole process from data acquisition to grasping rather long, around 40 s. in future work, we plan to optimize the motion generation and control module and use inverse reinforcement learning [40,41,42,43,44,45] to find a better trajectory from default pose to grasping than human experts suggested.

9. Conclusions

This work presented a robotic system that grasped objects in various orientations using an imitation learning algorithm composed of a 3D reconstruction, ResNet, KNN, a point-set registration, and DMPs. We presented a novel, imitation learning based autonomous robotic grasping system that fully utilized a high-DOF human-like robotic hand for delicate manipulation using several machine learning approaches. Furthermore, its reliability was demonstrated by an official certification evaluation. As this research was limited to imitating grasping the object, future work will include a system that learns how to handle objects through inverse reinforcement learning using tactile data from a robot hand equipped with tactile sensors [46,47,48]. In addition, we plan to adopt inverse reinforcement learning based approaches [49] to optimize the motion-planning part of the system.