Method for generating a sphere model for generating a real pose of an object

Abstract

According to various embodiments, a method for generating a real pose ball model of an object is described, having: receiving a wireframe model of the object having a skeleton structure; generating a first ball model from the wireframe model; generating a second ball model from the first ball model by determining for each ball of the first ball model a set of closest points of the wireframe model; calculating for each joint of one or more joints of the skeleton structure a weight of the ball by averaging the weights of the points closest to the joint, and assigning the calculated weight to the ball.

Description

Technical Field

[0001] This disclosure relates to a method for generating a sphere model of an object for generating a realistic pose. Existing technology

[0002] Training machine learning models that process images requires a large number of training images. To avoid the expense of collecting and labeling real images, training images can be generated synthetically. In the case of training images showing people, it is desirable to be able to efficiently render people in realistic poses. Summary of the Invention

[0003] According to various embodiments, a method is provided for generating a sphere model of an object for generating a realistic pose, the method comprising: receiving a wireframe model of the object having a skeleton structure; generating a first sphere model from the wireframe model; generating a second sphere model from the first sphere model by determining a set of nearest points of the wireframe model for each sphere of the first sphere model; calculating the weight of the sphere for each joint of one or more joints of the skeleton structure by averaging the weights of the points closest to the joints; and assigning the calculated weights to the spheres.

[0004] The above method enables the generation of a sphere model that allows for the generation of realistic poses and thus enables the generation of image data showing a person, animal, or robot in a realistic pose.

[0005] The use of spheres allows for the approximation of 3D geometry using a simple set of geometric primitives. Furthermore, compared to triangles, checking for (self)collisions can be performed simply and quickly with spheres. Representing the 3D geometry of a virtual human requires only a few hundred spheres instead of thousands of triangles, reducing both the storage required for representation and the number of collision tests. By choosing the appropriate number of spheres, a fine balance can be struck between accurate representation of the virtual human and the number of collision tests to be performed.

[0006] This sphere model can be used to generate virtual humans (or animals, robots, or other moving objects) in random but realistic poses. These virtual humans can then be placed in a virtual environment to create synthetic images that include humans in realistic poses. Because the poses and positions of the virtual humans are known, annotations that can be used to train ML (machine learning) models (especially object detectors) are available for the synthetic images. These annotations can also be used as test data, validation data, or verification data to check whether the trained machine learning model can operate safely.

[0007] The methods described above can be used to create images of people in a wide variety of poses and situations. In particular, poses and situations that do not typically appear in the training dataset (i.e., anomalies) can be considered. These images can then be used to test whether the system under test (e.g., containing a trained object detector) responds robustly to these scenarios.

[0008] The above method can also be used for "Human Motion Capture" (Mo-Cap), which involves generating and using poses from a spherical model. In Mo-Cap, the motion of a real person is recorded. For this purpose, a (e.g., black) garment is used, on which reflective markers are placed. The aim is to infer the person's pose, i.e., skeletal structure, from these markers. Since the markers are fixed to the person's surface, they can be considered as points with zero distance from the person. The spherical model (generated using the above method) can now be used to obtain the pose given the markers: in an optimization method, the pose of the spherical model can be changed so that all points (corresponding to the markers) lie on the surface of the spherical model. Thus, the pose is obtained from the skeletal structure of the spherical model for a given marker.

[0009] Various embodiments are described below.

[0010] Example 1 is a method for generating a sphere model of an object to produce a realistic pose, as described above.

[0011] Example 2 is based on the method of Example 1, which includes: calculating weights for each joint of the skeleton structure, and assigning a pre-given number of weights, the largest of the calculated weights, to the sphere.

[0012] In other words: Assign joints to each sphere, where the joints are such that the highest weight is obtained for each joint, for example, assigning four joints to a sphere where the highest weight is calculated by averaging the weights of the points closest to that joint.

[0013] Therefore, the sphere model reflects the motion given by the skeleton structure of the wireframe model, so that as long as the wireframe model and its skeleton structure are accurate, the sphere model provides a realistic pose.

