{'fraction_non_alphanumeric': 0.040417541849659476, 'fraction_numerical': 0.017970424118982455, 'mean_word_length': 4.636015783809638, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Learning to Rearrange Deformable Cables, Fabrics, and Bags with Goal-Conditioned Transporter Networks

Rearranging and manipulating deformable objects such as cables, fabrics, and bags is a long-standing challenge in robotic manipulation. The complex dynamics and high-dimensional configuration spaces of deformables, compared to rigid objects, make manipulation difficult not only for multi-step planning, but even for goal specification. Goals cannot be as easily specified as rigid object poses, and may involve complex relative spatial relations such as"place the item inside the bag". In this work, we develop a suite of simulated benchmarks with 1D, 2D, and 3D deformable structures, including tasks that involve image-based goal-conditioning and multi-step deformable manipulation. We propose embedding goal-conditioning into Transporter Networks, a recently proposed model architecture for learning robotic manipulation that rearranges deep features to infer displacements that can represent pick and place actions. We demonstrate that goal-conditioned Transporter Networks enable agents to manipulate deformable structures into flexibly specified configurations without test-time visual anchors for target locations. We also significantly extend prior results using Transporter Networks for manipulating deformable objects by testing on tasks with 2D and 3D deformables. Supplementary material is available at https://berkeleyautomation.github.io/bags/.


I. INTRODUCTION
Manipulating deformable objects is a long-standing challenge in robotics with a wide range of real-world applications. In contrast to rigid object manipulation, deformable object manipulation presents additional challenges due to more complex configuration spaces, dynamics, and sensing.
While several prior works have made progress largely centered around tasks with 1D (e.g., rope [46]) or 2D (e.g., fabric [53]) deformable structures, little prior work has addressed generalizable vision-based methods for manipulating 3D deformable structures such as the task of: "insert objects into a bag, and then carry the bag away". These types of tasks are especially challenging with diverse goal conditioning: the goal states of deformable objects are not easily specified, for example, by compact pose representations.
In this work, we propose a new suite of benchmark tasks, called DeformableRavens, to test manipulation of cables, fabrics, and bags spanning 1D, 2D, and 3D deformables. For several tasks in the benchmark, we propose to tackle them using novel goal-conditioned variants of Transporter Network [68] architectures. Our experiments also significantly extend results of using Transporter Networks for deformable manipulation tasks -while [68] Table I). The setup involves a simulated UR5 robot arm, a green target zone, a drawstring-style bag, and a red cube. The starting configuration is shown in the top left frame. The robot, with suction cup, must grasp and sufficiently open the bag to insert a cube, then (bottom row) picks and pulls upwards, enclosing the cube. The robot concludes by bringing the bag with the cube in the target zone. We overlay arrows to indicate the movement of the robot's arm just before a given frame. one 1D deformable task, we show results on 12 tasks, including those with fabrics and bags.
The main contributions of this paper are: (i) an opensource simulated benchmark, DeformableRavens, with 12 tasks manipulating 1D, 2D, and 3D deformable objects to help accelerate research progress in robotic manipulation of deformables, (ii) end-to-end goal-conditioned Transporter Network architectures that learn vision-based multi-step manipulation of deformable 1D, 2D, and 3D structures, and (iii) experiments demonstrating that the proposed vision-based architectures are competitive with or superior to baselines that consume ground truth simulated pose and vertex information. We also discuss the shortcomings of the system, which point to interesting areas for future research. The project website contains supplementary material, including the appendix, code, data, and videos.

A. Deformable Object Manipulation
In this work, deformables [51] refers to 1D structures such as ropes and cables (we use the terms interchangeably), 2D structures such as fabrics, and 3D structures such as bags.
locations, which may be specified by a target zone or a target image, and does not require modeling rope physics.
Much research on robotic fabric manipulation [10], [51], [13] uses bilateral robots and gravity to expose corners for ease of manipulation, which enables iteratively re-grasping the fabric's lowest hanging point [48], [34], [35]. Subsequent work [43], [15], [16], generalized to a wider variety of initial configurations of new fabrics. Other approaches focus on fabric smoothing. For example, Sun et al. [55], [56] attempt to detect and then pull perpendicular to the largest wrinkle. Another task of interest is wrapping rigid objects with fabric, which bridges the gap between manipulating 2D and 3D structures. Hayashi et al. [23], [24] present an approach for wrapping fabric around a cylinder using a bimanual robot.
Work on 3D deformable structures such as bags has been limited due to the complexities of manipulating bags. Early work focused on mechanical design of robots suitable for grasping [31] or unloading [33] sacks. Some work assumes that a sturdy, brown bag is already open for item insertion, as with a grocery checkout robot [36], or uses reinforcement learning for zipping bags [26] in constrained setups.
These works generally focus on optimizing a specific problem in deformable object manipulation, often with taskspecific algorithms or manipulators. In contrast, we propose a simulation setup with a single robot arm that applies to a wide range of tasks with 1D, 2D, and 3D deformables. In independent and concurrent work, Lin et al. [39] propose SoftGym, a set of environments with cables, fabrics, and liquids simulated using NVIDIA FleX, and use it to benchmark standard reinforcement learning algorithms.

