每日一省之————加权有向图的最短路径问题

六度分隔原理实战:用NetworkX量化社交网络连接效率 六度分隔是小世界网络的核心现象,本质是图论中平均路径长度在真实社会关系中的经验体现。其原理源于高聚类系数与短路径长度的协同涌现,由Watts-Strogatz模型通过少量随机重连边实现结构跃迁。该指标并非玄学口号,而是可测量、可优化的工程参数,直接关联信息扩散效率、应急联络可靠性及社群冷启动质量。在社区运营、校友平台、垂直行业网络等场景中,结合NetworkX计算平均路径长度与聚类系数,能精准诊断连接断点、识别枢纽节点、评估推荐策略有效性。本文聚焦实证分析方法论,覆盖仿真建模、真实数据采集、加权路径修正及动 阅读详情

1 加权有向图中边的数据结构


/**
 * 该类用于表示有向图中的一条有向边
 * @author lhever 2017年3月2日 下午11:25:30
 * @version v1.0
 */
public class DirectedEdge
{
    private final int v;
    private final int w;
    private final double weight;

    /**
     * 有向边对象的构造函数
     * 
     * @param v
     *            起点
     * @param w
     *            终点
     * @param weight
     *            边的权重
     * @author lhever 2017年3月2日 下午11:26:05
     * @since v1.0
     */
    public DirectedEdge(int v, int w, double weight)
    {
        if (v < 0)
        {
            throw new IllegalArgumentException("起始顶点名必须是非负整数");
        }
        if (w < 0)
        {
            throw new IllegalArgumentException("终点名必须是非负整数");
        }
        if (Double.isNaN(weight))
        {
            throw new IllegalArgumentException("权重不合法");
        }
        this.v = v;
        this.w = w;
        this.weight = weight;
    }

    /**
     * 获取起始顶点
     * @return
     * @author lhever 2017年3月2日 下午11:29:32
     * @since v1.0
     */
    public int from()
    {
        return v;
    }

    /**
     * 获取结束顶点
     * 
     * @return
     * @author lhever 2017年3月2日 下午11:29:55
     * @since v1.0
     */
    public int to()
    {
        return w;
    }

    /**
     * 获取权重
     * @return
     * @author lhever 2017年3月2日 下午11:30:15
     * @since v1.0
     */
    public double weight()
    {
        return weight;
    }

    public String toString()
    {
        return v + "->" + w + " " + String.format("%5.2f", weight);
    }

    /**
     * 测试
     * @param args
     * @author lhever 2017年3月2日 下午11:30:37
     * @since v1.0
     */
    public static void main(String[] args)
    {
        DirectedEdge e = new DirectedEdge(12, 34, 5.67);
        System.out.println(e);
    }
}

2 加权有向图的数据结构


import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * 该类抽象了加权有向图这种数据结构
 * @author xxx 2017年3月2日 下午11:34:33
 * @version v1.0
 */
public class EdgeWeightedDigraph {


    private static final String NEWLINE = System.getProperty("line.separator");

    private final int V;                // 有向图中的顶点数目
    private int E;                      // 有向图中边的数目
    private List<DirectedEdge>[] adj;    // adj[v] 的值表示顶点v的邻接边的列表
    private int[] indegree;             // indegree[v] 的值是顶点v的入度

    private static long seed; 
    private static Random random; 

    static
    {
        seed = System.currentTimeMillis();
        random = new Random(seed);
    }

    /**
     * 初始化加权有向图对象,构造函数需要指定图中的顶点总数
     * @param V
     * @author xxx 2017年3月2日 下午11:37:03
     * @since v1.0
     */
    @SuppressWarnings("unchecked")
    public EdgeWeightedDigraph(int V)
    {
        if (V < 0)
        {
            throw new IllegalArgumentException("加权有向图中的顶点数必须是非负数");
        }
        this.V = V;
        this.E = 0;
        this.indegree = new int[V];
        adj = (List<DirectedEdge>[]) new ArrayList[V];
        for (int v = 0; v < V; v++)
        {
            adj[v] = new ArrayList<DirectedEdge>();
        }
    }

