Robot control based on real-time environment digital twin reconstruction

Abstract

The present disclosure provides a computer-implemented method, the method comprises: receiving, from a camera, a real-time image data stream including a first two-dimensional image and a second two-dimensional image, wherein each of the first and second two-dimensional images includes a robot arm and at least one object; segmenting, by a trained neural network model, the first two-dimensional image to identify the robot arm and the at least one object, and obtain a first three-dimensional mask array representing positions of the robot arm and at least one object in the first two-dimensional image; generating a rendered robot arm image having a virtual robot arm pose that estimates a real robot arm pose in the first two-dimensional image and a rendered object image having a virtual object pose that estimates a real object pose in the first two-dimensional image, based on the first three-dimensional mask array, a robot arm digital model, an object digital model, and intrinsic parameters of the camera; and updating the virtual robot arm pose and the virtual object pose in real time by a second three-dimensional mask array segmented from the second two-dimensional image.

Description

ROBOT CONTROL BASED ON REAL-TIME ENVIRONMENT DIGITAL TWIN RECONSTRUCTIONFIELD OF THE INVENTION

[0001] The present disclosure generally relates to robotic technology, and more specifically, to a method and system for real-time robot control.BACKGROUND

[0002] Digital twin is a broad term for the scientific and industrial field where a virtual digital model of an intended or an actual real-world physical product, system, or process which serves as a practically indistinguishable virtual counterpart of the object for different practical purposes, such as control, simulation, integration, testing, monitoring, and maintenance. The digital twin technology has been widely used for designing robot pose layout and control programming sequences, especially in the field of high-value-product industry such as automotive vehicle, solar panel, lithium-ion battery, or semiconductor chip manufacturing. One of the most prominent software used in this field is the Process Simulate software from Siemens, which is used to plan, simulate, and validate human tasks, robotic processes, and automation during the entire product development lifecycle from concept, engineering and commissioning to production and continuous development. There are several other kinds of software in this category, which basically deals with manufacturing line design for extremely high-precision manufacturing, often with factory tolerances within 0.1 mm for specific robotic tasks (such as for those in the auto industry) . The software is specifically used as virtual design and validation software, and then the successful manufacturing line designs are subsequently replicated physically into actual manufacturing lines (from digital twin into physical twin) . There is no reconstruction of the digital twin based on real-time physical twin environment data to re-adjust the programming or control of the robot. Such prior art works best when there is a very high degree of control in the physical environment (minimize potential environmental noise) which makes sure that the physical environment always follows the intended digital twin design.

[0003] Accordingly, there is a need for providing a robust system for construction of the digital twin based on real-time physical twin environment data and for the real-time robot control based on the constructed digital twin.SUMMARY OF THE INVENTION

[0004] In one embodiment, the present disclosure provides a computer-implemented method, the method comprises: receiving, from a camera, a real-time image data stream including a first two-dimensional image and a second two-dimensional image, wherein each of the first and second two-dimensional images includes a robot arm and at least one object; segmenting, by a trained neural network model, the first two-dimensional image to identify the robot arm and the at least one object, and obtain a first three-dimensional mask array representing positions of the robot arm and at least one object in the first two-dimensional image; generating a rendered robot arm image having a virtual robot arm pose that estimates a real robot arm pose in the first two-dimensional image and a rendered object image having a virtual object pose that estimates a real object pose in the first two-dimensional image, based on the first three-dimensional mask array, a robot arm digital model, an object digital model, and intrinsic parameters of the camera; and updating the virtual robot arm pose and the virtual object pose in real time by a second three-dimensional mask array segmented from the second two-dimensional image.

[0005] In one aspect, the first two-dimensional image is a depth image, and the step of segmenting further comprising refining a boundary of the robot arm and the object in the first three-dimensional mask array based on depth information of the depth image.

[0006] In one aspect, wherein the first three-dimensional mask array includes time data and velocity data of the first three-dimensional mask array with respect to the real-time image data stream.

[0007] In one aspect, the step of segmenting comprises: comparing the first three-dimensional mask array with a previous second three-dimensional mask array to determine a difference in a pixel level between the first three-dimensional mask array and the previous three-dimensional mask array; and selecting or re-arranging indices of the robot arm and the object in the first three-dimensional mask array based on the difference in the pixel level between the first three-dimensional mask array and the previous three-dimensional mask array.

[0008] In one aspect, the second three-dimensional mask array is stored in a mask buffer, and the real-time image data stream includes a third two-dimensional image and at least one of the robot arm and the object is not identified in the third two-dimensional image; the method further comprises: updating the virtual robot arm pose and the virtual object pose in real time based the second three-dimensional mask array stored in the mask buffer and direction data and speed data of the robot arm and the object in the second three-dimensional mask array.

[0009] In one aspect, the step of generating comprising: defining a loss function evaluating a difference between the object in the first two-dimensional image and the rendered object image; and correcting the virtual object pose of the rendered object image by minimizing the loss function.

[0010] In one aspect, the step of generating further comprises: when the difference between the object in the first two-dimensional image and the rendered object image is greater than a threshold, utilizing a first smoothing edge having a first range for generating the rendered object image; and when the difference between the object in the first two-dimensional image and the rendered object image is less than the threshold, utilizing a second smoothing edge having a second range for generating the rendered object image, wherein the first range is greater than the second range.

[0011] In one aspect, the step of generating further comprises: generating a plurality of duplicates for the rendered object image, wherein the plurality of duplicates offset from the rendered object image by different rotation angles; determining a plurality of local loss minimum based on the difference between the object in the first two-dimensional image and the plurality of duplicates; determining a global loss minimum based on the plurality of local loss minimum; and utilizing a pose with the global loss minimum as the virtual object pose for the rendered object image.

[0012] In one aspect, the number of the plurality of duplicates and an offset angle of each of the plurality of duplicates are determined based on the symmetry of the object.

[0013] In one aspect, the computer-implemented method further comprises: controlling, by a reinforcement learning (RL) algorithm, a motion of the robot arm with respect to the object based on the rendered robot arm image and the rendered object image.

[0014] In one aspect, the robot arm having at least two components and at least one joint, and the motion of the robot arm with respect to the object is controlled further based on forward kinematics of the robot arm.

[0015] In one aspect, the robot arm having at least two components and at least one joint, and the rendered arm image further estimates an angle and a velocity of the at least one joint.

[0016] In one aspect, the computer-implemented method further comprises: receiving, from a pressure senor positioned on a surface of the robot arm, a pressure signal to generate a contact point map; and wherein the motion of the robot arm with respect to the object is controlled further based on the contact point map.

[0017] In one aspect, the RL algorithm is trained to generate a goal achieving policy based on a reward function in relation to energy cost and distance of movement.

[0018] In one aspect, the RL algorithm s trained to generate a collision avoidance policy based on the rendered object image.

[0019] In one aspect, the goal achieving policy and the collision avoidance policy are combined to control the motion of the robot arm.

[0020] In one aspect, the computer-implemented method further comprises: receiving, via a graphic user interface, an input for selecting a task; and controlling the robot arm to perform the task according to a policy generated by the RL algorithm.

[0021] In one aspect, the computer-implemented method is implemented at a cloud-based GPU server.

[0022] In another embodiment, the present disclosure provides a system, the system comprises: a camera, a processor; and a memory configured to store instructions executable by the processor. The processor is configured to: receive, from the camera, a real-time image data stream including a first two-dimensional image and a second two-dimensional image, wherein each of the first and second two-dimensional images includes a robot arm and at least one object; segment, by a trained neural network model, the first two-dimensional image to identify the robot arm and the at least one object, and obtain a first three-dimensional mask array representing positions of the robot arm and at least one object in the first two-dimensional image; generate a rendered robot arm image having a virtual robot arm pose that estimates a real robot arm pose in the first two-dimensional image and a rendered object image having a virtual object pose that estimates a real object pose in the first two-dimensional image, based on the first three-dimensional mask array, a robot arm digital model, an object digital model, and intrinsic parameters of the camera; and update the virtual robot arm pose and the virtual object pose in real time by a second three-dimensional mask array segmented from the second two-dimensional image.

[0023] In another embodiment, the present disclosure provides a non-transitory computer-readable storage medium having instructions stored therein that, when executed by a processor of a system, causes the processor to perform a method. The method comprises receiving, from a camera, a real-time image data stream including a first two-dimensional image and a second two-dimensional image, wherein each of the first and second two-dimensional images includes a robot arm and at least one object; segmenting, by a trained neural network model, the first two-dimensional image to identify the robot arm and the at least one object, and obtain a first three-dimensional mask array representing positions of the robot arm and at least one object in the first two-dimensional image; generating a rendered robot arm image having a virtual robot arm pose that estimates a real robot arm pose in the first two-dimensional image and a rendered object image having a virtual object pose that estimates a real object pose in the first two-dimensional image, based on the first three-dimensional mask array, a robot arm digital model, an object digital model, and intrinsic parameters of the camera; and updating the virtual robot arm pose and the virtual object pose in real time by a second three-dimensional mask array segmented from the second two-dimensional image.

[0024] Therefore, using the digital twin constructed in real-time according to one embodiment of the present application, a real-time motion planning algorithm can then control the robot and modify the object in the digital environment in real time as well, before transferring such motion control commands into the physical robot to achieve the desired object modification in the physical world (digital-to-physical twin) . The digital twin method and system of the present disclosure differs from the prior art, in one aspect, through the usage of real-time digital twin construction based on camera image data stream, and optionally pressure sensor inputs, taken from the actual physical twin of the robots and objects in the environment that the robots operate in. The real-time digital twin serves as a real-time feedback system which enables the real-time robot motion control algorithm of the present disclosure to alter its robot control commands (joint angle parameters, velocities, torques, etc. ) in real-time based on the actual physical twin conditions and noises in the environment. Effectively, the method and system of the present disclosure serves as a closed-loop real-time physical-digital-physical twin feedback system for complex robotic control in noisy environments.

