ClutterGen: A Cluttered Scene Generator for Robot Learning
Authors: Yinsen Jia
Boyuan Chen
Venue: CoRL 2024 (2024)
Keywords: Simulation Scene Generation
Manipulation
Robot Learning
TL;DR: ClutterGen, a physically compliant simulation scene generator capable of producing highly diverse, cluttered, and stable scenes for robot learning.

Abstract: We introduce ClutterGen, a physically compliant simulation scene generator capable of producing highly diverse, cluttered, and stable scenes for robot learning. Generating such scenes is challenging as each object must adhere to physical laws like gravity and collision. As the number of objects increases, finding valid poses becomes more difficult, necessitating significant human engineering effort, which limits the diversity of the scenes. To overcome these challenges, we propose a reinforcement learning method that can be trained with physics-based reward signals provided by the simulator. Our experiments demonstrate that ClutterGen can generate cluttered object layouts with up to ten objects on confined table surfaces. Additionally, our policy design explicitly encourages the diversity of the generated scenes for open-ended generation. Our real-world robot results show that ClutterGen can be directly used for clutter rearrangement and stable placement policy training.

ClutterGen: A Cluttered Scene Generator for Robot Learning
Yinsen Jia
Boyuan Chen
Duke University
Abstract: We introduce ClutterGen, a physically compliant simulation scene generator capable of producing highly diverse, cluttered, and stable scenes for robot learning. Generating such scenes is challenging as each object must adhere to physical laws like gravity and collision. As the number of objects increases, finding valid poses becomes more difficult, necessitating significant human engineering effort, which limits the diversity of the scenes. To overcome these challenges, we propose a reinforcement learning method that can be trained with physics-basee reward signals provided by the simulator. Our experiments demonstrate that ClutterGen can generate cluttered object layouts with up to ten objects on confined table surfaces. Additionally, our policy design explicitly encourages the diversity of the generated scenes for open-ended generation. Our real- world robot results show that ClutterGen can be directly used for clutter rearrangement and stable placement policy training.
Keywords: Simulation Scene Generation, Manipulation, Robot Learning
kandon lepecion Sancing
Mumber Doeds
(a)
(b)
Fig. 1: (a) The success rate of generating stable simulation setup. When the number of objects in the environment increases, the difficulty of creating such stable setup also increases. The traditional heuristic method cannot create simulation seene above objects, while ClutterGenn consistently achieves high success rates. (b) Diverse, cluttered, and stable simulation setups created by ClutterGen.
Introduction
Simulation has played an important role in advancing robot learning [1, 2, 4, by providing a controlled yet versatile environment for developing and testing algorithms. Data-driven approaches, in particular, typically deploy robots into simulations to undergo extensive training across a variety of diverse and randomized settings to enable generalizable and adaptable behaviors. Significant advancements in robot learning have been achieved by randomizing object shapes [4, 6, 7]. textures [8, 9, 10, 11], and dynamics [12]. However, the layout of objects, despite being another critical factor, remains challenging to reach fully endeee randomization.
Unlike object properties, which can be casily specified within a range without interfering with other objects, object layout must consider the presence of other objects and physical feasibility. For instance, arranging objects in a scene requires ensuring that they do not overlap and are placed in stable positions instead of falling down from the air. Existing efforts often prevent this issue by fixing the object bases [13, 4, 14. 15].
8th Conference Robot Leaming (CoRL 2024), Munich, Germany.

---

but this strategy is not suitable for many objects like bottles or cups. As the number of objects increases within a limited space, generating a randomized yet stable object layout becomes exponentially difficult. Fig. ((a) shows the challenge of using the widely adopted approach of random sampling and rejecting failure trials [16, 17, 18, 19] to generate valid scenes, with even seven objects on a table. Other methods require human manual specifications of object regions for local randomization [20, 21, 22] or apply discretization to the possible placement space to avoid collisions [17, 23, 24). However, navigating and manipulating cluttered environments are essential challenges to deploying robot learning the real world.
We introduce ClutterGen, an auto-regressive simulation scene generator for creating physically compliant and highly diverse cluttered scenes. By framing cluttered scene generation as a reinforcement learning prob- lem, ClutterGen learns a closed-loop policy from 3D observations without requiring pre-exise pre-existing datasets human specifications. Once trained, ClutterGen can be applied to variations of the original environment without fine-tuning. We further demonstrate the utility of ClutterGen in several downstream tasks including real-world clutter rearrangement and training robust placement policies for zero-shot sim-to-real transfer.
Our main contributions are summarized as follows:
We frame the scene generation problem reinforcement learning task, enabling closed-loop policy for creating physically compliant, cluttered, and diverse environments. Our model-free training process uses intuitive physics-basel -bsed rewards without relying on pre-existing datasets or human specifications.
Our policy design encourages scene diversity to enhance general robot training.
We demonstrate ClutterGen's applicability to real-world clutter rearrangement tasks and its effectiveness as a synthetic data generator for training robust stable placement policies.
2 Related Work
Procedural Content Generation (PCG) Recently, there has been growing interest in data-driven PCG al- gorithms using generative models for indoor scene generation [25, 26, 27], 3D object asset creation [28, 29], and household rearrangement [30. 31, 32, 32, 33, 34). Large-Lagguaee models (LLMs) have also been used to guide scene generation [35, 36, 37] due to their prior embedded human knowledge. However, existing methods often impose strong heuristics such as limiting the regions of each object, and fail to consider physics feasibility, resulting in scenes with intersecting objects, floating objects, and unstable placements that are not suitable for generating flexible, diverse, and realistic robot training environments. In contrast, our method frames scene generation reinforcement learning task while explicitly considering the physical stability of the scene generation without relying on human-designed training datasets or expert heuristics.
Scene-level Randomization for Robot Learning. Scene-level randomization has been crucial in robot learning. Recent work has focused on synthesizing object shapes [4, 6] and textures [8, 9, 10, 11] reduce data collection costs and improve model robustness. However, randomizing object poses in simulation scenes remains challenging. Traditional methods, such as random rejection sampling [16, 17, 18, 19], require significant human effort to define the range of object positions and verify scene validity. As the number of objects increases, finding valid poses becomes exponentially harder within a confined region, resulting in low diversity and success rates (Fig. (a))). Recently, LLMs have been used to synthesize simulation scenes [38, 22, 39], but they rely on pre-existing datasets or knowledge and extensive user-defined heuristics for object positions. Moreover, LLMs struggle to create accurate object placements without observing physical behaviors, leading to unstable scenes. Our method does not require a high-quality dataset pre-defined pose constraints and trains by directly interacting with the simulation environment. Our method can create stable, diverse, and highly cluttered scenes for robot training.
3 The ClutterGen Framework
Designing a simulation environment for robot training typically involves a human expert observing the scene and object geometry, deciding on a placement, running simulations to check for collision and unstable pose issues, and adjusting placements as needed. This iterative process, repeated until object poses are finalized, is difficult scale due to its heavy human involvement and time-consuming trial-and-ers We propose ClutterGen automate the steps for generating cluttered simulations using a single learning agent. ClutterGen controls scene generation in closed-loop manner under challenging cluttered scenarios. Our key idea is to formulate the process reinforcement learning task. Without prior knowledge or

---

Queried Scone
Points Cloud fronder
Pocement
Objjct Feature
Placement
Nusi Queree Object
Alterpl History
Object Movement Tregettory
Placement
Pown
Filled Placemont
Previous Placemmnt
Sequence Preander
Huatry Feature
Quartedd
Rog
Next Aftempt
ClutterGen. We stack soquence of attempt histories input to the history sequence encoder generate the history feature. This feature, combined with the perception feature from point cloud encoder, is taken by ClutterGen output the placement pose for the queried object. The simulator evaluates the placement's stability, determining whether to proceed to the next attempt or the next queried object placement.
Fig. 2:
human input, ClutterGen can generate diverse and cluttered scenes using simple reward signals. Fig. shows overview of our method.
3.1 Problem Formulation
Our problem formulated as follows: A supporting object with fixed support surface (e.g. a table) is placed the simulation. A queried region is part of this supporting object, such as section of table. The queried scene includes the supporting surface and all previously placed objects. A queried object is the current object to be arranged next. ClutterGen is asked to sequentially place movable objects into the queried region while ensuring stability for the new and previously placed objects. The episode succeeds when all queried objects are placed stably.
We formulate the generation process as Markov Decision Process, defined by the tple <S.A.P,R.y> of states, A is set of actions, P is state transition probability matrix; P(s|(s,a) indicating the probability of transitioning state s' from state after action a, R is reward function, and y is discount factor 0 o 5 1. A policy S - A determines the next action based on the current state. Our objective is to find an optimal policy n² that maximizes the sum of all discounted future rewards.
3.2 Cluttered Scene Generator
Observation and Action Space ClutterGen takes in the point cloud of the queried scene and object. If the current object placement fails, we inform the policy about its past actions and their impacts by providing a history of the queried object's movement trajectories M, = (m., Im E IR 13 (1,2....!/) Fach m includes the object's position E R3, orientation quaternion HI E TRd, linear velocity E R and angular velocity E 3 at each step. The hyperparameter & determines the number of simulation steps to verify placement success, and the predefined maximum number of attempts allowed.
We encode each point cloud with feature encoder to extract geometry embeddings. We concatenate the movement trajectory, previous placement poses, and queried regions and send them into a history sequence encoder to generate a history embedding. The concatenation of geometry and history embedding is the final input to our RI agent. Our policy outputs the object placement position and z-axis rotation relative to the queried region.
Policy Design We optimize RL agent with PPO [40] which is on-policy actor-critic algorithm. The critic computes the advantage during training and the actor generates the action distribution for the 3D

---

translation and ID rotation independently. Since our design requires bounded continuous action space, instead of using the conventional squashed normal distribution to bound the action space, we choose beta distribution as the policy distribution. Specifically, the actor of the agent outputs the a ERA and _ to build the action distribution (ela(ar,3). and then the relative placement pose can be obtained by sampling from the distribution.
Our choice of action distribution offers several benefits. First, beta distribution is well-defined among [0,1], which only requires simple linear operation to our action range [-1,1], while the unsquashed process for the squashed normal distribution will introduce numerical instability during training and requires extra post post-processing. Second, beta distribution can represent more distribution shapes by changing the a and values, which is essential improve the diversity of our scene generation. As shown in Sec. 4.1, our results demonstrate that the policy trained with the beta distribution outperforms the policy trained with the squashed normal distribution in both success rate and scene diversity.
Success Conditions A successfully placed object should not collide with existing objects and maintain a stable pose. To verify placement, we run the simulator and record the object's velocity and acceleration to check stability. The placement is considered stable if the following conditions are met: 1) the linear velocity and acceleration become less than 0.005m/s and 1m/s?, respectively, within 40 simulation steps (0.167s in real-time); 2) the angular velocity and acceleration become less than 0.5% and 180" /s², respectively, within 40 simulation steps; and 3) the velocity and acceleration remain below these thresholds for 20 continuous simulation steps.
Reward Function Guided by the success conditions, for each placement attempt, ClutterGen optimizes the following reward function to minimize the accumulated absolute values of the velocity and accelerate during new object placements:
& R₂ Σ (1lvll2++|addl))) +n- sable Ro
where e is a scaler to adjust the velocity and acceleration penalty, i; E R and a; E RC represents the velocity and acceleration the queried object at igh simulation step, the indicator function Laable will equal to if the placement pose is stable otherwise will equal to 0, represents the current queried object is the ne, object for the queried scene, and Ro is scalar reward.
3.3 Implementation Details
For each attempt, we the simulator for up to k ==240 240 steps (Is) to check the placement stability. We set the maximum allowed attempts as 5- We use PointNet++ [41] as the point cloud feature encoder and 3-layer MLP as the history sequence encoder. Both the actor and critic networks are composed of 5 layers of MLPs. We optimized the agent for 2.5M steps with learning rate 1e-4, All training was conducted on one NVIDIA RTX A6000 GPU. Other details are listed the Appendix.
4 Experiments
In this section, we aim to evaluate ClutterGen's capability to effectively generate cluttered, stable, and diverse scenes. We further investigate the generalizability of the learned model on various scene-level changes. We then conduct several real-world experiments to demonstrate the effectiveness of ClutterGen for downstream robotics tasks such as clutter rearrangement and stable placement policy training.
4.1 Scene Generation Evaluation
Dataset To include diverse everyday objects for our evaluation, we created a dataset consisting of five groups, each containing ten objects. The first four groups selected from the PartNet-Mobility [42], Objaverse [43], and YCB [44] datasets. The fifth group, referred to the real group, includes our 3D-scanned everyday objects that are also used in our physical experiments. We used a cuboid table with (60cm,70em,,7kke 70cm] in width, length, and height as the initial queried scene.
Baselines Since most prior studies on scene generation rely on either pre-collected datasets or human-specified heuristics and constraints, we cannot directly compare with them. The closest method, which is also widely adopted [16, 17, 18, 19] in recent literature, is the random rejection sampling (RRS) algorithm. We also compare our methods with other altemattve settings.

---

Obiject Group
Method
Group I
Gruup2 2
Group33 3
Gruu 4
Group 5
Success
Stable
Success Rate
Stable
Success Rate
Stable
Success
Stuble
Success Rate f
Stable
Rate
Steps 4
Steps. 4
Rate 1 Steps +
Steps
Steps |
RRS
0.005
9= 202.1
290.3:1:379.1
171.31188.2
0.02
214.241275.8
100005
175.6:1198.2
ClutteGGen-O0 OL.
0.212
139.4 168.2
0.145
206.7.1:47.55
0.086
179.9
0.232
182.91182.1
0.251
135.0-112..1
ChitteGen-SM
0.359
101.8= 125.
0.414
111.3+449..5
0.364
100.6
0.517
97.622 101.8
0.602
83.47:990.20
Chutee-Gen-Normal
0.925 73. 86 73
0.833
85, 96.25--911-1
0.951
66.37=61.15
0.969
51.19=56 22
0.989
43.86+333.40
ClutterGen
0.912 88.50 95.46
0.874 70.82:1997.880
0.963 59.70=55.73
0.973
49.89 (01.5550000000 0.988 45.72::311.21
Tab. I: Success rate comparison of cluttered scene generation. We report the average success rate and stable steps across three random seeds of training and five object groups. Our method significanlyy outperforms the widely adopted RRS baseline. The long-term attempt history and closed-loop design our framework deliver the best performance,
Random Rejection Sampling (RRS). This method heuristically computes the position of the supporting surface in the queried scene and randomly places objects within the queried region.
ChutterGen- ClutenGGen-ppnnLoop (OL). This method uses the same architecture as ClutterGen, but without previous object movement trajectory and placement pose information for the next attempt.
SounterGen-ShorMeenne (SM). This method uses the same architecture but only takes the latest attempt history (buffer length = 1) for the next attempt.
SuuterGennNormaa This method uses the truncated normal distribution instead of the beta distribution.
Metrics Our evaluation metrics include: 1) the success rate of placing all queried objects into the queried scene, and 2) the average simulation steps (stable steps) required for each object to achieve stability.
Additionally, we access setup diversity, a qualitative metric, using a diversity map to evaluate the variety of the generated scenes.
Average Stable Steps for Each Attempt
6m.p
Results Tab. 1 shows the testing restuls with 1,000 trials. The RRS almost always failed to produce a valid object layout. This is because RRS cannot learn from active interaction with the environment. While ClutterGen-OL and CluuterGen- SM can produce some reasonable layouts, the success rate is generated low with longer simulation steps for the scene to become stable, suggesting long-term close-loop history is important. Both the normal and beta distributions achieve high success rates.
Average Stabile Stepes
Group
Group
Group
Group
64
46
The Index Attempts
Fig. 3: Average stable steps across differ- ent numbers of attempts. We computed the average stable steps for object placements re- quiring 23 attempts. The x-axis represents the Ven, attempt, and the y-axis represents the aver- age simulation steps for the object stabilize. ClutterGen's closed-loop re-altempt mechanism increasingly improves placement stability.
To further understand the effectiveness of ClutterGen, we plot the average stable steps needed over different attempts. As shown in Fig.3, ClutterGen can use previous placement poses and object movement trajectories to adjust the next placement pose for faster convergence of stability. This closed-loop mechanism is extremely useful for cluttered scene generation within limited spaces. Fig. 4 shows an example of ClutterGen's 's closed-loop generation process to adjust its next action based on the past attempts.
Side View
Back View
1st falle attempt
2nd tailed sttempt
3rd fatled attempt
4th successful sttempt
Fig. 4: Example of the closed-loop generation process of ClutterGen. ClutterGen attempts to place a camera on a cluttered table. Failed placement attempts (c.g. floating in the air, colliding with objects, or inserting into the table) are marked by red circles. After each attempt, the simulator runs and records the movement trajectory. ClutterGen uses all previous failed atlempts to adjust its future actions until achieving successful placement.
5