B. Data-Driven Robot Manipulation
Robot manipulation using learned, data-driven techniques has become a highly effective paradigm for robot manipulation, as exemplified in the pioneering work of Levine et al. [38], Mahler et al. [42], Florence et al. [20], Kalashnikov et al. [30], and others. Tools used often involve either Imitation Learning (IL) [3] or Reinforcement Learning (RL) [58], and in recent years, such techniques have been applied for manipulation of deformables.
For example, IL is used with human [54] and scripted [53] demonstrators for fabric smoothing, while RL is applied for smoothing and folding in [44], [29], [63]. Using model-based RL, [17] were able to train a video prediction model to enable robots to fold pants and fabric, and a similar approach was investigated further in [28] for model-based fabric manipulation. Some approaches combine IL and RL [5], and others use techniques such as latent space planning [40], [65] or using dense object descriptors [22]. In this work, we use IL.
As described in Section III, the deep architecture we propose for image-based manipulation uses Fully Convolutional Neural Networks (FCNs) [41] to produce per-pixel scores in an image, where each pixel corresponds to an action. This technique [67] has shown promising results for robotic warehouse order picking [71], pushing and grasping [70], tossing objects [69], kit assembly [66], and mobile manipulation [62]. We show that similar approaches may be effective for picking and placing of deformables. In independent and concurrent work, Lee et al. [37] show how an approach can be used for fabric folding.

III. BACKGROUND
We first describe the problem formulation, followed by background on Transporter Networks [68]. Section IV then describes a novel goal-conditioned framework.

A. Problem Formulation
We formulate the problem of rearranging deformable objects as learning a policy π that sequences pick and place actions a t ∈ A with a robot from visual observations o t ∈ O: where T pick is the pose of the end effector when grasping part of an object, and T place is the pose of the end effector when releasing the grasp. Since deformable objects may require more than a single pick and place action to reach a desired configuration, it is important that the policy π learns from closed-loop visual feedback. Some rearrangement tasks [8] may also be specified by a target goal observation o g , in which case the policy takes that as additional input: In this work, we consider tabletop manipulation tasks where both poses T pick and T place are defined in SE (2). Picking and placing positions are sampled from a fixed-height planar surface, while rotations are defined around the z-axis (aligned with gravity direction). The T pick and T place both parameterize a motion primitive [21] that controls the end effector to approach T pick until contact is detected, activates the end effector to execute a grasp, moves upward to a fixed z-height, approaches T place , and lowers the end effector until contact is detected, then releases the grasp. While this discrete-time planar action parameterization has its limitations, we find that it remains sufficiently expressive for a number of tabletop tasks involving manipulation of bags, in which gravity helps to induce a natural adhesive force that brings objects back towards the tabletop plane.
To train the policy, we assume access to a small dataset of N stochastic expert demonstrations D = {ξ i } N i=1 , where each episode ξ i of length T i (i.e., the number of actions) consists of a sequence of observations and actions: used to supervise π, which may be goal-conditioned.

B. Background: Transporter Networks
Transporter Networks [68] is a model architecture for manipulation that learns to rearrange objects by (i) attending to a local region of interest, then (ii) predicting its target spatial displacement by cross-correlating its dense deep visual features over the scene. It can parameterize actions for pick and place, and has shown to work well for variety of tabletop manipulation tasks including stacking, sweeping, and kit assembly [66].
Transporter Networks consist of 3 Fully Convolutional Networks (FCNs). The first FCN f pick takes as input the visual observation o t , and outputs a dense per-pixel prediction of action-values Q pick that correlate with picking success: T pick = arg max (u,v) Q pick ((u, v)|o t ) where each pixel (u, v) corresponds to a picking action at that location via camera-to-robot calibration. The second FCN Φ key also takes as input o t , while the third FCN Φ query takes as input a partial crop o t [T pick ] from o t centered on T pick . Both the second and third FCNs output dense feature embeddings, which are then cross-correlated with each other to output a dense per-pixel prediction of action-values Q place that correlate with placing success: (4) and ∆τ covers the space of all possible placing poses.
A key aspect of Transporter Networks is that the visual observations o t must be spatially consistent, so that the 3D structure of the data is preserved under different visuo-spatial transforms ∆τ . In practice, this property also improves training data augmentation (since rotations and translations of the orthographic image appear as different configurations of objects in the scene). To leverage this, observations o t are top-down orthographic images of the tabletop scene, where each pixel represents a vertical column of 3D space.

IV. GOAL-CONDITIONED TRANSPORTER NETWORKS
In some tasks, it is more natural to specify a success criteria by passing in a goal observation o g showing objects in a desired configuration. In this case, we assume o g is fixed and available as an extra input with the current observation o t , and that o t and o g have the same pixel resolution.

