精华内容
下载资源
问答
  • 利用其中函数可以很方便的解决一些数学问题。本篇介绍如何使用python的numpy来求解积分。 代码如下: # -*- coding: utf-8 -*- import numpy as np from scipy.integrate import quad,dblquad,nquad def main(): ...
  • 因为爬虫可以帮你解决很多工作和生活中的问题,节约你生命。不过 Python 还有一个神秘而有趣应用领域,那就是量化交易。量化交易,就是以数学模型替代人主观判断来制定交易策略。通常会借助计算机程序来进行...

    Python 的学习者中,有相当一部分是冲着爬虫去的。因为爬虫可以帮你解决很多工作和生活中的问题,节约你的生命。不过 Python 还有一个神秘而有趣的应用领域,那就是量化交易。

    量化交易,就是以数学模型替代人的主观判断来制定交易策略。通常会借助计算机程序来进行策略的计算和验证,最终也常直接用程序根据策略设定的规则自动进行交易。

    Python 由于开发方便,工具库丰富,尤其科学计算方面的支持很强大,所以目前在量化领域的使用很广泛。市面上也出现了很多支持 Python 语言的量化平台。通过这些平台,你可以很方便地实现自己的交易策略,进行验证,甚至对接交易系统(由于政策原因,现在很多交易接口暂停开放)。

    在交易策略方面,我是外行(虽然曾经也有证券从业资格)。所以本文只是介绍几个 Python 量化平台,以及一些最基本的使用方法。更多的功能、更强大的策略还有待各位自己去挖掘。

    目前国内比较知名的几个平台:

    国外知名平台:

    它们都可以使用 Python 进行策略开发。

    以优矿为例,注册之后,在"开始研究”页面,新建一个 Notebook,就可以开始用 Python 写你自己的策略。

    24230741_9nEp.jpg

    右上角的下拉框选择"策略”,就会帮你自动填写上策略回测的基本结构代码。

    24230741_P9yk.jpg

    开始的一些变量是对回测的基本配置。initialize 里可以做一些初始化的工作。handle_data 则是回测代码的核心,用来实现每个交易日(或每分钟)的交易指令。

    具体的变量含义,这里不做特别细致的解释,文档里都有说明。仅从命名和注释里也可以看出,设定了回测的时间,股票池,资金,交易频率等。

    文档里给了一个最简单的日线策略代码:

    def handle_data(account):

    for stock in account.universe:

    order(stock,100)

    此策略就是,在每个交易日,把股票池里每一只股票都买入一手。

    account.universe 就是开头设定的 universe 值。这里遍历股票池中的股票。

    order 是买卖指令,函数原型是:order(symbol, amount)

    参数 symbol 是股票代码,amount 是买卖数量,正为买入,负为卖出。此处买入 100 股,即 1 手。

    点击"运行”,或 Ctrl+Enter,即可在页面上看到策略的执行情况。

    24230741_euZe.jpg

    我们再尝试改动一点点,写一个自己的策略。

    我拍脑袋想了这样一个策略:

    如果一只未持有的股票 2 个交易日累计涨了 10% 以上,就以当前资金的 5% 买入它。反过来,如果累计跌了 10% 以上,就全部卖出止损。

    下面把它实现出来看下回测效果如何。

    24230741_WYpH.jpg

    时间设为去年(2015)全年,起始资金 10 万元。

    universe = set_universe('A')

    股票池为 A 股所有股票。

    account.get_attribute_history('closePrice', 3)

    取得股票池中所有股票前 3 天的收盘价(closePrice)。

    hist[s][2] - hist[s][0]

    得到 1 天前和 3 天前收盘价的差值。

    account.valid_secpos

    是账户当前所持有的证券信息。

    如果收盘价 2 天的差值满足买入条件且未持有,就执行:

    order_pct(s, 0.05)

    order_pct 表示按账户当前总价值的百分比买入股票。

    如果满足卖出条件则执行:

    order_to(s, 0)

    OK,一个简单到不行的策略已完成。运行一下:

    24230741_zCjA.jpg

    居然,这么简单的策略在最高的时候有超过 90% 的收益,即使在经历了年中的股灾和下半年的震荡之后,到年底也还有 30% 多的收益率,应该超越了大部分散户去年的成绩吧。如果按照这个策略进行交易,啧啧,想想还有点小激动呢。(喂!快醒醒!)

    然而现实是残酷的,真实的市场分分钟教你做人。

    量化投资以及程序化交易是很有前途的行业,但在你想从事这行,甚至用它赚钱之前,请先深入了解它。

    有兴趣的,去看下这个问题:

    前面提到的另外几个平台,和优矿基本类似,API 和功能会有些差异,可以自行尝试,这里不再分别演示。也有人做过比较:

    如果你对这个领域充满好奇,不如现在就立刻动手,从你的第一个策略开始。谁知道你会不会成为下一个巴菲特呢:)

    其他文章及回答:

    Crossin的编程教室

    微信ID:crossincode

    24230741_Aozl.jpg

    展开全文
  • 推荐系统中经常需要处理类似user_id, item_id, rating这样数据,其实就是数学里面稀疏矩阵,scipy中提供了sparse模块来解决这个问题,但scipy.sparse有很多问题不太合用: 1、不能很好同时支持data[i, …]、...
  • 贝叶斯算法及实例python实现

    万次阅读 多人点赞 2018-10-14 12:06:16
    贝叶斯要解决的问题: 为什么要使用贝叶斯: 理解贝叶斯例子: 计算过程: 贝叶斯公式: 贝叶斯公式推导  python经典取球实例:  python拼写纠正实例: 模型比较理论 求解:argmaxc P(c|w) -> ...

    目录

    贝叶斯要解决的问题:

    为什么要使用贝叶斯:

    理解贝叶斯例子:

    计算过程:

    贝叶斯公式:

    贝叶斯公式推导 

    python经典取球实例:

     python拼写纠正实例:

    模型比较理论

    求解:argmaxc P(c|w) -> argmaxc P(w|c) P(c) / P(w)


    贝叶斯简介:

    贝叶斯(约1701-1761) Thomas Bayes,英国数学家

    贝叶斯方法源于他生前为解决一个“逆概”问题写的一篇文章。

    贝叶斯要解决的问题:

    正向概率:假设袋子里面有N个白球,M个黑球,你伸手进去摸一把, 摸出黑球的概率是多大

    逆向概率:如果我们事先并不知道袋子里面黑白球的比例,而是闭着眼睛 摸出一个(或好几个)球,观察这些取出来的球的颜色之后,那么我们可 以就此对袋子里面的黑白球的比例作出什么样的推测

    所谓的贝叶斯定理源于他生前为解决一个“逆概”问题写的一篇文章,而这篇文章是在他死后才由他的一位朋友发表出来的。在贝叶斯写这篇文章之前,人们已经能够计算“正向概率”,如“假设袋子里面有 N 个白球,M 个黑球,你伸手进去摸一把,摸出黑球的概率是多大”。而一个自然而然的问题是反过来:“如果我们事先并不知道袋子里面黑白球的比例,而是闭着眼睛摸出一个(或好几个)球,观察这些取出来的球的颜色之后,那么我们可以就此对袋子里面的黑白球的比例作出什么样的推测”。这个问题,就是所谓的逆向概率问题。

     

    为什么要使用贝叶斯:

    1、现实世界本身就是不确定的,人类的观察能力是有局限性的:

    --比如说我们上面说的N 个白球,M 个黑球,在现实里面可能是无穷大的,也就是说这个数值很难具体量化

    2、我们日常所观察到的只是事物表面上的结果,因此我们需要提供一个猜测

     

    理解贝叶斯例子:

    在一个学校里面,男生占比60%,女生占40%

    计算过程:

    1、正向概率:

    假设学校里面人的总数是 U 个(后面我们通过计算可以知道U是可以约分的),

    穿长裤的(男生):U * P(Boy) * P(Pants|Boy)

    P(Boy) 是男生的概率 = 60%

    P(Pants|Boy) 是条件概率,即在 Boy 这个条件下穿长裤的概率是多大,这里是 100% ,因为所有男生都穿长裤

    穿长裤的(女生): U * P(Girl) * P(Pants|Girl)

    穿长裤总数:U * P(Boy) * P(Pants|Boy) + U * P(Girl) * P(Pants|Girl)

    穿长裤概率=穿长裤总数/校里面人的总数=【U * P(Boy) * P(Pants|Boy) + U * P(Girl) * P(Pants|Girl)】/U

    2、逆向概率计算:一个人穿了长裤,是女生的概率?

    一个人穿了长裤,是女生的概率=P(Girl|Pants)=穿长裤的女生/穿长裤总数

    =U * P(Girl) * P(Pants|Girl)/【U * P(Boy) * P(Pants|Boy) + U * P(Girl) * P(Pants|Girl)】--我们发现这里U是可以消去的

    =P(Girl) * P(Pants|Girl)/【P(Boy) * P(Pants|Boy) + P(Girl) * P(Pants|Girl)】

    分母其实就是 P(Pants)      分子其实就是 P(Pants, Girl)

     

    贝叶斯公式:

     其中P(A|B)是在 B 发生的情况下 A 发生的可能性。

    P(A)是 A 的先验概率,之所以称为“先验”是因为它不考虑任何 B 方面的因素。
    P(A|B)是已知 B 发生后 A 的条件概率,也由于得自 B 的取值而被称作 A 的后验概率。
    P(B|A)是已知 A 发生后 B 的条件概率,也由于得自 A 的取值而被称作 B 的后验概率。
    P(B)是 B 的先验概率,也作标淮化常量(normalizing constant)。

    按这些术语,贝叶斯定理可表述为:

    后验概率 = (相似度 * 先验概率)/标淮化常量

    贝叶斯公式推导 

    通常,事件 A 在事件 B 发生的条件下的概率,与事件 B 在事件 A 发生的条件下的概率是不一样的;然而,这两者是有确定关系的,贝叶斯定理就是这种关系的陈述。

    贝叶斯公式的用途在于通过己知三个概率来推测第四个概率。它的内容是:在 B 出现的前提下,A 出现的概率等于 A 出现的前提下 B 出现的概率乘以 A 出现的概率再除以 B 出现的概率。通过联系 A 与 B,计算从一个事件发生的情况下另一事件发生的概率,即从结果上溯到源头(也即逆向概率)。

    通俗地讲就是当你不能确定某一个事件发生的概率时,你可以依靠与该事件本质属性相关的事件发生的概率去推测该事件发生的概率。用数学语言表达就是:支持某项属性的事件发生得愈多,则该事件发生的的可能性就愈大。这个推理过程有时候也叫贝叶斯推理。

     

    python经典取球实例:

    假设有两个各装了100个球的箱子,甲箱子中有70个红球,30个绿球,乙箱子中有30个红球,70个绿球。假设随机选择其中一个箱子,从中拿出一个球记下球色再放回原箱子,如此重复12次,记录得到8次红球,4次绿球。问题来了,你认为被选择的箱子是甲箱子的概率有多大?

     刚开始选择甲乙两箱子的先验概率都是50%,因为是随机二选一(这是贝叶斯定理二选一的特殊形式)。即有:

    P(甲) = 0.5, P(乙) = 1 - P(甲);

    这时在拿出一个球是红球的情况下,我们就应该根据这个信息来更新选择的是甲箱子的先验概率:

    P(甲|红球1) = P(红球|甲) × P(甲) / (P(红球|甲) × P(甲) + (P(红球|乙) × P(乙)))

    P(红球|甲):甲箱子中拿到红球的概率

    P(红球|乙):乙箱子中拿到红球的概率

    因此在出现一个红球的情况下,选择的是甲箱子的先验概率就可被修正为:

    P(甲|红球1) = 0.7 × 0.5 / (0.7 × 0.5 + 0.3 × 0.5) = 0.7

    即在出现一个红球之后,甲乙箱子被选中的先验概率就被修正为:

    P(甲) = 0.7, P(乙) = 1 - P(甲) = 0.3;

    如此重复,直到经历8次红球修正(概率增加),4此绿球修正(概率减少)之后,选择的是甲箱子的概率为:96.7%

    def bayesFunc(pIsBox1, pBox1, pBox2):
        return (pIsBox1 * pBox1)/((pIsBox1 * pBox1) + (1 - pIsBox1) * pBox2)
    def redGreenBallProblem():
        pIsBox1 = 0.5
    # consider 8 red ball
        for i in range(1, 9):
            pIsBox1 = bayesFunc(pIsBox1, 0.7, 0.3)
            print ("拿到 %d 个球是红球是甲箱子的先验概率: %f" % (i, pIsBox1))
    # consider 4 green ball
        for i in range(1, 5):
            pIsBox1 = bayesFunc(pIsBox1, 0.3, 0.7)
            print ("拿到 %d 个球是绿球是甲箱子的先验概率: %f" % (i, pIsBox1))
    redGreenBallProblem()
    

     

     python拼写纠正实例:

    问题:我们看到用户输入了一个不在字典中的单词,我们需要去猜 测:“这个家伙到底真正想输入的单词是什么呢?

    比如一个人输入了一个单词tha,其实他真正想输入的可能是the,也许是要输入than等等

    P(我们猜测他想输入的单词 | 他实际输入的单词)

    用户实际输入的单词记为D( D代表Data ,即观测数据)

    猜测1:P(h1 | D),猜测2:P(h2 | D),猜测3:P(h3 | D) 。。。

    统一为:P(h | D)

    P(h | D) = P(h) * P(D | h) / P(D)

    用户实际输入的单词记为 D ( D 代表 Data ,即观测数据)

    对于不同的具体猜测 h1 h2 h3 .. ,P(D) 都是一样的,所以在比较 P(h1 | D) 和 P(h2 | D) 的时候我们可以忽略这个常数

    P(h | D) ∝ P(h) * P(D | h) 对于给定观测数据,一个猜测是好是坏,取决于“这个猜测本身独 立的可能性大小(先验概率,Prior )”和“这个猜测生成我们观测 到的数据的可能性大小。

    贝叶斯方法计算: P(h) * P(D | h),P(h) 是特定猜测的先验概率

    比如用户输入tlp ,那到底是 top 还是 tip ?这个时候,当最大似然 不能作出决定性的判断时,先验概率就可以插手进来给出指示—— “既然你无法决定,那么我告诉你,一般来说 top 出现的程度要高许多,所以更可能他想打的是 top ”

    模型比较理论

    最大似然:最符合观测数据的(即 P(D | h) 最大的)最有优势

    掷一个硬币,观察到的是“正”,根据最大似然估计的精神,我们应该 猜测这枚硬币掷出“正”的概率是 1,因为这个才是能最大化 P(D | h) 的那个猜测

    奥卡姆剃刀: P(h) 较大的模型有较大的优势

    奥卡姆剃刀定律(Occam's Razor, Ockham's Razor)又称“奥康的剃刀”,它是由14世纪逻辑学家、圣方济各会修士奥卡姆的威廉(William of Occam,约1285年至1349年)提出。这个原理称为“如无必要,勿增实体”,即“简单有效原理”。正如他在《箴言书注》2卷15题说“切勿浪费较多东西去做,用较少的东西,同样可以做好的事情。”(百度百科)

    原理具体内容为:1.避重趋轻 2.避繁逐简 3.以简御繁 4.避虚就实

            剃刀原则从来没有说简单的理论就是正确的理论,通常表述为“当两个假说具有完全相同的解释力和预测力时,我们以那个较为简单的假说作为讨论依据。”(科学松鼠会)

    剃刀原则不是一个理论而是一个原理,它的目的是为了精简抽象实体。它不能被证明也不能被证伪,因为它是一个规范性的思考原则。大部分情况下,应用奥卡姆剃刀原理是合适的;但是这不代表奥卡姆剃刀就是正确的。(知乎)

    总结一下,剃刀原则并不是一种定理(在数学上有推导,数学之美——刘未鹏),而是一种思维方式,可用于指导我们的工作,比如我们可以用A和B达到同样的效果,但B更简单,于是我们选择B。同时,也有人说可能因为能力不足,于是我们选择更简单的方式来处理问题,这也是剃刀的原则的一种应用吧。举个贴切的例子,做决策树分析的时候,采用9个属性的预测性能和5个属性的预测性能是相似的,那么我们就会选择5个属性来预测。

    如果平面上有 N 个点,近似构成一条直线,但绝不精确地位于一条直线 上。这时我们既可以用直线来拟合(模型1),也可以用二阶多项式(模 型2)拟合,也可以用三阶多项式(模型3),特别地,用 N-1 阶多项式 便能够保证肯定能完美通过 N 个数据点。那么,这些可能的模型之中到 底哪个是最靠谱的呢?

    奥卡姆剃刀:越是高阶的多项式越是不常见

     

    求解:argmaxc P(c|w) -> argmaxc P(w|c) P(c) / P(w)

    • P(c), 文章中出现一个正确拼写词 c 的概率, 也就是说, 在英语文章中, c 出现的概率有多大
    • P(w|c), 在用户想键入 c 的情况下敲成 w 的概率. 因为这个是代表用户会以多大的概率把 c 敲错成 w
    • argmaxc, 用来枚举所有可能的 c 并且选取概率最大的
    import re, collections
     
    def words(text): return re.findall('[a-z]+', text.lower()) #把语料中的单词全部抽取出来, 转成小写, 并且去除单词中间的特殊符号
     
    def train(features):
        model = collections.defaultdict(lambda: 1)
        for f in features:
            model[f] += 1
        return model
    #要是遇到我们从来没有过见过的新词怎么办. 假如说一个词拼写完全正确, 但是语料库中没有包含这个词, 从而这个词也永远不会出现在训练集中. 于是, 我们就要返回出现这个词的概率是0. 这个情况不太妙, 因为概率为0这个代表了这个事件绝对不可能发生, 而在我们的概率模型中, 我们期望用一个很小的概率来代表这种情况. lambda: 1 
    NWORDS = train(words(open('big.txt').read()))#big.txt为语料库
     
    alphabet = 'abcdefghijklmnopqrstuvwxyz'
     
    #编辑距离:
    #两个词之间的编辑距离定义为使用了几次插入(在词中插入一个单字母), 删除(删除一个单字母), 交换(交换相邻两个字母), 替换(把一个字母换成另一个)的操作从一个词变到另一个词.
    def edits1(word):#改变其中一个字母
        n = len(word)
        return set([word[0:i]+word[i+1:] for i in range(n)] +                     # 删除某个字母
                   [word[0:i]+word[i+1]+word[i]+word[i+2:] for i in range(n-1)] + # 改变其中两个字母前后顺序
                   [word[0:i]+c+word[i+1:] for i in range(n) for c in alphabet] + # 替换某个字母
                   [word[0:i]+c+word[i:] for i in range(n+1) for c in alphabet])  # 插入某个字母
     
    def known_edits2(word):#改变两个字母
        return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in NWORDS)
     
    def known(words): return set(w for w in words if w in NWORDS)
    #如果known(set)非空, candidate 就会选取这个集合, 而不继续计算后面的
    def correct(word):
        candidates = known([word]) or known(edits1(word)) or known_edits2(word) or [word]
        return max(candidates, key=lambda w: NWORDS[w])

    比如我们输入了morw,那么根据语料库的统计,我们应该输入的是more 

    展开全文
  • 备战数学建模(Python

    千次阅读 2021-01-22 10:47:45
    Python之建模规划篇线性规划基本介绍线性规划的实例与定义线性规划问题的解的概念求解线性规划的Matlab 解法Python Scipy库实现Python plup库实现一个十分有趣的例子整数规划基本介绍整数规划的分类整数规划的特点...


    由于美国大学生数学建模大赛很快就要开赛了,所以我就打算在这几天内,好好的看看《数学建模算法与应用》这本书,里面很多都是用matlab实现的,我还想尝试着用python去实现它的算法,这里作为一个总目录进行查阅

    Python之建模规划

    Python之建模规划篇–线性规划
    Python之建模规划篇–整数规划
    Python之建模规划篇–非线性规划

    Python之建模数值逼近

    Python之建模数值逼近篇–一维插值
    Python之建模数值逼近篇–二维插值
    Python之建模数值逼近篇–最小二乘拟合

    Python之建模微分方程

    待续

    每日一句
    Man struggles upwards; water flows downwards.(人往高处走,水往低处流)

    展开全文
  • 基于匈牙利算法的任务分配问题的python实现

    万次阅读 多人点赞 2018-05-22 20:35:55
    问题数学描述: 二、实例分析---全排列法在讲将匈牙利算法解决任务分配问题之前,先分析几个具体实例。以3个工作人员和3项任务为实例,下图为薪酬图表和根据薪酬图表所得cost矩阵。 利用最简单方法(全排列法)...

    一、问题描述

    问题描述:N个人分配N项任务,一个人只能分配一项任务,一项任务只能分配给一个人,将一项任务分配给一个人是需要支付报酬,如何分配任务,保证支付的报酬总数最小。

    问题数学描述:

      

    二、实例分析---全排列法

    在讲将匈牙利算法解决任务分配问题之前,先分析几个具体实例。

    以3个工作人员和3项任务为实例,下图为薪酬图表和根据薪酬图表所得的cost矩阵。

      

    利用最简单的方法(全排列法)进行求解,计算出所有分配情况的总薪酬开销,然后求最小值。

    total_cost1 = 250 + 600 + 250 = 1100;  x00 = 1,x11 = 1,x22 = 1;

    total_cost2 = 250 + 350 + 400 = 1000;  x00 = 1,x12 = 1,x21 = 1;

    total_cost3 = 400 + 400 + 250 = 1050;  x01 = 1,x10 = 1,x22 = 1;

    total_cost4 = 400 + 350 + 200 = 950;   x01 = 1,x12 = 1,x20 = 1;  //最优分配

    total_cost5 = 350 + 400 + 400 = 1150; x02 = 1,x10 = 1,x21 = 1;

    total_cost6 = 350 + 600 + 250 = 1150; x02 = 1,x11 = 1,x22 = 1;

    对于任务数和人员数较少时,可利用全排列法计算结果。

    若将N任务分配给N个人员,其包含的所有分配情况数目为N!,N增大时,全排列法将难以完成任务。

    三、匈牙利算法

    下面简要介绍匈牙利算法。

    其基本的理论基础是针对cost矩阵,将cost矩阵的一行或一列数据加上或减去一个数,其最优任务分配求解问题不变。

      

    算法的基本步骤如下:

      

    四、实例分析---匈牙利算法

    下面结合具体实例,分析匈牙利算法如何解决任务分配问题。

    以N = 4为实例,下图为cost列表和cost矩阵。

      

    Step1.从第1行减去75,第2行减去35,第3行减去90,第4行减去45。

      

    Step2.从第1列减去0,第2列减去0,第3列减去0,第4列减去5。

      

    Step3.利用最少的水平线或垂直线覆盖所有的0。

      

    Step4.由于水平线和垂直线的总数是3,少于4,进入Step5。

    Step5.没有被覆盖的最小值是5,没有被覆盖的每行减去最小值5,被覆盖的每列加上最小值5,然后跳转到步骤3.

      

    Step3.利用最少的水平线或垂直线覆盖所有的0。

      

    Step4.由于水平线和垂直线的总数是3,少于4,进入Step5。

    Step5.没有被覆盖的最小值是20,没有被覆盖的每行减去最小值20,被覆盖的每列加上最小值20,然后跳转到步骤3.

      

    Step3.利用最少的水平线或垂直线覆盖所有的0。

      

    Step4.由于水平线和垂直线的总数是4,算法结束,分配结果如下图所示。

      

    其中,黄色框表示分配结果,左边矩阵的最优分配等价于左边矩阵的最优分配。

    以上内容为转载部分,下面代码内容为原创

    五、python代码

    import itertools
    import numpy as np
    from numpy import random
    from scipy.optimize import linear_sum_assignment
    
    
    # 任务分配类
    class TaskAssignment:
    
        # 类初始化,需要输入参数有任务矩阵以及分配方式,其中分配方式有两种,全排列方法all_permutation或匈牙利方法Hungary。
        def __init__(self, task_matrix, mode):
            self.task_matrix = task_matrix
            self.mode = mode
            if mode == 'all_permutation':
                self.min_cost, self.best_solution = self.all_permutation(task_matrix)
            if mode == 'Hungary':
                self.min_cost, self.best_solution = self.Hungary(task_matrix)
    
        # 全排列方法
        def all_permutation(self, task_matrix):
            number_of_choice = len(task_matrix)
            solutions = []
            values = []
            for each_solution in itertools.permutations(range(number_of_choice)):
                each_solution = list(each_solution)
                solution = []
                value = 0
                for i in range(len(task_matrix)):
                    value += task_matrix[i][each_solution[i]]
                    solution.append(task_matrix[i][each_solution[i]])
                values.append(value)
                solutions.append(solution)
            min_cost = np.min(values)
            best_solution = solutions[values.index(min_cost)]
            return min_cost, best_solution
    
        # 匈牙利方法
        def Hungary(self, task_matrix):
            b = task_matrix.copy()
            # 行和列减0
            for i in range(len(b)):
                row_min = np.min(b[i])
                for j in range(len(b[i])):
                    b[i][j] -= row_min
            for i in range(len(b[0])):
                col_min = np.min(b[:, i])
                for j in range(len(b)):
                    b[j][i] -= col_min
            line_count = 0
            # 线数目小于矩阵长度时,进行循环
            while (line_count < len(b)):
                line_count = 0
                row_zero_count = []
                col_zero_count = []
                for i in range(len(b)):
                    row_zero_count.append(np.sum(b[i] == 0))
                for i in range(len(b[0])):
                    col_zero_count.append((np.sum(b[:, i] == 0)))
                # 划线的顺序(分行或列)
                line_order = []
                row_or_col = []
                for i in range(len(b[0]), 0, -1):
                    while (i in row_zero_count):
                        line_order.append(row_zero_count.index(i))
                        row_or_col.append(0)
                        row_zero_count[row_zero_count.index(i)] = 0
                    while (i in col_zero_count):
                        line_order.append(col_zero_count.index(i))
                        row_or_col.append(1)
                        col_zero_count[col_zero_count.index(i)] = 0
                # 画线覆盖0,并得到行减最小值,列加最小值后的矩阵
                delete_count_of_row = []
                delete_count_of_rol = []
                row_and_col = [i for i in range(len(b))]
                for i in range(len(line_order)):
                    if row_or_col[i] == 0:
                        delete_count_of_row.append(line_order[i])
                    else:
                        delete_count_of_rol.append(line_order[i])
                    c = np.delete(b, delete_count_of_row, axis=0)
                    c = np.delete(c, delete_count_of_rol, axis=1)
                    line_count = len(delete_count_of_row) + len(delete_count_of_rol)
                    # 线数目等于矩阵长度时,跳出
                    if line_count == len(b):
                        break
                    # 判断是否画线覆盖所有0,若覆盖,进行加减操作
                    if 0 not in c:
                        row_sub = list(set(row_and_col) - set(delete_count_of_row))
                        min_value = np.min(c)
                        for i in row_sub:
                            b[i] = b[i] - min_value
                        for i in delete_count_of_rol:
                            b[:, i] = b[:, i] + min_value
                        break
            row_ind, col_ind = linear_sum_assignment(b)
            min_cost = task_matrix[row_ind, col_ind].sum()
            best_solution = list(task_matrix[row_ind, col_ind])
            return min_cost, best_solution
    
    
    # 生成开销矩阵
    rd = random.RandomState(10000)
    task_matrix = rd.randint(0, 100, size=(5, 5))
    # 用全排列方法实现任务分配
    ass_by_per = TaskAssignment(task_matrix, 'all_permutation')
    # 用匈牙利方法实现任务分配
    ass_by_Hun = TaskAssignment(task_matrix, 'Hungary')
    print('cost matrix = ', '\n', task_matrix)
    print('全排列方法任务分配:')
    print('min cost = ', ass_by_per.min_cost)
    print('best solution = ', ass_by_per.best_solution)
    print('匈牙利方法任务分配:')
    print('min cost = ', ass_by_Hun.min_cost)
    print('best solution = ', ass_by_Hun.best_solution)

    代码运行实例:


    展开全文
  • Pyomo可用于定义符号问题,创建具体的问题实例以及使用标准求解器解决这些实例。 Pyomo支持多种问题类型,包括: 线性规划 二次编程 非线性规划 混合整数线性规划 混合整数二次规划 混合整数非线性规划 混合整数...
  • 匈牙利算法基本原理与Python实现

    千次阅读 2019-07-09 15:59:01
    一、问题描述 问题描述:N个人分配N项任务...在讲将匈牙利算法解决任务分配问题之前,先分析几个具体实例。 以3个工作人员和3项任务为实例,下图为薪酬图表和根据薪酬图表所得cost矩阵。   利用最简单方法(...
  • 而我翻译的这本书是来源于 OpenCv的官方文档,内容全面,对各种的算法的描述简单易懂,而且不拘泥于长篇大论的数学推导,非常适合想使用OpenCⅤ解决实际问题的人,对他们来说具体的数学原坦并不重要,重要是能解...
  • Python Cookbook

    2013-07-31 22:33:26
    13.9 修复Python 2.4email.FeedParser 解析消息 477 13.10 交互式地检查POP3邮箱 479 13.11 探测不活动计算机 482 13.12 用HTTP监视网络 487 13.13 网络端口转发和重定向 489 13.14 通过代理建立SSL...
  • delorean:解决 Python 中有关日期处理的棘手问题的库。 maya:人性化的时间处理库。 moment:一个用来处理时间和日期的 Python 库。灵感来自于 Moment.js。 pendulum:一个比 arrow 更具有明确的,可预测的行为...
  • 在讲将匈牙利算法解决任务分配问题之前,先分析几个具体实例。 以3个工作人员和3项任务为实例,下图为薪酬图表和根据薪酬图表所得cost矩阵。   利用最简单方法(全排列法)进行求解,计算出所有分配情况总...
  • 本书通过数学解释和编程实例提供了机器学习概念。每章从真实世界数据集技术基础和工作示例开始。除了应用算法建议之外,每种技术都具有数据上优点和缺点。在本书中,我们提供了python代码示例。 Python...
  • 这本书是使用高级Python语言作为...除了学习如何编程计算机外,读者还将学习如何借助数值方法和编程来解决科学和工程各个分支中出现的数学问题。通过融合编程、数学和科学应用,本书为实践计算科学奠定了坚实基础。
  • 前面我们写了一篇关于python实例的汇率转换文章,有小伙伴说它虽然可以解决我们生活中实际问题,但是好像缺少点什么。 我仔细想了想,想起了一句话,“生活不止眼前苟且,还有诗和远方!”,确实我们应该用...
  • 1.2.3 引用模块解决除法问题 20 1.2.4 余数 21 1.2.5 四舍五入 22 1.3 常用数学函数和运算优先级 23 1.3.1 使用math 23 1.3.2 运算优先级 25 1.4 一个简单程序 26 1.4.1 程序 26 1.4.2 Hello,World 27 ...
  • 手写算法-python代码实现逻辑回归逻辑回归原理解析损失函数定义以及数学公式推导过程解释1:通俗易懂的手推损失函数:...逻辑回归是LogisticRegression的直译,它不是用来解决回归问题的,而是用来解决分类问题的,它
  • Python每日一练0020

    2018-04-16 05:50:40
    问题 你需要执行简单日期操作,计算两个日期间隔多少天、某个日期后多少天是几月几日、转换时间字符串格式等 解决方案 ...对于datetime实例,可以直接进行-数学运算得到一个timedelta实例,也就是...
  • 需要加入QQ交流群可以扫描下面二维码,交流群会为大家提供学习资源和问题解答,还会持续为大家带来免费线上Python体验课和行业公开课,敬请关注。 Python应用领域和职业发展分析 简单说,Python是一个...
  • 贝叶斯方法解决“逆概”问题。 贝叶斯公式: 拼写纠正实例:假如用户输入是错误D,那用户真正想要输入是哪个单词呢?可能是h1,也可能是h2,...,hn 那每种情况出现概率是P(h1|D),P(h2|D),...,P...
  • 跟老齐学Python-最新版

    2017-12-25 09:54:50
    1.2.3 引用模块解决除法问题 19 1.2.4 余数 20 1.2.5 四舍五入 20 1.3 常用数学函数和运算优先级 21 1.3.1 使用math模块 21 1.3.2 两个函数 23 1.3.3 运算优先级 23 1.4 第一个简单程序 24 1.4.1 程序 24 1.4.2 用...
  • Theano 是一个 Python 库,用来定义、优化和模拟数学表达式计算,用于高效的解决多维数组计算问题。Theano特点: l 紧密集成Numpy l 高效数据密集型GPU计算 l 高效符号微分运算 l 高速和稳定优化 ...
  • 接下来一学期选了门《机器学习》课程,所以打算把相关作业也发上来! 一: 请说明感知机为何不能解决异或问题。...其中sign是符号函数,w和b都是感知机参数,x表示实例的特征向量,而y=f(x)就是实例的类别。以...
  • 例如:第一章 Python 机器学习入门之pandas使用 提示:写完文章后,目录可以自动生成,如何生成可参考右边帮助文档 文章目录数学建模学习笔记 (一) 层次分析法前言一、层次分析法二、问题引入1.评价类问题2....

空空如也

空空如也

1 2 3 4 5 6
收藏数 102
精华内容 40
关键字:

python解决数学问题的实例

python 订阅