[0014] Example 3 is a method according to Example 1 or 2, the method comprising: generating a first sphere model from a wireframe model by means of a neural network, the neural network obtaining a randomly selected state vector from a state space as input, wherein the state vector is matched such that the first sphere model approximates the wireframe model (i.e., such that the sphere model conforms to the wireframe model according to a pre-given consistency criterion (e.g., as well as possible)).

[0015] Therefore, intuitively speaking, neural networks function as generative models in a decoder manner. In this way, it is possible to generate realistic sphere models after training the neural network.

[0016] Example 4 is a method according to any one of Examples 1 to 3, the method comprising: training a neural network to reduce a loss having at least a portion of the following loss components: • The penalty is a component of the loss that accounts for the deviation between the sphere model generated by the neural network for the training wireframe model (Trainings-Drahtgittermodell) and the training wireframe model; • For each sphere in the sphere model generated by the neural network for the training wireframe model, a penalty is applied if the sphere does not overlap with the training wireframe model, which is a component of the loss; and • The penalty is a component of the loss that utilizes the deviation between the probability distribution sampled from the state space and a pre-given probability distribution.

[0017] This makes it possible to efficiently train neural networks to generate sphere models from wireframe models.

[0018] Example 5 is a method for generating the pose of an object, the method comprising: generating a sphere model of the object according to one of Examples 1 to 4, and generating the pose by modifying the position of the center point of at least a portion of the sphere in the sphere model, taking into account the weights assigned to the sphere.

[0019] Example 6 is a method according to Example 5, the method comprising: examining the generated poses in terms of self-collision by: for pairs of spheres in a sphere model, examining whether the spheres intersect in the generated poses, and, in the case of one or more self-collisions, modifying the poses to avoid at least a portion of the one or more self-collisions.

[0020] In this way, a realistic posture can be produced in which no body parts intersect.

[0021] Example 7 is a method according to Example 6, wherein the modification includes: moving intersecting spheres away from each other by moving one or more joints, the intersecting spheres being assigned to one or more joints by weights assigned to the spheres.

[0022] Example 8 is a method for generating training images for a machine learning model, the method comprising: generating an object pose according to one of Examples 1 to 7, and rendering the object in the pose in front of a background.

[0023] This can be done by posing the wireframe model into the resulting pose and rendering the object (i.e., the image of the object) based on the wireframe model.

[0024] In the case of using training images, a machine learning model can be trained to identify objects (e.g., pedestrians) in the images and / or determine the distance, velocity, and / or acceleration of objects (e.g., pedestrians) represented by a sphere model from one or more images. This machine learning model (or the results it provides) can also be trained or used to track such objects. Thus, for example, training images can be generated for an object detector, and the object detector can be trained using these training images. The object detector can then be used to detect objects in the environment of the robotic device, and the robotic device can then be controlled based on the detected objects (e.g., to avoid people). The term "robotic device" can be understood to refer to any technical system (having mechanical parts whose movement is controlled), such as computer-controlled machines, vehicles, household appliances, power tools, manufacturing machines, personal assistants, or access control systems.

[0025] Example 9 is a method for training a machine learning model for recognizing objects, the method comprising: generating training images for the machine learning model according to Example 8, and training the machine learning model using the training images.

[0026] Example 10 is a method for controlling a robotic device, the method comprising: identifying one or more objects in the environment of the robotic device according to a trained machine learning model according to Example 9, and controlling the robotic device according to the identified one or more objects.

[0027] Example 11 is a data processing system configured to perform a method according to any one of Examples 1 to 10.

[0028] Example 12 is a computer program having instructions that, when executed by a processor, cause the processor to perform a method according to any one of Examples 1 to 10.

[0029] Example 13 is a computer-readable medium that stores instructions that, when executed by a processor, cause the processor to perform a method according to any one of Examples 1 to 10. Attached Figure Description