    /**
     * 初始化一个有向图,初始化的有向图有V个顶点,E条边
     * @param V
     * @param E
     * @author xxx 2017年3月2日 下午11:40:05
     * @since v1.0
     */
    public EdgeWeightedDigraph(int V, int E)
    {
        this(V);
        if (E < 0)
        {
            throw new IllegalArgumentException("加权有向图中的顶点数必须是非负数");
        }
        for (int i = 0; i < E; i++)
        {
            int v = random.nextInt(V);
            int w = random.nextInt(V);
            double weight = 0.01 * random.nextInt(100);
            DirectedEdge e = new DirectedEdge(v, w, weight);
            addEdge(e);
        }
    }

    /**
     * 使用一个已知的加权有向图实例化另外一个加权优先图,深拷贝?
     * @param G
     * @author xxx 2017年3月2日 下午11:45:11
     * @since v1.0
     */
    public EdgeWeightedDigraph(EdgeWeightedDigraph G)
    {
        this(G.V());
        this.E = G.E();
        for (int v = 0; v < G.V(); v++)
        {
            this.indegree[v] = G.indegree(v);
        }
        for (int v = 0; v < G.V(); v++)
        {
            List<DirectedEdge> edgeList = new ArrayList<DirectedEdge>();
            for (DirectedEdge e : G.adj[v])
            {
                edgeList.add(e);
            }
            for (DirectedEdge e : edgeList)
            {
                adj[v].add(e);
            }
        }
    }

    /**
     * 返回顶点总数
     * @return
     * @author xxx 2017年3月2日 下午11:48:06
     * @since v1.0
     */
    public int V()
    {
        return V;
    }

    /**
     * 返回边的总数
     * @return
     * @author xxx 2017年3月2日 下午11:48:24
     * @since v1.0
     */
    public int E()
    {
        return E;
    }

    private void validateVertex(int v)
    {
        if (v < 0 || v >= V) 
        {
            throw new IllegalArgumentException("顶点 " + v + " 必须介于 0 和 " + (V - 1) + " 之间");
        }
    }

     /**
     * 添加一条边
     * @param e
     * @author xxx 2017年3月2日 下午11:49:51
     * @since v1.0
     */
    public void addEdge(DirectedEdge e)
    {
        int v = e.from();
        int w = e.to();
        validateVertex(v);
        validateVertex(w);
        adj[v].add(e);
        indegree[w]++;
        E++;
    }

    /**
     * 获取起点是v的所有有向边
     * @param v
     * @return
     * @author xxx 2017年3月2日 下午11:50:36
     * @since v1.0
     */
    public Iterable<DirectedEdge> adj(int v)
    {
        validateVertex(v);
        return adj[v];
    }

    /**
     * 获取起点是v的所有有向边的总数,也即获取顶点v的出度
     * @return
     * @author xxx 2017年3月2日 下午11:50:36
     * @since v1.0
     */
    public int outdegree(int v)
    {
        validateVertex(v);
        return adj[v].size();
    }

    /**
     * 获取终点是v的所有有向边的总数,也即获取顶点v的入度
     * @return
     * @author xxx 2017年3月2日 下午11:50:36
     * @since v1.0
     */
    public int indegree(int v)
    {
        validateVertex(v);
        return indegree[v];
    }

    /**
     * 获取图中的所有有向边
     * @return
     * @author xxx 2017年3月2日 下午11:52:46
     * @since v1.0
     */
    public Iterable<DirectedEdge> edges()
    {
        List<DirectedEdge> list = new ArrayList<DirectedEdge>();
        for (int v = 0; v < V; v++)
        {
            for (DirectedEdge e : adj(v))
            {
                list.add(e);
            }
        }
        return list;
    }

    @Override
    public String toString()
    {
        StringBuilder s = new StringBuilder();
        s.append(V + " " + E + NEWLINE);
        for (int v = 0; v < V; v++)
        {
            s.append(v + ": ");
            for (DirectedEdge e : adj[v])
            {
                s.append(e + "  ");
            }
            s.append(NEWLINE);
        }
        return s.toString();
    }