[0025] In another embodiment, the present disclosure provides a stable real-time multi-object image segmentation system. The system is configured to: receive image data in a two-dimensional space; segment the image data into three-dimensional (or higher dimensional) individual object pixel data based on the class input prompts and machine learning methods; compare segmented individual object pixel data of the current frame to the segmented individual object pixel data of previous real-time image frames; and stabilize the multi-object segmentation pixel data value by selecting or re-arranging the indices based on differences or overlaps with previous real-time image frames’s egmented pixel data.

[0026] The present disclosure also provides a real-time inverse graphics rendering system. The system is configured to: receive 3-dimensional (or higher dimensional array) of individual object pixel data segmented from the original single 2-dimensional input image consisting of multiple objects; determine initial parameter values for the mathematical transformation of each geometric primitive in a three-dimensional space, wherein the geometric primitives, when rendered, produce 3-dimensional (or higher dimensional) individual object pixel array that approximates the individual object pixel data; render the geometric primitives by: generating a visibility function for each geometric primitive using the initial parameter values which can extend far beyond the physical edge of the geometric primitive modifying each geometric primitive visibility function based on the calculated depth information corresponding to other geometric primitives; filtering each visibility function to produce corresponding smooth and continuous functions; computing derivatives in the 3-dimensional (or higher dimension array) space for each smooth and continuous function; and computing shaded pixel values of the rendered image data based on the smooth and continuous functions; compare the individual object pixel data and the rendered individual object pixel array to produce differences; and update the initial parameter values based on the differences and the derivatives; and iteratively perform the rendering, comparison, and update of the parameter values based on successive real-time 3-dimensional (or higher dimensional array) individual segmented object pixel data inputs.

[0027] In one embodiment, the system is further configured to: update the point cloud mesh of robots and objects in the environment based on the current parameter values in a differentiable manner, which may include the estimated robot pose and joint angles, as well as the objects’ estimated pose for real-time tracking purposes; and render 2-dimensional image based on the point cloud mesh using standard non-differentiable computer graphics rendering pipeline.

[0028] The present disclosure further provides a real-time efficient motion control system based on a real-time virtual digital twin. The system is configured to: receive the parameters related to the robots and objects (joint angles and poses) in the real-time virtual digital twin, as well as the latest real-time point cloud mesh; and may or may not receive additional inputs from pressure sensors applied on the robot surfaces (according to the degree of accuracy required to complete the subtask) ; and define the manifold metrics and potential functions in the task space of collision avoidance and compute reward function in the reinforcement learning algorithm for refining contact events based on the current mesh of the robots and objects in the environment; and define the manifold metrics and potential functions in the task space of target approaching and compute reward function in the reinforcement learning algorithm associated with robot control objectives (such as grasping, lifting, opening drawer, pouring tea etc. ) based on virtual digital twin motion history; and utilize a neural network model pre-trained using reinforcement learning to determine the next time step robot pose which maximizes the cumulative reward functions and minimizes the cumulative cost function (calculated from the motion policy fusing process at each time step) .

[0029] In one embodiment, the real-time reconstruction of the virtual digital twin of the robot (s) and the environment that the robot (s) is operating, in the specific situation where the exact identities of the objects in the environment are known, there is sufficient physical information about the objects in the environment (for example the 3D point cloud mesh and texture of the objects in the environment, including the robot) , the degree of freedoms of the environment objects (rotation, translation, deformation, etc. ) and the forward kinematics of the robot is well-defined.

[0030] In one embodiment, the real-time digital twin reconstruction consists of successive real-time multi-class image segmentation and real-time differentiable rendering of the robot and environment objects in the scene.

[0031] In one embodiment, the real-time image mask segmentation produces continuous object mask images which track the location of desired object classes in the 2-dimensional camera images based on current camera image frame overlap with prior camera image frames. Even though the movement of an object or camera is fast, it outputs the estimated mask by considering the previously created mask and the movement of the object. This real-time image segmentation produces 3-dimensional (or higher dimensional) silhouette mask array for the multiple objects in the scene (including the robots and objects of interest in the environment, where each axis corresponds to the x-axis, y-axis, and the remaining axes correspond to individual objects) , which is used as the input to a real-time differentiable rendering algorithm.

[0032] In one embodiment, the real-time digital twin reconstruction is performed using the 3-dimensional silhouette mask array as input into the real-time differentiable rendering of the robot and environment objects in the scene. In this pipeline, individual geometry primitives are rendered using soft rasterization technique to produce separate 2-dimensional images of individual objects in the scene with their corresponding ghost shadow edge which can extend far beyond the edge of the object. These images and their associated pixel depth information are then used to modify and partially occlude each image, resulting in 3-dimensional (or higher dimensional) array outputs (where each axis correspond to the x-axis, y-axis, and the remaining axes correspond to individual objects) . This high-dimension soft-rendered output array is then combined with the 3-dimensional (or higher dimensional) silhouette mask array and the initial 2-dimensional RGB (+depth) image data to calculate a loss function. The backward propagation on the differentiable rendering pipeline will then enable multi-object structure pose optimization based on the loss function calculated from the digital twin mask silhouette rendered in a differentiable manner and the corresponding real-time camera video images (either RGB or depth images, or both) .

[0033] In one embodiment, the real-time virtual digital twin of the real robot and environment based on the differentiable rendering and the contact points identified by pressure sensor are utilized for generating real-time motion control and collision avoidance algorithm to enable the robot to navigate through the environment in autonomous manner to achieve specific objectives, such as, but not limited to: pick and place objects, polish object surfaces, assemble multiple components into an integrated object, deform flexible objects, etc.

[0034] In one embodiment, the real-time efficient motion generation and planning algorithm to control the robot to navigate through the dynamic and complex environment and complete target tasks is done using a combination of heuristic objectives and differentiable reinforcement learning based policy which optimizes cumulative rewards associated with the robot tasks at hand.

[0035] In one embodiment, graphical user interface software which allows the user to continuously track the robot and object poses in real-time, select desired objects to be processed by the robot, select algorithm and control loss function for the robot control, simulate the robot motion control in advance, and perform the desired control on actual robot hardware based on the real-time robot and environment digital twin reconstruction.

[0036] In one embodiment, cloud server configuration which enables the image processing, digital twin reconstruction, and control algorithm generation, to be done in real-time in a cloud-based GPU server, with only the input / output processes being performed in the local machine and the compute-heavy GPU-based computations performed in the cloud GPU server through high-speed real-time internet network communication. The GPU-heavy computation may be done either in a local machine GPU card or in a cloud GPU server, based on the computation load associated with the robot and its environment, and based on the user’s computation infrastructure availabilities.

[0037] The above is an overview of the present application, which may be simplified, summarized, and omitted in detail. Therefore, those skilled in the art should realize that this part is only illustrative and is not intended to limit the scope of the application in any way. This summary is neither intended to determine the key features or essential features of the subject matter sought to be protected, nor is it intended to be used as an auxiliary means to determine the scope of the subject matter sought to be protected. BRIEF DESCRIPTION OF THE FIGURES

[0038] The above and other features of the content of the present application will be more fully understood through the following description and appended claims in combination with the drawings. It can be understood that these drawings only illustrate several implementations of the content of the present application, and therefore should not be considered as limiting the scope of the content of the present application. By adopting the drawings, the content of the present application will be explained more clearly and in detail.

[0039] FIG. 1 is a flow diagram illustrating a method 100 of controlling a robot in real time according to one embodiment of the application.

[0040] FIG. 2 is a flow diagram illustrating the process 200 of generating an object mask array by real-time image segmentation according to one embodiment of the application.

[0041] FIG. 3 illustrates a data flow diagram of a segmentation module 304 with its data inputs and outputs.

[0042] FIG. 4 illustrates an example of a bounding box output at Block 306c and a silhouette mask array output at Block 306d.

[0043] FIG. 5 illustrates a reference model 502 and a batch of mesh duplicates 504-1 to 504-6 with different initial poses according to one embodiment of the present disclosure.

[0044] FIG. 6 illustrates an example of a teapot object in the local minimum and global minimum according to one embodiment of the present application.

[0045] FIG. 7 illustrates a pose calibration process of digital twins with respect to real objects according to one embodiment of the present application.

[0046] FIG. 8 illustrates a real-time pose tracking process of the digital twins according to the embodiment of FIG. 7.

[0047] FIG. 9 illustrates the pose calibration process of digital twins with respect to real objects according to another embodiment of the present application.

[0048] FIG. 10 illustrates the real-time pose tracking process of digital twins according to the embodiment of FIG. 9

[0049] FIG. 11 illustrates tree-structured task maps according to one embodiment of the present application.

[0050] FIG. 12 illustrates a structure diagram of a motion control algorithm according to one embodiment of the present application.

[0051] FIGS. 13-15 illustrate a control process in a scene with a vertical / horizontal cylinder and a teacup as the obstacles and a teapot as the target according to one embodiment of the present application.

[0052] FIG. 16 illustrates an overall software structure 1600 according to one embodiment of the present application.

[0053] FIG. 17 illustrates a program sequence diagram demonstrating the communication among a GUI 2000, a control algorithm 2002, a visual module 2004 and a robot arm 2008.

[0054] Before explaining any embodiments of the present invention in detail, it shall be understood that the application of the present invention is not limited to the details of the configuration and the arrangement of components set forth in the following description or shown in the following drawings.

[0055] The present invention can have other embodiments and can be practiced or implemented in various ways. Moreover, it shall be understood that the wording and terminology used herein are for illustrative purposes and shall not be considered limitative.DETAILED DESCRIPTION OF THE INVENTION