---

Mup
Tomato
Mustand Botte
Gelatin
Rost
Fig. 5: Generation diversity. A pro- jected view of the queried object's place- ments. The black dashed line represents the supporting surface area. The blue dots are queried object placement posi- tions (æ.z) across 500 setups. The red box is the coverage arca, bounding all placement positions. Beta distribution greatly enhances scene diversity.
ClutterSon Normal
Mustard
CluttenSon
Trunslation
Rotation
Shrinkage
Expunsion
Method
Original
r
15cm,11em
ra: rx:(- T.
Als:
10cm, Oem)
A (0::000m,11eei A0y:(00mm,
Randomly Combined
15em,15em
Aly
10cm,0en
ClutterGen
0.99
0.89
0.92
0.76
0.93
0.85
Tab. 2: Scene-level generalization results. We report the average success of cluttered scene generation under various test-time changes to the queried region. ClutterGen demonstrates strong generalizability.
Generating diverse object layouts is crucial for training robust robot policies by providing sufficient randomization, Although both ClutterGen and ClutterGen-Nomal achieved high success rates in generating cluttered scenes, we assess their ability to create diverse layouts by visualizing their successful placements through 2D projection. Each subplot Fig. 5 shows the placement distribution for one object across 500 scenes. ClutterGen-Nomme tends place objects in very similar positions resulting in homogeneous outcomes, while our ClutterGen with beta distribution generates significantly more diverse setups.
4.2 Scene-level Generalization
Translation
Rosation
Shrinkage
We are interested in evaluating ClutterGen's generalization capability to generate cluttered scenes when the queried region varies during test time, even if it was fixed during training. We propose five test-time changes: 1) translation (random 2D translation within a certain range), 2) rotation (random rotation around z-axis), 3) shrinkage (random reduction of ry half extents), 4) expansion (random enlargement of zy half-extents), and 5) randomly combinations of the previous changes. We used the real object group for this evaluation. To ensure the queried region remains covered by the support surface after the changes, [140cm, 1 140cm, (0emm for this test. Our evaluation across 500 episodes for each change is shown in Tab. 2. We observe a performance drop in the shrinkage test. This is because a narrower queried region forces the scene to be more cluttered, which increases the difficulty of finding stable poses for all objects. Overall, ClutterGen shows strong zero-shot generalization ability across all changes. Examples of the generated scenes are shown Fig. 6.
Expansion
Randomly Combined
Fig. 6: Qualitative examples the generated scenes under test-time changes of the queried region.
enlarged the table dimension to
To demonstrate the real-world use cases, we selected 10 furniture tables from our dataset and directly applied ClutterGen to them with all five object groups. We adjusted the queried region's 's zy extents to match the furniture's dimension. We also randomly applied the above four changes. By evaluating 50 episodes for each table, we achieved an overall 70% success rate. Qualitative examples are shown in Fig. 1. Another advantage of our method is the formulation of scene generation as a sequential 3D object placement task. Therefore, ClutterGen can naturally generate complex object relationships such mug on a book or fork under plate.
4.3 Real Robotics Task: Clutter Rearrangement
Given a clutter of objects, humans can easily determine the goal state of stable poses for each object when tasked with moving them to another location (e.g., from one table to another). However, achieving this behavior in robots remains challenging. For instance, when the target area is cluttered, robots must identify safe and stable pose for new object placements to avoid collisions simply dropping objects into the area. Consequently, existing biick-and-rrop solutions are inadequate in this scenario. Additionally, human

---

Sequantialy Grined objects the
Sequertiaa place objed the destted selip
ClutterGen
Caurted regeci
propeses aclaga cijects half tarle)
User
Fig. 7: Clutter rearrangement. The red circle indicates the position of the camera. The blue cube encloses the objects to be rearranged. ClutterGen proposes several different setups for rearrangement. After user selects preferred setup, the Panda arm will rearrange the table accordingly.
preferences for the resulting scene layout can vary, making it difficult to incorporate these preferences into robot planning.
We demonstrate ClutterGen's 's applicability in the challenging task of clutter rearrangement using a Franka Panda arm equipped with RGB-D camera. Fig. 7 provides an overview of our approach. We randomly selected five objects from our real object group and placed them on one side of table as the initial clutter. The robot's goal is to move this entire clutter to the other side of the table. We used GroundDINO [45] to identify the object categories, Segment Anything [46] to generate the object masks, and FoundationPose [47] to determine the 6 DoF pose of each object. To simplify the setting and focus on ClutterGen's 's key capabilities, we assume access to the 3D models these objects and a set of grasping poses [48], although these assumptions can be relaxed with recent advancements in grasp synthesis [49, 50, 51]. With this information, we render the queried scene point cloud to ClutterGen to propose possible target layouts.
We asked ClutterGen to generate ten possible layouts for the other side of the table, allowing users to select their preferred setup and obtain the target poses for each object. The robot amm then planned its motions to move the entire clutter to the target area using Movelt [52]. We evaluated the full pipeline over ten episodes. Success is counted if all objects are rearranged to the user-selected setup without any collisions or unstable poses. The overall success rate was 7/10. We include both successful and failed trials the supplementary videos. Failures were due arm-object or object-object collisions during motion planning (2/3) or failed object layout proposals from ClutterGen under the ten-trial limit (1/3).
4.4 Real Robotics Task: Stable Object Placement
While pick-and-droy tasks have seen great success robot manipulation, placing objects stably in cluttered scenes remains challenging. In this experiment, we leverage ClutterGen synthetic data generator to train robot policy for stable object placement. Fig. 8 provides an overview of our approach. Our stable
Mesh Sampling
Camera Capturel
Camera Capsure2
ClutterGan
Agent Training
Datasct
Zera-Shot Sim-to-Real Deployment
Fig. 8: Synthetic dataset generation and zero-shot sim-to-real policy deployment. We generate synthetic dataset by replaying the generation trajectory created by ClutterGen. Green points mark the ground truth pose of the queried object, while blue points represent the point cloud of the queried scene. To augment the dataset, we virtual camera capture scene point cloud from different angles. This synthetic dataset used to train a stable object placement policy, which is directly deployed on real robot.
7

---

placement policy takes the point clouds of the queried scene and object and learns to output the stable placement pose. Due to our novel formulation of ClutterGien as a sequential 3D placement task, ClutterGen naturally serves as a data generation source for training the stable placement policy. Specifically, we ran ClutterGen 500 times to create 500 layouts while recording its generation process for each object, resulting in 5,000 data points. To mitigate occlusion issues in the real world, instead of using the full point cloud, we captured the scene point cloud using virtual RGB-D camera in the simulator and randomly translated its position four times while ensuring focus on the center of the scene. We then randomly sampled the final 5,000 data points as our dataset termed ClutterGen-5000, This data generation process takes less than one minute on a single thread and can be further accelerated through parallelization. We then applied supervised learning to train the stable placement policy over 1,000 epochs using mean squared error loss. At test time, we achieve 91% success rate by using the simulator to verify placement success with the same physics-based stability metric.
To demonstrate the efficiency improvements of ClutterGen compared to a human engineer, we de-
Dataset
|
ClatteerGen-S00
Humar- 200
veloped a user interface within the Pybullet [53] simulator to allow humans to manually create sim- ulation setups. We manually constructed 20 stable setups, resulting in 200 data points. We applied the same augmentation process above to obtain the final dataset termed Human-200. The entire process took approximately 1.5 hours for an expert engineer. We then trained the stable object placement policy using this dataset under the same configura- tions as before. Both models were evaluated on the same test dataset as shown in Tab. 3. ClutterGGen50000 enables significant higher performance than using Human-200 for the policy training.
Success Rate
0.91
0.52
Tab, 3: Boost model performance by training with the synthetic dataset from ClutterGen. We report the success rate of two models trained on ClutterGen-5ti and Human- 200. ClutterGen can create diverse and effective training data in under one minute, whereas human expert needs 1.5 hours to create a dataset that is only 4% of its size.
We directly deployed the stable object placement policy trained with ClutteGen--000 Franka Panda arm equipped with an RGB-D camera. In each episode, the robot arm grasped and lifted queried object while six to eight other objects were randomly placed on the table to form an unseen clutter. Based on the scene point cloud captured by the RGB-D camera and the object point cloud, the policy predicted a stable placement pose, which was then used to plan and execute the robot's actions. We repeated this process by randomizing the clutter configurations for ten episodes per object. We used five target objects to be placed. An episode was counted as successful if the object was stably placed without any collisions. Failures occurred if the model failed predict stable pose, the arm could not reach the pose after five attempts, or a collision occurred during placement. Across all 50 episodes, our zero-shot sim-to-real policy achieved a 72% success rate. The performance drop is likely due to significant noise in the real-world point cloud. This could be mitigated by further randomizing the dataset to simulate real-world noises or using better hardware to capture the point clouds.
5 Conclusion, Limitations, and Future Work
In this work, we propose ClutterGen, an ruto-regressive simulation scene generator for robot learning. ClutterGen efficiently generates diverse, cluttered, and physically compliant environments without relying on pre-existing datasets or human specifications. Our key idea of framing the scene generation task as a reinforcement learning problem enables a closed-loop mechanism to sequentially generate 3D object placements. Our policy design further enhances the diversity of the generated scenes. Through both simulation and real robot experiments, we demonstrate that ClutterGen can help tackle several challenging robotics tasks, such as clutter rearrangement and stable object placement in cluttered environments.
Our work has a few limitations that should be addressed in future research. First, the object layouts are currently limited to rotation along the z-axis. Allowing rotations along the x and y axes could produce more diverse and complex layouts. Second, we have only demonstrated the setups on flat surfaces. Future work could explore various surface configurations, such as uneven or inclined surfaces. Finally, our current training involves only ten objects a limited space. Training the policy with great number of objects in the pool could enhance object-level generalization during testing. Overall, we hope that ClutterGen provides novel problem formulation for automated simulation scene design to facilitate the generation of large datasets for robot learning.
8

---

Acknowledgments
This work is supported by STRONG program under awards W91INF2320182 and W91 13, by DARPA FoundSci program under award HR001 12490372, and DARPA TIAMAT program under award HR001124904119
References
[1] J. Lee, Hwangbo, L. Wellhausen, V. Koltun, and M. Hutter. Learning quadrupedal locomotion over challenging terrain. Science robotics, 5(47))eab<5986, 2020.
[2] I. Akkaya, M. Andrychowicz, M. Chociej, M. Litwin, B. McGrew, A. Petron, A. Paino, M. Plappert,
G. Powell, R. Ribas, al. Solving rubik's cube with robot hand. arXiv preprint 13Xiv:1910.07113, 2019.
[3] F. Muratore, F. Ramos, G. Turk, W. Yu, M. Gienger, and Peters. Robot learning from randomized simulations: A review. Frontiers in Robotics and AI, 9:799893, 2022.
[4] P. Katara, Xian, and K. Fragkiadaki. Gen2sim: Scaling up robot learning simulation with generative models. arXiv preprint arXiv:2310. 183088,800 2023.
[5] J. Xu, Song, and M. Ciocarlie. Tandem: Learning joint exploration and decision making with tactile sensors. IEEE Robotics and Automation Letters, 703):10391-100 103998, 2022.
[6] D. Son and B. Kim. Local object crop collision network for efficient simulation non-convex objects in gpu-based simulators. arXiv preprint arXiv:2304.09433 2023.
[7] J. Xu, H. Lin, S. Song. and M. Ciocarlie. Tandem3d: Active tactile exploration for 3d object recognition. In 2023 IEEE International Conference on Robotics and Automation (ICRA), pages 10401-10407. IEEE, 2023.
[8] M. Schwarz and S. Behnke. Stillleben: Realistic scene synthesis for deep learning in robotics. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 10502-10508, IEEE, 2020.
[9] T. Jianu, D. F. Gomes, and S. Luo. Reducing tactile sim2real domain gaps via deep texture generation networks. In 2022 International Conference on Robotics and Automation (ICRA), pages 8305-8311. IEEE, 2022.
[10] A. Church, J. Lloyd, N. F. Lepora, et al. Tactile sim-to-real policy transfer via real-to-sim image translation. In Conference on Robot Learning, pages 1645-1654, PMLR, 2022.
[11] R. Burgert, J. Shang, X. Li, and M. Ryoo. Neural neural textures make sim2real consistent. arXiv preprint arXiv:2206. 135000 2022.
[12] J. Tobin, R. Fong, A. Ray, J. Schneider, W. Zaremba, and P. Abbeel. Domain randomization for transferring deep neural networks from simulation the real world. In 2017 IEEE/RSJ international conference intelligent robots and systems (IROS), pages 23-30. IEFE, 2017.
[13] Z. Chen, A. Walsman, M. Memmel, K. Mo, A. Fang, K. Vemuri, A. Wu, D. Fox, and A. Gupta. Urdformer: A pipeline for constructing articulated simulation environments from real-world images. arXiv preprint arXiv:2405.1 /656, 2024.
[14] Y. Chen, T. Wu, S. Wang, X. Feng, Jiang, Z. Lu, S. McAleer, H. Dong, S.-C Zhu, and Y. Yang. Towards human-level bimanual dexterous manipulation with reinforcement learning. Advances in Neurul Information Processing Systems, 35:5150-5161 2022.
[15] S. Nasiriany, A. Maddukuri, L. Zhang, A. Parikh, A. Lo, A. Joshi, A. Mandlekar, and Y. Zhu. Robocasa: Large-scale simulation of everyday tasks for generalist robots. In Robotics: Science and Systems (RSS), 2024.