A. Goal-Conditioned Transporter Networks
We propose two goal-conditioned architectures based on Transporter Networks. The first, Transporter-Goal-Stack, stacks the current o t and goal o g images channel-wise, then passes it as input through a standard Transporter Network. The second, Transporter-Goal-Split, separates processing of the goal image o g through a fourth FCN Φ goal to output dense features that are combined with features from the query Φ query and key Φ key networks using the Hadamard product: We hypothesize that this separation is beneficial for learning, since convolutional kernels may otherwise struggle to disambiguate which channels correspond to o t or o g . Figure 3 shows the architecture of Transporter-Goal-Split. For consistency, all Transporter modules Φ query , Φ key , and Φ goal employ a 43-layer, 9.9M parameter FCN [41] with residual connections [25], given that similar architectures have been used for FCN-based picking and placing [71], [68].
A key aspect of the goal-conditioned model is that the spatial structure of the goal images are preserved in the architecture. This prior encourages the deep networks to learn features that infer pick and place actions anchored on visual correspondences between objects in the current and goal images. This is useful for manipulating deformable objects, where changes between current and desired configurations are better captured with dense correspondences [22], [20].

B. Training Details for Goal Conditioned Models
To train both goal-conditioned architectures, we use an approach based on Hindsight Experience Replay [2]. For each task (Table I), we assume a dataset of N demonstrations . In standard Transporter Networks, a single sample (o k , a k ) containing the observation and the resulting action at time k, is drawn at random from D. For the goal-conditioned Transporter Networks, we use the same procedure to get (o k , a k ), then additionally use the corresponding observation o g after the last action from the demonstration episode containing o k , to get training sample (o k , a k , o g ).
As described in Section III-B, because observations o t are top-down orthographic images and are spatially consistent The proposed Transporter-Goal-Split, applied to an example on bag-color-goal, where given the current image ot and goal og, the objective is to insert the block in the correct, open bag; the goal og specifies that the yellow bag (with the block) is the target, not the blue bag. Transporter Networks use three Fully Convolutional Networks (FCNs), f pick for the attention module, and Φquery and Φ key for the transport module. Transporter-Goal-Split considers a new, separate goal image og and passes that through a new FCN, Φ goal . These are then combined with other features through element-wise multiplication. Finally, the standard cross-convolution operator is applied. Transporter-Goal-Stack dispenses with Φ goal and instead stacks ot and og as one image, and does not use Φ goal ). All tested Transporter architectures produce Q pick and Q place , which are each 320×160 dimensional heat maps colored so that darker pixels are low values and lighter pixels are high. The largest value in a heat map represents the pixel to pick or place. Tasks involve rearranging deformable objects (e.g., cables, fabrics, and bags). Each comes with a scripted expert demonstrator that succeeds with high probability, except for the four bag tasks which are challenging; for these, we filter to use only successful episodes in training. Some require precise placing to trigger a success. Tasks with a visible zone will have a green target zone on the workspace to indicate where items should be placed (e.g., a square target zone that a fabric must cover); other goal-conditioned tasks use a separate goal image to specify the success criteria for object rearrangement. See Figure 2 for visualizations.
with rotations and translations, this enables data augmentation by randomizing a rotation and translation for each training image. To handle the goal-conditioned case, both o t and o g are augmented using the same random rotation and translation, to ensure consistency.

V. SIMULATOR AND TASKS
We evaluate the system on DeformableRavens, a novel suite of simulated manipulation tasks involving cables, fab-rics, and bags, using PyBullet [14] with an OpenAI gym [11] interface. See Table I and Figure 2 for overviews.

A. Deformable Objects (Soft Bodies) in PyBullet
Data-driven methods in robot learning often require substantial amounts of data, which can be expensive to obtain in the real-world [30]. While simulators have been used in robotics to help alleviate this difficulty, such as for locomotion [59] and rigid object manipulation [47], many simulated benchmarks for manipulation focus on rigid objects, partially because of difficulties in simulation of deformables [4].
Motivated by these challenges, we provide support for deformable objects (called "soft bodies") in PyBullet [14], a widely-used publicly available simulator for robotics research. While prior work with soft bodies in PyBullet [18], [19], [44] use position-based dynamics solvers, we use new soft body physics simulation based on the Finite Element Method [7] with mass-springs and self-collisions among vertices [6]. Contact and friction constraints between soft bodies and multi bodies are solved in a unified constraint solver at the velocity level. Implicit damping of the velocity uses a Krylov style method and soft body contact and friction is based on Conjugate Gradient for symmetric positive definite systems and Conjugate Residual for indefinite systems [60].
In simulation, cables consist of a sequence of rigid bodies ("beads"). Fabrics and bags are soft bodies, where each consists of a set of vertices. For fabrics and bags, we create a plane and a sphere object, respectively, using Blender [12]. (For bags, we remove vertices to form an opening.) We then import the object mesh files into PyBullet. To improve physics stability of drawstring-style bagging behavior in PyBullet simulation, we additionally attach a ring of rigid . Bags with handles (e.g., top right) will be addressed in future work. Bottom row: to make bags, we create a sphere in Blender and remove vertices above a certain height (bottom left). We import the mesh into PyBullet and add a series of beads at the bag opening. For bag tasks, we initialize the bag by randomly sampling a starting pose (bottom middle), applying a small force, and allowing the bag to crumple (bottom right).
beads at the bag's opening, using the same beads that form cables. See Figure 4 for an overview.