    /**
     * 测试
     * @param args
     * @author xxx 2017年3月2日 下午11:53:37
     * @since v1.0
     */
    public static void main(String[] args)
    {
        EdgeWeightedDigraph g = new EdgeWeightedDigraph(5, 8);
        System.out.println(g);
    }

}

3 解决边的权重全部非负的最短路径问题的Dijikstra算法


import java.util.Stack;

/**
 * 解决加权有向图中单点最短路径的Dijkstra算法,该算法要求图中边的权重是非负
 * @author xxx 2017年3月3日 上午12:02:22
 * @version v1.0
 */
public class DijkstraSP 
{
    private double[] distTo;          // distTo[v]的值表示从起点s到终点v的最短路径
    private DirectedEdge[] edgeTo;    // edgeTo[v]的值表示从起点s到终点v的最短路径中的最后一条边
    private IndexMinPQ<Double> pq;    // 用于存储顶点v的索引优先队列


    /**
     * 计算加权有向图G中从起点s到图中其他所有顶点的最短路径
     * @param G
     * @param s
     * @author xxx 2017年3月3日 上午12:07:11
     * @since v1.0
     */
    public DijkstraSP(EdgeWeightedDigraph G, int s)
    {
        for (DirectedEdge e : G.edges())
        {
            if (e.weight() < 0)
            {
                throw new IllegalArgumentException("边 " + e + " 的权重为非负数,该算法不适用");
            }
        }

        distTo = new double[G.V()];
        edgeTo = new DirectedEdge[G.V()];
        for (int v = 0; v < G.V(); v++)
        {
            distTo[v] = Double.POSITIVE_INFINITY;
        }
        distTo[s] = 0.0;

        pq = new IndexMinPQ<Double>(G.V());
        pq.insert(s, distTo[s]);
        while (!pq.isEmpty())
        {
            int v = pq.delMin();
            for (DirectedEdge e : G.adj(v)) 
            {
                relax(e);
            }
        }

        // 验证
        assert check(G, s);
    }


    /**
     * 采用边的松弛算法,修正到各个终点的最短距离,同时不断修正到各个终点的最短路径上的最后一条边。
     * @param e
     * @author xxx 2017年3月3日 上午12:14:34
     * @since v1.0
     */
    private void relax(DirectedEdge e)
    {
        int v = e.from(), w = e.to();
        if (distTo[w] > distTo[v] + e.weight())
        {
            distTo[w] = distTo[v] + e.weight();
            edgeTo[w] = e;
            if (pq.contains(w))
            {
                pq.decreaseKey(w, distTo[w]);
            } else
            {
                pq.insert(w, distTo[w]);
            }
        }
    }


    /**
     * 返回起点s到终点v的最短距离(权重)
     * @param v
     * @return
     * @author xxx 2017年3月3日 上午12:14:53
     * @since v1.0
     */
    public double distTo(int v)
    {
        return distTo[v];
    }


    /**
     * 判断是否一条从起点s到终点v的路径
     * @param v
     * @return
     * @author xxx 2017年3月3日 上午12:15:51
     * @since v1.0
     */
    public boolean hasPathTo(int v)
    {
        return distTo[v] < Double.POSITIVE_INFINITY;
    }