---

[16] A. Murali, A. Mousavian, C. Eppner, A. Fishman, and D. Fox. Cabinet: Scaling neural collision detection for object rearrangement with procedural scene generation. In International Conference on Robotics and Automation, 2023.
[17] B. Shen, F. Xia, C. Li, R. Martín-Marthn Fan, G. Wang, C. Pérez-D' Arrpin,, S. Buch, S. Srivastava, L. Tchapmi, et al. igibson 1.0: simulation environment for interactive tasks in large realistic scenes. In 2021 JEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 7520-7527. IEEE, 2021.
[18] W. Yuan, A. Murali, Mousavian, and D. Fox. M212: Multi-task masked transformer for object- centric pick and place. In Conference on Robot Learning, pages 3619-3633 36300. PMLR, 2023.
[19] A. Fishman, A. Murali, C. Eppner, B. Peele, B. Boots, and D. Fox. Motion policy networks. In Conference on Robot Learning, pages 967-977, PMLR, 2023.
[20] C. Li, R. Zhang, J. Wong, C. Gokmen, S. Srivastava, R. Martín-Martín, C. Wang, G. Levine, M. Lingelbach, J. Sun, et al. Behavior-1k: A benchmark for embodied ai with 1,000 everyday activities and realistic simulation. In Conference on Robot Learning, pages 80-93. PMLR, 2023.
[21] C. L. F. Xia, R. Martin-Martin. M. Lingelbach. Srivastava, B. Shen, K. Vainio, C. Gokmen, G. Dharan, T. Jain, et al. igibson 2.0: Object-centric simulation for robot learning of everyday household tasks. arXiv preprint arXiv:2108.03272. 2021.
[22] Y. Wang, Z. Xian, F. Chen, T.-H. Wang, Wang. K. Fragkiadaki, Z. Erickson, D. Held, and C. Gan. Robogen: Towards unleashing infinite data for automated robot learning via generative simulation. arXiv preprint arXiv:2311.01455 2023.
[23] M. Deitke, E. VanderBilt, A. Herrasti, L. Weihs, K. Ehsani, J. Salvador, W. Han, E. Kolve, A. Kemb- havi, and R. Mottaghi. Procthor: Large-scale embodied ai using procedural generation. Advances in Neurul Information Processing Systems, 35:5982-5994, 2022.
[24] A. Szot, A. Clegg, E. Undersander, E. Wijmans, Y. Zhao, J. Tumnr,, N. Maestre, M. Mukadam, D. S. Chaplot, O. Maksymets, et al. Habitat 2.0: Training home assistants to rearrange their habitat. Advances in neural information processing systems, 34:251-266, 2021.
[25] X. Wang, C. Yeshwanth, and M. NicBner. Sceneformer: Indoor scene generation with transformers. pages 106-115, 2021.
[26] D. Paschalidou, A. Kar, M. Shugrina, K. Kreis, A. Geiger, and S. Fidler. Atiss: Autoregressive transformers for indoor scene synthesis. Advances in Neural Information Processing Systems, 34: 12013-12026, 2021.
[27] W. R. Para, P. Guerrero, N. Mitra, and P. Wonka. Cofs: Controllable fumiture layout synthesis. In ACM SIGGRAPH 2023 Conference Proceedings, pages 1-11, 2023.
[28] Liu, R. Wu, B. Van Hoorick, P. Tokmakov, S. Zakharov, and C. Vondrick. Zero-1-to-3: Zero-shot one image 3d object. pages 9298-9309, 2023.
[29] M. Liu, C. Xu, H. Jin, L. Chen, M. Varma T, Z. Xu, and H. Su. One-2-3-45: Any single image to 3d mesh in 45 seconds without per-shape optimization. Advances in Neural Information Processing Systems, 36, 2024.
[30] Q. A. Wei. S. Ding, J. Park, R. Sajnani, A. Poulenard, S. Sridhar, and L. Guibas. Lego-net: Learning regular rearrangements of objects in rooms. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 19037-19047, 2023.
[31] L. Gao, J.-M. Sun, Mo, Y.KK. Lai, L. Guibas, and Yang. Scenehgn: Hierarchical graph networks for 3d indoor scene generation with fine-grained geometry. IEEE Transactions Pattern Analysis and Machine Intelligence, 2023.
10