B. Benchmark for Manipulating Deformable Objects
We design 12 tasks with deformables, listed in Table I. For consistency, each uses a standardized setup: a UR5 arm, a 0.5×1m tabletop workspace, and 3 calibrated RGB-D cameras diagonally overlooking the workspace, producing top-down observations o t ∈ R 320×160×6 of pixel resolution 320×160, where each pixel represents a 3.125×3.125mm vertical column of 3D space. Observations contain 3 RGB channels and 3 channel-wise depth values. The goal is to train a policy that executes a sequence of pick and place actions in the workspace to achieve an objective, learned from demonstrations with behavior cloning [50]. Some tasks (e.g., cable-shape-notarget and fabric-flat-notarget) are specified by goal images of a target scene configuration, while others are described solely by the distribution of demonstrations (e.g., cable-ring-notarget and bag-alone-open).
The grasping motion primitive (introduced in Section III) is similar to the implementations in [28], [53] and approximates a pinch-grasp on a deformable by indexing the nearest vertex that comes in contact with the end effector tip, and locking in its degrees of freedom to match that of the end effector using fixed constraints. Certain tasks are divided into different stages, such as bag-items-1 and bag-items-2 which involve opening a bag, inserting items inside, and lifting a bag. Depending on the task stage and the gripped item, actions lift the gripped object to a different hard-coded height. For example, pulling the bag upwards requires a higher vertical displacement than opening the bag.

VI. EXPERIMENTS
We use scripted, stochastic demonstrator policies to get 1000 demonstrations (i.e., episodes) per task, and train policies using 1, 10, 100, or all 1000 demonstrations. We provide a detailed overview of the data generation process in the Appendix. We test the following models: Transporter. This model is directly from [68]. Transporter-Goal-Split. The Transport model that includes a separate goal module Φ goal to process o g .
Transporter-Goal-Stack. A model that stacks o t and o g channel-wise to form a 12-channel image, then passes it as input to standard Transporter Networks. GT-State MLP. A model that uses ground truth pose information as observations o t , and does not use images. It processes its input with a multi-layer perception (MLP) and directly regresses T pick and T place . GT-State MLP 2-Step. A baseline similar to the prior ground truth baseline, except it regresses in a two-step fashion, first regressing T pick , and then concatenates this result again to the ground truth information to regress T place .
We test Transporter on non-goal conditioned tasks, whereas for those that use goals o g , we test with Transporter-Goal-Split and Transporter-Goal-Stack. Ground truth baselines are tested in both settings, where in the goalconditioned case, we concatenate the ground truth pose information in both the current and goal configurations to form a single input vector. Following [68], to handle multimodality of picking and placing distributions, the models output a mixture density [9] represented by a 26-D multivariate Gaussian. During training, all models use the same data augmentation procedures for a fair comparison. Evaluation metrics. Episodes for cable-shape, cable-shapenotarget, and cable-line-notarget, are successful if all cable beads have reached designated target poses. For cable-ring, cable-ring-notarget, and bag-alone-open, success is triggered when the convex hull area of the ring of beads (forming the cable or the bag opening) exceeds a threshold. Episodes for fabric-cover are successful if the fabric covers the cube. Fabric-flat and fabric-flat-notarget are evaluated based on coverage [53]. Bag-items-1 and bag-items-2 consider a success when all blocks have been transported to the target zone with the bag. Finally, bag-color-goal evaluates success if the item has been inserted into the correct colored bag.

VII. RESULTS
We summarize results in Table II. For each model type and demo count N ∈ {1, 10, 100, 1000}, we train 3 models randomly initialized with different TensorFlow [1] seeds, except for bag-color-goal, where we report results from 1 model since the task is computationally expensive. Models are trained for 20K iterations, with a batch size of 1 for the three Transporter models and 128 for the two ground truth models (to strengthen the baseline). We save 10 snapshots throughout training at equally spaced intervals, and for each, we roll out 20 evaluation episodes. This gives 60 metrics (Section VI) for each snapshot, due to training 3 models. For each of the 10 snapshots and their associated metric, we average the 60 metrics and report the maximum over the 10 in Table II. The Appendix has more extensive analysis.