[0056] In the following detailed description, reference is made to the drawings constituting a part thereof. In the drawings, similar symbols usually indicate similar components, unless the context specifies otherwise. The illustrative embodiments described in the detailed description, drawings, and claims are not intended to limit. Without departing from the spirit or scope of the subject matter of the present application, other embodiments may be applied, and other changes may be made. It can be understood that various aspects of the content of the present application described generally in the present application and illustrated in the drawings can be configured with various configurations, substitutions, combinations, and designs, all of which clearly constitute a part of the content of the present application.

[0057] FIG. 1 is a flow diagram illustrating a method 100 of controlling a robot in real time according to one embodiment of the application. The method 100 includes: at Step 102, receiving, from a camera, a real-time image data stream including a first two-dimensional image and a second two-dimensional image, wherein each of the first and second two-dimensional images includes a robot arm and at least one object. In one embodiment, a two-dimensional image is a depth image, and depth information is added either through inference by machine learning methods or by using hardware such as a depth camera (e.g., stereo vision, LiDAR, or time-of-flight sensors) . Depth values typically contain values ranging from 0 to infinity. In one embodiment, the values can be adjusted to be normalized between 0 and 1 by Equation 1-1 below, which may help standardize depth information across the frame.

[0058]

[0059] Where d (x, y) is the depth value of a specific pixel, and d_min and d_max are the minimum and maximum depth values in the depth map.

[0060] In one embodiment, the brightness values of a pixel can be adjusted in proportion to its depth value by the Equation 1-2 below. For example, pixels with shallow depth can be made brighter, while those with deeper depth can be made darker.

[0061] I′ (x, y) =I (x, y) · (1-dnorm (x, y) ·α)      (Equation 1-2)

[0062] Where I (x, y) is the original pixel value, and α is the adjustment intensity parameter.

[0063] In one embodiment, color adjustment can be used to emphasize perspective based on depth values by the Equation 1-3 below. For example, distant objects can be adjusted to cooler colors (blue) , while close objects can be adjusted to warmer colors (red) .

[0064] C′ (x, y) =C (x, y) + β·dnorm (x, y)   (Equation 1-3)

[0065] Where β is the intensity of the color change. C (x, y) is the original color value, and the adjusted color C′ (x, y) changes its hue according to depth.

[0066] In one embodiment, final post-processing (e.g., clipping or limiting) can be performed on the adjusted RGB values to ensure that the adjusted pixel values fall within the valid range (0-255) . This allows for the output of the adjusted image. While conventional segmentation methods rely primarily on 2D image data, the utilization of depth information of the image can further improve the accuracy of segmentation, particularly in scenarios where objects are overlapping or closely positioned.

[0067]

[0068] FIG. 2 is a flow diagram illustrating the process 200 of generating an object mask array by real-time image segmentation according to one embodiment of the application. The process 200 includes three main steps: Step 202: Dataset Generation; Step 204: AI Model Training; and Step 206: Real-time Segmentation.

[0069] In one embodiment, a neural network model shall be trained for processing, e.g., segmenting, the two-dimensional images input form the camera. That is, Steps 202 and 204 are pre-processing steps that may be completed before step 206 begins, and can be fully automated through a computer. In one embodiment, humans can intervene to tune parameters to achieve the desired results.

[0070] Refer to FIG. 2, at Step 202, a training dataset is created for an AI model to detect objects. Raw data, which includes actual photos of objects and synthetic images obtained through a computer, is collected at Sub-step 202a. The raw data is then augmented at Sub-step 202b by randomly changing the environment within the image, such as the position of the object, lighting conditions, zoom, and noise. Each image data is annotated at Sub-step 202c with bounding boxes, object classification labels, and object masks for target objects. The images and annotation results are then converted to generate dataset at Sub-step 202d for training an AI model at Step 204.

[0071] At Step 204, the AI model is trained using the dataset loaded at Sub-step 204a. The AI model is designed and trained at Sub-step 204b to recognize all target objects from an image and perform segmentation in one pass to ensure quick real-time interaction. In one embodiment, the output result of the AI model for each image is evaluated by comparing it with the annotation result, and convergence is conducted at Sub-step 204c to ensure that the difference between the predicted value of the model and the actual value is the smallest, so as to obtain an optimal AI model at Sub-step 204d.

[0072] Refer to FIG. 1, the method 100 further includes, at Step 104, segmenting, by a trained neural network model, the first two-dimensional image to identify the robot arm and the at least one object, and obtain a first three-dimensional mask array representing positions of the robot arm and at least one object in the first two-dimensional image.

[0073] Refer again to FIG. 2, after the neural network model is trained and is loaded at Sub-step 206a in FIG. 2 and the two-dimensional image is received at Sub-step 206b, the image is immediately put into the trained neural network model and then prediction of object silhouette masks is performed at Sub-step 206c. The object silhouette masks capture the width and height of the objects, i.e., the positions of the objects in the image. In one embodiment, a 3D array is formed by arranging the silhouette masks of the detected objects into an array format, where each object is represented as a distinct 3D silhouette, which will be illustrated in FIG. 4 below.

[0074] Then, the object silhouette masks generated for the recognized objects are delivered to a pose estimation process at Step 210.

[0075] In one embodiment, the object silhouette mask array includes higher-dimensional data, e.g. time and velocity. In the real-time image data stream, the object silhouettes can be tracked across frames, treating time as an additional dimension. Velocity can also be added as an extra dimension to the object silhouette mask array, resulting in a higher-dimension data structure.

[0076] In one embodiment, at Sub-step 206d, the segmented individual object pixel data from the current frame is compared with that of the previous frame. The overlap or differences between corresponding pixel regions of segmented objects across consecutive frames is calculated. In one embodiment, the comparison is calculated using various metrics, such as Intersection-over-Union (IoU) or pixel-wise difference measures, to detect any discrepancies, shifts, or changes in the objects’ position or boundaries between frames.

[0077] Once discrepancies are identified between the current and previous frames, the system adjusts the pixel data for consistency over time. In one embodiment, this stabilization is done by selecting or re-arranging the indices of the segmented objects to maintain temporal coherence. For instance, when object indices are assigned to segmented areas (representing different objects) , the system ensures that these indices remain consistent between frames. If there are significant overlaps between current and previous frames’s egmented data, the same index is retained. If new objects are detected or existing ones are no longer visible, the indices are updated or re-assigned accordingly. The Sub-step 206d is crucial for maintaining stable object detection and segmentation in real-time, minimizing flicker in the segmented output as objects move or change position.

[0078] In the detection of moving objects, the following situations may occur: 1) the object moves out of the field of view of the camera; 2) temporary failure in object detection due to problems occurring in the imaging environment. In the latter case, an object silhouette mask is temporarily not transmitted to the 3D pose estimation process, which can disrupt the system. To deal with this problem, according to one embodiment of the application, the previously calculated object silhouettes are stored in an object silhouette mask buffer 208. If an object is detected and a valid silhouette mask is created, it is added to the object silhouette mask buffer 208. In one embodiment, the size of the buffer 208 is at least three. However, the size or value of the buffer 208 can be adjusted in accordance with the number of images captured by the camera per second. In a temporary problem with object detection, the direction and speed of the object on the buffer are calculated to estimate the current position of the object. If the object is still in the field of view of the camera, a silhouette mask of the object is created at the estimated position and transmitted to the 3D pose estimation process 210.

[0079] In one embodiment, the real-time segmentation 206 outputs the segmentation result in one pass, and the operation is performed quickly within e.g., a few milliseconds. The target objects that are involved in pose estimation are selected from the segmentation results and passed to the pose estimation process at Step 210.

[0080] FIG. 3 illustrates a data flow diagram of a segmentation module 304 with its data inputs and outputs. Segmentation involves dividing an image into multiple segments (sets of pixels) to simplify the representation of an image into something more meaningful and easier to analyze. Usually, image segmentation algorithms assign a label to every pixel in an image, and pixels with same label share certain characteristics (color, edge, texture, class, object instance, and so on) . Based on classification criteria, image segmentation algorithms can be categorized into various types. For example, instance image segmentation is an algorithm where each segment of the image uniquely represents a specific instance of an object. The approach not only categorizes the pixels of an image into different object classes but also distinguishes between different instances of the same class. For example, in a street scene, instance segmentation would identify and separate each individual car, pedestrian, or any other significant object, treating each as a unique entity despite their belonging to the same category.

[0081] Refer to FIG. 3, at Block 302, the input, which may be a RGB image or a RGBD image that includes depth values, is received from a camera. The segmentation module 304 processes on the input image in one pass based on the trained AI segmentation model by the following three sub-modules:

[0082] Sub-module 304a: Classification, which identifies what objects are present in the image.

[0083] Sub-module 304b: Localization, which determines where the objects are in the image.

[0084] Sub-module 304c: Segmentation, which isolates each identified object in the image.

[0085] The segmentation module 304 then outputs the following results:

[0086] Object classes at Block 306a: The types of objects found in the image.

[0087] Object class probabilities at Block 306b: The confidence level of object classifications.

[0088] Bounding boxes at Block 306c: The location of detected objects in the image.

[0089] 3D array silhouette mask at Block 306d: Silhouette mask array of detected objects.

[0090] Object classes 306a are the types of objects that the segmentation module 304 can recognize and are influenced by the Neural network model and the training Dataset. Object class probabilities 306b represent how much you can trust the found objects and range from 0.0 to 1.0. If this value is 1.0, it means that the found object matches 100%with the ground truth, and only when this value exceeds a certain value (e.g., 0.5) , the objects are passed to the next process (pose estimation) . A bounding box is defined by the x and y coordinates of the top left and bottom right in the image, and it represents the spatial location of each object in the image. A silhouette mask of each object shows exactly where the found object is in the image at the pixel level. A silhouette mask contains binary pixels where the object exists are assigned 1 and where it does not exist are assigned 0.