---

[32] X. Ju, Z. Huang, Y. Li, G. Zhang, Y. Qiao, and H. Li. Diffindseene: Diffusion-based high-qualiiy 3d indoor scene generation. 2023.
[33] G. Zhang, Y. Wang, C. Luo, S. Xu, J. Peng, Z. Zhang, and M. Zhang. Fumiscenn: A large-scale 3d room dataset with intricate furnishing scenes. arXiv preprint arXiv:2401.034700 2024.
[34] J. Tang, Nie, L. Markhasin, A. Dai, J. Thies, and M. NicBner. Diffuscene: Scene graph denoising diffusion probabilistic model for generative indoor scene synthesis. arXiv preprint arXiv:2303. 2023.
[35] Y. Yang. F.YY. Sun, L. Weihs, E. VanderBilt, A. Herrasti, W. Han, Wu, N. Haber, Krishna, L. Liu, et al. Holodeck: Language guided generation of 3d embodied environments. In The IEEE/CVF Conference Computer Vision and Pattern Recognition (CVPR 2024), volume 30, pages 20-25. IEEE/CVE, 2024.
[36] Z. Wen, Z. Liu, S. Sridhar, and Fu. Anyhome: Open-vocabulary generation of structured and textured 3d homes. arXiv preprint arXiv:2312.0664 2023.
[37] J. Zhang, X. Li, Z. Wan, C. Wang, and J. Liao. Text2nerf: Text-driven scene generation with neural radiance fields. IEEE Transactions on Visualization and Computer Graphics, 2024.
[38] L. Wang, Y. Ling, Z. Yuan, M. Shridhar, C. Bao, Y. Qin, B. Wang, H. Xu, and X. Wang. Gensim: Generating robotic simulation tasks via large language models. arXiv preprint arXiv:3100003611 2023.
[39] S. Zhang. P. Wicke, L. K. Şenel, L. Figueredo, A. Naceri, S. Haddadin, B. Plank, and H. Schütze. Lohoravens: A long-horizon language-conditioned benchmark for robotic tabletop manipulation. arXiv preprint arXiv:2310.1202) 2023.
[40] J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv: 2017.
[41] C. R. Qi, L. Yi, H. Su, and L. J. Guibas. Pointnet++: Deep hierarchical feature learning on point sets in metric space. Advances in neural information processing systems, 30, 2017.
[42] K. Mo, Zhu, A. X. Chang, L. Yi, S. Tripathi, L. J. Guibas, and H. Su. Partnet: A large-scale benchmark for fine-grained and hierarchical part-level 3d object understanding. In Proceedings of the IEFF/CVF conference computer vision and pattern recognition, pages 909-918, 2019.
[43] M. Deitke, D. Schwenk, Salvador, L. Weihs, O. Michel, E. VanderBilt, L. Schmidt, K. Ehsani, Kembhavi, and Farhadi. Objaverse: A universe of annotated 3d objects. In Proceedings of the ICEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13142-13153, 2023.
[44] B. Calli, A. Walsman, A. Singh, S. Srinivasa, P. Abbeel, and A. M. Dollar. Benchmarking in manipulation research: The ycb object and model set and benchmarking protocols. arXiv preprint arXiv:1502.031443 2015.
[45] S. Liu, Z. Zeng, T. Ren, F. Li, H. Zhang. J. Yang, C. Li, J. Yang, H. Su, J. Zhu, et al. Grounding dino: Marrying dino with grounded pre-training for open-set object detection. arXiv preprint arXiv:2303.05449 2023.
[46] A. Kirillov, E. Mintun, N. Ravi, H. Mao, C. Rolland, L. Gustafson, T. Xiao, S. Whitchead, A. C. Berg, W.Y Lo, et al. Segment anything. In Proceedings of the IEEF/CVF International Conference on Computer Vision, pages 4026-4026, 2023.
[47] B. Wen, W. Yang, J. Kautz, and S. Birchfield. Foundationpose: Unified 6d pose estimation and tracking of novel objects. arXiv preprint arXiv:2312.08344, 2023.
[48] C. Goldfeder, M. Ciocarlie, H. Dang, and P. K. Allen. The columbia grasp database. In 2009 IEEE international conference robotics and automation, pages 1710-1716. IEEE, 2009.
11

