当并非所有作业都成功输出先前规则中的文件时，如何编写蛇形输入？

如何解决当并非所有作业都成功输出先前规则中的文件时，如何编写蛇形输入？

基本上，我有三个蛇形规则（除了规则全部）并且无法解决这个问题，尽管有检查点资源。

规则一有我的第一个也是唯一一个文件。它将有 x 个输出（数量因输入文件而异）。这 x 个输出中的每一个都需要在规则 2 中单独处理，这意味着规则 2 将运行 x 个作业。但是，这些作业中只有一部分子集 y 会产生输出（软件只写出超过特定阈值的输入文件）。所以，同时 我希望这些输出中的每一个都作为作业 3 中的单独作业运行，我不知道规则 2 中会产生多少文件。规则 3 也将运行 y 个作业，每个作业对应规则 2 的每个成功输出。我有两个问题。第一个是我如何编写规则 3 的输入，不知道规则 2 会输出多少个文件？第二个问题是，当输入文件没有相应数量的输出文件时，我如何“告诉”规则 2 已完成？如果我添加第四条规则，我想它会尝试在没有获得输出文件的作业上重新运行第二条规则，这将永远不会产生输出。也许我在设置检查点时遗漏了什么？

类似：

rule a:
     input: file.vcf
     output: dummy.txt
     shell:"""
      .... make unkNown number of output files (x) x_1,x_2,...,x_n 
           """ 
#run a separate job from each output of rule a
rule b:
     input: x_1 #not sure how many are going to be inputs here
     output: y_1 #not sure how many output files will be here
     shell:"""
           some of the x inputs will output their corresponding y,but others will have no output
           """
#run a separate job for each output of rule b
rule c:
     input: y_1 #not sure how many input files here
     output: z_1
 

解决方法

您应该将 rule a 更改为评论中提到的检查点。 Rule b 将为每个输入生成一个输出，可以保持原样，在本例中 rule c 也是如此。

最终，您将拥有一个类似聚合的规则来决定需要哪些输出。它可能是规则 d，也可能最终成为规则所有。无论哪种方式，聚合规则都需要一个输入函数来调用检查点来确定存在哪些文件。如果您按照 the example 进行操作，您会得到如下结果：

checkpoint a:
     input: file.vcf
     output: directory('output_dir')
     shell:"""
           mkdir {output}  # then put all the output files here!
      .... make unknown number of output files (x) x_1,x_2,...,x_n 
           """ 
#run a separate job from each output of rule a
rule b:
     input: output_dir/x_{n}
     output: y_{n}
     shell:"""
           some of the x inputs will output their corresponding y,but others will have no output
           """
#run a separate job for each output of rule b
rule c:
     input: y_{n}
     output: z_{n}

# input function for the rule aggregate
def aggregate_input(wildcards):
    checkpoint_output = checkpoints.a.get(**wildcards).output[0]
    return expand("z_{i}",i=glob_wildcards(os.path.join(checkpoint_output,"x_{i}.txt")).i)

rule aggregate:  # what do you do with all the z files?  could be all
    input: aggregate_input

如果您将工作流程想象成一棵树，那么规则 a 的分支数量是可变的。规则 b 和 c 是一对一的映射。 Aggregate 将所有分支重新组合在一起，并负责检查存在多少个分支。规则 b 和 c 只看到一个输入/输出，不关心还有多少其他分支。

编辑以回答评论中的问题并修复了我的代码中的几个错误：

我仍然在这里感到困惑，因为规则 b 的输出不会与输入一样多，所以规则聚合永远不会运行，直到检查点 a 的输出中的所有通配符都存在于 z_{n} 中，即他们永远不会？

这令人困惑，因为这不是snakemake通常的工作方式，并导致了很多关于SO的问题。您需要记住的是，当运行 checkpoints.<rule>.get 时，该步骤的评估实际上会暂停。考虑 i == [1,2,3] 的三个值的简单情况，但在 i == 2 and 3 中只创建了 checkpoint a。我们知道 DAG 将如下所示：

rule             file
input           file.vcf
             /     |     \
a                 x_2    x_3
                   |      |
b                 y_2    y_3
                   |      |
c                 z_2    z_3
                    \     /
aggregate           OUTPUT

x_1 中缺少 checkpoint a。但是，snakemake 不知道 checkpoint a 会如何表现，只是它会创建一个目录作为输出，并且（因为它是一个检查点）一旦完成，DAG 将被重新评估。因此，如果您运行 snakemake -nq，您会看到 checkpoint a 和 aggregate 将运行，但没有提及 b 或 c。在这一点上，这些是snakemake知道并计划运行的唯一规则。调用 checkpoint.<rule>.get 基本上是说“在这里等一下，在这条规则之后，你将不得不看看做了什么”。

所以当 snakemake 第一次开始运行你的工作流时，DAG 看起来像这样：

rule             file
input           file.vcf
                   |     
a                 ...
                   |     
????              ...
                   |     
aggregate        OUTPUT

Snakemake 不知道规则 a 和 aggregate 之间的关系，只是它需要运行 a 才能知道。

rule             file
input           file.vcf
             /     |     \
a                 x_2    x_3
                        
????              ...
                   |     
aggregate        OUTPUT

检查点 a 被安排、运行，现在 DAG 被重新评估。 aggregate_input 的其余部分查看 与 glob_wildcards 一起呈现的文件，然后使用该信息来决定它需要哪些文件。请注意，扩展正在请求来自 rule c 的输出，它需要 rule b，它需要 x_{n}，现在检查点已经运行。现在，snakemake 可以构建您期望的 DAG。

这是带有更多注释的输入函数，希望能说清楚：

def aggregate_input(wildcards):
    # say this rule depends on a checkpoint.  DAG evaulation pauses here
    checkpoint_output = checkpoints.a.get(**wildcards).output[0]
    # at this point,checkpoint a has completed and the output (directory)
    # is in checkpoint_output.  Some number of files are there

    # use glob_wildcards to find the x_{i} files that actually exist
    found_files = glob_wildcards(os.path.join(checkpoint_output,"x_{i}.txt")).i
    # now we know we need all the z files to be created *if* a x file exists.
    return expand("z_{i}",i=found_files)