[0091] FIG. 4. illustrates an example of a bounding box output at Block 306c and a silhouette mask array output at Block 306d. At the top of FIG. 4, bounding boxes 402a-c are illustrated for marking detected objects, e.g., the teapots and teacups, positioned at different places on the table. At the bottom of FIG. 4, the detected objects are illustrated as a 3D array of object silhouette masks. In the embodiment, the 3D array of object silhouette masks includes three channels 404a-c each corresponds to one of the detected teapots and teacups.

[0092] Referring to FIG. 3, when the class probabilities of the found object exceed a certain threshold, the object is classified and decided as a target object at Block 308, and the class, bounding box, and silhouette data of the object are passed to the pose estimation process at Block 310. In one embodiment, the 3D model of the target object at Block 312 that corresponds to the found object is also used in the pose estimation process at Block 310. In one embodiment, 3D objects are represented using 3D object models which typically consists of point-cloud triangular meshes, represented by coordinates of vertices and triangular faces, in addition to color texture map for the model.

[0093] Refer back to FIG. 1, the method 100 further includes, at Step 106, generating a rendered robot arm image having a virtual robot arm pose that estimates a real robot arm pose in the first two-dimensional image and a rendered object image having a virtual object pose that estimates a real object pose in the first two-dimensional image, based on the first three-dimensional mask array, a robot arm digital model, an object digital model, and intrinsic parameters of the camera.

[0094] Given an input image (RGB or RGBD)  which may contain N target objects, the task of 6D object pose estimation is to estimate the rigid transformation  of all target objects to transform their 3D object model M = {Mn | n ∈ {1, 2, …N} } from the object coordinate system O to the camera coordinate system C. In one embodiment, 3D object model M and the camera intrinsic parameters K is known. The model Mn is defined as a set of vertices in and a set of polygons that describe the object surface. The object pose Pn is represented by a 4 × 4 rigid transformation matrix Pn = [R, T; 0, 1] , where R is a 3 × 3 3D-rotation matrix and T is a 3 × 1 3D-translation vector. 3D-translation T is represented by xyz coordinate, which is the origin of O in the camera coordinate system C. For 3D-rotation R, to ensure the rotation is physically valid, it can be represented as quaternions q, which can be easily converted into a 3 × 3 rotation matrix.

[0095] According to one embodiment, a differentiable renderer can be used for rendering a reprojected image of the 3D model M in an initial object pose P′ with camera intrinsics K. The parameters of P can be set as learnable parameters and to get the correct object pose by minimizing the reprojection error of Equation 2-1 below:

[0096]

[0097] Where Loss is the metric to evaluate the discrepancy between each target object in the real captured image I and its corresponding digital twin in the rendered image I can consist of RGB Ic, depth information Id. Based on the instance segmentation algorithm performed on I, the silhouette mask tensor can be obtained, where each channel of the tensor contains the silhouette mask of one target object. For rendered image these corresponding RGB depth smoothing edge silhouette tensor can also be achieved in differentiable rendering library using soft rasterization technology. In one embodiment, each channel of smoothing edge silhouette tensor can match with that of silhouette mask tensor based on the class identification information provided by a segmentation algorithm. Additionally, the rendered smoothing edge silhouette tensor may have changeable range of smoothing edge, which can be set to large or small according to the optimization timeline. In one embodiment, when there is large discrepancy between real object pose and virtual digital twin object pose, large smoothing range can be utilized to allow the gradient flow when the digital twin is far away from the real target object. When the discrepancy between the two is small, short-ranged ghost shadow edge can be used instead for higher accurate pose estimation.

[0098] The loss function Loss (Equation 2-2 below) is defined as a weighted combination of the error (such as mean squared error (MSE) , mean absolute error, Intersection over Union (IoU) , Dice coefficient, etc. ) of each modality: Loss= λcLc+λdLd+λmaskLmask     (Equation 2-2)

[0099] Where I (y, x, n) represent the pixel value of I, and λc, λd and λmask are weights to balance the loss. The above loss function is fully differentiable, and the optimization of P can be performed e.g., using the gradient descent method.

[0100] Optimally, with the gradient descent method, P would reach the global minimum. However, in practical scenarios, the optimization of P may be stuck at a local minimum. Specifically speaking, the initial object pose P′ may be far away from the expected global minimum P, in this case, the gradient decent method may lead to the optimized current object pose stuck at the local minimum. One of the representative issues is the large-angle rotation problems of some objects.

[0101] FIG. 5 illustrates a reference model 502 and a batch of mesh duplicates 504-1 to 504-6 with different initial poses according to one embodiment of the present disclosure. Instead of a single mesh, for each 3D object model, a main mesh M′d with its pose  is first fixed. Sequentially, a batch of mesh duplicates based on M′dwith offset poses  are created, where J is the batch size of each 3D model.

[0102] FIG. 6 illustrates an example of a teapot object in the local minimum and global minimum according to one embodiment of the present application. Refer to FIG. 6, in the loss value curve, there exists multiple local minimums as noted in dots 602-1 to 602-4, and one global minimum as noted in the dot 604 at 182 degrees. In the gradient descent, it may be stuck at the local minimums and may not reach the global minimum, which is the most precise pose estimation. With the batch optimization strategy provided by the present application, the global minimum 604 at 182 degrees can be obtained accurately and quickly to prevent P from being stuck at any of the local minimum 602-1 to 602-4.

[0103] In some embodiments, the offset poses P′d comprises both translation offset matrix and rotation offset matrix  (also represented as quaternions ) , where parameters and can be fixed constants or learnable parameters based on different settings. Preferably, the translation offset parameters is learnable. During learning, the initial values of the translation offset parameters can be set as geometry center of the object, indicating no translation. Preferably, the rotation offset parameters are fixed constants.

[0104] In some embodiments, the rotation offset parameters can be generated by a method for uniform sampling of 3D rotations using Euler angles by giving the variant number of x, y and z axis, noted as var | i ∈ {x, y, z} . It generates a uniform distribution of angles for each x, y, z axis in the range [0, 360) degrees, with sampling intervals Δθ given by (Equation 2-3) :

[0105]

[0106] Then, a Cartesian product of these rotation angles is created, resulting in a comprehensive 3D grid of all possible rotation combinations. The Euler angles are then converted to rotation matrices using the convention of Equation 2-4:

[0107] R=Rz (γ) Ry (β) Rx (α)   (Equation 2-4)

[0108] where Rx, Ry, and Rz are the elementary rotation matrices about the x, y, and z axes, respectively, and α, β, and γ are the corresponding Euler angles. These matrices are subsequently converted to quaternions q′d for efficient 3D transformations. The total number of the batch size J is given by Equation 2-5:

[0109] J=varx×vary×varz   (Equation 2-5)

[0110] According the geometric shape of the target objects, it is possible to assign different value of var across different axes. Basically, for the objects with less symmetry in certain directions, it is necessary to set higher number of variants in the corresponding axes. Preferably, when an object lacks symmetry along a particular axis, the corresponding variant number typically ranges from 1 to 16, more preferably, 6 to 12, contingent upon the volume of object’s unique geometric feature. For example, for objects with complete symmetry, such as spheres, batch creation is unnecessary as their appearance remains constant regardless of orientation. For objects with partial symmetry, like cylinders, we assign higher variant numbers, such as ranging from 6 to 16, along the axis lacking symmetry.

[0111] Regarding the combination of translation and rotation configuration of the duplicates, the inventors of the present applicant discover that, rotation estimate is more challenging than translation estimate. Therefore, in the present method, the batch strategy is primarily designed to enhance rotation estimation accuracy. The translation offset serves to assist the rotation batch to have freedom to move within a local space, facilitating the optimization convergence. That is, translation offset assists to define a position of a rotation center.

[0112] Based on the above translation and rotation offset, P′d with different settings can be provided.

[0113] 1) Shared Translation, Fixed Rotation: Regardless of the batch size J, all the duplicates share the same learnable translation offset while the rotation offsets remain fixed. The pose offset is defined as Equation 2-6:

[0114] In this case, translation offset could be considered as a learnable rotation center for rotated mesh duplicates.

[0115] 2) Independent Translation, Fixed Rotation: Each duplicate has its own set of learnable translation parameters, while remains constant. The pose offset is defined as Equation 2-7:

[0116] In this case, each rotation duplicate is given additional translational freedom, allowing it to explore a larger local space.

[0117] 3) Fully Learnable Translation and Rotation: Both and are independently learnable. The pose offset is defined as Equation 2-8:

[0118] In this case, each mesh duplicate can be considered as an independent mesh, which can freely translate and rotate in 3D space.

[0119] In practical applications, the above different settings can be selected according to the geometric properties of target objects to balance the computation cost and accuracy.

[0120] After the duplicates are prepared, the loss value Ldup is calculated for each duplicate in the batch based on the current object pose matrix Note that the mesh batch share the same matrix during optimization. Then the loss with minimum value in Ldup and the corresponding index index of the duplicates in the batch are obtained by Equations 2-9 and 2-10 below.

[0121] Here,  represents the loss value for each batch j.

[0122] Finally, we backpropagate the Loss summation (Equation 2-11) of total loss of duplicates and one of the duplicates losses with minimum value is backpropagated to optimize P and PΔ (Equation 2-12) , and then the main mesh is set as for the next optimization iteration. Losstotal=Lbest+ Ldup         (Equation 2-11)  P,PΔ=argmin Losstotal         (Equation 2-12)

[0123] As illustrated above, such duplicates with translation and rotation offset may keep the optimization process from being stuck in a local minimum. Further, with the loss function designed above, the present method may iteratively search for the optimal pose and finally finds the pose of the digital twin that best fits with the physical twin.