A. Non-Goal Conditioned Tasks
In these tasks, Transporter generally achieves orders of magnitude better sample efficiency than ground truth models. It performs reliably on fabric-cover with 100% success rates with just 10 demos (compared to 25% or less for all ground truth models), and does well on cable-shape (≥ 90.1%) TABLE II: Results. Task success rate (mean % over 60 test-time episodes in simulation of the best saved snapshot) vs. # of demonstration episodes (1, 10, 100, or 1000) used in training. For the first eight tasks listed, we benchmark with Transporter Networks [68] and two baselines that use ground-truth pose information instead of images as input. The last row of four tasks tests goal-conditioned policies, and we test with proposed goal-conditioned Transporter Network architectures (see Section IV-A), along with similar ground-truth baselines. Section VI and the Appendix contain more details.
cable-ring cable-ring-notarget cable-shape fabric-cover and bag-items-2, the best raw performance numbers (with 1000 demos) are 51.7% and 46.7%, which exceed demonstrator performance of 41.7% and 32.5% (see Table I).
Qualitatively, the learned policies may generalize to new starting configurations from the same data distribution. Figure 1 shows an example successful rollout on bag-items-1, where the robot opens the bag, inserts the cube, picks and pulls the bag (which encloses the cube in it), then deposits the bag to the target zone. The project website contains videos.

B. Goal Conditioned Tasks
For cable-line-notarget and cable-shape-notarget with 1 and 10 demos, Transporter-Goal-Stack and Transporter-Goal-Split outperform ground-truth baselines, but the performance gap narrows with larger datasets, perhaps because ground-truth models should eventually do well given sufficient data. Furthermore, we observe from training curves (see the supplementary material) that at around 16-20K training iterations, both goal-conditioned Transporter models with larger datasets (100 and 1000 demos) start to get significantly higher test-time performance across the goal-conditioned tasks (especially bag-color-goal). From inspecting test roll outs, we hypothesize that these models need to train longer to disambiguate o t and o g for the picking network f pick .

VIII. LIMITATIONS AND FUTURE WORK
In this work, we present a new suite of tasks that evaluate end-to-end vision-based manipulation of deformable objects, spanning cables, fabrics, and bags. In addition, we propose goal-conditioned model architectures with Transporter Networks for rearranging objects to match goal configurations. Manipulating deformable objects is challenging, and while the proposed method yields promising results, its limitations point to interesting directions for future work. For example, Figure 5 shows several failure modes in the bag tasks. The bag opening step is challenging because a single counterproductive action that visually occludes the bag opening makes it difficult to recover. In addition, for bag-items-1 and bag-items-2, items may fail to remain enclosed in the bag when lifted vertically. Future work may investigate higher rates of control that learn recovery policies to react in realtime, or stateful systems that can track objects under visual occlusions, or bimanual manipulation policies, which may help prevent items from falling out of bags. We also observe that the performance of policies on goal-conditioned tasks are slightly below those that explicitly rely on visual anchors in the workspace (e.g., fabric-flat vs. fabric-flat-notarget), suggesting a performance gap. Finally, given the COVID-19 pandemic which limited access to robots, as conditions improve, we will conduct physical experiments with bags. ACKNOWLEDGMENTS Daniel Seita is supported by the Graduate Fellowships for STEM Diversity. We thank Xuchen Han for assistance with deformables in PyBullet, and Julian Ibarz for helpful feedback on writing. This appendix is structured as follows: • In Appendix I we discuss COVID-19 restrictions, and how results may or may not transfer to the real world. • In Appendix II we describe the tasks in more detail. • In Appendix III we define the demonstrator policies. • In Appendix IV we provide more details of the various Transporter Network architectures. • In Appendix V we provide details of the experiment methodology. • In Appendix VI, we present additional results. More details, including videos of the learned policies and open-source code, are available on the project website. 1

APPENDIX I COVID-19 DETAILS
The ongoing COVID-19 pandemic meant that it was infeasible for us to perform physical robotics experiments, which led us to use PyBullet simulation. As in Zeng et al. [68], we strive to avoid system features that would be difficult to replicate in the real world. For example, we assume perception relies on color and depth cameras, which can be established in a physical environment.
One exception is that in simulation, we assume the gripper can "perfectly" grip objects, either a rigid body or a vertex within a soft body (i.e., fabrics and bags). Whenever the simulated suction/pinch gripper comes within a distance threshold to a rigid body or a soft body vertex, it anchors the nearest one to the gripper tip. This is similar to the pinchgrasp implementations found in [28], [39], [53], [63], [65]. In reality, suction-based grasping or pinch-grasping may be unreliable for certain material properties. To learn policies that capture behaviors robust to such cases, it is ideal to develop environments that explicitly simulate friction and contact forces using these grippers. We leave this investigation to future work.

APPENDIX II TASK DETAILS
In DeformableRavens, we propose 12 tasks, with details in Table I and visualizations in Figure 2. Here, we elaborate upon the tasks and success criteria in more detail. In addition, we derive the size of the ground truth observation passed into the GT-State MLP and GT-State MLP 2-Step baseline models (see Section VI).