    /**
     * 返回从起点s到终点v的一条最短路径,如果存在的话
     * @param v
     * @return
     * @author xxx 2017年3月3日 上午12:17:33
     * @since v1.0
     */
    public Iterable<DirectedEdge> pathTo(int v)
    {
        if (!hasPathTo(v))
        {
            return null;
        }
        Stack<DirectedEdge> path = new Stack<DirectedEdge>();
        for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.from()])
        {
            path.push(e);
        }
        return path;
    }


    /**
     * 验证算法求得的最短路径是不是确实最短
     * @param G
     * @param s
     * @return
     * @author xxx 2017年3月3日 上午12:19:34
     * @since v1.0
     */
    private boolean check(EdgeWeightedDigraph G, int s)
    {

        // 验证边权重都是非负
        for (DirectedEdge e : G.edges())
        {
            if (e.weight() < 0)
            {
                System.err.println("检测到负权重的边存在");
                return false;
            }
        }

        // 验证distTo[v]的值和 edgeTo[v]隐含的信息的一致性
        if (distTo[s] != 0.0 || edgeTo[s] != null)
        {
            System.err.println("distTo[s] 的值与 edgeTo[s] 隐含的信息不一致,s 居然不是起点,算法逻辑矛盾");
            return false;
        }
        for (int v = 0; v < G.V(); v++)
        {
            if (v == s)
            {
                continue;
            }
            if (edgeTo[v] == null && distTo[v] != Double.POSITIVE_INFINITY)
            {
                System.err.println("distTo[v] 的值与 edgeTo[v] 隐含的信息不一致,算法逻辑矛盾");
                return false;
            }
        }

        for (int v = 0; v < G.V(); v++)
        {
            for (DirectedEdge e : G.adj(v))
            {
                int w = e.to();
                if (distTo[v] + e.weight() < distTo[w])
                {
                    System.err.println("边 " + e + " 不是最短边");
                    return false;
                }
            }
        }

        for (int w = 0; w < G.V(); w++)
        {
            if (edgeTo[w] == null)
            {
                continue;
            }
            DirectedEdge e = edgeTo[w];
            int v = e.from();
            if (w != e.to())
            {
                return false;
            }
            if (distTo[v] + e.weight() != distTo[w])
            {
                System.err.println("最短路径上的边 " + e + "居然不是最短边 ");
                return false;
            }
        }
        return true;
    }



    /**
     * 测试
     * @param args
     * @author xxx 2017年3月3日 上午12:28:19
     * @since v1.0
     */
    public static void main(String[] args)
    {
        EdgeWeightedDigraph g = new EdgeWeightedDigraph(5, 9);

        System.out.println(g);

        // 计算最段路径
        DijkstraSP sp = new DijkstraSP(g, 0);

        // 打印出最短路径
        for (int t = 0; t < g.V(); t++)
        {
            if (sp.hasPathTo(t))
            {
                System.out.printf("%d -> %d (%.2f)  ", 0, t, sp.distTo(t));
                for (DirectedEdge e : sp.pathTo(t))
                {
                    System.out.print(e + "   ");
                }
                System.out.println();
            } else
            {
                System.out.printf("顶点 %d 到顶点  %d 的路径不存在\n", 0, t);
            }
        }
    }

}
描述城市出行需求模式的复杂网络视角:大规模起点-目的地需求网络的图论分析 研究背景:全球城市人口增长导致对活动和出行需求增加,城市面临压力。传统的基于活动和代理的出行需求模型虽有助于理解出行选择机制,但出行需求通常未从网络角度分析。而交通网络建模进展多集中在供给侧,如日内平衡和日间交通流演变等。研究目的和方法:提出一种基于复杂网络的跨学科定量框架,通过分析起讫点需求网络的统计特性来理解和刻画城市出行需求模式。选取芝加哥和墨尔本两个城市的出行需求模式进行比较,运用复杂网络理论中的图论分析方法。研究结果和结论:尽管两城市在地形和城市结构上存在差异,但出行需求网络展现出相似的性质。 阅读详情

相关推荐

求图中任意两点的最短路径和全部路径应用

图的应用,实现了求任意两城市间的最短距离以及全部路径,基于MFC实现。

加权有向图 - 最短路径

1. 最短路径问题 一个最直观最常用的最短路径问题就是用地图软件或者导航系统来获取从一个地方到另一个地方的路径。在一副加权有向图中,从顶点s到顶点t的最短路径是所有从s到t的路径中的权重最小者。 我们的重点是单点最短路径问题,也就是说给定任意一个顶点,找到其对其他所有顶点的最短路径。 2. 加权有向图的数据结构 加权有向边的数据结构 //加权有向边的数据类型 public c...

weixin_34405925的博客 1456

利用featureCounts实现高效转录本定量:从比对到下游分析

本文详细介绍了利用featureCounts工具进行RNA-seq转录本定量的完整流程。从软件安装、输入文件准备,到核心命令参数解析与批量样本处理,再到将生成的计数矩阵无缝衔接至DESeq2进行差异表达分析,提供了从比对到下游分析的一站式实战指南。文章重点阐述了featureCounts在效率与易用性上的优势,并分享了常见问题排查与性能优化技巧,帮助研究者高效完成转录本定量这一关键步骤。

