Learning Model Preconditions for Planning with Multiple Models
Anonymous Author(s)
Af ﬁ liation Address email
Abstract: Different types of models can provide differing levels of ﬁ delity whenplanning for a robot’s task execution.
Analytical models are often fast to evaluatebut only work in a limited range of conditions.
Meanwhile physics simulators areeffective at modeling interactions between objects but are typically more computationally expensive.
Learning when to switch between the various models cangreatly improve the speed of planning without sacri ﬁ cing task success.
In thiswork, we learn model deviation estimators (MDEs) to predict the error betweenreal-world states and the states outputted from skill effect models.
Afterwards, weuse the prediction from MDEs to switch between various models in order to speedup planning when possible.
We evaluate our method on two real-world tasks:placing a rod into a box, and placing a rod into a closed drawer.
Introduction
Predictive models that are helpful for intelligent behaviors can take a variety of different forms, e.g.,analytical models [1, 2], physics simulations [3, 4], and learned models [5, 6, 7], and the bestchoice of model is context dependent.
For example, a high ﬁ delity simulator can capture complexinteractions between objects in a dynamic sweeping motion accurately with limited to no real-worlddata.
However, for a simple tabletop pick and place task, a simulator model is unnecessary comparedto a simple kinematic model. [Figure]
a
[Figure]
asa Masa M M 1 (s 1 ,a 11 )
M 0 (s 1 ,a 11 ) s 1 , a
Simulator Analytical model A planner may need to make many predictions to ﬁ nd a plan, so it is important to prioritize usingcomputationally expensive models to only those situations where they are most needed. We de ﬁ nemodel preconditions , shown abstractly in Figure 1, which when satis ﬁ ed demarcate regions of statesand actions where the model accurately represents real-world dynamics.
We use those model preconditions during planning to leverage complementary advantages and disadvantages of differentmodel classes during planning. The robot learns to predict the total state deviation as a continuous value for each model to informplanning to avoid regions that require expensive models, and to not use actions where no modelsare suf ﬁ ciently accurate. The amount of acceptable model error is task-dependent, but by predictingstate deviation as a continuous value rather than a binary one, the thresholds can be set based on thetask accuracy requirements.
This work’s contribution is a method for de ﬁ ning model preconditions using a learned scalar modeldeviation term, and then using those preconditions for planning with multiple models to minimizedeviation during real-robot execution.
We ﬁ rst show how to ﬁ t Model Deviation Estimators (MDEs)from planning-relevant data to predict state deviations.
We then use MDEs to de ﬁ ne model preconditions for multiple skills for speci ﬁ c tasks.
We evaluate our method for learning and planning with MDEs on two real-world tasks including: placing a rod that can rotate in-hand into a box, and placing a rod into a closed drawer.
The robot has access to incomplete analytical models for each actionclass and a physics simulator.
Like in many real-world planning applications, none of the modelsclosely match the real-world for all possible interactions. We compare two planning approacheswith MDEs against other model selection baselines.
Related work
We review related work relevant to our two main contributions: predicting model error, and planningusing multiple imperfect models by reasoning about speed and reliability tradeoffs.
Improving planning reliability with past experience: Learning model preconditions for planningdraws from the high-level idea of identifying similarities to states encountered in previous plans toapply behavior that previously led to successful plans, which can signi ﬁ cantly improve planningspeed [8, 9]. Plan reliability can also be improved by learning skill preconditions, which describefrom which states skills achieve desired effects Konidaris et al.
[10], Sharma and Kroemer [11], Wang et al.
Avoiding regions with model error: For predicting where the model is accurate using data, [13]and [14] use hyperspheres to represent proximity to training data for a learned model as a proxy forthe model precondition.
CMAX and its successor also use hyperspheres, but uses points where theaction effects differed signi ﬁ cantly from that predicted by the internal model [15, 16].
However,proximity to training data and predicted collisions do not always capture model accuracy whenexecuted on a real robot. Our work proposes a method to learn a model from plan execution datato predict whether model error will occur.
Other works bias search away from states where thesimple planning model is known to be inaccurate, but also do not use other models to compensatefor transitions the simple model cannot model accurately [14, 13, 15, 17]. For example, our methodalso uses a more expensive model and an additional simple model for planning when needed, whichmay be necessary when the simple model is not suf ﬁ cient to ﬁ nd a plan to the goal. Predicting model error:
The two works most similar to ours use real robot visual similarity to ﬁ ta GP on the uncertainty of their simple model prediction in [18] and learning a classi ﬁ er in [17].
The primary difference is they do not use their model error estimates as a criterion for switchingmodels, whereas we use the planning data to learn model error estimates to decide between multiplemodels.
Furthermore, our state space representation obviates the need to realistically render allmodel predictions, and also allows prediction where two very different states may be visually similar.
: [19] uses a rule where a simulator is only used when collisionis detected using an internal model to speed up planning. However, there are many situations wherethere are many transitions where objects are in contact, but an analytical model can still be used.
Our planning algorithm is based on Multi-Graph Multi-Heuristic A* [20], with the additional complication that we do not know whether a node will be high cost to evaluate until after at least a partialexpansion, and as a result, the choice of which representation to use is not straightforward.
Problem Formulation
The overall problem is to ﬁ rst learn the MDEs to predict the total model deviation given a state,action, and model being used to predict the next state.
The next challenge is to then use MDEs forplanning using multiple models, applying the fastest one to evaluate where possible.
The state space is denoted by S and is assumed to be fully observable at the end of an action.
Theaction space a ∈ A is a set of closed-loop skills parameterized by θ which are available to therobot.
Skills follow the options formulation [21].
An action executed at high-level time step t isdenoted by a t .
The low level controls occur at a different level of abstraction.
Low-level state isx t ∈ S .
Each skill is executed from a state s t until reaching a termination condition β ( x t � , θ ) ∈{ 0 , 1 } is 1 .
The actions are intended to be run for a signi ﬁ cant period of time such that feedbackcontrol at a lower level of abstraction can correct low-level errors, leaving the MDEs to capturemodel error that is harder to correct.
The behavior of the controllers are described entirely by( s t , a t , θ t ) .
For example, a placement skill would move the gripper with an object in hand from itsinitial pose described by s t to a pose described by θ and then open the gripper to place the object.
Skills have an associated precondition set, I a ( s t , θ ) .
The precondition depends on both the stateand the parameters de ﬁ ning the skill behavior.
To execute a t with parameters θ t , s t must be in I a ( s t , θ ) .
Each skill has its own set of user de ﬁ ned preconditions, termination conditions, predictiveeffect models, and controllers.
The skill preconditions narrow the space where the skill has de ﬁ nedbehavior, but do not comprehensively describe the set of states where the dynamics models areaccurate.
The precondition simply relates to the skill’s applicability and are separate from MDEsand effect models, which we describe next.
The robot is given a prioritized list of K models, [ M 0 , M 1 , . . .
M K ] used to compute the forwarddynamics: ˆ s t +1 ← M ( s t , a t , θ t ) .
The models are ordered by decreasing computation times where
M i is more expensive to evaluate than M j if i < j .
For example, M 0 a high- ﬁ delity simulator that isslow but very accurate, M 1 a simulator with a coarse timestep discretization, M 2 an analytical modelrequiring more computation, and M 3 may be a simple linear model.
To measure model deviation,the robot is given a distance function between states, d ( s i , s j ) , such as Euclidean distance.
The
MDE predicts d from φ ( s t ) and a t , where φ ( s t ) is a function that extracts relevant features such asobject poses, or distances between objects.
Lastly, the robot is given a task which includes a goal set, cost function, heuristic, and action parameter generators.
The state satis ﬁ es the goal if it is in the goal set, S g .
The cost function describesthe cost of high-level state transitions and is denoted by c ( s i , s j ) .
The heuristic is an underestimateof the cost to a goal state.
The action parameter generators return a set of potentially useful θ valuesfor planning, and can be shared across tasks.
To train the MDEs, the robot needs to ﬁ rst compute an of ﬂ ine dataset D of transitions ( s t , a t , s t +1 ) .
We assume the robot knows the initial state distribution, but not all states visited during planning.
Initial states are samples from the initial state distribution, but the rest of the states are determinedfrom planning.
Then, the robot trains the MDE ˆ d ( s t , a t , θ t ) which estimates d ( s t +1 , M k ( s t , a t , θ t )using D .
The eventual goal is for the robot to search for a high-level plan of action types[ a 0 , a 1 , . . .
a T − 1 with corresponding action parameters [ θ 0 , θ 1 , . . .
θ T − 1 ] to create a sequence ofstates [ s 0 , s 1 , . . .
s T ] such that it reaches a goal state s T ∈ S g .
Approach
First we explain how we collect training data and train the MDE, describing the desired characteristics for a useful MDE.
We then show how MDEs can be used in planning to use multiple modelswhile prioritizing states that can be reliably evaluated using simpler models.
4.1 Learning Model Deviation Estimates
Training data is collected by computing and executing plans using all models.
If a path to the goal isfound, it is executed.
Each transition is saved as ( s t , a t , θ t , s t +1 ) tuples for every transition observedin the path.
Training data for transitions is used across all models even though that transition wascomputed using just collected using one model.
A dataset for the MDE for skill a and model M isgenerated by concatenating the s t and θ t values to form the input vectors.
The output is the distancebetween the predicted state and the actual state: d ( M k ( s t , a t , θ t ) , s t +1 ) .
We train an MDE for everycombination of skill and model.
The reason MDEs are ﬁ tted using regression rather than directly asclassi ﬁ cation of a predicted deviation over d max with is so the MDEs can be applied to new tasks,potentially with a different d max .
The representation we use is a 3-layer MLP with 32 hidden unitsin each layer.
Next we will describe the loss function for MDEs.
An underestimated deviation is worse for planreliability than an overestimated error.
Overestimates cause the planner to be overly conservative,but an underestimate can cause plans to not be executed reliably on the real robot.
As a result, wepropose a loss function that weighs underestimates more than overestimates:
[Equation]
To get the desired behavior, we set c 1 > c 2 .
Using relational features, φ ( s t ) such as the distancesbetween objects can be helpful local features.
These features can appended to the end of the inputvector to form [ φ ( s t ) , θ t ] .
4.2 Planning Using Multiple Models Using MDEs
To compute plans that are predicted to be executed reliably in the real-world, we onlyuse a model M to compute the effects of an action if the current state and action are inthe model precondition.
A model precondition is de ﬁ ned using MDEs as pre( M k , a t ) =
s t ∈ S | ˆ d ( M k ( s t , a t , θ t ) , s t +1 )
> d max .
Model preconditions can be used in the same manner asskill preconditions by using the model preconditions as an constraint during planning. The constraint can be an inequality or a predicate constraint. To be an inequality constraint, the planner usesthe MDE directly: ˆ d ( M k ( s t , a t , θ t ) , s t +1 )
> d max .
Model preconditions as a predicate constraintcan be directly applied to STRIPS-style planners by including ( s t , a t , θ t ) ∈ pre ( M ) to the existingaction preconditions, where M is the model used to compute the effects. Although MDEs can be used to select between models in a more general setting, in this section,we propose a planner that can more effectively use MDEs by using a user-de ﬁ ned model priorityweighting to prioritize expanding subgraphs that are less expensive to evaluate.
Our planner prioritizes simpler models by using a weighting factor similar to the one used in Multi-Heuristic A*[22]. Because successors come from different models, our planner is also based on Multi-Heuristic Multi-Representation A* [20].
Our proposed planning algorithm uses up to K models for each skill. Models can either be skillspeci ﬁ c for shared.
The planner maintains K queues which expands K graphs. All graphs sharesuccessors though maintain their own open and closed queues.
An anchor queue expands its graphusing all models. K − 1 additional open queues are used to expand the graph using the faster models. Priorities between models are adjustable using the w =
[ w 0 , w 1 , . . .
w K ] , which is a list of scalarsdecreasing in value representing how much to penalize slower models We now go into detail abouthow the separate queues and graphs are used to switch between models.
Like for Weighted A*, each planning node has a cost g , heuristic value h , and priority f = g + wh .
The function M IN K EY () returns the node in a queue with the lowest f value.
To handle partialexpansions, a node can optionally have a set of un-evaluated actions associated with it, A incomplete
The anchor search uses open queue OPEN 0 and closed queue CLOSED 0 . It uses a full expansion ,which computes the successor with the fastest model that satis ﬁ es the precondition for a particularstate and action. If no model satis ﬁ es the precondition, there is no successor for that state and action. Nodes that are fully expanded in the anchor search are added to all closed queues.
Each additionalsearch maintains its own open queue OPEN i and closed queue CLOSED i .
It computes successorsusing a partial expansion only using M i as long as ( s t , a t , θ t ) ∈ pre( M i ) , saving other actions forexpansion by other graphs. All open queues are initialized to { s 0 } and all closed queues are initialized to {} .
All graphs are 170 implicit and bidirectional.
The rule for which queue to expand from is based on MHA*.
Graph and node selection: We expand from queue i where: [Equation] If i = 0 , then a node is expanded in the anchor search using the full expansion.
If i > 0 then thenode is expanded using a partial expansion for graph i .
The node to be expanded is OPEN i , similarto standard A* search.
We begin by describing steps used for both types of expansions, and then describe what is different.
All expansions begin ﬁ rst checking the goal condition.
The search is terminated when s t ∈ S g isexpanded.
As shown in the ﬁ rst decision node in Figure 2, if s t / ∈ S g , both expansions check if A incomplete = {} and if so, use the task’s parameter generation function to generate a candidatelist of possible ( a t , θ t ) pairs. If A incomplete is non-empty, A incomplete are the actions used for [Figure]
expansion. The graph to expand is chosen using the rule in Equation 2. After expansion, the childnodes are added to all queues, and paths are updated using the standard A* re-connection rule: ifthe child cost is lower than the cost of an existing node, replace the existing node with the new childnode.
Full expansion from OPEN
Full expansion evaluates all successors (the top right box in Figure 2)using M i ( s t , a t , θ t ) for the highest value of i that satis ﬁ es ( s t , a t , θ
t ) ∈ pre( M i ) .
Add s t to all CLOSED lists as it is fully closed.
Partial expansion from OPEN i The intuition here is to evaluate nodes using faster models sooner,but delay slower evaluations.
For all ( s t , a t , θ t ) ∈ pre( M i ) , compute the successors, s t +1 using M i .
For all states and actions not in the precondition, do not evaluate the successors.
Instead, addthose successors to A incomplete of s t . If there are actions that were not evaluated using M i duringpartial expansion because they are not in the precondition, those actions are added as A incompleteto the expanded node to be potentially evaluated by other models, and the node is only added to
CLOSED i .
Otherwise, the node happened to be fully expanded and it added to all closed queue. Itssuccessors are added to all open queues. This step helps bias the search to nodes that are cheap toevaluate, while still allowing the planner to ﬁ nd plans when more expensive models are necessaryfor completeness.[-The full pseudocode for the algorithm is in Appendix 7.
-]
Experiments
First, we describe the metrics we use to evaluate our method.
Next we describe the experimentalsetup we use for two real-world tasks and data collection.
Then, we show the accuracy of MDEs foreach skill for data from different tasks.
Finally, we evaluate two planners that using MDEs on tworeal-world tasks against baselines: one using a single queue with model preconditions as constraints,and another using our multiple-queue planner described in Section 4.2.
We compare timing metrics,demonstrate the model selection for each skill in RodInDrawer , and discuss how the models selectedin each algorithm impacts plan time and reliability For plan performance, we test: 1) the time tocompute a plan (seconds), 2) the model evaluations rate (model evaluations per second) to measurethe planner’s ability to explore ef ﬁ ciently, 3) whether the planner computed a plan if one exists, and4) whether the robot achieved the goal if a plan was found to measure reliability.
Tasks:
For both tasks, the robot manipulates a steel rod into the desired container.
Steel rod rotatesin the gripper in some grasps (Figure 6).
The target rod is chosen randomly at the beginning of eachtask.
Both rods are placed in arbitrary reachable con ﬁ gurations unoccluded by other objects on thetable.
The ﬁ rst task is RodInBox .
A state is in S g if the target rod is in the green box shown in Figure 3.
The signi ﬁ cance of this task is to evaluate what happens when our method is applied on a taskwhere high precision is not necessary for task completion, but some actions are easier to model thanothers.
The distance function used as a heuristic is the distance between the target rod and the centerof the box.
The second task we evaluate on is RodInDrawer , shown in Figure 3 where the goal is toplace a rod in the drawer.
Goal states are speci ﬁ ed by the rod being within the bounds of the drawer.
Perception is accurate enough to differentiate between the rod being on the ground, on top of box,or in the drawer.
Actions in both simulation and the real world are implemented by using Cartesian impedance controllers.
In simulation, the world is fully observable.
In the real world, the rod poses are estimatedusing color segmentation from the overhead camera.
When a grasped object is occluded by therobot, an in-hand camera is used to con ﬁ rm that the object is in-hand and the previously recorded [Figure] pose is used.
This perception is suf ﬁ cient for our use case because the skills with the most variabilityin end state do not end with an object in-hand.
Skills: For all motions, the robot moves horizontally only at an obstacle-free height, so collisionis only checked at the beginning and end of each motion.
The state includes the pose and geometryof all objects in the scene, including the robot joint angles.
The robot is given access to two skillsto use per task.
A Pick skill is available in both tasks.
The parameters are the goal pose representedusing [ x, y, z, yaw ] .
The precondition is that no object is currently in the gripper, and that there willbe no collision at the goal pose.
The controller opens the gripper if it is not already open, moves toz free , moves to the desired yaw , then moves down to the goal z .
Once the gripper is close enoughto the goal pose or has reached a timeout, it closes the gripper to a pre-determined width based onthe rod dimensions.
We use task-centric parameter sampling to sample grasps around the target rod.
The precondition of LiftAndDrop is that an object is between the gripper, and that the goal pose willnot cause collisions.
The parameter generator for LiftAndDrop is task oriented, sampling goal posesabove the goal box.
The parameter vector is also [ x, y, z, yaw ] .
Similar to Pick, the controller closesthe gripper if not already closed, moves up to z free , moves to the goal z , then opens the gripper.
OpenDrawer moves the gripper to a ﬁ xed location relative to the front of the box and pushes thedrawer by moving along the negative y axis by an amount speci ﬁ ed by the parameters.
This skillassumes that the drawer is opened along the negative y axis of the world.
The precondition isthat there is no rod already in the hand.
The parameters are [ x, y 0 , z, yaw, y f ] where y 0 is theinitial y values of the gripper and y f is the target ﬁ nal y value of the gripper after executing theskill.
Parameter generation is object-centric, sampled based on the drawer pose to a random openedamount.
Detailed descriptions of all the skills is in Appendix 7.
The simulator we use for both tasks is IsaacGym [3].
For RodInBox , we use a setupwith a box shown in Figure 3(a).
The detailed simulation parameters used for both experiments areshown in Appendix 7.2.1.
For RodInDrawer , the drawer is modeled as a single drawer chest usingcuboids, as shown in Figure 3(c).
For all simulator models, the robot computes the controllers itwould use for plan execution in the real-world and executes them in simulation instead and returnsthe result.
We use two types of kinematic analytical models for our tasks.
One model only computes the transition model for the rod and robot: Analytical (robot & rods) .
Another model, Analytical (robot& drawer) , only reasons about the articulation mechanism of the drawer, but does not model interactions between the rods and drawer.
Details about each analytical model are in Appendix {+7.2.
+}
5.1 MDE Accuracy
In this section, we evaluate MDE accuracy on each skill used.
As shown in Table 1, deviationprediction error is highest for LiftAndDrop because there is a wider range of possible outcomes.
The predicted deviation error for the simulation is lower but not close to 0 because predicting theprecise deviation requires an accurate real world dynamics model.
For example, a poorly-graspedrod may drop in simulation earlier than it would on the real robot system by dragging on the grounddifferently or drooping more. Since Analytical (robot & drawer) does not model movement of therods, the exact deviation depends on the state and parameters, but the error is always predicted to behigh, which is suf ﬁ cient information to guide planning.
[Table]
[Table]
5.2 Planning Speed
For planning, we evaluate the performance from ten different initial start states per task.
5 parameters are generated per skill for RodInBox , meaning a maximum branching factor of 10 for
RodInBox .
RodInDrawer uses three skills, with three parameters generated per skill.
WA* uses� = 5 for RodInBox and � = 10 for RodInDrawer . w M is [10,1] for RodInDrawer and [10,1.1,1]for RodInBox ..
The cost function is given by the end effector distance between the start and endstate of the trajectory, || x eet − x eet +1 || .
For timing experiments shown in Table 2a, we allow the 273 planner to run for at most 300 seconds (5 minutes).
Average plan times do not include timeouts Baselines: We compare planning using MDEs to planning with each individual model, and randomly selecting which model to use when computing each successor. Additionally, we perform anablation test by removing the additional queues and only performing full expansions using OPEN 0 ,though still evaluating the fastest model that satis ﬁ es the preconditions. For RodInBox , (Table 2a) the planning time and model evaluation rate are fastest using only theanalytical model.
In contrast, the model evaluation rate for the simulator baseline is three ordersof magnitude slower.
Because our method uses the fastest reliable model wherever possible, andfor this task a short plan to the goal can be computed only using the fastest model, the modelevaluation rate for our method is still high.
The one-queue planner that uses MDEs is slow becausethe precondition for the simulator model for LiftAndDrop is usually satis ﬁ ed, so those states areexpanded although they do not need to be to compute a plan.
The planning speed of the randombaseline is only a modest improvement over the simulator-only baseline.
The model evaluation rate and planning time for both methods using MDEs RodInDrawer (Table 2b) are faster than the simulator only baseline because it can always use an analytical modelfor Pick and OpenDrawer , and sometimes use the analytical model for LiftAndDrop .
The improvement of using multiple queue in this domain is smaller than for RodInBox . The reason is that thesimulation environment with the drawer is more inaccurate than the environment with the box, andthe rods are placed in a different location for each setup, so the actions are different. As a result,the one-queue planner never uses the simulator, which can also be seen in Figure 4. The randombaseline is the slowest because it uses the largest number of simulator evaluations.
Both plannersthat use MDEs use the fastest analytical model, and avoid simulating LiftAndDrop in this domainbecause it is both slow and inaccurate.
Furthermore, in Figure 4 we can see how both MDEs andthe planning method can affect the distribution of models chosen. For example, only using onequeue causes the planner to compute successors for ( s, a, θ ) sets in the model precondition of moreexpensive models at the same priority of sets in the faster models, which causes some actions to be
[Figure]
����������� ���� ��� ��� ��� ��� ��� ��� � � � � � � � �� � �������������������������������������������������������������������������������������������������������������� �������� ����������� ���� ��� ��� ��� ��� ��� ��� � � � � � � � � � � � � � � � � � �� � �� �������������������������������������������������������������������������������������������������������������� simulated.
For RodInDrawer we see that does not signi ﬁ cantly affect model distribution selection orperformance, as the one-queue ablation test has very similar model selection to the {+multiple-queueplanner, which is also discussed in Section 5.
 5.3 Reliability of Computed Plans+}