[0030] In the accompanying drawings, similar reference numerals generally refer to the same parts in all different views. The drawings are not necessarily to scale, and instead, they generally emphasize the illustration of the principles of the invention. In the following description, various aspects are described with reference to the following drawings.

[0031] Figure 1 The vehicle is shown.

[0032] Figure 2 The flowchart illustrates the training of a neural network to convert a wireframe network into a sphere model.

[0033] Figure 3 The flowchart illustrates the process of generating a sphere model from a wireframe model.

[0034] Figure 4 The flowchart illustrates how to generate a pose using a spherical model that can be posed.

[0035] Figure 5 The flowchart illustrates a method for generating a sphere model that produces a realistic pose for an object. Detailed Implementation

[0036] The following detailed description relates to the accompanying drawings, which illustrate specific details and aspects of this disclosure for illustrative purposes, in which the invention may be practiced. Other aspects may be used, and structural, logical, and electrical changes may be made without departing from the scope of the invention. The various aspects of this disclosure are not necessarily mutually exclusive, as some aspects of this disclosure may be combined with one or more other aspects of this disclosure to form new aspects.

[0037] The different examples are described in more detail below.

[0038] Figure 1 Vehicle 101 is shown.

[0039] exist Figure 1 In the example, vehicle 101, such as a motor vehicle, like a passenger car or a truck, is equipped with a vehicle control device (e.g., an electronic control unit (ECU)) 102.

[0040] The vehicle control unit 102 has data processing components, such as a processor (e.g., a CPU (Central Processing Unit)) 103 and a memory 104 for storing control software 107 and data. The vehicle control unit 102 operates according to this software, and the data is processed by the processor 103. The processor 103 implements the control software 107 (which therefore...) Figure 1(represented as part of processor 103).

[0041] For example, the stored control software (computer program) has instructions that, when executed by the processor, cause the processor 103 to perform driver assistance functions or even autonomously control the vehicle.

