标签: directed-acyclic-graphs

有人能用简单的语言向我解释一个有向无环图是什么？我看过维基百科,但它并没有真正让我看到它在编程中的用途.

如何检查有向图是否是非循环的？算法如何调用？我很感激参考.

在星火研究论文已规定了新的分布式编程模型,相比于传统的Hadoop MapReduce的,声称在许多情况下,特别是机器学习的简化和广阔的性能提升.但是,材料揭开internal mechanics上Resilient Distributed Datasets有Directed Acyclic Graph似乎缺乏本文.

通过调查源代码可以更好地学习吗？

你好地球人!我正在使用Airflow来安排和运行Spark任务.我此时发现的只是Airflow可以管理的python DAG.
DAG示例:

spark_count_lines.py
import logging

from airflow import DAG
from airflow.operators import PythonOperator

from datetime import datetime

args = {
  'owner': 'airflow'
  , 'start_date': datetime(2016, 4, 17)
  , 'provide_context': True
}

dag = DAG(
  'spark_count_lines'
  , start_date = datetime(2016, 4, 17)
  , schedule_interval = '@hourly'
  , default_args = args
)

def run_spark(**kwargs):
  import pyspark
  sc = pyspark.SparkContext()
  df = sc.textFile('file:///opt/spark/current/examples/src/main/resources/people.txt')
  logging.info('Number of lines in people.txt = {0}'.format(df.count()))
  sc.stop()

t_main = PythonOperator(
  task_id = 'call_spark'
  , dag = dag
  , …

我想将DAG表示为JSON文本,并想知道是否有人尝试过此以及他们处理的有关验证JSON是否实际上是DAG的任何问题.

想象一下有向无环图如下,其中:

• "A"是根(总有一个根)
• 每个节点都知道它的父节点
• 节点名称是任意的 - 没有什么可以从它们推断出来
• 我们从另一个来源得知节点是按照A到G的顺序添加到树中的(例如它们是版本控制系统中的提交)

我可以使用什么算法来确定两个任意节点的最低共同祖先(LCA),例如,共同的祖先:

• B和E是B.
• D和F是B.

注意:

• 从根开始到给定节点不一定有一条路径(例如"G"有两条路径),因此您不能简单地遍历从根到两个节点的路径并查找最后一个相等的元素
• 我发现树的LCA算法,特别是二叉树,但它们不适用于此,因为一个节点可以有多个父节点(即这不是一棵树)

我需要管理ETL任务的大型工作流程,其执行取决于时间,数据可用性或外部事件.在执行工作流程期间,某些作业可能会失败,并且系统应该能够重新启动失败的工作流程分支,而无需等待整个工作流程完成执行.

python中有没有可以处理这个的框架？

我看到几个核心功能:

• DAG建筑
• 执行节点(运行shell cmd,等待,记录等)
• 能够在执行期间在父DAG中重建子图
• 能够在父图运行时手动执行节点或子图
• 在等待外部事件时挂起图执行
• 列出作业队列和作业详细信息

像Oozie这样的东西,但更通用的目的和python.

我指的是Skienna的算法书.

测试图是否G包含a的问题Hamiltonian path是NP-hard,哈密顿路径P是一个只访问每个顶点一次的路径.与汉密尔顿循环问题不同,从结束顶点到P的起始顶点不一定有G的边缘.

给定有向非循环图G(DAG),给出O(n + m)时间算法来测试它是否包含哈密顿路径.

我的方法,

我打算用DFS和Topological sorting.但我不知道如何将这两个概念联系起来解决问题.如何使用拓扑排序来确定解决方案.

有什么建议？

在我的webapp中,我们有许多字段总结了其他字段,这些字段总结了更多字段.我知道这是一个有向无环图.

页面加载时,我计算所有字段的值.我真正想要做的是将我的DAG转换为一维列表,该列表包含计算字段的有效顺序.

例如:A = B + D,D = B + C,B = C + E有效计算顺序:E - > C - > B - > D - > A

现在我的算法只是迭代地插入到List中,但是我遇到了一些开始破坏的情况.我在想什么需要将所有依赖项解决为树结构,并从那里将其转换为一维形式？是否有一个简单的算法将这样的树转换为有效的排序？

如何将有向非循环图转换为哈希值,使得任何两个同构图哈希到相同的值？这是可接受的,但两个同构图散列到不同的值是不可取的,这是我在下面的代码中所做的.我们可以假设图中的顶点数最多为11.

我对Python代码特别感兴趣.

这就是我做的.如果self.lt是从节点到后代(不是子项!)的映射,那么我根据修改的拓扑排序重新标记节点(如果可以的话,首先优先命令具有更多后代的元素).然后,我哈希排序的字典.一些同构图将散列到不同的值,尤其是随着节点数量的增长.

我已经包含了所有代码来激励我的用例.我正在计算找到7个数字的中位数所需的比较次数.同构图散列到相同值的越多,重做的工作就越少.我考虑先放置更大的连接组件,但没看到如何快速完成.

from tools.decorator import memoized  # A standard memoization decorator


class Graph:
    def __init__(self, n):
        self.lt = {i: set() for i in range(n)}

    def compared(self, i, j):
        return j in self.lt[i] or i in self.lt[j]

    def withedge(self, i, j):
        retval = Graph(len(self.lt))
        implied_lt = self.lt[j] | set([j])
        for (s, lt_s), (k, lt_k) in zip(self.lt.items(),
                                        retval.lt.items()):
            lt_k |= lt_s
            if i in lt_k or k == i:
                lt_k |= implied_lt
        return retval.toposort()

    def toposort(self):
        mapping = …