[0124] FIG. 7 illustrates a pose calibration process of digital twins with respect to real objects according to one embodiment of the present application. The left image shows the initial pose of a real teapot 701, a teacup 702 and their digital twins 711 and 712. The models of digital twin were rendered by the current estimated pose, known 3D models of the teapot 701 and the teacup 702, and camera intrinsics K. From left to right, the algorithm of the present disclosure can calibrate the pose of digital twins to fit the real ones. FIG. 8 illustrates a real-time pose tracking process of the digital twins according to the embodiment of FIG. 7. From left to right, when the physical pose of the teapot 701 and teacup 702 are adjusted simultaneously, and the system of the present disclosure can keep tracking the pose of the target objects for real-time digital twin reconstruction.

[0125] It can be seen that, the system of the present disclosure aims to address real-time dynamic multiple objects tracking along with 6D object pose estimation. The system of the present disclosure has two processing phases: 1) static pose calibration of initial digital twin model. 2) dynamic pose tracking of digital twin model. The 2nd phase is achieved by continuously optimizing the above loss function by updating I from real camera, which lets the rendered image of digital twin follow the captured image of target object when the target object moves in 3D space.

[0126] In some embodiments, the object can be a robot arm, and the robot pose estimation can be conducted similarly. Given an image (RGB or RGBD) I , the aim of robot pose estimation is to recover the state of a known articulated robot within a 3D scene. The articulated robot state is defined by (i) its 6D pose of robot base, i.e. a 3D translation and a 3D rotation with respect to the camera coordinate, and (ii) the joint angle θ values of the robot's articulations.

[0127] Similar as the optimization method used with object pose estimation, the robot pose estimation further takes joint angle θ into account. Using a differentiable renderer areprojected image of the robot mesh M (P′, θ′) in an initial robot pose and θ′ can be rendered with camera intrinsics K. M (P′, θ′) is ready-to-render robot mesh, including each robot link l (P′, θ′) meshes conditioned on initial joint angles θ′. For articulated robot, robot is usually represented by robot links and joint angles, where joint angles decide the pose of each robot link regarding robot base coordinate. The point cloud mesh of each robot link can be calculated using following Equations 2-13 and 2-14:

[0128] where N is the number of robot links.  is the mesh of n-th robot link conditioned on robot base pose and joint angles θ.  is the mesh of n-th robot link in its own robot link coordinate system.  is the transformation matrix between robot root and n-th link can be calculated from joint angles θ by robot forward kinematics. Forward kinematics is a series of physical transformations which describes the physical transformations available for every component in a robot. The physical pose of a robot component is determined not just by its immediately-connected joint angle or translation stage (relative pose to a neighboring component) , but also by the relative pose of such neighboring component with respect to its own neighboring components. Consequently, it is more straightforward to describe the physical transformation of a robot component as a compound of serial transformations. In computer graphics, this compound transformation can be simply described as a multiplication of the component geometry point cloud coordinate mesh with a 4x4 matrix. A unique 4x4 matrix is usually provided for each independent component of the robot to describe the full forward kinematics.

[0129] Then, based on the type of robot segmentation algorithm used, a robot mask can be obtained from I, which could either be a single-channel mask that combines all links or a multi-channel mask where each channel represents an individual link. Following the shape of Imask, all robot links can be treated as a single object or as individual objects for rendering. In addition, robot forward kinematics process can be differentiable. Therefore, the parameters of P and joint angles θ can be set as learnable parameters and the correct robot 6D pose and joint angle by can be obtained minimizing the reprojection error of Equation 2-15:

[0130] Where Loss is the same metric used in the object pose estimation.

[0131] Similar as the multiple objects pose estimation of the present disclosure described above, the robot pose estimation system of the present disclosure can optimize multiple objects or robot arms (or both) simultaneously, and it is also built for static pose calibration and real-time pose tracking. As a result, given an input image containing robot arm and target object with known 3D model, the robot and object pose estimation system of the present disclosure can first calibrate their corresponding digital twins into correct poses and continuously tracking the poses of robot arm and object in real-time when they are in motion.

[0132] Refer to FIG. 1, the method 100 further comprises, at Step 108, updating the virtual robot arm pose and the virtual object pose in real time by a second three-dimensional mask array segmented from the second two-dimensional image. Since the two-dimensional images of the real-time video stream is continuously input and processed by the segmentation method provided by the present application, the virtual robot arm pose and the virtual object pose in the digital twins can be updated continuously.

[0133] FIG. 9 illustrates the pose calibration process of digital twins with respect to real objects according to another embodiment of the present application. The left image shows a robot arm 901, a teapot 902, and the initial pose of their digital twin 911 and 902. From left to right, the system of the present disclosure can calibrate the poses of digital twins to fit the target ones. FIG. 10 illustrates the real-time pose tracking process of digital twins according to the embodiment of FIG. 9. From left to right, when the poses of the target robot 901 and teapot 902 are adjusted, and the system of the present disclosure can keep tracking the poses 911 and 912 of the target robot 901 and teapot 902 with e.g., a rate of 20 frame per second (FPS) .

[0134] Refer to FIG. 1, the method 100 further includes, at Step 110, controlling, by a reinforcement learning (RL) algorithm, a motion of the robot arm with respect to the object based on the rendered robot arm image and the rendered object image.

[0135] A RL algorithm is a powerful automated decision-making method that finds its broad applications in robotics, industrial automation, resource allocation and management, etc. Different from supervised learning (which requires full availability of labels for the data samples) and unsupervised learning (which only derives patterns from the data by itself without labels) , RL can help agents find “good” policies with just partial availability of labels along the sequence of actions and observations. Reinforcement learning includes the following key elements:Agent: The entity that conduct actions in the environment, observe feedbacks and learn  to optimize its policy of taking actions.Environment: The external system with which the agent interacts. The environment  responds to the actions taken by the agent, providing feedback in the form of rewards or penalties.State: The current situation or configuration of the environment which influences the  agent’s decision-making process.Action: The set of possible moves that the agent can take. Actions are selected by the  agent based on its current state.Reward: A numerical value provided according to the environment and the task as  feedback for the action taken in a particular state. The objective of the agent is to maximize the cumulative reward over time.Policy: The strategy or mapping from states to actions that the agent follows.

[0136] The RL process typically involves the following steps:

[0137] The agent observes the current state of the environment.

[0138] The agent selects an action according to its policy.

[0139] The selected action is applied to the environment.

[0140] The environment transitions to a new state, and a reward is feedbacked according to the task to be completed.

[0141] The agent updates its policy based on the observed reward and the process continues.

[0142] Although many RL algorithms have been proposed in general settings before, real-time robust RL algorithms have not been studied and verified systemically in the scenarios of robotic learning yet. Specifically, most of them, such as RMPflow, do not consider the potential combination with collision avoidance mechanisms, which are crucial in real-world manipulation of robots. According to one embodiment, a RL algorithm in robotic learning interweaved with collision avoidance is provided. The collision avoidance module can not only guide the RL algorithms to generate motion policy that can bypass obstacles, but also calculate the work implemented by the forces applied for each move. The rewards of RL algorithms will then be defined based on this information. As a result, the policy attained by the RL algorithm will enable the agents to complete the tasks at minimum energy cost without causing any collisions in the route.

[0143] Moreover, the application of RL algorithms to universal robots (e.g., ur5e, ur10 etc. ) in order to complete industrial manufacturing tasks has not been investigated and explored as well. Therefore, the RL algorithm provided in the present disclosure target to bridge these gaps and enable the robot agents of the present disclosure to complete the tasks smoothly and efficiently in complex and dynamic environments.

[0144] An overview of the workflow of the proposed algorithm according to one embodiment of the present disclosure is first provided.

[0145] Input: real-time virtual digital twin of objects and environments; the space of actions, states (including terminal states defined based on tasks to be completed) .

[0146] With these inputs, the algorithm can do virtual training in parallel as in the following steps:

[0147] 1) Each agent observes its current state of the environment; and

[0148] 2) Each agent selects an action according to its policy.

[0149] For example, the action can by selected by:

[0150] (a) epsilon-greedy method;

[0151] (b) random sample from a distribution given by the policy; and

[0152] (c) argmax Q-value, etc.

[0153] 3) The selected action is applied to the agent’s environment.

[0154] 4) Each agent’s environment transitions to a new state and receives a feedback in the form of a reward function defined according to the task to be completed and the energy needed to finish the move.

[0155] 5) Each agent updates its policy based on the observed reward and experiences of other agents at each given steps; then the process continues.

[0156] Output: the motion generation policy to achieve the highest cumulative rewards.

[0157] Robots implement the actions generated from the obtained motion policy (updated every certain frames / time steps) to eventually complete the tasks in the physical world.

[0158] According to one embodiment, the training pipeline of the present disclosure employs the population based training (PBT) idea, which can be regarded as an application of evolutionary algorithms to reinforcement learning. Specifically, at every given step, the algorithm will evaluate the performance of all the agents. Based on their performance, it will determine which agents can continue the training process without any mutation, which need to mutate their hyperparameters, and which ones have to both mutate their hyperparameters and replace their model parameters by those of better performing agent before the training is resumed.

[0159] To achieve the above goals of collision avoidance, the method of the present disclosure uses a pushforward and pullback procedure for automatic motion policy generation, during which it also calculates the work conducted in the action sequence during the training process.

[0160] FIG. 11 illustrates tree-structured task maps according to one embodiment of the present application. Refer to FIG. 11 (a) , an arrow 1101 denotes the direction of pushforward, and an arrow 1102 denotes the direction of pullback.

[0161] Refer to FIGS. 11 (b) and 11 (c) , in the forward pass, states (positions, velocities) can be pushed forward from the configuration space to the task spaces where i is the index of the leaf representing the i-th task space (see the graph below) ; in the backward pass, not only the forces and inertial matrices are pulled back in the opposite direction, but also the energy / distance cost is calculated in this time interval, which is important in defining the rewards of the moves in this time interval.