[0042] Control software 107 is transmitted to vehicle 101, for example, via network 106 (or also by means of a storage medium, such as a memory card), from computer system 105. This can also occur during operation (or at least when vehicle 101 is at the user's location), as control software 107 is updated to a new version, for example, over time.

[0043] For example, the control software 107 can be trained using machine learning (ML), meaning the control software 107 implements one or more ML models 108 (or "machine learning models") trained based on training data—in this example, by the computer system 105. The computer system 105 then implements ML training algorithms for training the one or more ML models 108, which, for example, are used for object recognition (e.g., for other traffic participants).

[0044] Training ML models, such as neural networks, requires a large amount of training data. For example, if an ML model performing object recognition—that is, an object detector that identifies people in images—is to be trained as in the example above, then thousands of images representing people in a wide variety of poses are needed for this training. Additionally, these images must be labeled (“annotated”) to indicate exactly where the people can be seen in the images. Image recording and annotation are costly and expensive, especially since this involves three-dimensional data with human body poses. Furthermore, data protection laws are also involved in the case of images containing people.

[0045] One possibility for mitigating these difficulties is to use synthetically generated (image) data. The main advantage in this case is the ability to create large quantities of such data at low cost, and additionally, the ability to automatically and highly accurately label the generated data. Data protection laws also do not need to be considered in this scenario.

[0046] However, the synthetically generated data must represent people in real poses. Therefore, ML models trained on synthetic data work without problems on real data (real images), i.e., training an ML model that can generalize to real situations.

[0047] The 3D geometry of a virtual human is essentially constructed from two components: a "skin" and a basic skeleton. The "skin" is typically represented by a polygonal wireframe network composed of triangles. This wireframe network stretches onto the virtual skeleton, which can be used to pose the virtual human in various ways. This latter practice is also known as "posing." It's important to note that not all poses represent a real human. For example, consider a virtual human's arms positioned inside its chest cavity, which would not occur in reality. Therefore, self-intersections of the wireframe network may be possible.

[0048] There are solutions to minimize or avoid self-intersections. A naive approach is to check for collisions between each triangle in the wireframe network and any other triangle. However, commonly used virtual human wireframe networks consist of thousands of triangles, which translates to significant time and storage overhead in collision testing. Another possibility is to approximate the wireframe network using a set of cylinders, which reduces the number of collision tests required. However, in this case, only a rough approximation of the virtual human's geometry is possible, which is often insufficiently accurate.

[0049] According to various implementations, one approach involves approximating a wireframe network (particularly a wireframe network for a virtual human, but also potentially for an animal or robot) using a set of geometric primitives (e.g., spheres). Then, a posed sphere model (i.e., a sphere model that can be posed into different (realistic) poses) is generated from this sphere model. This sphere model is then posed into different poses, taking into account the self-intersections between the spheres.

[0050] In other words, according to various implementations, the 3D geometry of a person is approximated by a set of posable spheres (i.e., sphere models that follow a skeletal structure and have posable spheres according to various implementations), which enables efficient collision calculations for efficiently verifying self-intersections. The posability of the spheres allows the calculated collisions to be avoided by changing the position of the spheres so that they no longer have self-intersections.

[0051] The primary objective is therefore to place a set of spheres in three-dimensional space such that the surfaces of these spheres represent the surfaces of the virtual human. To this end, it is assumed that for different wireframe networks of the virtual human, the SDF values ​​of points in space (i.e., the SDF values ​​of points in space with respect to the corresponding wireframe network) are made available. This set of points is referred to below as the pre-given set of points in space. For example, this set can be randomly selected, and then it is possible to compute the SDF values ​​of its points with respect to the wireframe network (e.g., by calculating the distances to each triangle of the wireframe network and finding the minimum among these distances).

[0052] A signed distance function (SDF) is a mathematical representation of the possibility of 3D geometry. A signed distance function can be constructed using a wireframe network of a 3D geometry (in this example, the shape of a person). For any point in space (for which an SDF value should be determined), the minimum distance between that point and the surface of the wireframe network is calculated. The sign of this distance indicates whether the point is inside the wireframe (negative sign) or outside the wireframe (positive sign). Points on the surface of the wireframe network have an SDF value of zero. Therefore, the surface of a 3D geometry can be represented by a set of points with their respective SDF values. In general, SDF is also suitable for calculating collisions between two objects. For a point on the surface of one object, an SDF value for a second object can be calculated. If the SDF value is positive, no collision occurs. If the value is negative, the objects collide. However, this method cannot be applied to self-intersections: the SDF value is always the minimum distance to the surface. Therefore, if a portion of the wireframe network is within itself, and a point is chosen on the surface, the SDF value will always be zero because the point is already on the surface of the wireframe network. Thus, testing for self-intersection is a more difficult problem than general collision testing and requires alternative collision calculation methods.

[0053] According to various implementation methods, a 3D geometric model of a sphere is generated. Then, a self-intersection test can be performed based on a check of whether any two spheres in the sphere model intersect. To test whether two spheres intersect, the distance between the center points of the spheres is first calculated. Now, the radii of the two spheres are subtracted from this distance. If the value is less than zero, the spheres collide; if the value is greater than zero, no collision occurs.

[0054] A sphere model can be generated for a given wireframe network using SDF values ​​as follows: First, note that for a set of spheres, the SDF value can be determined for any point in space. To do this, determine the minimum distance from that point to the surfaces of all the spheres. Use the minimum of these distances as the SDF value (with respect to the set of spheres) for that point. To generate a sphere model for a given wireframe network, match the center point and radius of the spheres such that the error between the SDF value of the point with respect to the set of spheres and the SDF value of the point with respect to the wireframe network is minimized. In this way, the surface of the wireframe network is approximated by the surface of the spheres.

[0055] To achieve generalization across various wireframe networks, a neural network can be used. The network's task is to predict the parameters of a sphere. The input parameters of the neural network are sampled from the hidden state space (i.e., the latent space) according to a probability distribution whose parameters are learned during training (e.g., a Gaussian normal distribution). This results in similar sphere models having similar values ​​in the hidden state space. This property can then be fully utilized to transform any wireframe network into a sphere model.

[0056] Figure 2 Flowchart 200 is shown, illustrating the training of a neural network to convert a wireframe network into a sphere model.

[0057] In 201, state vectors are first sampled from the hidden state space. This is based on a probability distribution with defined parameters, such as a Gaussian normal distribution with mean and variance as parameters (these parameters are initially set to initial values, but are matched during training).

[0058] In 202, the sampled state vector is fed as input to a neural network (which is initialized with random weights at the beginning, for example), which then determines the parameters of the sphere model (the center point of the sphere and the radius of the sphere).

[0059] For this neural network, three components of the loss (i.e., the components of the loss function) are identified in 203: 1) The error between the SDF value of a pre-given set of points in space with respect to a sphere set and the SDF value of a pre-given set of points in space with respect to a wireframe network.