---

[49] H.-S. Fang, C. Wang, H. Fang, M. Gou, J. Liu, H. Yan, W. Liu, Y. Xie, and C. Lu. Anygrasp: Robust and efficient grasp perception in spatial and temporal domains. IEEE Transactions on Robotics, 2023.
[50] W. Wan, H. Geng, Y. Liu, Z. Shan, Y. Yang, L. Yi, and H. Wang. Unidexgrasp++: Improving dexterous grasping policy learning via geometry- aware curriculum and iterative generalist-specialist learning. In Proceedings of the IEEF/CVF International Conference on Computer Vision, pages 3891-3902, 2023.
[51] X. Liu and L. Yi. Geneoh diffusion: Towards generalizable hand-object interaction denoising via denoising diffusion. arXiv preprint (rXiv:2402.144100, 2024.
[52] D. Coleman, Sucan, S. Chitta, and N. Correll. Reducing the barrier entry of complex robotic software: a moveit! case study, arXiv preprint 30443785, 2014.
[53] E. Coumans and Y. Bai. Pybullet, a python module for physics simulation for games, robotics and machine learning. 2016.
[54] Z. Wu, S. Song, A. Khosla, F. Yu, L. Zhang, X. Tang, and Xiao. 3d shapenets: A deep representation for volumetric shapes. In Proceedings of the IEEE conference on computer vision and pattem recognition, pages 1912-1920, 2015.
12

---

Appendix
Loss Function We the PPO algorithm to optimize CSG. The policy objective function is given by
L (0) -00)=BB 12, min |:in::171044..ippp::00111-----10
(a (st)
(0)
n8 (at (t))
where ry is the probability ratio between the new policy and the old policy; A, the advantage function estimate at timestep t; clip(-) is a function that clips re( within the range [1 - e, + tej; is a small hyper-parameter that controls the clipping range.
The value function emror and the entropy bonus are given by
I. (0) R (Vo(s)) Ro. 2
(4)
I. [A(
(5)
where Vs(ss) is the value function parameterized by 0: Rg is the cumulative return at timestep t; H (m))((s) is the entropy of the policy at state
The combined loss function is given by
where e1 and og the coefficients that balance the importance of the value function eroor and the entropy bonus, respectively.
3.0
9.8
0.6
Success Rate
Success Rate
Gmup1
0.2
Gmip?
Goup
Goup
5
0.0
0.5
5.5
1.4
1.0
0.0
0.5
2.0
3.5
2.0
2."
Steps
Steps
Learning curves of ClutterGen. The x-axis shows the number steps, and y-axis shows suc- cess rate. The solid curve represents the average success rate from three different initial random seeds for each group, with the semi- transparent indicating the stan- dard deviation.
Fig. 9:
Fig. 10: Maximum allowed attempts selection. The performance drop if the maximum allowed attempts
< 2. We choose attempts for the ClutterGen.
Extra Explanation of the Stable Conditions It difficult precisely define object stable conditions with single thresholds for the velocity and acceleration the simulation. On one hand, the simulator perfect, meaning visually stable pose usually has non-zero velocity and acceleration. Too small thresholds for the velocity and acceleration usually introduce false negatives (i.e., the queried object that already stable by human judgment but can not pass the stable conditions). On the other hand, too large thresholds usually introduce false positives. In this work, we applied small thresholds for both values, formulating a relatively strict checking condition.
Implementation Details of the ClutterGen The PointNet++ encoder was pre-trained on modelnet40 dataset [54] and the weights were frozen during the training of ClutterGen. The attempt history was flattened and then padded by 0 if the current attempts were fewer than the maximum allowed attempts to
13

---

Group 1 Dinner Table
Group 2
Group 3 Office Table
Study Table
Group 4
Group Real Objects
Kitchen Table
Fig. 11: groups objects dataset. Each group contains objects. The group to are selected from existing
object dataset. Group 5 is 3Dsscanned everyday ohjects that are also used in our physical experiments.
Fig. 12: 10 test tables dataset. We select 10 different tables from the existing object dataset for the scene-level randomization test.
guarantee fixed-size input before being sent the history sequence encoder. All the training and test was conducted in the PyBullet simulator [53].
ClutterGen Training Results We trained ClutterGen on different group objects. The training results are shown in Fig.9. ClutterGen could reach above 0.85 success rate after 2.3M steps optimization for all groups, which shows the high adaptation of different objects.
Selection of Maximum Allowed Attempts. We test the performance of ClutterGen with different maxi- mum attempts on group 1 objects. Increasing allowed attempts will boost the performance. However, too many attempts will slow down the training process. We set attempts at most to balance the performance and training speed.
Implementation Details of Stable Placement Policy We used two pre-trained PointNet+ models the perception encoders for the queried scene point cloud and the queried object point cloud respectively. We did not freeze their weights during the training in this task. The perception features were concatenated and
14

---

sent to a 4-yyer MLP to generate the predicted placement pose into the scene surface center frame. This pose was then transformed into the robot base frame for motion planning.
Tab. 4: PPO Hyperparameters
Hyperparameter
Value
Description
Learning Rate
0.0001
The step size at each iteration while moving toward minimum of loss function.
Batch Size
1000
Number of steps per gradient update.
Update Epochs
5
Number of epochs to update the policy.
7
0.99
The discount factor for reward.
Agee
0,95
The discount for the general advantage estimation.
e
0.2
The surrogate clipping coefficient.
C1
0.5
The coefficient of the value function.
0.01
The coefficient of the entropy.
Jelip-mer Hidden Layer Size
0.5
The maximum norm for the gradient clipping.
256
The number of units of hidden layer in MLP.
Optimizer
Adam
Optimization algorithm for updating weights.
Tab. 5: ClutterGen Hyperparameters
Hyperparameter
Value
Description
Pakj
1024
Number of points of queried object point cloud.
Pace
20480
Number of points of queried scene point cloud.
Max Attempts
Number of allowed attempts placing the queried object.
0.005
The coefficient of the velocity and acceleration penalty.
Ro
100
The scalar reward.
15


Reviews:
[{"review_id": "GKjc2CIVoo", "reviewer": "Reviewer_fQzd", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": 3, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "The paper introduces an approach to the problem of cluttered scene generation for robotics simulation: the authors formulate the problem as a MDP and apply RL methods to learn a policy that can place objects in a scene in a physically stable and plausible way.", "summary_of_recommendation": "The paper introduces a new approach to an important problem, and is presented well. I believe it should be presented at CoRL despite its shortcomings in terms of the method's limitations and the limited experiments against other solutions.", "technical_quality": 3, "clarity_of_presentation": 5, "potential_impact": 3, "robotics_focus": 4, "quality_of_limitations": 3, "questions_for_rebuttal": "1. How do you ensure the diversity / completeness of the physically stable configurations (e.g. doesn't the model just learn to build the _easier_ physically stable configurations rather than a good sample of the full distribution?)\n\n2. How do you ensure semantic realism (e.g. the kind of clutter we see is actually relevant for work a robot might do IRL)?\n\n3. How does the approach compare against clutter generation heuristics from the SOTA simulators rather than just random placement?", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "r1rne3oQ3a", "reviewer": "Reviewer_4LKe", "summary": "", "questions": "", "limitations": "", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": 4, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "The paper presents ClutterGen, an automatic, policy-driven method for procedurally sampling multiple object placements on a given surface. The paper highlights the reliability and scalability of ClutterGen, and showcase applications in downstream robot tasks such as Clutter Rearrangement and Stable Object Placement.", "summary_of_recommendation": "The paper presents an interesting method for tackling procedural scene generation, showcasing a learned policy that can automatically place a set of objects stably on a given surface with high success. Given the increasing interest in the broader field of scene generation, this approach may serve as an important step in fully end-to-end methods for ecologically rich scene generation.", "technical_quality": 5, "clarity_of_presentation": 5, "potential_impact": 4, "robotics_focus": 4, "quality_of_limitations": 3, "questions_for_rebuttal": "Please see Weaknesses section above.\n- How were the different dataset groups selected? Were they all randomly selected or was there some semantic / geometric distinction (e.g: \"all kitchen items\" or \"all convex items\", etc.)\n- One interesting qualitative trait of the learned placement policy is that it appears it is biased towards placing objects towards the edges of the supporting surface (as Fig. 5 also quantitatively shows). Could this possibly bias results and result in object placement distributions that don't necessarily align with \"natural\" distributions found in the real world? I also wonder if this is in part due to the fact that the policy only observes the current set of already-placed objects and the current queried object instead of the full set of future objects to be placed, leading the policy to avoid placing objects in the center because it limits the possibility for future (unknown) objects to be placed. I am curious to hear the author's thoughts on this or if they have considered this alternative setup!\n- Can the method be applied to non-rectangular surfaces, e.g.: a circular or abnormally-shaped table?\n- It seemed surprising that the placement policy suffered when the sampling surface was translated (Sec. 4.2). Assuming that the entire surface is still sampleable, I would expect the same placements to be valid. Has any sort of normalization with respect to the sampling surface been considered to prevent overfitting?\n- What is the role of the human selecting the preferred setup for the object rearrangement task? It seems that this would mainly allow the user to select setups that are \"easier\" to achieve for the robot compared to other alternative proposals.\n- Minor syntax issues:\n\t- L147: closet -> closest\n\t- L148: RSS presumably should be RRS", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "DEk2KGbkGZ", "reviewer": "Reviewer_qZ9R", "summary": "", "questions": "", "limitations": "", "rating": 2, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": 3, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "The paper presents a novel approach to generating physically compliant, cluttered scenes for robot learning using reinforcement learning.  The presented framework framework that casts the scene generation problem as a reinforcement learning task, using a closed-loop mechanism and beta distribution for action space to enhance scene diversity and stability.  The paper provides extensive evaluation through simulations and real-world experiments, demonstrating the effectiveness of ClutterGen in generating diverse and stable object layouts.", "summary_of_recommendation": "The paper presents a significant and well-executed contribution to the field of robot learning.  The problem is clearly defined, the solution is well-explained, and the evaluation is robust and comprehensive.  However, the necessity of the complex reinforcement learning approach should be better justified, and comparisons with simpler baseline methods should be included.", "technical_quality": 3, "clarity_of_presentation": 5, "potential_impact": 3, "robotics_focus": 4, "quality_of_limitations": 3, "questions_for_rebuttal": "- The paper should include comparisons with simpler baseline methods like potential fields and 2D packing algorithms.  Demonstrating that ClutterGen significantly outperforms these baselines would strengthen the justification for its complexity.\n- Provide a stronger justification for why reinforcement learning is necessary for this problem. This could include a discussion of the limitations of simpler methods in the specific context of ClutterGen’s objectives.\n- Address concerns about the perceived complexity of the problem.  Explain why objects might fall in the simulation and how ClutterGen addresses these challenges uniquely compared to simpler methods.\n- Longer term, I highly recommend incorporating full translations and rotations.  Many of my previous concerns would go away.", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Meta-review: Strengths:
1.  Addresses the significant issue of generating ecologically rich scenes for robotic simulation, which is crucial for bridging the sim-to-real gap.

2. Introduces a reinforcement learning (RL) approach to frame the scene generation task, using a closed-loop mechanism and beta distribution for action space.

3. Extensive experiments conducted both in simulations and real-world settings, demonstrating the robustness and practical utility of ClutterGen.

4. The paper is well-written and easy to understand, with detailed explanations of the problem, methodology, and results.

5. Demonstrates the ability to generate diverse and stable object layouts, showcasing practical relevance through real-world experiments.

Weaknesses:
1. The paper does not compare ClutterGen to other recent procedural generation tools (e.g., AI2Thor, BEHAVIOR) or simpler heuristic-based methods, making it difficult to assess its significance and performance relative to existing approaches.

2. The current implementation only performs transformations along one rotational axis, which restricts the semantic realism of the generated scenes.

3. The necessity of using a complex RL approach is not well justified, as simpler methods like potential fields or 2D packing algorithms might achieve similar results for the presented problem.

4. The algorithm focuses on physical stability but lacks mechanisms to ensure semantically meaningful clutter, which is essential for realistic scene generation.

5. The approach does not adequately address more complex spatial constraints or interactions, such as stacking objects or ensuring stability throughout all transformations.
Decision: Accept