A. Preliminaries
Each cable is formed from a set of either 24 or 32 rigid beads attached together. Each fabric consists of a grid of 100 vertices, and each bag consists of 353 vertices along with 32 rigid beads to form the bag opening (see Figure 4). The ground truth baselines account for every rigid object in a task by collecting the 2D coordinate position and a rotational angle about the z-axis, to get a single pose (x, y, θ). We account for fabrics by taking its 100 vertices and stacking all the 3D vertex positions together, to get a 300D vector. For bags, to reduce the ground truth state complexity and dimensionality, the baselines use ground truth pose information for the 32 rigid beads that form the bag opening, and do not use vertex information. The ground truth state also uses an additional 3D pose representing the displacement vector from the center of the bag's initial pose. Hence, a ground truth description of one bag is a vector of size 33×3 = 99. This reduced state representation to simplify the input to methods using ground truth information has been used in independent and similar work in benchmarking deformable object manipulation [39].
The four bag tasks have different "task stages," where the pull height and end-effector velocity vary based on the stage. All bag tasks have an initial stage where the robot opens up the bag if necessary. This stage has a low pull height and a slow gripper speed to increase physics stability. Then, bagitems-1, bag-items-2, and bag-color-goal have stages where the robot must insert an item into the bag, and bag-items-1 and bag-items-2 additionally have a third stage after that where the robot must transport the bag to a target zone. In these later stages, the pull vector must be high enough so that either a rigid item can be successfully inserted into the bag opening, or that the bag can be lifted in midair. For testtime deployment, these task stages are determined based on a segmented image which determines the object corresponding to a pick point.

B. DeformableRavens Task Details
(a) cable-ring has a cable with 32 beads attached together in a ring. The robot must open the cable towards a target zone specified by a ring, which contains the same area as the cable with maximized convex hull area. The termination condition is based on whether the area of the convex hull of the cable is above a threshold. Size of ground truth state: with 32 beads and 32 targets (one per bead), each consisting of a 3D description, the state vector is of size (32 + 32) × 3 = 192.
(b) cable-ring-notarget is the same as cable-ring, except the target zone is not visible. Size of ground truth state: with 32 beads, the state vector is of size 32 × 3 = 96.
(c) cable-shape has a cable with 24 beads attached together, with both endpoints free (i.e., it is not a ring-like cable). The robot must adjust the cable towards a green target shape anchored on the workspace, specified by a series of 2, 3, or 4 line segments attached to each other. Success is based on the fraction of beads that end up within a distance threshold of any point on the target zone. Size of ground truth state: with 24 beads, and 24 targets (one per bead), plus one more pose to represent the center of the target shape, all of which are represented with 3D poses, the state vector is of size (24 + 24 + 1) × 3 = 147.
(d) cable-shape-notarget is the same as cable-shape, except the target zone is not visible on the workspace, but specified by a separate goal image of the beads in a desired configuration. In this case, we save the poses of the 24 beads corresponding to the target image, and stack that with the ground-truth state vector. Size of ground truth: with 24 beads for the current cable and 24 for the cable in the target image, the state vector is of size (24 + 24) × 3 = 144.
(e) cable-line-notarget is a simpler version of cableshape-notarget, where the target image is specified with beads that form roughly a straight line. Size of ground truth state: as with cable-shape-notarget, the state vector is of size (24 + 24) × 3 = 144.
(f) fabric-cover starts with a flat fabric and a cube. The robot must place the cube onto the fabric, and then fold the fabric so that it covers the cube. Success is based on if the cube is not visible via a top-down object mask segmentation. Size of ground truth state: we use a 300D representation of fabrics, along with 3D pose information from the cube, resulting in a state vector of size 300 + 3 = 303.
(g) fabric-flat inspired by Seita et al. [53], [54] and Wu et al. [63], the robot must manipulate a square fabric to move it towards a visible target zone of the same size as a flat fabric. The fabric starts flat, but does not fully cover the target zone. 2 Success is based on if the robot exceeds a coverage threshold of 85%, computed via top-down image segmentation. Size of ground truth state: we use a 300D representation of fabrics, along with a 3D pose for the target zone, so the state vector is of size 300 + 3 = 303.
(h) fabric-flat-notarget is the same as fabric-flat, except the target is specified with a separate image showing the fabric in the desired configuration. For ground truth information, we store the 300D representation of the fabric in the target zone, and stack that as input with the current fabric. Size of ground truth state: with 300D representations for the current and target fabrics, the state vector is of size 300+300 = 600.
(i) bag-alone-open has a single bag with random forces applied to perturb the starting configuration. The objective is to expand the bag opening, which is measured via the convex hull area of the ring of beads that form the bag opening. Success is based on whether the convex hull area exceeds a threshold. Size of ground truth state: as reviewed in Appendix II-A, each bag is a 99D vector, and that is the size of the state dimension as there are no other items.
(j) bag-items-1 contains one bag, one cube, and one target zone, with forces applied to perturb the initial bag state. The goal is to first open the bag (if necessary), insert the cube into the bag, then lift and transport the bag to the target zone. The task is successful only if the cube is entirely contained in the target zone, and part of the bag opening is also in the target zone. Size of ground truth state: as with bag-aloneopen, the bag is 99D, and we additionally consider the 3D cube pose and the 3D target zone pose, so the state dimension is 99 + 3 + 3 = 105.
(k) bag-items-2 is a harder variant of bag-items-1, where there exists two items that must be transported to the target zone, and where the two items can be of various shapes and colors. The sizes of the items are constrained so that they can be feasibly inserted within the bag. Size of ground truth state: it contains similar information as bag-items-1, but has one more rigid item, so the state dimension is 99+3+3+3 = 108.
(l) bag-color-goal is a goal conditioned bag task with two 2 We tried perturbing the starting fabric configuration to induce folds, but found that it was difficult to tune self-collisions among fabric vertices. Fig. 6: block-notarget. This task involves a red, rigid L-shaped block. At the current observation ot, the block starts at some random location on the workspace, and the robot must use the same pick and place action formulation to get the block to a target pose specified in the goal image og. 5.0 cable-shape (20) 6.86 ± 3.3 6.0 cable-shape-notarget (20) 6.94 ± 3.4 6.0 cable-line-notarget (20) 5.55 ± 2.2 6.0 fabric-cover (2) 2.00 ± 0.0 2.0 fabric-flat (10) 3.10 ± 1.5 3.0 fabric-flat-notarget (10) 3.12 ± 1. 2.84 ± 0.8 3.0 bag-items-2 (9) 4.07 ± 0.9 4.0 bag-color-goal (8) 2.60 ± 1.3 2.0 block-notarget (2) 1.00 ± 0.0 1.0 bags and one rigid item. The two bags have the same size but different colors. The target image specifies two bags with one item inside it, and the objective is for the robot to put the item in the correct colored bag. Critically, the current state will have a bag of the same color as the target bag, and in the same spatial location. Size of ground truth state: each bag is 99D, and there is one 3D rigid item pose. Finally, each bag is augmented with a 3D vector specifying the RGB color value.
The dimension for the current state is (99+99+3+3+3) = 207. This is repeated for the goal state, hence the final state dimension is 207 × 2 = 414.