[0060] 2) Utilize the deviation of the probability distribution sampled from the latent space from a pre-given probability distribution (e.g., the difference between the Gaussian distribution mean and 0 and the difference between the Gaussian distribution variance and 1). 3) Error, which assesses whether all spheres of the determined sphere model contain points within (or at least exactly on) the wireframe network, i.e., at least partially overlapping the wireframe model. This error is, for example, the sum of individual errors on all spheres of the sphere model, where, for example, if a sphere contains points within (or on) the wireframe network, then the individual error of that sphere is zero, and, for example, the further away the nearest point of a sphere from the wireframe network, the larger the individual error of that sphere.

[0061] If the value of the loss function (which has these three components, such as that computed on a batch of wireframe models for training) is small enough (i.e., below a pre-given limit), then training ends in 204.

[0062] If the error is not small enough, in step 205 (with the help of backpropagation), the parameters of the neural network and the parameters of the probability distribution are matched in the direction of reducing the loss function, and the training continues iteratively (typically for new batches).

[0063] Therefore, the loss function is matched not only to the neural network but also to the parameters based on the probability distribution it samples from the latent space. For example, matching the expectation and variance of a Gaussian normal distribution makes the state vector that will provide a small loss function value more likely than the sampled state vector (e.g., on average over a batch).

[0064] Regarding the third component of the loss function as described above, it should be noted that for any point with a given SDF value, there are arbitrarily many ways to place the spheres to achieve the same SDF value for that point. Specifically, the spheres can be placed inside or outside the wireframe network that should be approximated by the sphere model. For a true approximation of the wireframe network, it is desirable that all spheres are located within the wireframe network. Therefore, it is required during training, through the third component of the loss function, that each sphere contains at least one point that was initially located within the wireframe network.

[0065] After training the neural network, it can be used to transform any wireframe network of a virtual human into a spherical model.

[0066] Figure 3 Flowchart 300 is shown, which illustrates the generation of a sphere model from a wireframe model.

[0067] In 301, points on the surface of the wireframe network are determined (the SDF value of the points with respect to the wireframe network is zero).

[0068] In 302, state vectors are sampled from the latent space based on the learned probability distribution.

[0069] In 303, a trained neural network is used to obtain a sphere model, i.e., a set of spheres, from Gaussian state vectors, which includes the positions of the spheres in space and the radii of the spheres. These spheres may not yet reflect the desired wireframe network well enough.

[0070] Therefore, in step 304, the SDF values ​​of the points defined on the surface of the wireframe network with respect to the sphere model are calculated and summed to form the error. Now, an optimization method is used to find a state vector that, when used as input to the neural network, results in the smallest possible error. This state vector is then iteratively changed, fed into the neural network, and the error of the resulting sphere model is calculated until it is sufficiently small.

[0071] Alternatively, the upstream second neural network (encoder) can also directly predict the state vector given the points determined on the wireframe network. This encoder must then be trained either jointly with the downstream neural network (which determines the sphere model from the state vector and can be considered a decoder) or post-processed using the training data.

