精华内容
下载资源
问答
  • title: 【概率论】1-4:事件的的并集(Union of Events and Statical Swindles) categories: Mathematic Probability keywords: Union of two Events 两个事件的并 Union of Finite Number of Events 有限个...

    原文地址1:https://www.face2ai.com/Math-Probability-1-4-Union-of-Event转载请标明出处

    Abstract: 本文主要介绍事件的并集对应的概率计算,以及一个补充的概率小知识,怎么用统计骗人
    Keywords: Union of two Events,Union of Finite Number of Events,Statical Swindles

    事件的的并集

    废话还是说说数学吧,学数学真的看不到立竿见影的事,相比学个C++、TensorFlow,这些更有成就感,毕竟写了就有结果可以看,数学学习的结果就是,你可能只会做两道题,没办法直接让你升值加薪,但是凡事都有因果,通过这几个月简单的学习,我发现身边的很多事都能用数学解释,比如今天要写的,如果我早些学习可能可以避免很多不必要的损失,而且通过学数学分析,可以通过一个人的语言来判断这个人的逻辑,进而判断这个人的性格,这是心理学的内容了,我不懂心理学,但是很感兴趣,如果有机会去研究下心理学,毕竟也跟人工智能强相关。
    本篇介绍两个小知识点,关于事件的并集的概率求法,以及一些概率的日常应用

    两个事件的并 Union of Two Events

    在前面1-1概率定义中的T7给出了两个相交的事件的并集的概率计算方法:
    P r ( A ∪ B ) = P r ( A ) + P r ( B ) − P r ( A ∩ B ) Pr(A\cup B)=Pr(A)+Pr(B)-Pr(A\cap B) Pr(AB)=Pr(A)+Pr(B)Pr(AB)
    详细的证明在1-1中也有给出,这个公式在本文中将会进一步展开,把其延展到无数项,但是在开始之前我们还是来复习下这个定理,事件是试验结果的集合,集合的基本运算就是交,并,补,补集和概率的对应我们在1-1中的T3就是最基础的补集的概率计算,剩下就是交集和并集的计算了,T7给出了两个集合并集的概率计算公式,并给出了分析的证明方法,之前看书和上课老师都是给我们画个Venn图没然后说 P r ( A ∪ B ) Pr(A\cup B) Pr(AB) P r ( A ) + P r ( B ) Pr(A)+Pr(B) Pr(A)+Pr(B) 但是重复加了一遍 P r ( A ∩ B ) Pr(A\cap B) Pr(AB) 所以要减去。
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WJRXZWXT-1592533787695)(https://tony4ai-1251394096.cos.ap-hongkong.myqcloud.com/blog_images/Math-Probability-1-4-Union-of-Event/two_events.png)]

    提到Venn图说一下,就是关于理解数学,到底是用图形化的可视化的方法好,还是分析法好,这个没办法一棍子打死,大学之前老师们都喜欢用画图的方法教大家理解概念知识点,原因是高中,初中,知识点极其少,更多是的各种拐弯的习题,所以为了加深大家的理解,画个图,直观,而且更容易被人接受,但是到了大学以后,画图就不再合适了,因为知识点变多,而且有很多没办法用二维三维的图来解释,所以,分析的方法到了大学以后是更有用的,拿机器学习的例子来说,做可视化是一个方向,但是这个方向的结果大多是为了展示给一些没有背景的人来看的,业内人士多半关注参数。

    这里说了一大堆话的目的就是说明,分析到后面越来越有用,所以数学分析是数学系的开蒙课程。

    有限个事件的并 Union of Finite Number of Events

    多个事件的并集,就是对上面“分析”理论的一个很好的诠释,当事件数量超过五个,Venn图马上就乱掉了,我们这里省去三个事件的并集的概率计算,直接进行更高难度的有限个事件的并集:

    Theorem For every events A 1 , … , A n A_1,\dots,A_n A1,,An ,
    P r ( ⋃ i = 1 n A i ) = ∑ i = 1 n P r ( A i ) − ∑ i < j P r ( A i ∩ A j ) + ∑ i < j < k ( A i ∩ A j ∩ A k ) − ∑ i < j < k < l ( A i ∩ A j ∩ A k ∩ A l ) + ⋯ + ( − 1 ) n + 1 P r ( A 1 ∩ A 2 ∩ ⋯ ∩ A n ) Pr(\bigcup^n_{i=1}A_i)=\sum^n_{i=1}Pr(A_i)-\sum_{i<j}Pr(A_i\cap A_j)\\ +\sum_{i<j<k}(A_i\cap A_j \cap A_k)-\sum_{i<j<k<l}(A_i\cap A_j\cap A_k \cap A_l)+\\ \dots + (-1)^{n+1}Pr(A_1\cap A_2 \cap \dots \cap A_n) Pr(i=1nAi)=i=1nPr(Ai)i<jPr(AiAj)+i<j<k(AiAjAk)i<j<k<l(AiAjAkAl)++(1)n+1Pr(A1A2An)

    给出了个公式,证明过程其实就是一个分析过程,所以证明需要用数学语言来完成,而不是画个图放在那,那么我们来分析这个问题,首先这个公式的变量n是个自然数,那么最基础的方法就是归纳法。

    1. n = 1 n=1 n=1 时,显然是成立的,其与1-1中的T7相等。
    2. 设当 n = m n=m n=m 时成立
      P r ( ⋃ i = 1 m A i ) = ∑ i = 1 m P r ( A i ) − ∑ i < j P r ( A i ∩ A j ) + ∑ i < j < k ( A i ∩ A j ∩ A k ) − ∑ i < j < k < l ( A i ∩ A j ∩ A k ∩ A l ) + ⋯ + ( − 1 ) m + 1 P r ( A 1 ∩ A 2 ∩ ⋯ ∩ A m ) Pr(\bigcup^m_{i=1}A_i)=\sum^m_{i=1}Pr(A_i)-\sum_{i<j}Pr(A_i\cap A_j)\\ +\sum_{i<j<k}(A_i\cap A_j \cap A_k)-\sum_{i<j<k<l}(A_i\cap A_j\cap A_k \cap A_l)+\\ \dots + (-1)^{m+1}Pr(A_1\cap A_2 \cap \dots \cap A_m) Pr(i=1mAi)=i=1mPr(Ai)i<jPr(AiAj)+i<j<k(AiAjAk)i<j<k<l(AiAjAkAl)++(1)m+1Pr(A1A2Am)
    3. n = m + 1 n=m+1 n=m+1 时,我们套用 P r ( A ∪ B ) = P r ( A ) + P r ( B ) − P r ( A ∩ B ) Pr(A\cup B)=Pr(A)+Pr(B)-Pr(A\cap B) Pr(AB)=Pr(A)+Pr(B)Pr(AB) 公式,
    • 其中 ⋃ i = 1 m A i \bigcup^m_{i=1}A_i i=1mAi A A A A m + 1 A_{m+1} Am+1 B B B
    • 那么, A ∪ B = ⋃ i = 1 m + 1 A i A\cup B=\bigcup^{m+1}_{i=1}A_i AB=i=1m+1Ai
    • 最关键的是 A ∩ B = ⋃ i = 1 m ( A i ∩ A m + 1 ) A\cap B=\bigcup^{m}_{i=1}(A_i\cap A_{m+1}) AB=i=1m(AiAm+1) ,可以根据集合论的工时得到,可以看到 P r ( B ) − P r ( A ∩ B ) Pr(B)-Pr(A\cap B) Pr(B)Pr(AB) 有:
      P r ( B ) − P r ( A ∩ B ) = P r ( A m + 1 ) − ∑ i = 1 m P r ( A i ∩ A m + 1 ) + ∑ i < j P r ( A i ∩ A j ∩ A m + 1 ) − ∑ i < j < k ( A i ∩ A j ∩ A k ∩ A m + 1 ) + ∑ i < j < k < l ( A i ∩ A j ∩ A k ∩ A l ∩ A m + 1 ) − ⋯ + ( − 1 ) m + 2 P r ( A 1 ∩ A 2 ∩ ⋯ ∩ A m + 1 ) ) Pr(B)-Pr(A\cap B)=Pr(A_{m+1})-\sum^m_{i=1}Pr(A_i\cap A_{m+1})+\sum_{i<j}Pr(A_i\cap A_j \cap A_{m+1})\\ -\sum_{i<j<k}(A_i\cap A_j \cap A_k \cap A_{m+1})+\sum_{i<j<k<l}(A_i\cap A_j\cap A_k \cap A_l\cap A_{m+1})-\\ \dots + (-1)^{m+2}Pr(A_1\cap A_2 \cap \dots \cap A_{m+1})) Pr(B)Pr(AB)=Pr(Am+1)i=1mPr(AiAm+1)+i<jPr(AiAjAm+1)i<j<k(AiAjAkAm+1)+i<j<k<l(AiAjAkAlAm+1)+(1)m+2Pr(A1A2Am+1))
    • 最关键的是,当 n = m + 1 n=m+1 n=m+1 时, P r ( ⋃ i = 1 m + 1 A i ) − P r ( ⋃ i = 1 m A i ) Pr(\bigcup^{m+1}_{i=1}A_i)-Pr(\bigcup^{m}_{i=1}A_i) Pr(i=1m+1Ai)Pr(i=1mAi) 和上面的表达式一致(计算过程太复杂,所以,这里省略)
    • Q.E.D

    上述证明比较粗糙,大家可以自己计算下,对于有限时间的并集的概率计算大致的意思就是加多了减,减多了再加,直观的,可以通过画三个集合的Venn图来观察,分析的,就是上述的大致过程。

    匹配问题 Matching Problem

    上面是严格的数学证明,下面我们来分析一个简单但是有趣的应用,其中用到了多事件并集的概率计算,matching problem,配对或者叫做匹配游戏。
    描述下问题,假设我们已有一个n个不同的符号的序列,我们来自己随便排列这n个符号的顺序(我们不知道这已有的排列顺序),如果我们排列的符号序列对应位置上的符号和已有符号能够对应上,就叫做一个match,那么当n变化的时候,match的概率 p n p_{n} pn 怎么描述呢?

    分析:

    • 假设第i个字母matching的事件为 A i A_i Ai,其概率 P r ( A i ) = 1 n Pr(A_i)=\frac{1}{n} Pr(Ai)=n1
    • 如果有1个match(k=1): ∑ i = 1 n P r ( A i ) = n ⋅ 1 n = 1 1 ! \sum^{n}_{i=1}Pr(A_i)=n\cdot \frac{1}{n}=\frac{1}{1!} i=1nPr(Ai)=nn1=1!1
    • 如果有2个match(k=2): ∑ i < j n P r ( A i ∩ A j ) = ( n 2 ) ⋅ 1 n ( n − 1 ) = 1 2 ! \sum^{n}_{i<j}Pr(A_i\cap A_j)=\begin{pmatrix}n\\2\end{pmatrix}\cdot \frac{1}{n(n-1)}=\frac{1}{2!} i<jnPr(AiAj)=(n2)n(n1)1=2!1
    • 如果有3个match(k=3): ∑ i < j < m n P r ( A i ∩ A j ∩ A 3 ) = ( n 3 ) ⋅ 1 n ( n − 1 ) ( n − 2 ) = 1 3 ! \sum^{n}_{i<j<m}Pr(A_i\cap A_j\cap A_3)=\begin{pmatrix}n\\3\end{pmatrix}\cdot \frac{1}{n(n-1)(n-2)}=\frac{1}{3!} i<j<mnPr(AiAjA3)=(n3)n(n1)(n2)1=3!1
    • ⋮ \vdots
    • 如果有k个match: ( n k ) ⋅ n ! ( n − k ) ! = 1 k ! \begin{pmatrix}n\\k\end{pmatrix}\cdot\frac{n!}{(n-k)!}=\frac{1}{k!} (nk)(nk)!n!=k!1
    • 所以,根据我们上面证明多事件并集得到的公式 p n = 1 1 ! − 1 2 ! + 1 3 ! − 1 4 ! ⋯ + ( − 1 ) n + 1 1 n ! p_n=\frac{1}{1!}-\frac{1}{2!}+\frac{1}{3!}-\frac{1}{4!}\dots +(-1){n+1}\frac{1}{n!} pn=1!12!1+3!14!1+(1)n+1n!1
    • l i m n → ∞ p n = 1 1 ! − 1 2 ! + 1 3 ! − 1 4 ! ⋯ + ( − 1 ) n + 1 1 n ! = 1 − 1 e ≈ 0.63212 lim_{n\to \infty}p_n=\frac{1}{1!}-\frac{1}{2!}+\frac{1}{3!}-\frac{1}{4!}\dots +(-1){n+1}\frac{1}{n!}=1-\frac{1}{e}\approx 0.63212 limnpn=1!12!1+3!14!1+(1)n+1n!1=1e10.63212

    也就是说当n无限多的时候,匹配成功的概率将会收敛到0.63212。我们可以发现当n=7的时候,写个小程序计算下结果:

    a=20
    result=1.0
    factorial=1
    for i in range(2,a,1):
        factorial=factorial * (i )
        result+=(-1)**(i+1)*(1.0/(factorial))
        print 'n='+`i`+':'+`result`
    
    n=2:0.5
    n=3:0.6666666666666666
    n=4:0.625
    n=5:0.6333333333333333
    n=6:0.6319444444444444
    n=7:0.6321428571428571
    n=8:0.6321180555555556
    n=9:0.632120811287478
    n=10:0.6321205357142857
    n=11:0.6321205607663941
    n=12:0.6321205586787184
    n=13:0.6321205588393088
    n=14:0.6321205588278381
    n=15:0.6321205588286029
    n=16:0.6321205588285551
    n=17:0.6321205588285579
    n=18:0.6321205588285578
    n=19:0.6321205588285578
    
    Process finished with exit code 0
    
    

    仔细观察发现当n=7的时候,就已经开始收敛了,也就是说,后面再怎么增加n也不会影响其概率了。

    概率欺诈 Statistical Swindles

    接下来这些话题都是属于知识联系实际的科普小软文,有事的同学可以先行离开了。

    统计滥用 Misleading Using of Statistics

    马克吐温说过:“世界上的谎言有三种,谎言,无耻的谎言,统计”,“你可以通过统计证明任何事情。”
    我们学习概率的另一个重要用途就是日常中不会被报纸新闻上的统计信息欺骗,通过已有知识的判断真实的情况。比如经常说的平均工资,人均收入,这些都是统计概念,相比对其真实性大家都有所怀疑。

    完美预测 Perfect Forecasts

    神预测,如果一个投资公司每周一给你推送一只股票,这个股票本周大涨50%,第二周又给你推送了另一只,结果又是大涨50%,第三周第四周,周周如此,你是不是会觉得,卧槽,发财的机会来了,卖房卖地卖媳妇也要进去赚一笔,但是实际投资公司不是神,只是耍了你而已。
    他们的做法是什么呢?
    首先我们假定其推送的股票涨50%的概率是 P r = 1 n Pr=\frac{1}{n} Pr=n1,那么他们想保证k周有人连续正确,他们只需要发给 n k n^k nk 个人就可以了

    • 第一周,发送给所有人
    • 第二周,发给第一周正确地人,正确的人数大概在 n k − 1 n^{k-1} nk1 左右
    • 第三周,发给第二周正确地人,正确的人数大概在 n k − 2 n^{k-2} nk2 左右
    • 第四周,发给第二周正确地人,正确的人数大概在 n k − 3 n^{k-3} nk3 左右
    • ⋮ \vdots
    • 第k周,发给第k-1周正确地人,正确的人数大概在 1 1 1左右

    怎么样,如果他连续发给你一年都是正确的,可以保证,这个人有内幕消息,估计那样他根本不用发给你,他自己可以卖车卖房卖媳妇,而没必要从你身上赚取服务费了。
    完美预测,需要的要么是人多,要么就是概率高一些。

    保证胜利 Guaranteed Winner

    保证胜利,看球赛,有公司这么搞,给你推荐获胜球队,你可以去买彩票或者赌球,推荐对的收取一定服务费,不对不收费,你看起来这事没问题,稳赚不赔,但是,从概率的角度分析,他并不能提高你的获奖概率,而且当你获奖时他要收取服务费,当他没有内幕消息的时候,这个完全是骗人的,而这些公司完全没有任何风险,按照一定的比例给不同的人,推送不同的获胜方,这样他肯定会有收入(肯定会有正确的),具体怎么将收入最大化,那就是优化问题,

    买彩票 Improving Your Lottery Chances

    买彩票,不知道大家有没有买过,我买过,我发现每期都有两个连续的数字,我们来分析下这种现象是否有概率依据。
    假设我们的彩票是40个数字选6个,without replacement,各个数字间没有影响,那么这个模型就是个见得组合,那么一共有:
    ( 40 6 ) = 3 , 838 , 380 \begin{pmatrix}40\\6\end{pmatrix}=3,838,380 (406)=3,838,380
    种组合,一等奖,全部命中的概率是 1 3 , 838 , 380 \frac{1}{3,838,380} 3,838,3801 那么出现至少两个连续的号码呢?结果是大约有0.577的概率,怎么算?你可以先算出所有号都不连续的组合方式,然后用1-1中的T3,就可以得到一个大概的数字,因为这个存在一个边界的问题,所以还是要小心一点。

    总结

    学习知识,就不会被人骗了,哈哈哈哈,明天继续。。

    展开全文
  • 前言 今天主要总结一些js数组...例如:我前面文章讲includes方法,时候就提到了计算交集及差集。还有之前文章去重的方式,其实去重就是取并集的一种方式嘛! 一、new Set 方式实现 这种方式实现起来比较简单,...

    前言
    今天主要总结一些js数组操作并集,交集,差集的一些方式。发现这些方式在工作用经常遇到,方法有很多种。今天主要总结一下我在工作用通常使用的方式,及一些简单的实现。其实我前面很多文章中都提及了我在工作中用的一些方式。例如:我前面文章讲includes方法,时候就提到了计算交集及差集。还有之前文章去重的方式,其实去重就是取并集的一种方式嘛!

    一、new Set 方式实现

    这种方式实现起来比较简单,原理就是参考new Set可以去重的功能 ,关于去重可以点击 https://www.haorooms.com/post/qd_ghfx 第17条。

    new Set取并集
    我封装了一个函数,可以取传入所有数组的并集,函数如下:

      //并集
        function unionArray(a,b){
           let tempArray = [];
           for(let i = 0;i<arguments.length;i++){
            tempArray.push(...new Set(arguments[i]))
           }
           return [... new Set(tempArray)]
       }
    

    使用如下:

     unionArray([1,2,3,4],[3,4,5,6],[8,8,7,7,6,6,5,5,4,4,3,3]) //(8) [1, 2, 3, 4, 5, 6, 8, 7]
    

    new Set取交集
    这里也是取2个数组的交集,多的可以自己扩展

     //交集
       function intersect(a,b){
        let set1 = new Set(a),set2 = new Set(b);
          return [...new Set([...set1].filter( x => set2.has(x)))];
       }
    

    使用方式如下:

    intersect([1,2,3,4],[3,4,5,6]) //(2) [3, 4]
    

    new Set取差集
    我这里只是取2个数组的差集,多的大家可以自行扩展。

      function difference(a,b){
        let set1 = new Set(a),set2 = new Set(b);
          return [...new Set([...set1].filter(x => !set2.has(x))),...new Set([...set2].filter(x => !set1.has(x)))];
       }
    

    用法如下:

    difference([1,2,3,4],[3,4,5,6]) //(4) [1, 2, 5, 6]
    

    二、include 方式实现

    include方式我之前写过取交集和差集的方式:https://www.haorooms.com/post/es6_string_object_array

    今天简单再来列举一下吧:

    include取并集

    function unionArray(a,b){
      let tempArr = a.slice() ;
      b.forEach(v => {!tempArr.includes(v) && tempArr.push(v)})   //tempArr=[1,2,3,4]
      return tempArr
    }
    

    用法和上面一样,传2个数组就可以取其并集

    unionArray([1,2,3,4],[3,4,5,6]); //(6) [1, 2, 3, 4, 5, 6]
    

    include方式 数组a和数组b的交集:

    a.filter(v => b.includes(v))
    

    include方式 数组a和数组b的差集:

    a.concat(b).filter(v => !a.includes(v) || !b.includes(v))
    

    函数自己封装哈,一句话

    三、 es5的方式实现

    上面的方式用的是ES6,下面我们用ES5实现一下! filter可以实现简单的去重,因此,实现并集也很简单,把数组push到一起(或者连接到一起concat),去重就可以实现并集了。

    [1,3,4,5,1,2,3,3,4,8,90,3,0,5,4,0].filter(function(elem,index,Array){
       return index === Array.indexOf(elem);
    })
    

    当然也可以用indexOf的方式(注:indexOf要考虑NAN或者不考虑NAN 2种情况)

    //不考虑NAN
    var union = a.concat(b.filter(function(v) {
    return a.indexOf(v) === -1})) 
    
    //考虑可以这么写
    var aHasNaN = a.some(function(v){ return isNaN(v) })
    var bHasNaN = b.some(function(v){ return isNaN(v) })
    var union = a.concat(b.filter(function(v) {
    return a.indexOf(v) === -1 && !isNaN(v)})).concat(!aHasNaN & bHasNaN ? [NaN] : []) 
    

    交集和差集可以模仿上面include方式,把include改成indexOf

    indexOf方式 数组a和数组b的交集:
    不考虑NaN(数组中不含NaN)

     a.filter(v => b.indexOf(v)!=-1)
    

    考虑的话如下:

    var aHasNaN = a.some(function(v){ return isNaN(v) })
    var bHasNaN = b.some(function(v){ return isNaN(v) })
    a.filter(function(v){ return b.indexOf(v) > -1 }).concat(aHasNaN & bHasNaN ? [NaN] : []) 
    

    indexOf方式 数组a和数组b的差集:
    不考虑NaN(数组中不含NaN)

       a.concat(b).filter(v => a.indexOf(v) ==-1 || b.indexOf(v)==-1)
    

    考虑的话如下:

    var aHasNaN = a.some(function(v){ return isNaN(v) })
    var bHasNaN = b.some(function(v){ return isNaN(v) })
    var difference = a.filter(function(v){ return b.indexOf(v) === -1 && !isNaN(v) }).concat(b.filter(function(v){ return a.indexOf(v) === -1 && !isNaN(v) })).concat(aHasNaN ^ bHasNaN ? [NaN] : []) 
    

    四、原始方式,假如要兼容IE9及以下版本,可以考虑

    function array_remove_repeat(a) { // 去重
        var r = [];
        for(var i = 0; i < a.length; i ++) {
            var flag = true;
            var temp = a[i];
            for(var j = 0; j < r.length; j ++) {
                if(temp === r[j]) {
                    flag = false;
                    break;
                }
            }
            if(flag) {
                r.push(temp);
            }
        }
        return r;
    }
    
    function array_intersection(a, b) { // 交集
        var result = [];
        for(var i = 0; i < b.length; i ++) {
            var temp = b[i];
            for(var j = 0; j < a.length; j ++) {
                if(temp === a[j]) {
                    result.push(temp);
                    break;
                }
            }
        }
        return array_remove_repeat(result);
    }
    
    function array_union(a, b) { // 并集
        return array_remove_repeat(a.concat(b));
    }
    
    function array_difference(a, b) { // 差集 a - b
        //clone = a
        var clone = a.slice(0);
        for(var i = 0; i < b.length; i ++) {
            var temp = b[i];
            for(var j = 0; j < clone.length; j ++) {
                if(temp === clone[j]) {
                    //remove clone[j]
                    clone.splice(j,1);
                }
            }
        }
        return array_remove_repeat(clone);
    }
    

    另外写一下多维数组转为一维数组的简单方式

    var arr = [1,[2,[[3,4],5],6]];
    
    function unid(arr){
            var arr1 = (arr + '').split(',');//将数组转字符串后再以逗号分隔转为数组
            var arr2 = arr1.map(function(x){
                return Number(x);
            });
            return arr2;
    }
    console.log(unid(arr));
    

    小结
    上面方式是我平时工作中用的比较简单的方式,当然还有其他的实现方式。这里就不在列举了。上面有ES6的实现,也有ES5的实现。也有低版本浏览器的实现方式。

    就写到这里吧,欢迎交流!

    展开全文
  • 计算集合的交集和并集

    千次阅读 2012-09-16 13:05:00
    在数据结构书上看到了求集合的交集和并集的运算的算法,心里就想着写写,但是之前一直没时间,今天趁着周末就就把它解决了。其实交集非常简单的,就是并集想了下子。唉,没办法,技术有限。 code: #include #...

        在数据结构书上看到了求集合的交集和并集的运算的算法,心里就想着写写,但是之前一直没时间,今天趁着周末就就把它解决了。其实交集非常简单的,就是并集想了下子。唉,没办法,技术有限。

    code:

    #include<stdio.h>
    #define MAXN 1000
    
    void jiaoji(int a[], int b[], int p, int q)
    {
        int k = 0;
        int c[MAXN];
        for(int i = 0; i < p; i++)
        {
            for(int j = 0; j < q; j++)
            {
                if(a[i] == b[j])
                    c[k++] = a[i];
            }
        }
        for(int m = 0; m < k; m++)
            printf("%d ", c[m]);
        printf("\n");
    }
    
    void bingji(int a[], int b[], int p, int q)
    {
        int array[MAXN], c[MAXN];
        int k = 0;
        for(int i = 0; i < p; i++)
        {
            for(int j = 0; j < q; j++)
            {
                if(a[i] == b[j])
                    array[i] = 1;
            }
        }
        for(int m = 0; m < p; m++)
        {
            if(array[m] != 1)
                c[k++] = a[m];
        }
        for(int n = 0; n < q; n++)
            c[k++] = b[n];
        for(int m = 0; m < k; m++)
            printf("%d ", c[m]);
        printf("\n");
    }
    
    int main()
    {
        int _a[MAXN], _b[MAXN];
        int l_1,l_2;
        while(scanf("%d%d", &l_1, &l_2) != EOF)
        {
            for(int i = 0; i < l_1; i++)
                scanf("%d", &_a[i]);
            for(int j = 0; j < l_2; j++)
                scanf("%d", &_b[j]);
    
            jiaoji(_a, _b, l_1, l_2);
            bingji(_a, _b, l_1, l_2);
        }
        return 0;
    }
    

    听说集合还有其他的运算,以后再看看吧。

    展开全文
  • 目标检测---IoU计算公式

    千次阅读 2020-12-02 11:42:05
    目标检测之IoU计算 在研究目标检测中,IOU的计算是肯定必不可少的。就比如说在R-CNN网络中,正负样本就是按照候选框与真实框之间的IOU值大小进行区分的,可见该细节还是值得单独拎出来写一篇blog的~~ 下面的思路与...

    目标检测—IoU计算公式

    在研究目标检测中,IOU的计算是肯定必不可少的。就比如说在R-CNN网络中,正负样本就是按照候选框与真实框之间的IOU值大小进行区分的,可见该细节还是值得单独拎出来写一篇blog的~~
    下面的思路与代码是本人的理解结合百度飞浆的使用教程文档整理出来的(下面附上了飞浆的url,大家可以自主去研究~~~)
    百度飞浆–IOU计算
    废话不多说,直接上干货~

    思路分析

    例如,在R-CNN网络中,我们通过SS(selective search)算法可以实现在每张图片上获得2k左右的候选框,那么如何区分这么多的候选框到底是属于正样本还是负样本呢?
    那么IOU这个概念就诞生了~它其实是来源于数学中的集合的概念,用来反应两个集合之间的空间关系;下面是它的计算公式:
    在这里插入图片描述
    该公式是用来描述两个框之间的重合度的。公式分子是两个框的交集,公式分母是两个框的并集,所以他们的比值就代表交并比。
    在这里插入图片描述

    两个框可能存在的所有空间位置

    在这里插入图片描述
    1.第一种情况:两个框之间存在部分重叠
    2.第二种情况:两个框之间不存在任何重叠
    3.第三种情况:一个框在另外一个框内部

    分析

    假设,按照第一种情况进行分析~
    在这里插入图片描述
    a,b分别表示两个框,其中1,2表示每个框的左上角坐标与右下角坐标
    先计算交集部分(即公式分子部分):
    相交部分左上角坐标为:
    在这里插入图片描述
    相交部分右下角坐标为:
    在这里插入图片描述
    那么相交部分的面积计算公式就是为:
    在这里插入图片描述
    这里,都+1的目的,我个人认为是为了排除两个框之间重叠的像素对面积的影响,取max(*,0)的目的是为了避免出现负数的情况

    再来计算一下两个框的并集部分:
    两个框的面积为:
    在这里插入图片描述
    计算相比部分面积:
    在这里插入图片描述
    所以,最终的iou计算公式为:
    在这里插入图片描述

    代码实现

    在目标检测中,框一般都有两种表现手法,一种是(xyxy),一种是(xywh),其实二者之间实现方式都差不多,这里我就仅仅按照第一种方式进行代码实现了~

    def cal_iou_xyxy(box1,box2):
        x1min, y1min, x1max, y1max = box1[0], box1[1], box1[2], box1[3]
        x2min, y2min, x2max, y2max = box2[0], box2[1], box2[2], box2[3]
        #计算两个框的面积
        s1 = (y1max - y1min + 1.) * (x1max - x1min + 1.)
        s2 = (y2max - y2min + 1.) * (x2max - x2min + 1.)
    
        #计算相交部分的坐标
        xmin = max(x1min,x2min)
        ymin = max(y1min,y2min)
        xmax = min(x1max,x2max)
        ymax = min(y1max,y2max)
    
        inter_h = max(ymax - ymin + 1, 0)
        inter_w = max(xmax - xmin + 1, 0)
    
        intersection = inter_h * inter_w
        union = s1 + s2 - intersection
    
        #计算iou
        iou = intersection / union
        return iou
    
    box1 = [100,100,200,200]
    box2 = [120,120,220,220]
    iou = cal_iou_xyxy(box1,box2)
    print(iou)
    

    下面的代码是指在实战中使用的iou计算代码:

        def calc_iou(self, boxes1, boxes2, scope='iou'):
            """calculate ious
            Args:
              boxes1: 5-D tensor [BATCH_SIZE, CELL_SIZE, CELL_SIZE, BOXES_PER_CELL, 4]  ====> 4:(x_center, y_center, w, h)
              (2,7,7,2,4)
              boxes2: 5-D tensor [BATCH_SIZE, CELL_SIZE, CELL_SIZE, BOXES_PER_CELL, 4] ===> 4:(x_center, y_center, w, h)
              (2,7,7,2,4)
            Return:
              iou: 4-D tensor [BATCH_SIZE, CELL_SIZE, CELL_SIZE, BOXES_PER_CELL]  --(2,7,7,2)
            """
            with tf.variable_scope(scope):
                # transform (x_center, y_center, w, h) to (x1, y1, x2, y2)
                boxes1_t = tf.stack([boxes1[..., 0] - boxes1[..., 2] / 2.0,
                                     boxes1[..., 1] - boxes1[..., 3] / 2.0,
                                     boxes1[..., 0] + boxes1[..., 2] / 2.0,
                                     boxes1[..., 1] + boxes1[..., 3] / 2.0],
                                    axis=-1)  #tf.stack:矩阵拼接
    
                boxes2_t = tf.stack([boxes2[..., 0] - boxes2[..., 2] / 2.0,
                                     boxes2[..., 1] - boxes2[..., 3] / 2.0,
                                     boxes2[..., 0] + boxes2[..., 2] / 2.0,
                                     boxes2[..., 1] + boxes2[..., 3] / 2.0],
                                    axis=-1)
    
                # calculate the left up point & right down point
                lu = tf.maximum(boxes1_t[..., :2], boxes2_t[..., :2]) #左上角坐标最大值
                rd = tf.minimum(boxes1_t[..., 2:], boxes2_t[..., 2:]) #右下角坐标最小值
    
                # intersection
                intersection = tf.maximum(0.0, rd - lu)
                inter_square = intersection[..., 0] * intersection[..., 1]
    
                # calculate the boxs1 square and boxs2 square
                square1 = boxes1[..., 2] * boxes1[..., 3]
                square2 = boxes2[..., 2] * boxes2[..., 3]
    
                union_square = tf.maximum(square1 + square2 - inter_square, 1e-10)
    
            return tf.clip_by_value(inter_square / union_square, 0.0, 1.0) #截断操作,即如果值不在指定的范围里,那么就会进行最大小值截断
    

    效果展示

    在这里插入图片描述

    展开全文
  • IOU计算公式

    千次阅读 2020-06-01 14:06:36
    集合 A 和集合 B 的并集包括了上面 3 种颜色区域。 集合 C 是集合 A 与集合 B 的交集。 在目标检测当中,IOU 就是上面两种集合的比值。 A \cup BA∪B其实就是A + B - CA+B−C。 那么公式可以转变为: IOU = \...
  • 怎样对数组进行交集与并集运算

    千次阅读 2018-01-10 11:35:09
    以下不代表最优解,只是在学习中突然想到要怎么对数组进行交集与并集的运算 所以在自己尝试写了一遍后记录下来。数组的并集给定两个数组: int[] a = {1, 2, 3, 4, 5}; int[] b = {2, 3, 5, 6, 7}; 输出: 1,2,...
  • 几种常见的距离计算公式

    万次阅读 2019-10-20 10:41:59
    我们常用的距离计算公式是欧几里得距离公式,但是有时候这种计算方式会存在一些缺陷,那么就需要另外的计算方法去加以补充,本文将介绍几种在机器学习中常用的计算距离。 在做很多研究问题时常常需要估算不同样本...
  • 计算集合的并集、交集、差集

    千次阅读 2015-09-14 11:24:37
     * 计算集合的并集、交集、差集  * @author Administrator  *  */ public class SetOpt {     public List intersect(List ls, List ls2) {   List list = new ArrayList(Arrays.asList(new...
  • 机器学习中的各种距离计算公式

    千次阅读 2017-03-21 21:56:41
    作者同类文章X •推荐一系列优秀的Android... 在做分类时常常需要估算不同样本之间的相似性度量(SimilarityMeasurement),这时通常采用的方法就是计算样本间的“距离”(Distance)。采用什么样的方法计算距离是很讲
  • MATLAB交并集运算

    2021-02-26 15:13:14
    union:取并集 setxor:取独立部分,去除重复部分 Matlab中集合的交运算函数intersect intersect Set intersection of two vectors Syntax c = intersect(A,B) c = intersect(A,B,‘rows’) [c,ia,ib] = intersect...
  • 计算距离常用方法 欧氏距离 二维平面上点a(x1,y1)与b(x2,y2)间的欧式距离 d12=(x1−x2)2+(y1−y2)2\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}(x1​−x2​)2+(y1​−y2​)2​ 三维空间点a(x1,y1,z1)与b(x2,y2,z2)a(x_1,y_1,...
  • //两个集合的并集 var i = 1; Console.WriteLine("输出并集"); foreach (string item in query1) { Console.WriteLine(i + ":" + item); i++; } var query2 = arr1.Intersect(arr2); i = 1; Console....
  • YOLO

    千次阅读 2019-10-15 12:41:34
    左边代表包含这个标定框的格子里是否有目标有1没有0,右边达标标定框的准确程度, 右边的部分是把两个标定框(一个是groundtruth一个是预测的标定框)进行一个IOU操作,即两个标定框的交集比并集,数值越大,即标定...
  • C#基础教程-c#实例教程,适合初学者

    万次阅读 多人点赞 2016-08-22 11:13:24
    C#基础教程-c#实例教程,适合初学者。 第一章 C#语言基础 本章介绍C#语言的基础知识,希望具有C语言的读者能够基本掌握C#语言,并以此为基础,能够进一步学习用C#语言编写window应用程序和Web应用程序。...
  • 方法一:最普遍的做法 使用 ES5 语法来实现虽然会麻烦些,但兼容性...1,直接使用 filter、concat 来计算 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ...
  • 上面两个区域 的计算公式是一样的 ; 透明度 : α o u t = α s r c \alpha_{out} = \alpha_{src} α o u t ​ = α s r c ​ 颜色值 : C o u t = C s r c C_{out} = C_{src} C o u t ​ = C s r c ​ 3. ...
  • 计算 两个集合的交集、并集、差集、对称集 import sys import time #刷新缓冲区 def flush(): time.sleep(1) #除去重复元素 def duplicate_removal(lt): lt1 = [] for i in lt: if i not in lt1: lt1....
  • Python实验实例

    万次阅读 多人点赞 2019-06-27 19:28:05
    Python 运算符、内置函数 ... 2、编写程序,输入两个集合 setA 和 setB,分别输出它们的交集、并集和差集 setA-setB。  3、编写程序,输入一个自然数,输出它的二进制、八进制、十六进制表示形式。 num ...
  • EAST算法详解

    万次阅读 多人点赞 2018-06-18 14:54:54
    并集区域公式如下:  因此,可以很容易地计算出IoU区域。接着 ,计算旋转角度的损失:  其中,θ^是对旋转角度的预测,并且θ*表示标注值。最后,总体几何损失是AABB损失和角度损失的加权和,公式如下...
  • 【深度学习】目标检测中 IOU 的概念及计算

    万次阅读 多人点赞 2019-06-10 11:59:45
    在目标检测当中,有一个重要的概念就是 IOU。一般指代模型预测的 bbox ...集合 A 和集合 B 的并集包括了上面 3 种颜色区域。 集合 C 是集合 A 与集合 B 的交集。 在目标检测当中,IOU 就是上面两种集合的比值。 A∪...
  • 深度学习算法原理——RCNN

    千次阅读 2019-09-29 22:54:03
    最理想情况是完全重叠,即比值为1,如下图所示: 那么,IoU的计算公式为: IoU=A∩BA∪BIoU=\frac{A\cap B}{A\cup B}IoU=A∪BA∩B​ 2.1.2. 边框回归Bounding Box regression 在RCNN中,使用边框回归的目的是提高...
  • 集合运算(并集、交集、余集)

    万次阅读 2016-03-19 15:30:08
     给出两个整数集合A、B,求出他们的交集、并集以及B在A中的余集。 输入格式  第一行为一个整数n,表示集合A中的元素个数。  第二行有n个互不相同的用空格隔开的整数,表示集合A中的元素。  第三行为一个...
  • 写了几个查并集得题,成功把自己写晕了 之后写下面得题(写不下去了) **poj-2912 poj 文章目录 1.POJ - 1611(模板题) 2.HDU - 1213(模板题) 3.poj2236(稍稍复杂的查并集) 4.HDU - 1272(查并集判断图是否连通...
  • 2、再利用余弦相似度公式计算 两字符串对应的向量的相似度。 s1和s2的相似度为: 0.545544725589981 代码: import numpy as np import re import warnings warnings.filterwarnings('ignore') def get_...
  • 深度学习——mAP 计算

    2021-01-03 22:04:36
    在中学数学中,我们学习了交集、并集,而在深度学习中,使用交并的概念设计了交并比IoU用以评估预测质量,简单来说就是计算预测框与标注框的交集面积、并集面积,当IoU值越大时,则表明预测结果与标注结果越接近。...
  • }/*The intersection has 2 elements: 10 20 */ 并集 // set_union example #include // cout #include // set_union, sort #include // vector using namespace std; int main () { int first[] = {5,10,15,20,25}...
  • 史上最易懂AP、mAP计算解析

    万次阅读 多人点赞 2019-04-08 23:17:47
    博主最近也有在接触目标检测相关的相关研究,其中有一个环节博主卡了很久,那就是AP的计算过程。相信大家都看到过很多关于AP的介绍,但是都很空泛,而且大家的答案都是千篇一律,我们只能看个大概,但是一到看代码...
  • 下面数学公式表示:用addWeighted函数计算两个数组的加权和: dst = src1 * alpha + src2 * beta + gamma; 头文件 quick_opencv.h:用于声明类与公共函数 #pragma once #include using namespace cv; class Quick...
  • IOU,全称为intersection of union, 中文名“交并比”。这个概念理解起来不难,本文将从原理以及代码实践来解读IOU。 首先要说明的是,IOU在检测领域和分割领域都有应用,但这两个领域...根据IOU计算公式: iou=A∩...
  • python计算iou以及nms

    千次阅读 2020-04-02 11:59:28
    就是拿两个矩形的交集/并集,我们设交集为inner_area,矩形1面积为area1,矩形1面积为area2,则对应iou为inner_area/(area1+area2-inner_area) ,而两个矩形的面积很好计算,这里关键是计算两个矩形的交集,因为这个交集...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,631
精华内容 3,852
关键字:

并集计算公式