Java实现简单的考虑时态的HTN规划

前提知识

请参考之前的CSDN文章内容。

1. 简单时态网络STN
2. HTN规划
3. 智能规划基础

考虑时态的HTN规划

概述

时态HTN规划是一种高效的计划方法，用于处理具有时间约束的复杂任务。这种方法在智能代理和自动化系统中尤为重要，特别是在需要考虑任务执行时间和顺序的场景中。本文将介绍一种基于时态HTN的规划算法，该算法融合了POPF算法的思路，并专注于任务的时间维度。

算法输入

初始状态：定义了规划开始时的环境状态。

方法及操作符：

复合任务分解方法：包含名称、前置条件和子任务列表、子任务间的时态约束、要求的开始和结束时刻。

原子任务操作符：具有名称、前置条件和效果、原子任务持续时间。

任务网络：由原子任务和复合任务构成的网络结构。

Literal库：存储动作引发的谓词及其参数，用于维护动作间、任务间的因果链约束。

算法输出

动作序列及其时态网络。

算法流程

初始化：设置任务列表、状态和Literal库。

任务分解：选择并分解满足前置条件的任务。如果任务列表为空，则结束。

处理复合任务：将时态约束传递给子任务，并将子任务加入任务网络。

处理原子任务：根据前置条件在Literal库中添加因果链约束，并更新状态和任务列表。

一致性检验：检查时态网络的一致性，并输出规划解。

关键考虑点

添加原子任务约束：主要考虑任务的持续时间约束，任务的删除效果引发的因果链约束，动作的添加效果引发的因果链约束，动作的前提条件引发的因果链约束。

添加复合任务约束：考虑子任务之间的约束、最早开始时刻和最晚结束时刻的时间窗约束。任务的前提条件引发的因果链约束；

时态规划算法代码

    /**
     * a TemporalHTN Algorithm.
     * 
     * @param tasks
     * @param state
     * @param temporalPlan
     * @param literalActionMap
     * @param stn
     * @return
     */
    public boolean planbyTemporalHTN(List<Task> tasks, Map<String, Object> state, TemporalPlan temporalPlan,
            Map<String, PrimitiveTask> literalActionMap) {

        // 迭代终止条件。
        if (tasks.isEmpty()) {
            this.plan = temporalPlan;
            return true;
        }

        for (int i = 0; i < tasks.size(); i++) {
            Task currentTask = tasks.get(i);
            // 是原子任务且状态被满足:
            System.out.println(currentTask + " " + currentTask.isPrimitive());
            if (currentTask.isPrimitive()) {
                PrimitiveTask pTask = (PrimitiveTask) currentTask;
                // System.out.println(pTask);
                Operator o = findOperator(currentTask);
                if (o.CouldApply(state)) {
                    // 建立新节点
                    List<Task> newTasks = new ArrayList<>(tasks);
                    TemporalPlan newPlan = new TemporalPlan(temporalPlan);
                    SimpleTemporalNetwork stn = new SimpleTemporalNetwork(temporalPlan.getStn());
                    List<String> newAction = new ArrayList<>(temporalPlan.getActions());
                    Map<String, PrimitiveTask> newliteralMap = new HashMap<>(literalActionMap);

                    // 先判断添加约束以后是否一致性
                    stn.addTcList(CreateDurationTC(pTask)); // 添加持续时长约束
                    // System.out.println("add constraints:" + CreateDurationTC(pTask));
                    // 添加literal约束;
                    for (String l : o.getPrecondition().getKeys()) {
                        PrimitiveTask otherPT = newliteralMap.get(l);
                        if (otherPT != null) {
                            stn.addEdge(pTask.getStartTimepoint(), otherPT.getEndTimepoint(), -1 * eplsion); // oe-as<=-0.0001
                        } else {
                            stn.addEdge(pTask.getStartTimepoint(), "Z", -1 * eplsion); // Z-"t-e"<=-0.0001
                        }
                    }

                    if (!stn.checkConsistency()) {
                        System.out.println("is Consistent?:  " + stn.checkConsistency());
                        continue;
                    }

                    // 维护Literal库,说明这个Literal的改变是由pTask引发的.
                    for (String l : o.getEffect().keySet()) {
                        newliteralMap.replace(l, pTask);
                    }
                    System.out.println("literalSet:   " + o.getPrecondition().getKeys());
                    System.out.println("stn:  " + stn);
                    // temporalPlan.setStn(stn);

                    newAction.add(pTask.getName());

                    // temporalPlan.setActions(newAction);
                    // System.out.println("applied Action:" + pTask.name + " UpdateState:" + state);
                    newTasks.remove(currentTask);
                    // temporalPlan.setActions(newAction);
                    // temporalPlan.setStn(stn);
                    newPlan.setActions(newAction);
                    newPlan.setStn(stn);
                    Map<String, Object> newstate = ApplyAction(state, o.getEffect());
                    System.out.println("newstate:" + newstate);
                    // SimpleTemporalNetwork stn = tp.getStn();

                    System.out.println("literalAction:  " + newliteralMap);
                    System.out.println("COA:" + newAction);
                    System.out.println("remainTask:" + newTasks);
                    // return plan(newTasks, state, actions, exploredPaths);

                    if (planbyTemporalHTN(newTasks, newstate, newPlan, newliteralMap)) {

                        // 如果后续的路为True的话...直接返回结果。
                        return true;
                    } // else continue;基于此节点的后续节点，如果后续路不通，则同节点的搜索其他路。

                } // else continue; 如果当前原子任务前提条件不满足，搜索其他任务。

            } else {
                // CompoundTask
                CompoundTask cTask = (CompoundTask) currentTask;
                Method m = findMethod(currentTask);

                // 搜索前提条件满足的分支，执行第一个可行的分支。
                for (int j = 0; j < m.getPreconditions().size(); j++) {
                    if (m.CouldDecompose(state, j)) {
                        // 建立备份节点
                        List<Task> newTasks = new ArrayList<>(tasks);
                        TemporalPlan newPlan = new TemporalPlan(temporalPlan);
                        newTasks.addAll(m.getTasklists().get(j));
                        newTasks.remove(currentTask);
                        // return plan(newTasks, state, actions, exploredPaths);
                        SimpleTemporalNetwork stn = new SimpleTemporalNetwork(temporalPlan.getStn());
                        stn.addTcList(CreateTaskListConstraint(cTask, m.getTasklists().get(j)));
                        stn.addTcList(m.getTemproalconstraints().get(j));
                        // stn.addTcList(cTask.getTemproalconstraints().get(i));
                        if (!stn.checkConsistency()) {
                            System.out.println("is Consistent?:  " + stn.checkConsistency());
                            continue;
                        }
                        // temporalPlan.setStn(stn);
                        newPlan.setStn(stn);
                        System.out.println("stn" + stn);
                        this.plan = newPlan;
                        if (planbyTemporalHTN(newTasks, state, newPlan, literalActionMap)) {

                            // 如果后续的路为True的话,直接返回结果。
                            return true;
                        } // 否则搜索下一分支
                    }
                }
                // 若该复合任务所有的前提条件都不满足，则搜索其他任务。
            }

        }
        return false;
    }

结论

时态HTN规划是一种强大的方法，适用于需要考虑时间约束的复杂任务规划。本文提出的算法框架为理解和实现这种类型的规划提供了一个清晰的指南。