C. Additional Task: Block-Notarget
In addition to tasks in DeformableRavens, we create block-notarget, for fast prototyping of goal-conditioned Transporter Network architectures. This task is based on the insertion task from Zeng et al. [68], where the robot must pick, rotate, and precisely place an L-shaped block into a target receptacle. To adapt it to the goal-conditioned setting, we remove the the visible receptacle, and instead pass a separate goal image o g which contains the receptacle in the desired location. See Figure 6 for a visual. The ground truth state vector is of size 6, due to having 3D pose information for the current block and target block.

APPENDIX III DEMONSTRATOR DATA POLICY
All tasks come with a scripted demonstrator. We briefly highlight how the demonstrator is scripted, and refer the reader to the open-source code for details.
For cable-shape, cable-shape-notarget, and cable-linenotarget, the demonstrator computes, for each cable bead, its distance to the nearest point on the target zone. It performs a pick and place to correct the largest discrepancy. For fabriccover, the demonstrator places the cube onto the center of the flat fabric, then picks a corner at random and pulls it to the opposite corner of the fabric to cover the item. For fabric-flat and fabric-flat-notarget, we use a corner-pulling demonstrator as in [53] by sequentially correcting for the fabric corner furthest from the target zone corner.
In cable-ring, cable-ring-notarget, and all four bag tasks, the demonstrator begins with a common sub-procedure. These tasks contain a set of attached beads that either form a ring or the bag's opening (for bag tasks). For each action in this stage, the demonstrator first computes a set of target positions on the workspace (forming a circle) corresponding to what a maximally spread out cable ring would look like. It then enumerates all valid bipartite graphs between the set of cable beads and the set of targets, and picks the one with minimum distance, and concludes with a pick and place to correct the largest bead-to-target discrepancy.
Once the area of the convex hull contained by the beads exceeds a tuned threshold, the task either ends (if cable-ring, cable-ring-notarget, or bag-alone-open) or the demonstrator proceeds to inserting items (if bag-items-1, bag-items-2, or bag-color-goal). For inserting items, the demonstrator picks at a valid item and then places it at a random spot within the bag opening, computed via OpenCV contour detection. Finally, for the bag moving stage in bag-items-1 and bagitems-2, the demonstrator does a pick on a random visible bag bead, pulls with a hard-coded higher height delta, and ultimately places the bag at the center of the target zone.
We briefly highlight two aspects of the demonstrator: 1) Since the demonstrator has access to ground truth state information (i.e., rigid object poses and deformable vertices), it performs the same on tasks that only differ based on the existence of a visible target zone on the workspace (e.g., fabric-flat versus fabric-flat-notarget).
2) The demonstrator is stochastic (i.e., behaviors are different between demonstrations). PyBullet provides built-in image segmentation code to find all pixels corresponding to an object. When the demonstrator picks an object, it samples uniformly at random among all pixels corresponding to the target object in the segmentation mask. The stochastic nature, along with randomly sampled object poses at the start of each new episode, ensures some level of dataset diversity. Since the models we test use behavior cloning, the performance of the learned agents is bounded by the datagenerating policy. For the bag tasks, it is difficult to script a high-performing demonstrator given the complexity of bag simulation and manipulation. Therefore, we ignore unsuccessful episodes and run the demonstrator to generate as much data as needed until it gets 1000 successful demos. Due to stochasticity, we hypothesize that seeing only the successful demonstrations may be sufficient for policies to learn reasonable pick and place patterns from data. For bag-alone-open, bag-items-1, bag-items-2, and bag-colorgoal, getting 1000 successful demonstrator episodes required running 1661, 2396, 3276, and 1110 times, respectively.