[0072] Now, if the desired wireframe network has been transformed into a sphere model, then, as explained above, using this sphere model, images of people in realistic poses can be generated. This requires posing the sphere using a corresponding skeleton structure as the underlying framework. This can be achieved by directly utilizing the skeleton of the wireframe network as the basis (i.e., the virtual skeleton of the wireframe network).

[0073] To this end, the spheres of the sphere model are assigned to the joints of the skeleton, so that the spheres can correspond to joint movements. For this purpose, a wireframe network as the basis is again considered. Each point in the wireframe network has a corresponding skeleton weight, which is assigned to the joint of the skeleton. Now, for each sphere, the distance from the sphere surface to a point in the wireframe network is determined. Therefore, a set of wireframe network points, which are the nearest neighbors (e.g., eight) for each sphere, can be determined. The skeleton weights for each sphere can then be determined by interpolating the skeleton weights of these neighboring points. This results in a sphere model that can now be used to generate poses that are realistic (avoiding self-intersection in the case of realistic poses).

[0074] Figure 4 Flowchart 400 is shown, which illustrates how to generate a pose using a spherical model that can be posed.

[0075] First, pose 402 is generated from any initial pose 401 by changing the position of the sphere while taking into account the skeleton structure (i.e., the sphere weights relative to the skeleton).

[0076] Therefore, the center point of the sphere (considering its weights) is moved in the same way that the points of the wireframe network (considering their weights) are moved, as in methods such as LinearBlend Skinning. For example, the pose of the joints can be changed randomly and the resulting center point of the sphere can be determined, or the position of the center point of a single sphere can be changed and matched to the center points of other spheres according to the skeleton structure (where boundary conditions (e.g., maximum distance) are observed when changing the position of a single sphere: for example, if two adjacent spheres are placed very far apart from each other, it may be difficult or impossible to find a good pose that reflects them).

[0077] Then, in step 403, collision calculations between the spheres are performed. That is, for the pose, each sphere of the sphere model is tested for collisions with respect to all the remaining spheres, as described above. If no collisions are found, the pose is valid and can be considered realistic, and is further processed in step 404 (i.e., for example, for rendering training images).

[0078] If a collision is found, in step 405, the skeleton weights of the spheres can be used to determine which joint of the skeleton is responsible for the collision. The poses of the corresponding joints can then be changed so that the colliding spheres move away from each other (i.e., "push away"). For example, the poses of the two colliding spheres can be changed such that the distance between them depends on the pose of the joints until the spheres no longer intersect.

[0079] This generates a new pose. Starting from this new pose (i.e., replacing the arbitrary initial pose), the process can be repeated, i.e., iterated, until there are no more ball collisions (where one can start again from the initial pose if a "dead end" is reached or a certain number of unsuccessful iterations are exceeded). The resulting pose can then be considered valid. This pose can also be automatically and iteratively optimized in an Auto-Gradient Framework.

[0080] If an effective (realistic) pose has been found in this way using the sphere model, it can be used to generate an image. To do this, the realistic pose is applied to a wireframe network as the base, so that the wireframe network can be used to generate the image.

[0081] In summary, various implementation methods are provided as follows: Figure 5 The method shown.

[0082] Figure 5 Flowchart 500 is shown, which illustrates a method for generating a sphere model that is in a realistic pose (i.e., a sphere model that can pose realistically) for generating an object (typically in human form, but could also be an animal).

[0083] In 501, the receiving object is a wireframe model, wherein the wireframe model has a skeleton structure (i.e., each point of the wireframe model, i.e., each vertex, typically a triangle vertex in the case of a wireframe model composed of triangles, has one or more weights that assign the point to one or more joints of the skeleton).

[0084] In 502, a first sphere model is generated from the wireframe model (the first sphere model contains multiple spheres, each having a corresponding center point in three-dimensional space and a radius).

[0085] In 503, a second (capable of realistically posing) sphere model is generated from the first sphere model by determining the set of nearest points (i.e., vertices) of the wireframe model for each sphere of the first sphere model. The weight of the sphere is calculated for each joint of one or more joints of the skeleton structure by averaging the weights of the points closest to the joint, and the calculated weights are assigned to the spheres.