[0162] The algebras of this energy / distance-aware Riemannian motion policy generation method are explained as follows.

[0163] 1. pushforward

[0164] where x is a point in the configuration space yi is a point in the i-th task space and are their derivates with respect to time,  is the mapping from the configuration space to the i-th task space is a Jacobian matrix.

[0165] 2. pullback

[0166] where M is the inertia matrix at defines the directional importance of a (the acceleration of an RMP) when it is combined with other motion policies. Mi is the inertia for subtask in i-th task space, f is the desired force map and fi is the desired force map for the i-th task.

[0167] 3. energy / distance cost computation at time t

[0168] where Δt is the time interval during which the force is implemented.

[0169] Based on such an energy / distance-aware motion policy generation mechanism for combining multiple policies (including collision avoidance) , the RL algorithm of the present disclosure can learn policies that are able to complete tasks efficiently and robustly in dynamic and evolving environments.

[0170] In one embodiment, apart from creating and using an energy / distance-aware collision avoidance method in the reinforcement learning algorithm of the present disclosure, which enables the computation of a reward related to the energy needed or the distance of movement, the RL algorithm of the present disclosure also utilizes a transformer architecture to generate actions learned from long-range memories. Sometimes, the environments are dynamic and open-ended (e.g., Minecraft) , which means the policy needs to adjust in real time to deal with unseen tasks during online interaction. For these scenarios, the transformer structure will bring the RL algorithms with better generalization ability to perform stably in unfamiliar situations.

[0171] FIG. 12 illustrates a structure diagram of a motion control algorithm according to one embodiment of the present application. At a certain time step, a visual input o, joint angle measurements x and joint velocities are obtained at 1201. Then, β-VAE encoder 1202 is used to encode image o to generate the visual latent z. With the robot kinematics and jacobian J at 1203, an end-effector position y and velocity are computed from x and respectively. Subsequently x and as well as the rewards of energy / distance cost re are fed into a goal achieving policy 1204 to generate a user-defined behavior. At the same time, all available information sr is passed into a reactive policy 1205. The reactive policy 1205 generates a reactive behavior dependent on the objects in the environment. Both outputs are then fused together based on e.g., the RMPflow framework 1206, to generate a desired joint acceleration This acceleration is then inputted to a robot controller to control a robot 1207’s motion.

[0172] According to one embodiment, to achieve collision avoidance, a local RMP policy “collision_rmp” is defined with the distance between the robot’s and other objects’ collision spheres and their derivatives w. r. t. time as the inputs (corresponding to y and in FIG. 14, or yi and in the explanation of the pushforward and pullback process) . Using these measures in the local policy subspace, the local acceleration or force and the metrics in the subspace can be defined so that the robot can be guided away from the obstacles and to a feasible position when it is near them. The goal achieving local RMP policy can be designed and implemented in a similar workflow. As in the description of the algorithm, the collision avoidance local policy will then be fused with other polices (e.g., the policy to attain the target location, or the policy to achieve a proper pose) to generate a joint base policy that are supposed to control the robot to complete all the subtasks with joint movements. According to one embodiment, to make the control more robust to different environments, rewards and neural networks which will be utilized by the residual reinforcement learning frameworks can be designed to further guide the improvement of the joint base policy.

[0173] In one embodiment, ionic pressure sensor, e.g., iontronic sensing paper (ISP) can be deployed to cover the robot arms, e.g., the skin of the grippers. ISP is a pressure sensing technology which can be applied on flexible substrates such as paper. This pressor sensor works by putting ionically conductive cellulose fiber layer on top of electrically conductive cellulose fiber layer, which produces capacitance based on the effective contact area between the two fiber layers. Initially, there will be very small contact area between the two fiber layers. Upon the application of external pressure, the effective contact area between the two layers will linearly increase with respect to pressure (and hence resulting in linear capacitance increase vs the applied pressure) . The ionically conductive fiber layer is made by infusing a polymer fiber matrix with ionic liquid solution. The advantage of the ISP sensor is that it can be made using low-cost fiber  / ionic liquid materials, deposited on flexible substrates like paper through simple method like inkjet printing or screen printing, and be cut / configured into different geometries.

[0174] In one embodiment, because there are capacitance-based pressure sensors arranged in pixelated manner across the robotic skin, it is possible to know exactly where on the robot surface a pressure is being sensed. This input will look like a 2-dimensional pressure heat map, so that the profile of pressure vs pixel address can be obtained. However, because the pixel of the robotic skin will stay on pre-defined position on the robot surface, w the pressure vs robot surface area map can be obtained effectively. In one embodiment, the robot-object contact point map (higher pressure on the contact point, and normal pressure elsewhere) can be utilized by the RL algorithm to implement the motion control plan.

[0175] In one embodiment, when the RL algorithm is trained based on the data of digital twin estimated from above procedures, noises and pose estimation errors are almost inevitable. The aspects below can be further provided to make the RL algorithm more robust to variances.

[0176] First, the RL algorithms can be trained virtually in a simulator, such as Isaac Sim, Pybullet, or any other customized simulators, so that the data of the scenes and objects can be augmented freely. For example, diverse initial poses and positions of the robot’s arms can be set and the RL algorithms can be kept training by searching through the policies that can still complete the target tasks with different conditions.

[0177] Second, the algorithm of the present disclosure can be trained by combining it with classical motion policies such as collision avoidance using heuristic potential functions and Riemannian task manifold metrics. As a result, the final policy obtained will have the ability of avoiding obstacles by nature, making it robust to unseen environments.

[0178] Third, the neural network structures with better generalization ability in sequential data such as the transformer can be employed by the present disclosure. By training on dynamic environments with augmented data sequences, the RL algorithm will be more robust to unexpected events, which ensures the agents to generate proper behaviors in real time.

[0179] With these three measures, a robust model which does not depend heavily on precise initial conditions and zero estimation errors can be trained. Moreover, as discussed above in the population-based training, different trials can be carried out and explored by multiple agents in parallel, thus generating the policies with the account for more unusual paths and dynamics. Therefore, in real-time control, inference can be made directly based on the trained model without any additional training and a high-quality policy guiding the motion of the robots to complete the tasks can be obtained.

[0180] FIGS. 13-15 illustrate a control process in a scene with a vertical / horizontal cylinder and a teacup as the obstacles and a teapot as the target according to one embodiment of the present application. Refer to FIG. 13, a robot 1301 can be controlled to attain a grasp point on a handle of a target teapot 1302 while avoiding the collision with other objects, e.g. a teacup 1304 and a horizontal cylinder 1306. The control method is dynamic so that the robot 1301 can move and adjust its pose accordingly when the state of the objects in the scene changes in the process. Refer to FIG. 14, the robot 1301 is guided to bypass a vertical cylinder 1308 and attain the grasp point of the teapot 1302. Refer to FIG. 15, in the scene where the shortest path to the targets (e.g., teapot 1302) is blocked by the vertical cylinder 1308, the robot 1301 is guided to take the longer but feasible route to go around the large vertical cylinder 1308 behind it (from the robot side) without causing any collision and attain the grasp point of the teapot 1302. Due to the pose estimation module provided by the present application and the image data stream obtained from the camera is fed to the pose estimation module in real time, the robot 1301 can be guided by the robust RL algorithm to approach the target teapot 1302 and avoid collision with other objects. In one embodiment, the real-time robot control can be achieved in about 15 FPS.

[0181] FIG. 16 illustrates an overall software structure 1600 according to one embodiment of the present application. Refer to FIG. 16, the software structure 1600 includes a segmentation module for segmenting the realistic 2D images 1601 obtained from a camera into an object mask of the 2D image 1602; a pose estimation module for reconstructing the object mask of the 2D image 1602, together with the realistic 2D image 1601 as well as the robot forward kinematics 1603, into a real-time virtual digital twin of the real object so as to obtain the object pose estimation 1604; a contact point module for identifying contact points of the robot by ionic pressure sensor signals 1605 to obtain robot-object contact point map 1606; and a motion control module for generating a robot motion control plan 1607 by a reinforcement learning algorithm according to the inputs of 3D pose estimation 1604, robot-object contact point map 1606 and the robot forward kinematics 1603. In one embodiment, the realistic 2D images 1601, ionic pressure sensor signals 1605 and the robot control are frontend local inputs or outputs, and the rest are processed in backend GPU. The image processing and robot control can be done in local or on the remote cloud GPU server. In the case of remote cloud GPU server configuration, the client will send camera video stream input to the cloud server for image processing and the server will return a list of objects with their estimated 6D poses and for the client to rendered image video stream output to display.

[0182] In one embodiment, the software of the present disclosure further includes a Graphical User Interface (GUI) for user to easily and intuitively control a robot. The GUI can display video from each camera and rendering result of 3D scene. To control the robot, user can simply select command from the toolbar, and click the interactive video panel.

[0183] In one embodiment, asynchronous programing can be used to design the software structure, so that the GUI is not blocked by image processing and robot control threads. This asynchronous programing also helps software to adapt different pace between modules. To achieve real-time performance, the software only gets and passes the latest data between modules.

[0184] FIG. 17 illustrates a program sequence diagram demonstrating the communication among a GUI 2000, a control algorithm 2002, a visual module 2004 and a robot arm 2008.

[0185] To start the software, a user first will initialize the software to load configuration file of the system. Then initializing will calibrate hardware and software to be more accurate. Once the initialization is complete, the GUI 2000 will show on the screen for user to interact with.