weixin_29069131的博客 320

图论(六):所有节点对的最短路径

所有节点对之间的最短路问题:给定一个加权有向图G=(V,E),对于每一对结点(u,v)∈V(u,v)\in V(u,v)∈V,找到从u到v的最短路径。 Input:用邻接矩阵表示有向加权图。 Output:一个n×n的矩阵D=(dij)D=(d_{ij})D=(dij​),dijd_{ij}dij​表示从i结点到j节点的最短路径。 一种简单的思路是对集合V中所有的结点使用单源最短路算法,这样就能求得所有结点之间的最短路径,时间复杂度为原时间复杂度×n(n为结点个数),但Dijkstra单源最短

qq_45785407的博客 5113

仓储控制系统(WCS)设计

WCS系统设计方法

cetclyb的博客 2万+

TSmaster CANFD配置避坑指南:为什么你的PCAN盒不支持最新版本?

本文针对TSmaster配置PCAN硬件进行CANFD通信时的常见问题,提供了详细的避坑指南。重点解析了CANFD配置中TSEG1等关键参数的理解误区,并深入探讨了TSmaster新版本与PCAN硬件驱动之间的兼容性变化,帮助工程师快速定位并解决连接失败或无法发送CANFD报文等问题。

alpha的博客 547

利用代码具体实现加权有向图中的dijkstra算法

我们可以使用C / C ++或Java来实现Dijkstra算法。首先,定义一个图,其中包含每个节点的邻接表,以及节点之间的距离。然后,定义一个数组来存储每个节点到起始节点的最短距离,并将其初始化为无穷大。接下来,从起始节点开始,检查该节点的邻接节点,更新最短路径数组,如果当前节点到该邻接节点的距离更短,则更新最短路径数组。然后,选择一个未被处理的节点,距离起始节点最近,重复以上步骤,直到所有节点...

weixin_35755434的博客 264

基于大模型的恶性胸腔积液全周期预测与诊疗方案研究

本研究基于大模型技术构建了恶性胸腔积液全流程预测与诊疗体系,涵盖术前风险评估、术中方案优化、术后恢复预测及并发症预防。通过整合多源医疗数据,实现了手术风险概率预测(准确率80%)、并发症预警(AUC值0.85)及个性化康复方案制定,显著提升诊疗精准度。研究创新性地将Transformer架构与多模态数据融合,在100例临床验证中显示良好性能,但存在数据样本局限、模型可解释性不足等问题。未来将扩大多中心临床验证,优化算法可解释性,探索与基因检测等技术的结合应用,推动恶性胸腔积液的精准诊疗发展。

嵌入式毕设/课设资料清单(速查手册·文档模板·题库,持续更新)→ 见最新文章 1901

[C++]加权有向图 求任两顶点之间的最短有向路径 (Floyd算法)

Floyd算法和Dijkstra算法都可以用于计算加权有向图中两顶点之间的最短路径,但是Floyd算法要相对简单许多,而且当该算法完成时,我们可以得到图中任两点之间的最短路径。 算法实现 我们通过先限制任两点之间可经过的顶点来计算此时的最短路径,然后逐渐放宽这一限制,最终允许这两点之间的路径经过任何顶点,从而确定这两点在整张图上的最短路径。 用二维数组minDistance来记录两点之间的有向最短路径长度,用k来描述经过顶点的限制,小于等于k的顶点是允许经过的顶点。起初k=0,表示两点间的最短路径不允许经过

mzman的博客 1650

群晖Video Station海报墙插件更新了!手把手教你用c5h12o5插件搞定豆瓣/TMDB搜刮

本文详细介绍了如何使用c5h12o5插件为群晖Video Station配置高效的海报墙系统。该插件支持豆瓣、TMDB等多数据源并行搜刮,智能优先级设置和本地化优化,解决TMDB API失效问题,提升影视库管理体验。包含安装教程、配置策略和高级使用技巧,适合影视爱好者优化NAS媒体库。

weixin_29250403的博客 269

23种设计模式-享元(Flyweight)设计模式