[0086] Figure 5 The method can be executed by one or more computers having one or more data processing units. The term "data processing unit" can be understood as any type of entity capable of processing data or signals. For example, data or signals can be processed according to at least one (i.e., one or more) specific functions performed by the data processing unit. The data processing unit may include analog circuits, digital circuits, logic circuits, microprocessors, microcontrollers, central processing units (CPUs), graphics processing units (GPUs), digital signal processors (DSPs), programmable gate arrays (FPGAs), integrated circuits, or any combination thereof, or constructed from these. Any other means of implementing the corresponding functions described in more detail herein can also be understood as a data processing unit or logic circuit arrangement. One or more method steps in the method steps described in detail herein can be implemented (e.g., carried out) by the data processing unit through one or more specific functions performed by the data processing unit.

[0087] Therefore, depending on the implementation scheme, this method is particularly computer-based.

Claims

1. A method for generating a sphere model of an object for generating a realistic pose, the method comprising: Receive (501) a wireframe model of the object with a skeleton structure; A first sphere model (502) is generated from the wireframe model; (503) A second sphere model is generated from the first sphere model by determining the set of nearest points of the wireframe model for each sphere of the first sphere model, and the weight of the sphere is calculated for each joint of one or more joints of the skeleton structure by averaging the weights of the points closest to the joint, and the calculated weights are assigned to the sphere.

2. The method according to claim 1, the method comprising: calculating weights for each joint of the skeleton structure, and assigning a pre-given number of weights, the largest of the calculated weights, to the sphere.

3. The method according to claim 1 or 2, wherein the method comprises: generating (303) the first sphere model from the wireframe model by means of a neural network, the neural network obtaining a randomly selected state vector from the state space as input, wherein the state vector is matched such that the first sphere model approximates the wireframe model.

4. The method according to any one of claims 1 to 3, the method comprising: training the neural network to reduce loss, the loss having at least a portion of the following loss components: The penalty is a component of the loss calculated by the neural network for the deviation between the sphere model generated by the training wireframe model and the training wireframe model; For each sphere in the sphere model generated by the neural network for the training wireframe model, a penalty is applied if the sphere does not overlap with the training wireframe model, which is a component of the loss; and The penalty is a component of the loss that utilizes the deviation between the probability distribution sampled from the state space and a pre-given probability distribution.

5. A method for generating the pose of an object, the method comprising: generating a sphere model of the object according to any one of claims 1 to 4, and generating the pose by modifying the position of the center point of at least a portion of the sphere in the sphere model, taking into account the weights assigned to the sphere (402).

6. The method according to claim 5, wherein the method comprises: examining the generated pose in terms of self-collision by: for pairs of spheres in the sphere model, examining whether the spheres intersect in the generated pose, and, in the case of one or more self-collisions, modifying the pose to avoid at least a portion of the one or more self-collisions.

7. The method of claim 6, wherein the modification comprises: moving intersecting spheres away from each other by moving one or more joints, the intersecting spheres being assigned to the one or more joints by weights assigned to the spheres.

8. A method for generating training images for a machine learning model (108), the method comprising: generating an object pose according to any one of claims 1 to 7, and rendering the object in the pose in front of a background.

9. A method for training a machine learning model (108) for recognizing objects, the method comprising: generating training images for the machine learning model (108) according to claim 8, and training the machine learning model (108) using the training images.

10. A method for controlling a robotic device (101), the method comprising: training a machine learning model (108) according to claim 9, identifying one or more objects in the environment of the robotic device (101), and controlling the robotic device (101) based on the identified one or more objects.

11. A data processing system configured to perform the method according to any one of claims 1 to 10.

12. A computer program having instructions that, when executed by a processor, cause the processor to perform the method according to any one of claims 1 to 10.

13. A computer-readable medium storing instructions that, when executed by a processor, cause the processor to perform the method according to any one of claims 1 to 10.

Images