[0186] In one embodiment, the GUI 2000 can show the original camera video and the rendering result of the digital twin and other user-selected video channels. For user interaction, the user can first select the command from the toolbar, then click the object or the location in the video panel. As stated above, the 2D image masks from the digital twin information can be used to determine the object or the location that the user selects. Based on that user input, the robot control algorithms will generate script for robot to do action, though the robot control library application programming interface (API) . In one embodiment, the client will send user inputs with desired object manipulation tasks (e.g., pick and put object) though, e.g., a server API, and the server will return the robot control script / commands to the client. The client will then use the command script to control the robot API through the local machine.

[0187] After a command (e.g., pick and put object) is selected, a signal will be transmitted to the control algorithm 2002, which will then communicate with the visual module 2004 to obtain the object and destination location, and then instruct the robot arm 2006 to move to the object location. Then, the control algorithm 2002 communicates with the visual module 2004 to obtain the robot arm location and instructs the robot arm to pick the object and move to the destination. At last, the control algorithm 2002 communicates with the visual module 2004 to obtain the robot arm location and instructs the robot arm to put down the object. It can be seen that, the user no longer needs to manually program (micro-program) individual robot joint angles or translations. The user simply needs to define high-level tasks (macro-program) for the robot to execute, such as ‘pick up teapot A’ and ‘pour the tea into cup B’ .

[0188] Compared to prior art, the real-time physical-digital-physical twin approach of the present disclosure enables a closed loop and real-time feedback system for the robotic control. State-of-the-art digital twin software such as Siemens’ Process Simulate deals with high-precision tasks which relies on physical twin creation based on digital twin design, which creates a high setup cost for the physical environment (which has to be kept closed and free from environmental noises) , making it more suitable for high-value product manufacturing only. The approach of the present disclosure which on the other hand enables complex robotic control with real-time feedback based on real-time digital twin reconstruction, making it more versatile for usage in different scenarios while taking into account environmental noises (and correspondingly larger tolerances) . This makes it suitable for larger-scale usage across middle and lower value manufacturing or service purposes. Example of these lower-accuracy activities, which are typically done by intensive human labor are: mechanical / electrical parts assembly, goods packaging, tying up cables, cooking, pouring / serving food and drinks, household chores, etc. Correspondingly, the approach of the present disclosure which deals with real-time environmental noise is suitable for enabling easier robotic programming across wide range of human-labor-intensive activities at lower cost, unlike traditional approaches which is limited to high-value high-tech product manufacturing.

[0189] In addition, the real-time differentiable rendering and pose estimation approach of the present disclosure is different from these prior art as the pipeline of the present disclosure does not use the static 2-dimensional image data input. The present disclosure instead uses the real-time video stream (continuous real-time stream of 2-dimensional image data input, either RGB image or depth image or both) which is continuously processed using machine learning image segmentation methods to turn it into 3-dimensional silhouette mask data, where each entry in the 3-dimensional array contains simple binary entry (0 / 1) with pixel area corresponding to select specified objects from the original image specified as 1. As there may be ambiguity on object silhouette mask extracted from the real-time image frames, further silhouette selection is done based on silhouette identified in the previous real-time image frame. This multi-object 3-dimensional silhouette image mask is the input into the differentiable rendering pipeline of the present disclosure. In addition, the method and system disclosed by the present disclosure is relatively fast, and is able to handle complex tasks, such as including multiple classes of objects, multiple objects occluding each other, multiple internal rotation / translation batch per object, and inclusion of robot arm with the correct forward kinematics in the pipeline, etc.

[0190] In some embodiments, the present disclosure optionally provides several engineering techniques for further accelerating the process.

[0191] Conventionally, differentiable rastering can be inherently slow. When dealing with complex scenarios where issues like multiple classes of objects, multiple objects occluding each other, multiple internal rotation / translation batch per object, and inclusion of robot arm with the correct forward kinematics in the pipeline exist, it is not even possible to reach a speed of 1 fps, let alone achieving real-time tracking effect.

[0192] Specifically, by profiling the differentiable rastering pipeline, the inventors of the present application discovers that the calculation of the robot forward kinematics is one of the most inefficient processes, which occupies a large amount of compute time, resulting in GPU running with low utilization and pose estimation fps. Such inefficiencies often originate from existing implementations which did not optimize the GPU practices.

[0193] In order to speed up, the present disclosure optionally includes one or more of the following techniques.

[0194] In some embodiments, the present disclosure provides a method of reducing the unnecessary construction of PyTorch3D Mesh object. The inventors of the present disclosure discovers that, although the conventional implementation with PyTorch3D Mesh object is suitable for differentiable rastering, the operations of constructing object or performing transformation on PyTorch 3D Mesh objects incur significant overhead. Therefore, the present disclosure mitigates this by directly performing any necessary transformation on a customized mesh vertices manually first, before finally constructing a PyTorch3D Mesh object in the last step prior to executing differentiable rastering (using either PyTorch3D, NVDiffRast, or other differentiable rastering kernel) .

[0195] In some embodiments, the present disclosure provides a method of reducing frequent small-sized CPU-GPU data transfer. In practical implementations, GPU may need to wait for data to be transferred from CPU, and vice versa. Such transfer and waiting may be implicit in the conventional implementations. In order to reduce such inefficiency, the method identify the codes that may cause data transmission from CPU to GPU, and eliminate or reduce such transmission. In some embodiments, the present method eliminates PyTorch tensors ‘. to (…) ’ in the iteration wherever possible and move it into the software initialization step instead. In some embodiments, the method eliminates new constant PyTorch tensor / matrix construction in each iteration. In some embodiments, if absolutely necessary, the tensor is generated directly inside the GPU instead of generating it in CPU before sending it to GPU. In some embodiments, the method reuses PyTorch matrices or modify some of their contents in-place whenever possible instead of generating new matrices using torch. cat function which takes list of matrices as input.

[0196] In some embodiments, since in the tracking task, not every surface detail of the object and the mesh are necessary, simply the object mask with high geometric fidelity is needed when rendered on the virtual camera, the method further reduces the detail of the object mesh or the robot mesh by reducing the mesh vertices count. Correspondingly, for each object or robot component used in the workflow, the method may reduce the mesh vertices count using graphical processing software such as Blender. In the beginning of mesh reduction, the objects  / robot components will maintain their geometric fidelity. As the mesh vertices reduces, eventually the object will start deforming and the method would stop the mesh vertices reduction process. In the method, preferably, it is possible to reduce the mesh count by up to ～20x.

[0197] Unified robotics description format (URDF) is an example of data format to describe the physical geometries of a robot and its components (in the form of point cloud mesh) , as well as the degree of freedoms available on the robot to enable its physical structure transformations (such as joint angle rotations, physical translations, etc) . The mesh components of a URDF file may consist of visual mesh (large number of trimesh polygons for visualization purposes) and collision mesh (smaller number of trimesh polygons for efficient collision detection purposes) . The inventors of the present application realizes that in a typical robot URDF file from manufacturer, a visual mesh (high vertices count and can generate beautiful images) and a collision mesh (low vertices count and look very coarse) are provided. Neither of these files are usable for the disclosed differentiable rastering pipeline because the visual mesh is computationally too expensive while the collision mesh looks completely different from the real robot. However, the visual mesh with reduced vertices that is generated by the present method using Blender is typically somewhere in between the two in terms of the vertices count, but still maintain the geometric fidelity important for differentiable rastering purposes.

[0198] In some embodiments, the method avoids recursive GPU code for the robot forward kinematics. The inventors of the present method discovers that, in the conventional implementation of GPU-compatible differentiable robot forward kinematics matrix calculation, such as the PyTorch Kinematics library, code is written in a recursive manner suitable for CPU operation, instead of suitable for GPU. For example, a typical forward kinematics library will evaluate a robot’s parent link (typically named the ‘base link’ ) , calculate its constant offset translation / rotation matrix, and calculate the additional translation / rotation matrix for that robot component based on the supplied input joint angles to generate the final parent link transformation matrix. Afterward, for each of the child link of the parent robot link, the process above is repeated, and the child link’s final transformation matrix will be multiplied with the parent link’s transformation matrix. The process is repeated recursively for each child of the child links, until there are no more children in the robot forward kinematics tree. This recursive algorithm is very slow when executed on the GPU for the robot’s parent link.

[0199] To solve this inefficiency, the method constructs the constant rotation / translation matrix for each link’s frame in advance during the software initialization (constant matrix is just calculated once) . The present method calculates the maximum number of tree branch length nmax (longest recursive parent-child chain from the base link until the farthest child link) in advance during the software initialization. During each forward kinematics function call, the present method creates an nbatch×nlink×nmax×4×4 identity transformation matrices with nbatch corresponding to the number of sets of joint angles expected to evaluate (in most purposes this will be 1) and nlink corresponding to the number of robot links, for which the present method generates the transformation matrix for. In the beginning of the iteration, these are just 4×4 identity matrices. The present method calculates the transformation matrices which correspond to each input joint angle and modify the relevant indices of the nbatch×nlink×nmax×4×4 transformation matrices based on the calculated joint angle transformation matrices. Note that many entries in this big matrix will stay as 4×4 identity matrices. Just like the recursive version, the present method then multiply these additional translation / rotation matrices with the relevant static offset matrices (pre-calculated) . However, unlike the recursive version where the compound transformation matrix multiplication is performed serially along each individual branch across multiple loops, this version of parallel forward kinematics compound transformation matrix multiplication of the present method will simply be done in one for loop along the nmax dimension, and the present method ends up with the necessary nbatch×nlink×nmax×4×4 forward kinematics transformation matrices. While this version will calculate a lot of ‘useless’ identity matrix multiplication M=M×I, when performed in a GPU this version will typically be more than 4x faster compared to the traditional recursive forward kinematics version.