软考中级-软件设计师 享元设计模式

片言可决讼,半纸能缚龙 3227

2021-1 加权有向图 最短路径 理论准备

定义 最短路径:在一幅加权有向图中,从顶点s到顶点v的最短路径指的是所有s到t中路径权重的最小者。 最短路径树:包含起点s到所有可达顶点的最短路径,s为根节点,树中的每条路径都是一条最短路径。 最短路径的性质 路径是定向的。 最短的路径必须遵循其边缘的方向。 权重不一定是距离。 几何直觉可能会有所帮助,但是边缘权重权重可能代表时间或成本。 并非所有顶点都需要可达。 如果t不能从s到达,则根本没有路径,因此从s到t没有最短的路径。 负权重会带来并发症。 假设边缘权重为正(或为零)。 最短路径通常很简单。

六根胡子 1133

R语言 地理加权随机森林(GWRFC )

随机森林可以产生高准确度的分类器,被广泛用于解决模式识别问题。然而,随机森林赋予每个决策树相同的权重,这在一定程度上降低了整个分类器的性能。该算法引入二次训练过程,提高分类正确率高目前,鲜有中文文章介绍GWRFC的技术文档,作者想使用该方法时会遇到重重困难,因此有必要利用R来建模,通过流程演示,供读者参阅。............

qingchen98的博客 6639

Python 每日一记275@Java加权有向图实现

加权有向图 和加权无向图不同的是,加权有向图只是一个点指向另一个点,当然也可以双向指向,和加权无向图相同的是,在边中加入了另外一个属性,权重,这个权重可以是这个边的任何属性,比如长度,时间,粗细,颜色等等。正是因为假如了另外一个属性,边的实现就相对复杂了,因此将边抽象为一个类,这个类包括两个节点成员变量和一个权重成员变量,用来模拟边。 加权有向图可以真正解决最短路径问题。 java代码 package mypackage; import java.util.Iterator; //队列类,用链表实现,后面

教练我想学编程 543

vue支付项目-APP支付宝支付功能

如果用户已安装支付宝客户端,商家 App 唤起支付宝完成支付,支付完后跳回到商家 App 内,最后展示支付结果。如果用户没有安装支付宝客户端,商家 App 内会调起支付宝网页支付收银台,用户登录支付宝账号,支付完后展示支付结果。1.点击按钮开通或者续费,会验证是否选择会员商品以及对协议是否查看选中(这里根据项目需要自行验证,可忽略),验证通过打开选择支付方式弹窗页面,选择微信支付或者支付宝支付;4.可取消支付,放弃支付会返回会员页面,页面提示支付取消;1.判断支付方式,如果是2,则是支付宝支付方式。

总结前端开发中遇到的问题,分享前端知识 1万+

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Python 每日一记276@Java加权有向图最短路径实现(Dijkstra算法)

最短路径Dijkstra算法 这部分没有理解的太清楚,表达不出来,后续再理解 java代码 package mypackage; import com.sun.source.tree.WhileLoopTree; import javax.swing.plaf.PanelUI; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Iter

教练我想学编程 301

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

洛谷每日一刷Day 13

Johnson 算法用于解决多源最短路径问题,时间复杂度优于 Floyd 算法,能处理含负权边的图。其核心是通过重赋权将负权边转为非负,再结合 Dijkstra 算法求解。

P_18_的博客 887

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

2959.力扣每日一题7/17 Java(暴力枚举+Floyd算法)

通过枚举所有可能的节点集合状态,对于每个状态,复制相关节点的距离信息到一个临时矩阵,然后在这个子集上运行 Floyd 算法计算最短路,最后检查这个子集中任意两个节点的最短路是否都不超过给定的最大距离,统计满足条件的方案数。在上述提到的问题中,使用 Floyd 算法来计算各个顶点之间的最短路径,通过三重循环遍历所有可能的中转顶点 k,以及起点 i 和终点 j,根据状态转移方程不断更新距离矩阵 f,以得到最终的最短路径信息。其核心思路是通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。

程序员天天困的博客 1172

图论——问题篇