[Figure] The next set of experiments, shown in Figure 5 evaluates the ability of our method to improve planreliability without signi ﬁ cantly increasing planning speed by balancing model accuracy and time [Figure] when using a physics simulator in addition to a internal model.
[Figure]
All methods that use a model that reasons about interactions between the rod and drawer are ableto compute a plan in the allotted time for RodInBox .
Since RodInDrawer is more challenging, therandom and simulator-only baselines sometimes time out due to longer planning times (Figure 2b. The execution reliability for the analytical-model-only and simulator baselines is the lowest becauseboth of those models are inaccurate for side grasps.
In the real-world, the rod either pivots in thegripper during a side grasp, causing it to hit the box and fall to the side (Figure 6c), or simplyfalls when the gripper is lifted. When the center grasps are chosen, Analytical (robot & rods) for LiftAndDrop is correct: the rod does not fall.
If the plan is comprised only of Pick and LiftAndDropmotions, then as long as a center grasp is chosen the plan will succeed. Execution reliability forboth planners using MDEs signi ﬁ cantly improves over the baselines for RodInDrawer by avoidingunreliable side grasps.
Conclusion
We present a method for de ﬁ ning model preconditions using MDEs that predict model deviationgiven a state and a parameterized skill, which can be used to inform tradeoffs between models wheneach has complementary advantages and disadvantages in evaluation time and accuracy.
Although MDEs can be used as constraints, we show a planner that uses multiple queues corresponding todifferent models that prioritizes planning using the faster models. Experimental evaluation showpromise in speeding up planning by choosing between multiple models while keeping high planreliability during execution.
In both tasks, our results show that a robot can learn and reason aboutwhich transitions it needs to use more expensive models, which transitions none of the models workfor, and how to plan accordingly.
For placing a rod in a drawer, we show the robot can reason aboutusing two low- ﬁ delity models that model different interactions. For future work, we will share moredata across skills by using a shared action representation, which will also allow changing a low-levelmodel multiple times in a skill.