[0200] In some embodiments, the method avoids using unnecessary quaternions. Quaternions are useful as it is a simple way of constructing physically valid transformation operations. However, it needs to be converted into 4×4 transformation matrices before it can be used for mesh transformation. The conversion process from quaternion to matrix and vice versa is done frequently. While individual operations are not necessarily very expensive, the large number of function calls have also made this a bottleneck function. The present method modifies the differentiable rastering pipeline to mostly operate using 4×4 matrices and only use quaternion when necessary to impose physical restriction on our transformation matrix. In addition to that, the conversion code is modified to ensure that there is no unnecessary extra multiplication operations. In this way, the present method reduces the frequency and cost of quaternion to matrix conversion function call.

[0201] In some embodiments, the method uses the Boost library to improve C++linear algebra operations, and re-compiles many relevant differentiable rastering tools using this Boost library toolchain to further accelerate many of the tensors’ linear algebra operations.

[0202] In some embodiments, as the number of target objects increases, so does the computational complexity, resulting in a decrease in frames per second (FPS) for scene-level pose estimation. In this case, the present method utilizes some sign (such as position of detected bbox, mask, or loss value) to determine when the pose digital twin has converged and it’s corresponding real object also in a static state. Upon identifying such instances, the present method ceases pose estimation for these objects, thereby reducing the overall computational load by skipping the gradient backward process of differentiable rasterization.

[0203] In some embodiments, the method utilizes the CUDA’s interoperability features to allow OpenGL and PyTorch (via CUDA) to share GPU memory buffers directly. This enables seamless data transfer between PyTorch and OpenGL, eliminating the need for intermediate CPU memory copies and reducing latency. By leveraging CUDA interoperability, the method can efficiently render the digital twin in real-time, providing a smooth and responsive user experience.

[0204] The embodiments of the present invention may be implemented by hardware, software, or a combination of software and hardware. The hardware part can be implemented using dedicated logic; the software part can be stored in a memory and executed by an appropriate instruction execution system, such as a microprocessor or dedicated design hardware. Those skilled in the art can understand that the above-mentioned devices and methods can be implemented using computer-executable instructions and / or included in processor control codes, for example, such codes are provided on a carrier medium such as a disk, CD or DVD-ROM, on a programmable memory such as a read-only memory (firmware) or on a data carrier such as an optical or an electronic signal carrier provide such codes. The device and modules thereof of the present invention can be implemented by hardware circuits such as very large scale integrated circuits or gate arrays, semiconductors such as logic chips, transistors, etc., or programmable hardware devices such as field programmable gate arrays, programmable logic devices, etc. It can also be implemented by software executed by various types of processors. It can also be implemented by a combination of the above-mentioned hardware circuit and software, such as firmware.

[0205] It should be noted that although several steps or modules of the method, and device for real-time robot control in the above detailed description, this division is only exemplary and not mandatory. In fact, according to the embodiments of the present application, the features and functions of two or more modules described above can be embodied in one module. In contrary, the features and functions of a module described above can be further divided into multiple modules to be embodied.

[0206] Those skilled in the art can understand and implement other changes to the disclosed embodiments by studying the description, the disclosed content, the drawings, and the appended claims. In the claims, the word “comprise” does not exclude other elements and steps, and the word “a” and “an” do not exclude plurals. In the practical application of the present application, one part may perform the functions of multiple technical features cited in the claims. Any reference numerals in the claims should not be construed as limiting the scope.

Claims

1.A computer-implemented method, comprising:receiving, from a camera, a real-time image data stream including a first two-dimensional image and a second two-dimensional image, wherein each of the first and second two-dimensional images includes a robot arm and at least one object;segmenting, by a trained neural network model, the first two-dimensional image to identify the robot arm and the at least one object, and obtain a first three-dimensional mask array representing positions of the robot arm and at least one object in the first two-dimensional image;generating a rendered robot arm image having a virtual robot arm pose that estimates a real robot arm pose in the first two-dimensional image and a rendered object image having a virtual object pose that estimates a real object pose in the first two-dimensional image, based on the first three-dimensional mask array, a robot arm digital model, an object digital model, and intrinsic parameters of the camera; andupdating the virtual robot arm pose and the virtual object pose in real time by a second three-dimensional mask array segmented from the second two-dimensional image.2.The computer-implemented method according to claim 1, wherein the first two-dimensional image is a depth image, and the step of segmenting further comprising refining a boundary of the robot arm and the object in the first three-dimensional mask array based on depth information of the depth image.3.The computer-implemented method according to claim 1, wherein the first three-dimensional mask array includes time data and velocity data of the first three-dimensional mask array with respect to the real-time image data stream.4.The computer-implemented method according to claim 1, wherein the step of segmenting comprises:comparing the first three-dimensional mask array with a previous second three-dimensional mask array to determine a difference in a pixel level between the first three-dimensional mask array and the previous three-dimensional mask array; andselecting or re-arranging indices of the robot arm and the object in the first three-dimensional mask array based on the difference in the pixel level between the first three-dimensional mask array and the previous three-dimensional mask array.5.The computer-implemented method according to claim 1, wherein the second three-dimensional mask array is stored in a mask buffer, and the real-time image data stream includes a third two-dimensional image and at least one of the robot arm and the object is not identified in the third two-dimensional image; the method further comprising:updating the virtual robot arm pose and the virtual object pose in real time based the second three-dimensional mask array stored in the mask buffer and direction data and speed data of the robot arm and the object in the second three-dimensional mask array.6.The computer-implemented method according to claim 1, the step of generating comprising:defining a loss function evaluating a difference between the object in the first two-dimensional image and the rendered object image; andcorrecting the virtual object pose of the rendered object image by minimizing the loss function.7.The computer-implemented method according to claim 6, the step of generating further comprising:when the difference between the object in the first two-dimensional image and the rendered object image is greater than a threshold, utilizing a first smoothing edge having a first range for generating the rendered object image; andwhen the difference between the object in the first two-dimensional image and the rendered object image is less than the threshold, utilizing a second smoothing edge having a second range for generating the rendered object image, wherein the first range is greater than the second range.8.The computer-implemented method according to claim 6, the step of generating further comprising:generating a plurality of duplicates for the rendered object image, wherein the plurality of duplicates offset from the rendered object image by different rotation angles;determining a plurality of local loss minimum based on the difference between the object in the first two-dimensional image and the plurality of duplicates;determining a global loss minimum based on the plurality of local loss minimum; andutilizing a pose with the global loss minimum as the virtual object pose for the rendered object image.9.The computer-implemented method according to claim 8, wherein the number of the plurality of duplicates and an offset angle of each of the plurality of duplicates are determined based on the symmetry of the object.10.The computer-implemented method according to claim 1, further comprising:controlling, by a reinforcement learning (RL) algorithm, a motion of the robot arm with respect to the object based on the rendered robot arm image and the rendered object image.11.The computer-implemented method according to claim 10, wherein the robot arm having at least two components and at least one joint, and the motion of the robot arm with respect to the object is controlled further based on forward kinematics of the robot arm.12.The computer-implemented method according to claim 1, wherein the robot arm having at least two components and at least one joint, and the rendered arm image further estimates an angle and a velocity of the at least one joint.13.The computer-implemented method according to claim 10, further comprising:receiving, from a pressure senor positioned on a surface of the robot arm, a pressure signal to generate a contact point map; andwherein the motion of the robot arm with respect to the object is controlled further based on the contact point map.14.The computer-implemented method according to claim 10, wherein the RL algorithm is trained to generate a goal achieving policy based on a reward function in relation to energy cost and distance of movement.15.The computer-implemented method according to claim 14, wherein the RL algorithm s trained to generate a collision avoidance policy based on the rendered object image.16.The computer-implemented method according to claim 15, wherein the goal achieving policy and the collision avoidance policy are combined to control the motion of the robot arm.17.The computer-implemented method according to claim 10, further comprising:receiving, via a graphic user interface, an input for selecting a task; andcontrolling the robot arm to perform the task according to a policy generated by the RL algorithm.18.The computer-implemented method according to claim 1, wherein the computer-implemented method is implemented at a cloud-based GPU server.19.A system comprising:a camera,a processor; anda memory configured to store instructions executable by the processor,wherein the processor is configured to:receive, from the camera, a real-time image data stream including a first two-dimensional image and a second two-dimensional image, wherein each of the first and second two-dimensional images includes a robot arm and at least one object;segment, by a trained neural network model, the first two-dimensional image to identify the robot arm and the at least one object, and obtain a first three-dimensional mask array representing positions of the robot arm and at least one object in the first two-dimensional image;generate a rendered robot arm image having a virtual robot arm pose that estimates a real robot arm pose in the first two-dimensional image and a rendered object image having a virtual object pose that estimates a real object pose in the first two-dimensional image, based on the first three-dimensional mask array, a robot arm digital model, an object digital model, and intrinsic parameters of the camera; andupdate the virtual robot arm pose and the virtual object pose in real time by a second three-dimensional mask array segmented from the second two-dimensional image.20.A non-transitory computer-readable storage medium having instructions stored therein that, when executed by a processor of a system, causes the processor to perform a method, the method comprising:receiving, from a camera, a real-time image data stream including a first two-dimensional image and a second two-dimensional image, wherein each of the first and second two-dimensional images includes a robot arm and at least one object;segmenting, by a trained neural network model, the first two-dimensional image to identify the robot arm and the at least one object, and obtain a first three-dimensional mask array representing positions of the robot arm and at least one object in the first two-dimensional image;generating a rendered robot arm image having a virtual robot arm pose that estimates a real robot arm pose in the first two-dimensional image and a rendered object image having a virtual object pose that estimates a real object pose in the first two-dimensional image, based on the first three-dimensional mask array, a robot arm digital model, an object digital model, and intrinsic parameters of the camera; andupdating the virtual robot arm pose and the virtual object pose in real time by a second three-dimensional mask array segmented from the second two-dimensional image.

Images