图论---问题篇 小书匠Graph图论 声明:图论中的算法基本都是提出后,经过检验的.我就不讨论算法很基础的原理,只是从看懂一个算法的角度去学习.本着不花时间去重复别人优秀工作的原则,本文中很多部分引用了别人的工作,甚至是照搬过来,因为我觉得算法这东西已经类似真理,证明不需要你,你可以看得懂,别人也可以,只是表达方式不同,别人有优秀的表达方式,我为什么不用呢! 如认为侵权,可联系删除! 目...

shazao的专栏 1107

程序员的进阶课-架构师之路(18)-图

一、图的定义 在计算机科学中,图(Graphics)是由顶点集合(Vertex)及顶点间的关系(边)集合(Edge)组成的一种数据结构,这些顶点通过一系列边结对(连接)。顶点用圆圈表示,边就是这些圆圈之间的连线。顶点之间通过边连接。 记作G=(V, E) G:Graphics 图形 V:Vertex 顶点 E:Edge 边 二、图种类 1.有向图和无向...

十步杀一人-千里不留行 1171

LeetCode-网络延迟时间(Dijkstra算法)

每日一题今天刷到一道有关的图的题,需要求单源最短路径,因此使用Dijkstra算法。

深夜无眠的博客 1519

图论---问题篇

小书匠Graph图论声明:图论中的算法基本都是提出后,经过检验的.我就不讨论算法很基础的原理,只是从看懂一个算法的角度去学习.本着不花时间去重复别人优秀工作的原则,本文中很多部分引用了别人的工作,甚至是照搬过来,因为我觉得算法这东西已经类似真理,证明不需要你,你可以看得懂,别人也可以,只是表达方式不同,别人有优秀的表达方式,我为什么不用呢! 如认为侵权,可联系删除! 目录: 一.问题类 ...

weixin_34355559的博客 746

无向完全图k6有几条边_程序员的进阶课-架构师之路(18)-图

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接:https://blog.youkuaiyun.com/m0_37609579/article/details/99706576 一、图的定义 在计算机科学中,图(Graphics)是由顶点集合(Vertex)及顶点间的关系(边)集合(Edge)组成的一种数据结构,这些顶点通过一系列边结对(连...

weixin_33860377的博客 1696

Python数据结构高级:图的表示与遍历

图(Graph)是由顶点(Vertex)集合和边(Edge)集合组成的数据结构,形式化表示为 G = (V, E)

Bruce_xiaowei的博客 656

数据流健康度评估与故障传播建模:从系统韧性到应急决策优化

在数据驱动的决策体系中,数据流是支撑业务运行的神经网络。其核心原理在于通过实时、连续的数据传输与处理,将原始信息转化为可指导行动的洞察。数据流系统的技术价值在于提升决策的时效性与准确性,但系统依赖度的加深也带来了新的风险——数据流中断或质量劣化可能直接导致决策瘫痪。这引出了对系统健康度评估与故障传播建模的迫切需求。通过构建数据流健康度综合评估模型,可以量化系统的吞吐量、延迟、完整性等关键指标,识别脆弱节点。进一步,结合故障传播动力学模型(如基于智能体的模型),能够模拟局部故障如何引发系统性风险,从而在智慧城

weixin_30463341的博客 357

用NetworkX解决中国邮路问题:图优化实战指南

中国邮路问题(CPP)是经典的边覆盖型路径优化模型,核心在于通过最小代价重复遍历部分边,使原图转化为存在欧拉回路的偶度图。其数学原理基于图论中‘连通无向图存在欧拉回路当且仅当所有节点度数为偶数’这一判定定理,技术价值体现在将NP-hard组合优化问题分解为奇度节点识别、最短路径批量计算、最小权完美匹配与图增强四步可编程流程。典型应用场景包括物流巡检、市政环卫调度、管网检测等必须100%覆盖指定路段的工业任务。本文以真实公园步道数据为载体,全程基于NetworkX实现端到端求解,突出图建模、权重设计与结果可验

weixin_30416871的博客 419
上一篇: 如何查看windows系统端口号是否被占用
下一篇: 自己常用的Sublime Text3快捷键列表
lhever_
博客等级 码龄14年 213粉丝 130原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值