APPENDIX IV ADDITIONAL TRANSPORTER NETWORK DETAILS
For standard Transporter Networks [68] (reviewed in Section III-B), we swap the cropping order within the query network Φ query , so that cropping happens after the observation image o t passes through the network. This enables subsequent features to use a larger receptive field.
For Transport-Goal-Split, we demonstrate the forward pass for the transport module using Tensorflow-style [1] pseudo-code. This module includes Φ key , Φ query , and Φ goal , but does not include the attention module f pick , which is used prior to the transport module forward pass. import numpy as np import tensorflow as tf import tensorflow_addons as tfa   Table II. For brevity, we use "Transporters" here to collectively refer to Transporter, Transporter-Goal-Split, and Transporter-Goal-Stack. See Sections III and IV for background on notation for Transporter-based models. We also report values for the ground truth (GT) baseline models.   Figure 6. The table is formatted in a similar way as in Table II. block-notarget by fully connected layers for actions [38], two ground-truth state baselines, and ablations to Transporter Networks. In an effort to alleviate compute, we only use the best versions of the Transporter Networks and Ground-Truth methods in [68], and we do not use the Form2Fit or CNN baselines, which exhibited significantly worse performance than Transporters. We show relevant hyperparameters, such as the Adam [32] learning rate, in Table IV. As described in Section VII, for each model type and demo count N ∈ {1, 10, 100, 1000}, we train for 20K iterations, where each iteration consists of one gradient update from one minibatch of data. We save snapshots every 2K iterations, resulting in 10 snapshots. Each snapshot is then loaded to run 20 episodes using held-out "test set" random seeds. We repeat this process by considering 3 separate training runs (per model type and demo count) to get more evaluation data points. The exception is with bag-color-goal, where we train and load (i.e., test) just 1 time (instead of 3) for each demo count, due to the computationally intensive nature of testing, which requires simulating environment steps with two bags. For the 100 and 1000 demonstration bag-color-goal datasets, we additionally train Transporter-Goal-Split and Transporter-Goal-Stack for 40K iterations instead of 20K (while keeping the batch size at 1), since preliminary results showed that performance of the models notably improved at around 20K iterations.

APPENDIX VI ADDITIONAL EXPERIMENT RESULTS
We find in Table V that Transporter-Goal-Stack and Transporter-Goal-Split are roughly two orders of magnitude more sample efficient on block-notarget, with success rates from 10 demos (88.3% and 90.0% for the two variants) on par with success rates from 1000 demos for the ground truth models (90.0% and 91.7%). Figure 7 contain learning curves showing the performance of the models as a function of training iterations.
In Figures 8, 9, 10, and 11, we show similar learning curves for the tasks in DeformableRavens (see Table I), where model architectures in each figure are all trained on the same set of 1, 10, 100, and 1000 demonstrations, respectively. Besides the number of demonstrations used for training each of the models, we keep experimental settings consistent across Figures 8, 9, 10, and 11. Fig. 7: Results for models on the block-notarget task. From left to right, we report models trained with 1, 10, 100, and 1000 demonstrations. All models are trained for 20K iterations, and perform test-time evaluation on iterations: 2K, 4K, 6K, 8K, 10K, 12K, 14K, 16K, 18K, 20K. Each data point represents the average of 60 test-time episode evaluations; we train 3 separate training runs, and run each of those snapshots for 20 test-time episodes at each iteration checkpoint. We also report performance of policies at "iteration 0" with random parameters. Shaded regions indicate one standard error of the mean. Fig. 8: Results for various models, each trained on 1 demonstration, with shaded regions indicating one standard error of the mean. We train for 20K iterations, and perform test-time evaluation on iterations: 2K, 4K, 6K, 8K, 10K, 12K, 14K, 16K, 18K, 20K. Each data point represents the average of 60 test-time episode evaluations; we train three separate training runs, and run each snapshot within those runs for 20 test-time episodes. Random seeds for test-time episodes are kept fixed among all methods so that evaluation is done on consistent starting states. We also report performance of policies at "iteration 0" with random parameters.   Figure 8, with the exception that Transporter-Goal-Split and Transporter-Goal-Stack are trained with 40K iterations (rather than 20K) for bag-color-goal, due to the need to train longer for this task. (The batch size is still 1, meaning that the models utilize fewer samples than ground-truth models that use a batch size of 128.)