精华内容
下载资源
问答
  • 做最简单的事
    万次阅读
    2019-07-02 13:18:24

    辞职的原因千千万,但是有些原因不能真实的告诉领导,那么怎么说比较体面呢?下面小编推荐一下简单的辞职理由给大家。

    最简单的个人辞职原因[范文7篇]

    1、由于我个人的原因,经过深思熟虑地思考,我决定辞去我目前在公司所担任的职位

    2、鉴于目前的身体及生活状态,自认为不能够为公司创造更大的价值,现向公司提出辞职,望公司予以批准。

    3、由于个人职业规划和一些现实因素,经过慎重思考之后,特此提出离职申请,敬请批准。

    4、我因为要去美国留学,故需辞去此刻的工作,请上级领导批准。

    5、因为诸多原因,最近感觉自己的心态很不好,不能够很好的完成岗位工作

    6、父母都已年迈,家里无人照顾,人都有选取的权利,在经过深思熟虑以及和父母的商议过后,我在此时选取离开公司

    7、由于我婆婆最近身体不太好,不能尽心地照顾我家宝宝。小孩子此刻正是调皮捣蛋的时候,我婆婆一个人顾但是来了,所以,我想辞职回家照看宝宝

    8、我生于农村,父母思想与城市人不同,次次回家被逼婚。今年本命年,我不再是小孩子了,自觉也该为这方面思考一二

    9、由于我要回老家结婚,考虑到结婚后可能就在家乡发展,所以我无法在目前的岗位继续下去,在此我请求领导同意解除我的劳动合同关系

    下面推荐几篇辞职信范文

    个人辞职申请书范文(一)

    尊敬的领导:

    首先感谢企业的领导和同事在这三年多时间里对我的关心与照顾,我对我的辞职感到很抱歉。我辞职有我自已的原因,希望企业的同仁能够理解我。

    当前企业正处于快速发展的阶段,同事都是斗志昂扬,壮志满怀,而我在这时候却因个人原因无法为企业分忧,实在是深感歉意。

    我希望企业领导在百忙之中抽出时间商量一下工作交接问题。本人在20xx年x月x日离职,希望能得到企业领导的准许!

    感谢诸位在我在企业期间给予我的信任和支持,并祝所有同事和朋友们在工作和活动中取得更大的成绩和收益!

    此致

    敬礼!

    辞职人:

    20xx年xx月xx日

    个人辞职申请书范文(二)

    尊敬的各级主管:

    您们好!

    我很遗憾自己在这个时候向企业正式提出辞职。

    来到富士康也已经四年多了,从最初的idpbg,群创光电,奇美电子到现在的ccpbg,在每个部门都学到了很多,很多。也正是在这里我开始踏上了社会这个大家庭,完成了自己从一个学生到社会工作者的转变。 有过欢笑,有过收获 ,也有过泪水和无奈,企业平等的人际关系和开明的工作作风,一度让我有了依靠的感觉。在这里,我能踏实的工作,适时的学习,然而在工作上的好无成就感总让我彷徨,或许这是对的,因此,我开始了认真的思考。

    或许只有重新再去到社会其他环境中去经历挫折,在不断的打拼中去寻找属于自己的定位,才是我人生的下一步选择。所以我慎重的考虑了很久,还是选择要离开,离开这些曾同甘共苦的同事们,很舍不得,舍不得同事间的那片真诚和友善。最后只愿富士康越来越强大!

    希望各位主管予以批准,谢谢!

    此致

    敬礼!

    辞职人:

    20xx年xx月xx日

    个人辞职申请书范文(三)

    尊敬的领导:

    工作虽然只有4个月,但是我发现了自己有很多不足。

    毕业工作是一个新的起点,新的环境使我接触到了新的人,感觉到以前在学校就像井底之蛙,虽然现在晚上还在上夜课,但离毕业还要2年,感觉好遥远所以我很迫不及待的要充实自己。再这4个月的工作中的确让我感觉很轻松,但轻松的让我觉得我自己好没用。我还很年轻,不应该在这种轻松的工作中麻痹自己。

    很庆幸的是再这段工作时候我没有受到任何前辈的排挤,反而前辈们都很照顾我,可能还把我看成小女孩吧。在这我祝所有关心过我的前辈工作顺利、心想事成。我会把这段时间看成时我从校园到社会的一个过渡期。

    望领导批准我的申请,并协助办理相关离职手续。

    此致

    敬礼!

    辞职人:cizhixin.com

    20xx年xx月xx日

    个人辞职申请书范文(四)

    尊敬的各位领导:

    您们好!

    我从年月份来到公司,到如今已经有一年半了,非常感激公司给了我这个工作和学习的机会,使我得到了很多的历练,同时我也得到了很多的照顾,在此我对关心过照顾过教导过我的领导们说声谢谢。

    如今,由于公司发展方向的转变,把我从供热中心调到了一线部门经过近两个月的工作和了解,一方面,我发现自己在一线部门的能力有限,有些抓不到头绪,担心适应不了一线部门的各项工作,而不能为公司创造更大的价值,如果因为我个人的问题影响到公司整体我也于心不安。另一方面,我家中出了些急事需要我立即去处理,随时都可能因为这些事影响耽误正常的工作。所以经过我的深思熟虑,我决定向领导提出辞职申请,希望领导能够批准,也希望领导能招聘到更加适合的人来做一线部门的工作。

    在公司工作的日子是我从毕业经历的这些工作单位最温馨最愉快的,一想到离开公司,离开曾经一起共事的同事和领导,我很舍不得,舍不得领导们的关心,舍不得同事之间的那片真诚和友善。我期待公司以后能在同事和领导们的努力下能实现突飞猛进的发展。

    综上所述,因我个人原因,现正式向公司提出辞呈,希望领导给予批准,谢谢。

    此致

    敬礼!

    辞职人:

    20xx年xx月xx日

    个人辞职申请书范文(五)

    尊敬的公司经理:

    您好!因为结婚的个人原因,我很遗憾自己在这个时候向公司正式提出辞职。辞职报告已经递交给人力资源部;

    来到xxx公司工作生活这段时间让我知道很多自己不足之处,正是这些不足让我感觉到自己完全不能胜任这份工作,还有我国内女朋友要我回去结婚实在没办法才请求离职。对于辞职我心里也想了很久,其实,公司平等的人际关系和开明的工作作风,一度让我有着找到了依靠的感觉,在这里我能很好的工作,很好的学习。然而总会发生点生活中不愿意抉择的事情,人总是要面对现实的,自己的兴趣是什么,自己喜欢什么,自己适合做什么,这一连串的问号一直让我沮丧。或许只有重新再跑到社会上去遭遇挫折,在不断打拼中去寻找属于自己的定位,才是我人生的下一步选择。从小到大一直过得很顺,这曾让我骄傲,如今却让自己深深得痛苦,不能自拔,也许人真的要学会慢慢长大。

    本着对公司负责的态度,为了不让公司因我而造成的工作失误,我郑重向公司提出辞职。我想提前这么久给公司安排人力,公司在安排上能做得更加合理和妥当。长痛不如短痛,或许这对公司对我都是一种解脱吧.能为公司效力的日子不多了,我一定会把好自己最后一班岗,做好属于自己的所有工作,尽力让职务做到平衡过渡。希望我的辞职没有给公司带来损失。

    离开这个公司,离开这些曾经同甘共苦的同事,很舍不得,舍不得领导们的譐譐教诲,舍不得同事之间的那片真诚和友善。也愿公司在今后的工作中发挥优势,扬长避短,祝愿公司兴旺发达!

    此致

    敬礼!

    辞职人:

    20xx年xx月xx日

    个人辞职申请书范文(六)

    尊敬的公司领导:

    您们好!首先感谢领导在百忙之中抽出时间阅读我的离职信。我是怀着十分不舍的心情写这下封离职信的。自我进入公司以来,由于各位领导和同事对我的关心、指导和信任,使我学到了不少知识和处事道理。经过这段时间在公司的工作,我在这里学到了很多知识,积累了一定的经验,对此我深表感激。 基于个人原因、市场环境和职业规划等因素,经过我这段时间进行了认真的思考后,我做了离职决定。

    我知道这个过程会给公司带来一定程度上的不便,对此我深表抱歉。 我会在近期完成工作交接工作。为了尽量减少对现有工作造成的影响,在我离开公司初期,如果有同事对我以前的工作有任何疑问,我将及时做出答复协助解决。

    在此,我非常感谢领导在这段时间里对我的教导和关怀,在公司的这段经历对于我而言是非常珍贵的。将来无论何时,无论何地,我都会为自己曾经是公司的一员而感到荣幸。我确信在公司的这段工作经历将是我整个人生中相当重要的一部分。

    最后,祝公司领导和同事们身体健康、工作顺利!再次对我的离职给公司带来的不便表示抱歉,同时我也希望公司能够体恤我的个人实际,对我的申请予以考虑并批准。谢谢!

    此致

    敬礼!

    辞职人:

    20xx年xx月xx日

    个人辞职申请书范文(七)

    尊敬的公司领导:

    首先致以我深深地歉意,很遗憾自己在这个时候突然向公司提出辞职,纯粹是出于个人的原因,不能在公司继续发展!

    在公司的近一年里公司给了我一个又一个很好的学习平台,这里的工作使我真正从校园踏上了社会,自己也在踏进社会后第一次有了归属的感觉。在公司工作经历带给了我很多愉快的记忆,也带给我人生经验的增长,在这短暂的时间里我学到了很多。离开对于我个人来说或许是一种损失!但我也想跑到社会上去遭遇挫折,在不断打拼中去寻找属于自己的定位,寻找人生的下一步选择

    不论以后的成功与否,至少努力过,也给自己有过成功或者失败的机会。

    非常的抱歉,在工作的近一年时间里,我并没有为公司创造多大的价值个人原因辞职报告工作报告。十分感谢公司近一年以来对我的培养,感谢领导和同事对我的帮助和照顾。即使是乍现的昙花也曾肆意的绽放过,即使是瞬息的流星也曾尽情的燃烧过。没有遗憾,没有怨言,虽然我并未成功,但是我努力了。

    很荣幸曾身为公司的一员,能有机会在这里工作学习,不胜感激!衷心祝愿所有同事工作顺利,事业有成!

    诚祝公司业绩百尺竿头,更进一步!

    此致

    敬礼!

    辞职人:

    20xx年xx月xx日

    文章标题:最简单的个人辞职原因[范文7篇]
    文章地址:https://www.cizhixin.com/lizhiyuanyin/5628.htm

    更多相关内容
  • 一、最简单的神经网络--Bp神经网络

    万次阅读 多人点赞 2018-09-04 20:44:38
     下面将通过实例,来给大家搭建一个最简单的神经网络:Bp神经网络,来理解 AI 。   第 3 部分 最简单的神经网络Bp神经网络 1.Bp 神经网络的简单理解  这里要从名字开始说起了,首先从名称中可以看出...

    先向各位小伙伴道歉,文中可能会出现许多错别字,表达不清楚,病句,标点符号使用不当,图片难看且潦草的情况,必须诚恳地向大家表示:凑合看吧,还能咬我咋的...

            在之前的文章中,有提到过,所谓的 AI 技术,本质上是一种数据处理处理技术,它的强大来自于两方面:1.互联网的发展带来的海量数据信息  2.计算机深度学习算法的快速发展。 所以说 AI 其实并没有什么神秘,只是在算法上更为复杂。要想理解这一点,我们要从一个问题说起:找数据的规律...

            如果你是一名上过大学的人,有几个数学上的方法你应该不太陌生:线性拟合,多项式拟合,最小二乘法...如果这个你都不知道的话,我建议你现在 假装明白 ,然后往下看,应该不难。

            先看一下下面这组数据:

    xy
    01
    12
    29
    328
    465
    5126
    6217
    7344
    8513
    9730

            这里没什么好说的,这个表是一个 x 与 y 的对应关系,我们现在的目标比较明确,找到x与y的对应关系,也就是求y=f(x)的关系式。

    第 1 部分  传统数学方法回顾

            这部分内容就很简单了,关键记住一个名词 ——  一通(tòng)操作 ...

    方法一:线性拟合

            我们知道,在大多数情况下,当我们拿来一组数据,进行拟合时,首先想到的肯定是线性拟合,因为其方法简单暴力直接有效,往往很快就能得到一个差不多的结论。虽然不是很精确,但是有句名言说得好,要啥自行车?直接来看结果。

            关于线性拟合在数学上的方法,这里就不讲了,随便找本教材应该就有,我相信看到上面的图,你应该已经理解了。总之就是经过 一通操作 ,得到线性关系。我这里并没有用数学方法亲自去进行计算和拟合关系式,而是用了一种很高端的工具,叫 Excel ... 以示说明,领会精神即可。

            红色虚线为拟合线,蓝色实线为实际点的连线,可以看到,利用线性拟合,得到的结果是 y = 75.4x - 135.8 这样一个数学关系,很显然,它的效果不是他别理想,可以看到,误差还是不小的。

    方法二:多项式拟合

            这个的思路也比较直接,其实就是假设  y = ax^{^{n}} + bx^{^{n-1}} + cx^{^{n-2}} + ... , 比如我们要拟合一个2次的多项式,就可以假设

    y = ax^{^{2}} + bx + c 。同样的,3次方的关系就是y = ax^{^{3}} + bx^{^{2}} + cx^{^{1}} + d 。应该是很好理解吧······

            跟刚才一样,又是一通操作,拟合的方法我不就不赘述了,直接用我们的高端工具 Excel 来完成这个工作。效果如下:

            可以看到,二次拟合的效果比线性拟合的结果要更接近于真实的结果,而三次曲线就是真实的关系(当然大多数实际情况下并不是严格对应)。

            通常利用更高阶的多项式,得到的结果就更加接近于实际的数据。

    方法三:其他

            最小二乘法,指数拟合,对数拟合,根据数据的不同,用不同的方法来进行拟合得到接近真实情况的数学关系。区别就是利用不同的 一通操作 ... 但是无论是哪一种,解决的数学问题相对来说比较有限,并不能准确拟合出很复杂的数学关系。

            如果利用逻辑回归、贝叶斯、决策树、KNN、套袋法等等,也能够解决很多很复杂的数学问题,但这又是另外一个很大的领域,不过建议有机会还是要把这些基础打好,但是这篇博客中,我们不探讨,完全不熟悉也没关系,只要知道这些都是传统的数据处理方法就好。

    第 2 部分  现代技术中的难题

            下面我们来思考一个 重!要!问!题!:别人爸爸 跟 你爸爸 的不同之处,在数学上的表达是怎么样的 ?

            多么深奥的问题,也许你觉得这是一个显而易见的问题,你爸爸就是你爸爸,他爸爸就是他爸爸。这点我十分相信,虽然你不知道如何去回答这个问题,但是你这辈子应该是没喊错过你父亲... 可是问题来了,你怎么让计算机去熟练的分辨出两个人谁是谁?这就必须要依赖数学了...

            所以回到问题中来:别人爸爸 跟 你爸爸 的不同之处,在数学上的表达是怎么样的 ?你可能要打我了。但是先别急,先来分析分析。首先,必须明搞明白一件事,这个世界上的事情可以分为两种,可归纳的问题不可归纳的问题

            首先什么是不可归纳的问题,举个例子,你不能用一套完美的数学公式去表达 所有的质数 , 因为目前的研究表明,还没有什么方法是能够表达质数的,也就是说,质数的出现,本身不具备严格的数学规律,所以无法归纳。

            可归纳问题就比较好理解了,一只猫 和 一只狗 出现在你的面前时 ,你能够清晰地将他们进行分辨,这说明在猫和狗之间,确实存在着不同,虽然你很难说清楚它们的不同到底是什么,但是可以知道,这背后是可以通过一套数学表达来完成的,只是很复杂而已。理论上来讲,凡是人类能够掌握的事情,比如再怎么复杂的语言,人类的快速分辨物体的视觉,复杂的逻辑思考,都是可以用数学来表达的可归纳问题。我们人类之所以能够快速地对这些复杂的问题进行快速地反应,得益于我们的大脑内部复杂的神经网络构造。当我们不经意间看到一些物体时,大脑其实是在高速的进行计算,我们天生拥有这种能力,以至于我们根本没有察觉。多么神奇,可以说我们每个人其实都是超级算法工程师...

            对比第一部分的那个表格,和如何分辨爸爸的问题,可以得到结论是,这是同一个层次的问题:可归纳数学问题,只是用到的方法不同,复杂度不同而已。都可以用公式来表达:

            问题一: x 与 y 的对应关系  y = f(x)

            问题二:你爸爸 = f (你爸爸的特征)

            这当然是一个复杂的问题,因为首先需要将人的特征转化为数字信息,比如图像(图像本质上就是二位的数组),然后根据不同人的特征,对应的不同人的代号,来拟合一个复杂的,一一对应的函数关系,就是现在技术中的一个难题。解决的方法就是 AI :神经网络。

             所以所谓的 AI 技术 ,说到底 是找规律的问题,是拟合复杂函数的问题,是数据处理的问题。

             下面将通过实例,来给大家搭建一个最简单的神经网络:Bp神经网络,来理解 AI 。

     

    第 3 部分  最简单的神经网络Bp神经网络

    1.Bp 神经网络的简单理解

            这里要从名字开始说起了,首先从名称中可以看出,Bp神经网络可以分为两个部分,bp和神经网络。

            bp是 Back Propagation 的简写 ,意思是反向传播。而神经网络,听着高大上,其实就是一类相对复杂的计算网络。举个简单的例子来说明一下,什么是网络。

            看这样一个问题,假如我手里有一笔钱,N个亿吧(既然是假设那就不怕吹牛逼),我把它分别投给5个公司,分别占比 M1,M2,M3,M4,M5(M1到M5均为百分比 %)。而每个公司的回报率是不一样的,分别为 A1, A2, A3, A4, A5,(A1到A5也均为百分比 %)那么我的收益应该是多少?这个问题看起来应该是够简单了,你可能提笔就能搞定  收益 = N*M1*A1 + N*M2*A2+N*M3*A3+N*M4*A4+N*M5*A5 。这个完全没错,但是体现不出水平,我们可以把它转化成一个网络模型来进行说明。如下图:

            图有点丑,领会精神,领会精神。上面的问题是不是莫名其妙的就被整理成了一个三层的网络,N1到N5表示每个公司获得的钱,R表示最终的收益。R = N*M1*A1 + N*M2*A2+N*M3*A3+N*M4*A4+N*M5*A5 。我们可以把 N 作为输入层 ,R作为输出层,N1到N5则整体作为隐藏层,共三层。而M1到M5则可以理解为输入层到隐藏层的权重,A1到A5为隐藏层到输出层的权重。

            这里提到了四个重要的概念 输入层(input) , 隐藏层 (hidden),输出层(output)和权重(weight) 。而所有的网络都可以理解为由这三层和各层之间的权重组成的网络,只是隐藏层的层数和节点数会多很多。

            输入层:信息的输入端,上图中 输入层 只有 1 个节点(一个圈圈),实际的网络中可能有很多个

            隐藏层:信息的处理端,用于模拟一个计算的过程,上图中,隐藏层只有一层,节点数为 5 个。

            输出层:信息的输出端,也就是我们要的结果,上图中,R 就是输出层的唯一一个节点,实际上可能有很多个输出节点。

            权重:连接每层信息之间的参数,上图中只是通过乘机的方式来体现。

            在上面的网络中,我们的计算过程比较直接,用每一层的数值乘以对应的权重。这一过程中,权重是恒定的,设定好的,因此,是将 输入层N 的 信息 ,单向传播到 输出层R 的过程,并没有反向传播信息,因此它不是神经网络,只是一个普通的网络。

            而神经网络是一个信息可以反向传播的网络,而最早的Bp网络就是这一思想的体现。先不急着看Bp网络的结构,看到这儿你可能会好奇,反向传播是什么意思。再来举一个通俗的例子,猜数字:

            当我提前设定一个数值 50,让你来猜,我会告诉你猜的数字是高了还是低了。你每次猜的数字相当于一次信息正向传播给我的结果,而我给你的提示就是反向传播的信息,往复多次,你就可以猜到我设定的数值 50 。 这就是典型的反向传播,即根据输出的结果来反向的调整模型,只是在实际应用中的Bp网络更为复杂和数学,但是思想很类似。

    2.Bp 神经网络的结构与数学原理(可以不细看)

            此节的内容 极!其!重!要!但是要涉及到一些数学,所以我尽量用人话去跟大家细细解释,并且结合实例来给大家进行一下分析。

            如果你不想看太多的推导和数学,那么只需要大概理解 Bp 网络的运行思想就好:我们知道,一个函数是由自变量x和决定它的参数θ组成。比如 y=ax + b 中,a,b为函数的固定参数 θ ,x为自变量。那么对于任意一个函数我们可以把它写成 y = f(θ,x)的形式,这里的 θ 代表所有参数的集合[\theta _{1},\theta _{2},\theta _{3},...],x代表所有自变量的集合[x _{1},x _{2},x _{3},...]。而 Bp 网络的运行流程就是根据已有的 x 与 y 来不停的迭代反推出参数 θ 的过程,这一过程结合了最小二乘法与梯度下降等特殊的计算技巧。这一节看到这儿就基本上可以了,但是如果还想继续深入理解,可以跟着思路,往下接着看。

           事实上,这些内容已经被各路神仙们写烂了,因为 Bp网络对于 AI 技术来说,实在太基础,太重要,但是由于在实际学习中,我也遇到过一些困难,现在根据我的学习过程和理解过程,还是要再拿出来写一遍。大神们勿喷···

             还是老样子,先来看一个问题,找到下列数据中,y 与 x1,x2,x3的关系,即 y = f(x1,x2,x3)的数学表达式。 

    表 3.1
    x1x2x3y
    1122
    1236
    21612
    52550
    83496
    774196
    777343
    1383312
    61011660
    130170
    147121176

            这里一共是 11 组数据(数据量很少),很明显 y 是关于 x1,x2,x3 的三元函数,通常情况下,想要通过一套固定的套路来拟合出一个三元函数的关系式,是一件很复杂的事。而实际问题中的参数往往不止三个,可能成千上百,也就是说 决定 y 的参数会有很多,这样的问题更是复杂的很,用常规的方法去拟合,几乎不可能,那么换一种思路,用 Bp神经网络的方法来试一下。

            根据上表给出的条件和问题,我们先来分析一下。首先,我们的输入信息是 3 个参数,x1,x2,x3 。输出结果是 1 个数 y 。那么可以画一个这样的关系网路图(直接手画了,凑合看吧···):

            在这个网络中,输入层(input )有三个节点(因为有三个参数),隐藏层(hidden )先不表示,输出层(output )有1个节点(因为我们要的结果只有一个 y )。那么关键的问题来了,如何进行这一通操作,它的结构究竟是怎样的?

         2.1 正向传播

            正向传播就是让信息从输入层进入网络,依次经过每一层的计算,得到最终输出层结果的过程。

            我直接把设计好的结构图给大家画出来,然后再一点一点地解释。结构如下:

            看到这儿你可能会有点懵,不过不要紧,一步一步来分析。先来看网络的结构,输入层(input )没有变,还是三个节点。输出层(input )也没有变。重点看隐藏层(hidden ),就是图中红色虚线框起的部分,这里我设计了一个隐藏层为两层的网络,hidden_1和hidden_2 ,每层的节点为 2 个,至于为什么是两层,节点数为什么是 2 两个 ,这里你只需要知道,实验证明,解决这个问题,这样的网络就够用了。具体的一会儿讲。

            关键看一下连线代表的意义,和计算过程。可以从图上看到,每层的节点都与下一层的每个节点有一一对应的连线,每条连线代表一个权重,这里你可以把它理解为信息传输的一条通路,但是每条路的宽度是不一样的,每条通路的宽度由该通道的参数,也就是该通路的权重来决定。为了说明这个问题,拿一个节点的计算过程来进行说明,看下图:

            这上上图中的一部分,输入层(input )与 第一层隐藏层(hidden )的第一个节点 H_{1,1}的连接关系。根据上边的图你可能自然的会想到:  H_{1,1} = x_{1}\times u_{1,1}+ x_{2}\times u_{2,1}+ x_{3}\times u_{3,1} 。如果你这么想,那就说明你已经开窍了,不过实际过程要复杂一些。我们可以把 H_{1,1} 这个节点看做是一个有输入,有输出的节点,我们规定输入为 Hi_{1,1} , 输出为 Ho_{1,1} ,则真实的过程如下:

            计算的方法我直接写到图里了,字儿丑,但是应该能看清楚···解释一下,Hi_{1,1}就是x1,x2,x3与各自权重乘积的和,但是为什么非要搞一个 sigmoid() ,这是什么鬼? 其实最早人们在设计网络的时候,是没有这个过程的,统统使用线性的连接来搭建网络,但是线性函数没有上界,经常会造成一个节点处的数字变得很大很大,难以计算,也就无法得到一个可以用的网络。因此人们后来对节点上的数据进行了一个操作,利用sigmoid()函数来处理,使数据被限定在一定范围内。此外sigmoid函数的图像是一个非线性的曲线,因此,能够更好的逼近非线性的关系,因为绝大多数情况下,实际的关系是非线性的。sigmoid在这里被称为 激励函数 ,这是神经网络中的一个非常重要的基本概念。下面来具体说一下什么是 sigmoid() 函数。

            不作太具体的分析,直接看公式和图像:

            图像来自百度百科,可以看到sigmoid函数能够将函数限制在 0到1 的范围之内。

            这里还要进行一下说明,sigmoid 是最早使用的激励函数,实际上还有更多种类的激励函数 ,比如 Relu ,tanh 等等,性质和表达式各有不同,以后再说,这里先用 sigmoid 来说明。

            如果说看到这儿,你对 激励函数 这个概念还是不太懂的话 ,没关系,可以假装自己明白了,你就知道这个东西很有用,里面必有道道就行了,以后慢慢体会,慢慢理解,就行了。接着往下看。

            刚刚解释了一个节点的计算过程,那么其他节点也就可以举一反三,一一计算出来。现在我们来简化一下网络。我们可以把x1,x2,x3作为一个向量 [x1,x2,x3] ,权重矩阵 u 也作为一个 3x2 的矩阵 ,w 作为一个 2x2 的矩阵 ,v作为一个 2x1 的矩阵,三个矩阵如下:

             可以看到这三个矩阵与网络中的结构图中是一一对应的。下面我们把隐藏层与输出层也写成矩阵的形式:

            可以看到这两层隐藏层(hidden)的输入Hi 与 Ho 均为 1x2 的矩阵,输出层(output )为 1x1 的矩阵。下面就可以把网络简化为下面的结构:

            根据我们刚才讲过的每个节点的计算方法,以及我们简化后的网络,则可以将整个计算过程等效的化为以下几个矩阵相城的步骤(矩阵相乘是怎么会回事,请复习线性代数...):

            注意:下式中,除sigmoid代表激励函数以外,其余各个符号都代表一个矩阵(或者向量),而非常数,乘积符号“ x ”代表常规的矩阵乘法计算。

            H_{i}^{1} = x \times u                     ※ 由于矩阵 x 维度为 1*3 ,u 维度为 3*2 ,所以自然得到维度为1*2的矩阵(或者向量) H_{i}^{1}

            H_{o}^{1} = {\color{Blue} sigmoid}(H_{i}^{1}+h_{b}^{1})      ※ 维度不变

            H_{i}^{2} = H_{o}^{1} \times w                 ※ (1*2) x (2*2) →(1*2) 括号内为各矩阵维度

            H_{o}^{2} = {\color{Blue} sigmoid}(H_{i}^{2}+h_{b}^{2})      ※ 维度不变

            y_{i} = H_{o}^{2} \times v                     ※ (1*2) x (2*1) →(1*1)  括号内为各矩阵维度

            y_{o} = {\color{Blue} sigmoid}(y_{i} + y_{b})

            注意:细心的小伙伴应该发现公式中出现了几个之前没有提到的符号 h_{b}^{1}h_{b}^{2}y_{b} 。它们也各自代表一个矩阵,它们的概念为阈值,通常用符号b来表示。阈值的意义是,每个节点本身就具有的一个数值,设置阈值能够使网络更快更真实的去逼近一个真实的关系。

            以上这个过程,就是该网络的信息进行了一次 正向传播 

         2.2 反向传播

            那么有正向传播,就必须得有反向传播,下面来讲一下 反向传播 的过程。首先明确一点,反向传播的信息是什么,不卖关子,直接给答案,反向传播的信息是误差,也就是 输出层(output )的结果 与 输入信息 x 对应的真实结果 之间的差距(表达能力比较差,画个图说明...)。

             拿出上文的数据表中的第一组数据  x1 = 1,x2=1,x3=2,y=2 为例。

            假设我们将信息x1,x2,x3 输入给网络,得到的结果为 y_{out} = 8 ,而我们知道真实的 y 值为 2,因此此时的误差为 |y_{out}-y|  ,也就是 6 。 真实结果与计算结果的误差被称作 损失 loss , loss = |y_{out} - y|  记作 损失函数 。这里有提到了一个很重要的概念,损失函数,其实在刚才的例子中,损失函数 loss = |y_{out} - y|  只是衡量误差大小的一种方式,称作L1损失(先知道就行了),在实际搭建的网络中,更多的用到的损失函数为 均方差损失,和交叉熵损失。原则是分类问题用交叉熵,回归问题用均方差,综合问题用综合损失,特殊问题用特殊损失···以后慢慢说吧,因为损失函数是一个超级庞大的问题。

            总之我们先知道,损失函数 loss 是一个关于 网络输出结果 y_{out} 与真实结果 y 的,具有极小值的函数 。那么我们就可以知道,如果一个网络的计算结果 y_{out} 与 真是结果 y 之间的损失总是很小,那么就可以说明这个网络非常的逼近真实的关系。所以我们现在的目的,就是不断地通过调整权重u,w,v(也就是网络的参数)来使网络计算的结果 y_{out} 尽可能的接近真实结果 y ,也就等价于是损失函数尽量变小。那么如何调整u,w,v 的大小,才能使损失函数不断地变小呢?这理又要说到一个新的概念:梯度下降法 

            梯度下降法 是一个很重要很重要的计算方法,要说明这个方法的原理,就又涉及到另外一个问题:逻辑回归。为了简化学习的过程,不展开讲,大家可以自己去搜一下逻辑回归,学习一下。特别提醒一下,逻辑回归是算法工程师必须掌握的内容,因为它对于 AI 来说是一个很重要的基础。下面只用一个图(图片来自百度)进行一个简单地说明。

            假设上图中的曲线就是损失函数的图像,它存在一个最小值。梯度是一个利用求导得到的数值,可以理解为参数的变化量。从几何意义上来看,梯度代表一个损失函数增加最快的方向,反之,沿着相反的方向就可以不断地使损失逼近最小值,也就是使网络逼近真实的关系。

            那么反向传播的过程就可以理解为,根据 损失loss ,来反向计算出每个参数(如 u_{1,1} ,u_{1,2} 等)的梯度 d(u_{1,1}) ,d(u_{1,2}) ....等等,再将原来的参数分别加上自己对应的梯度,就完成了一次反向传播。

            来看看 损失loss 如何完成一次反向传播,这里再定义一些变量 H_{e}^{1} , H_{e}^{2} 和 y_{e} 。注意:它们都代表矩阵(向量),而非一个数值。它们分别代表第一层,第二层隐藏层,以及输出层每个神经元节点反向输出的值。dv,dw,du,dh_{b}^{1},dh_{b}^{2},dy_{b} 分别代表权值矩阵与阈值矩阵对应的梯度矩阵,用符号 \delta 代表损失,\sigma {}'()来表示sigmoid函数的导数。这里只简单的说一下计算公式,推导过程后边讲。

            计算梯度,注意:下式中未标红的都代表一个矩阵(或者向量)标红符号的代表一个常数

            y_{e}= \delta\cdot (\sigma {}'(y_{i}+y_{b}))

            dv= (y_{e}\times y_{i})^{T}

            dy_{b} = y_{e}

            H_{e}^{2} = (v\times y_{e})\cdot (\sigma {}'(H_{i}^{2}+h_{b}^{2}))

            dw= (H_{i}^{2})^{T}\times H_{e}^{2}

            dh_{b}^{2} = H_{e}^{2}

            H_{e}^{1} = (v\times H_{e}^{2})\cdot (\sigma {}'(H_{i}^{1}+h_{b}^{1}))

            du= (H_{i}^{1})^{T}\times H_{e}^{1}

            dh_{b}^{1} = H_{e}^{1}

            更新权值与阈值

            u = u+{\color{Red} \alpha} \cdot du

            w = w+{\color{Red} \alpha} \cdot dw

            v = v+{\color{Red} \alpha} \cdot dv

            y_{b} = y_{b}+{\color{Red} \alpha} \cdot dy_{b}

            h_{b}^{1} = h_{b}^{1} +{\color{Red} \alpha} \cdot dh_{b}^{1}

            h_{b}^{2} = h_{b}^{2} +{\color{Red} \alpha} \cdot dh_{b}^{2}

            公式中的 乘号 “ x ”表示常规的矩阵乘积运算,运算后会发生维度的变化。 符号 “ · ” 表示按位乘积,运算后维度不变。

            以上就是一次完整的反向传播过程,需要说明的是,上式当中用到了一个符号 \alpha ,这又是一个重要的概念,学习率,一个小于1的实数,它的大小会影响网络学习的速率以及准确度。可以把它理解为梯度下降时的步长。

            反向传播过程实际上还是有点复杂的,下面我来简单说一下为什么梯度是这样求的。

            我们知道,整个网络可以简化成一个函数 f(x) = \theta _{1}\times x_{1}+\theta _{2}\times x_{2}+\theta _{3}\times x_{3}+...,也就是说这个函数的表达式,主要由各个参数 \theta _{i} 来决定,而现在为了确定网络的参数,则可以把 \theta _{i} 作为函数的自变量,而x作为参数,对 \theta _{i} 求偏导    \frac{\partial f(\theta )}{\partial \theta } ,这个偏导的结果就是该参数 \theta _{i} 对应的梯度,这个思想实际上来自于最小二乘法,反正求完就是上边式子中的结果,这里不再进行推导。

         2.3 网络的训练

            通过一次正向传播,和一次反向传播,我们就可以将网络的参数更新一次,所谓训练网络,就是让正向传播和反向传播不断的往复进行,不断地更新网络的参数,最终使网络能够逼近真实的关系。

            理论上,只要网络的层数足够深,节点数足够多,可以逼近任何一个函数关系。但是这比较考验你的电脑性能,事实上,利用 Bp 网络,能够处理的数据其实还是有限的,比如 Bp 网络在图像数据的识别和分类问题中的表现是很有限的。但是这并不影响 Bp 网络是一种高明的策略,它的出现也为后来的 AI 技术做了重要的铺垫。

    3.Bp 神经网络的代码实现

            回到 表 3.1 中的数据,将用 python 来实现一个 Bp 网络 ,对数据的关系建立一个网络模型。

            这里有几点需要说明,首先在数据进入网络之前,要先进行归一化处理,即将数据除以一个数,使它们的值都小于 1 ,这样做的目的是避免梯度爆炸。其次为了更好、更快的收敛得到准确的模型,这里采用了对数据进行特征化的处理。最后,这段代码中用到的激励函数是Relu,并非我们之前所讲的 sigmoid ,因为Relu的计算速度更快,更容易收敛。

            这里有几个参数和数组需要说明,其中 p_s 中的数组代表 表 3.1 中 11组数据的 [x1,x2,x3] ,t_s代表对应的 y 。p_t 与t_t用来存放测试网络训练效果的 测试数据集 。我们用p_s与t_s来训练 Bp 网络 ,用 p_t 与 t_t 来检验训练的效果。表 3.1 的数据中,y 与 x1,x2,x3 的对应关系实际上是 y = x1 * x2 * x3 。

            代码如下:

    import time
    from numpy import *
    
    
    ######## 数据集 ########
    
    p_s = [[1,1,2],[1,2,3],[2,1,6],[5,2,5],[8,3,4],[7,7,4],[7,7,7],[13,8,3],[6,10,11],[13,0,17],[14,7,12]]              # 用来训练的数据集 x
    t_s = [[2],[6],[12],[50],[96],[196],[343],[312],[660],[0],[1176]]   # 用来训练的数据集 y
    
    p_t = [[6,9,1017],[2,3,4],[5,9,10]]      # 用来测试的数据集 x_test    
    t_t = [[54918],[24],[450]]               # 用来测试的数据集 对应的实际结果 y_test                                                                        
    
    ######## 超参数设定 ########
    
    n_epoch = 20000             # 训练次数
    
    HNum = 2;                   # 各层隐藏层节点数
    
    HCNum = 2;                  # 隐藏层层数
    
    AFKind = 3;                 # 激励函数种类
    emax = 0.01;                # 最大允许均方差根
    LearnRate = 0.01;           # 学习率
    
    ######## 中间变量设定 ########
    TNum = 7;                   # 特征层节点数 (特征数)
    
    SNum = len(p_s);            # 样本数
    
    INum = len(p_s[0]);         # 输入层节点数(每组数据的维度)
    ONum = len(t_s[0]);         # 输出层节点数(结果的维度)
    StudyTime = 0;              # 学习次数
    KtoOne = 0.0;               # 归一化系数
    e = 0.0;                    # 均方差跟
    
    ######################################################### 主要矩阵设定 ######################################################
    
    I = zeros(INum);
    
    Ti = zeros(TNum);
    To = zeros(TNum);
    
    Hi = zeros((HCNum,HNum));
    Ho = zeros((HCNum,HNum));
    
    Oi = zeros(ONum);
    Oo = zeros(ONum);
    
    Teacher = zeros(ONum);
    
    u = 0.2*ones((TNum,HNum))                  # 初始化 权值矩阵u
    w = 0.2*ones(((HCNum-1,HNum,HNum)))        # 初始化 权值矩阵w
    v = 0.2*ones((HNum,ONum))                  # 初始化 权值矩阵v
    
    dw = zeros((HCNum-1,HNum,HNum))
    
    Hb = zeros((HCNum,HNum));
    Ob = zeros(ONum);
    
    He = zeros((HCNum,HNum));
    Oe = zeros(ONum);
    
    p_s = array(p_s)
    t_s = array(t_s)
    p_t = array(p_t)
    
    ################################# 时间参数 #########################################
    
    time_start = 0.0
    time_gyuyihua = 0.0
    time_nnff = 0.0
    time_nnbp = 0.0
    time_begin = 0.0
    
    time_start2 = 0.0
    
    time_nnff1 = 0.0
    time_nnff2 = 0.0
    time_nnbp_v = 0.0
    time_nnbp_w = 0.0
    time_nnbp_u = 0.0
    time_nnbp_b = 0.0
    
    
    
    ######################################################### 方法 #######################################################
    
    def Calcu_KtoOne(p,t):                         # 确定归一化系数
    	p_max = p.max();
    	t_max = t.max();
    	return max(p_max,t_max);
    	
    def trait(p):                                  # 特征化
    	t = zeros((p.shape[0],TNum));
    	for i in range(0,p.shape[0],1):
    		t[i,0] = p[i,0]*p[i,1]*p[i,2]
    		t[i,1] = p[i,0]*p[i,1]
    		t[i,2] = p[i,0]*p[i,2]
    		t[i,3] = p[i,1]*p[i,2]
    		t[i,4] = p[i,0]
    		t[i,5] = p[i,1]
    		t[i,6] = p[i,2]
    	
    	return t
    	
    def AF(p,kind):   # 激励函数
    	t = []
    	if kind == 1:   # sigmoid
    		pass
    	elif kind == 2:   # tanh
    		pass
    	elif kind == 3:    # ReLU
    
    		return where(p<0,0,p)
    	else:
    		pass
    
    
    		
    def dAF(p,kind):   # 激励函数导数
    	t = []
    	if kind == 1:   # sigmoid
    		pass
    	elif kind == 2:   # tanh
    		pass
    	elif kind == 3:    # ReLU
    		
    		return where(p<0,0,1) 
    	else:
    		pass
    
    		
    		
    def nnff(p,t):
    	pass
    	
    def nnbp(p,t):
    	pass
    	
    
    def train(p,t):                                # 训练
    	
    	global e
    	global v
    	global w
    	global dw
    	global u	
    	global I 
    	global Ti 
    	global To 
    	global Hi 
    	global Ho 
    	global Oi 
    	global Oo 
    	global Teacher 
    	global Hb 
    	global Ob 
    	global He 
    	global Oe
    	global StudyTime
    	global KtoOne
    	
    	global time_start
    	global time_gyuyihua
    	global time_nnff
    	global time_nnbp	
    	global time_start2
    	global time_nnff1
    	global time_nnff2
    	global time_nnbp_v
    	global time_nnbp_w
    	global time_nnbp_u
    	global time_nnbp_b
    	
    	
    	time_start = time.clock()
    	
    	
    	e = 0.0
    	p = trait(p)
    		
    	KtoOne = Calcu_KtoOne(p,t)
    	
    	time_gyuyihua += (time.clock()-time_start)
    	
    	time_start = time.clock()
    		
    	for isamp in range(0,SNum,1):
    		To = p[isamp]/KtoOne
    		Teacher = t[isamp]/KtoOne
    		
    		
    		################ 前向 nnff #############################
    			
    		time_start2 = time.clock()
    		######## 计算各层隐藏层输入输出 Hi Ho ########
    		
    		for k in range(0,HCNum,1):
    			if k == 0:
    				Hi[k] = dot(To,u)
    				Ho[k] = AF(add(Hi[k],Hb[k]),AFKind)
    			else:
    				Hi[k] = dot(Ho[k-1],w[k-1])
    				Ho[k] = AF(add(Hi[k],Hb[k]),AFKind)
    		
    		
    		time_nnff1 += (time.clock()-time_start2)	
    		time_start2 = time.clock()
    		
    		########   计算输出层输入输出 Oi Oo    ########
    		Oi = dot(Ho[HCNum-1],v)
    		Oo = AF(add(Oi,Ob),AFKind)
    		
    		
    		time_nnff2 += (time.clock()-time_start2)	
    		time_start2 = time.clock()	
    		time_nnff += (time.clock()-time_start)	
    		time_start = time.clock()
    				
    		################ 反向 nnbp #############################
    		
    		######## 反向更新 v ############
    		
    		Oe = subtract(Teacher,Oo)
    		Oe = multiply(Oe,dAF(add(Oi,Ob),AFKind))
    						
    		e += sum(multiply(Oe,Oe))
    		
    		
    		
    		#### v 梯度 ####		
    		
    		dv = dot(array([Oe]),array([Ho[HCNum-1]])).transpose()			  # v 的梯度
    
    		v = add(v,dv*LearnRate)    # 更新 v
    		
    		time_nnbp_v += (time.clock()-time_start2)
    	
    		time_start2 = time.clock()
    		
    		######## 反向更新 w #############
    		He = zeros((HCNum,HNum))
    	
    		for c in range(HCNum-2,-1,-1):
    			if c == HCNum-2:
    				He[c+1] = dot(v,Oe)
    				He[c+1] = multiply(He[c+1],dAF(add(Hi[c+1],Hb[c+1]),AFKind))
    				
    				
    				#dw[c] = dot(array([He[c+1]]),array([Ho[c]]).transpose())
    				dw[c] = dot(array([Ho[c]]).transpose(),array([He[c+1]]))
    				#dw[c] = dw[c].transpose()  #@@@@@@ 若结果不理想,可尝试用此条语句
    				
    				w[c] = add(w[c],LearnRate*dw[c])
    				
    		
    				
    			else:
    				He[c+1] = dot(w[c+1],He[c+2])
    				He[c+1] = multiply(He[c+1],dAF(add(Hi[c+1],Hb[c+1]),AFKind))
    				
    				dw[c] = dot(array([Ho[c]]).transpose(),array([He[c+1]]))	
    				
    				w[c] = add(w[c],LearnRate*dw[c])
    
    		time_nnbp_w += (time.clock()-time_start2)
    	
    		time_start2 = time.clock()
    		
    		######## 反向更新 u #############
    		
    		He[0] = dot(w[0],He[1])
    		He[0] = multiply(He[0],dAF(add(Hi[0],Hb[0]),AFKind))
    				
    				
    		du = dot(array([To]).transpose(),array([He[0]]))
    				
    		u = add(u,du)
    		
    		time_nnbp_u += (time.clock()-time_start2)
    	
    		time_start2 = time.clock()
    		
    		######### 更新阈值 b ############
    		
    		Ob = Ob + Oe*LearnRate
    				
    		Hb = Hb + He*LearnRate
    		
    		time_nnbp += (time.clock()-time_start)
    	
    		time_start = time.clock()
    		
    		time_nnbp_b += (time.clock()-time_start2)
    	
    		time_start2 = time.clock()
    	
    	e = sqrt(e)
    
    	
    def predict(p):
    				
    	p = trait(p)
    	p = p/KtoOne
    	p_result = zeros((p.shape[0],1))
    
    	for isamp in range(0,p.shape[0],1):
    		for k in range(0,HCNum,1):
    			if k == 0:
    				Hi[k] = dot(p[isamp],u)
    				Ho[k] = AF(add(Hi[k],Hb[k]),AFKind)
    			else:
    				Hi[k] = dot(Ho[k-1],w[k-1])
    				Ho[k] = AF(add(Hi[k],Hb[k]),AFKind)
    			
    			
    		########   计算输出层输入输出 Oi Oo    ########
    		Oi = dot(Ho[HCNum-1],v)
    		Oo = AF(add(Oi,Ob),AFKind)
    		Oo = Oo*KtoOne
    		p_result[isamp] = Oo
    	return p_result
    
    	
    time_begin = time.clock()
    
    for i in range(1,n_epoch,1):
    	if i%1000 == 0:
    		print('已训练 %d 千次 ,误差均方差 %f'%((i/1000),e))
    	train(p_s,t_s)
    print('训练完成,共训练 %d 次,误差均方差 %f'%(i,e))
    
    print('共耗时: ',time.clock()-time_begin)
    
    print()
    		
    result = predict(p_t)
    
    print('模型预测结果 : ')
    for i in result:
    	print('%.2f'%i)
    		
    print('\n实际结果 : ')	
    for i in t_t:
    	print(i)
    		
    

            运行代码后,得到的结果如下图:

     

            可以看到,经过训练后,该 Bp 网络确实从原始数据中学到了特征 , 并且较为准确地对测试数据进行了推测。

            此外还要说明,此段代码历史较为悠久,因此很多地方写的很不规范(很多地方保持了C的习惯···实际上是多余的),符号使用的也比较混乱(但是实在懒得整理),仅拿来供大家参考和理解,望小伙伴们见谅。

    4.Bp 神经网络的经验总结

            以上内容对 Bp 网络的基本用法和数学关系 进行了讲解。下面有几个重要的知识点,需要特别指出:

            a.对于一个神经网络来说,更宽更深的网络,能够学到更加复杂的特征,其能够解决的问题也就越复杂,但是其计算过程也越繁琐,参数越多,越容易出现过拟合的情况(过拟合即网络过度学习了数据的特征,将噪声也同时考虑到了网络中,造成网络只在训练集上表现良好,而无法泛化到其他数据上,说白了就是这个网络已经学傻了...),因此要根据数据的实际情况来设计网络的层数,节点数,激励函数类型 以及 学习率。

            b.对于一个神经网络来说,用来训练神经网络的数据集的质量,很大程度上决定了网络的预测效果。数据越丰富,神经网络越能够贴近实际关系,泛化能力越强。

            c.Bp神经网络是区别于传统数据处理的一种方法,其特点在于寻找数据之间的相关性,并非严格地数学关系,因此是一种有效但是并非严格地网络。对于实际问题的处理非常有用,但不能作为严谨数学计算的方法。

     

            Bp网络的出现,为后来的 AI 技术提供了理论基础,无论是 AlphaGo ,计算机视觉,还是自然语言处理等复杂问题,都可以理解为这一结构的升级和变种(不过升级幅度有点大,变化样式有点多···)。因此这一对于这一网络的理解,大家应该亲自写写代码,多看一看大神们写的推导过程,深入理解。

    展开全文
  • 世界上最简单的会计书—读书笔记

    万次阅读 2017-12-31 22:39:07
    世界上最简单的会计书 美 Darrell Mullis, Judith Orloff前言本书以一个柠檬汁摊的前世今生,讲述了经营一个企业的过程中会遇到的各种各样与会计相关的知识。正如本书页面文字那样: 摆个果汁摊,钱从何处来?怎么...

    世界上最简单的会计书
    美 Darrell Mullis, Judith Orloff

    前言


    本书以一个柠檬汁摊的前世今生,讲述了经营一个企业的过程中会遇到的各种各样与会计相关的知识。正如本书页面文字那样:

    摆个果汁摊,钱从何处来?怎么花?每杯果汁卖多少钱合适?每天必须卖多少才能保本?总共赚多少钱?要不要扩张?三大基本账务报表——资产负债表、利润表及现金流量表可以为柠檬汁生意提供什么信息?

    以上这些问题,书中都会娓娓道来。

    资产负债表


    本书将以一个孩子经营柠檬汁摊的视角讲述在经营这个小柠檬汁摊的生意中所接触到的财务方面的知识。

    为了跟踪经营柠檬汁摊过程中获得的可观收入,需要一些纸和一支笔,来记录做生意时金钱的流入与流出,这样记录的过程就是会计

    就像在棒球赛中使用记分牌记录比赛双方的成绩一样,我们需要为柠檬汁摊创建一张记账卡片。为了理解生意中的钱是如何流入流出的,需要在卡片上记录两件事:我们有什么谁拥有它

    于是,我们需要在卡片的中间画一条线,左边记录你拥有并且用在生意上的东西,右边记录谁拥有这些东西。此时财务记账的一个重要法则出现了:左边必须等于右边

    把左边表格的标题变为资产(我们有什么),右边表格区分为负债(我们欠别人的钱,为了扩大生产或购置原材料,我们得借点钱)和所有者权益(我们自己的钱)。于是,会计准则出现了:资产=负债+所有者权益

    为了制作可口的柠檬汁,你必须得购买制作柠檬汁的原材料,包括鲜柠檬、白糖等,它们被称作存货。存货是描述原材料、正在加工的在产品和准备出售的产成品的专业术语。存货是一种资产。

    所有工作准备就绪,柠檬汁开卖了!生意非常好,所有柠檬汁抢售而空。你用10美元原材料制作的柠檬汁一共卖了25美元,毛利15美元就产生了。毛利就是用销售收入减去商品成本所得到的结果。此项(我们记为本周盈利)列入所有者权益一栏。

    费用是指那些剔除产品生产成本之外企业经营所需要的花费。无论你调制了多少杯且卖了多少杯柠檬汁,你都必须花费这笔钱。那些诸如玻璃杯租金、广告费、租赁费等虽然与产品的生产不直接相关,但仍需支出的费用都属于该范畴。

    资产负债表是一个快照,记录了某个时刻的经营状态,那么,通常情况下,每做一笔交易都要填一次表吗?当然不用。

    资产负债表的编制时间要求因企业的类别不同而异。银行通常每天都要编制,因其每天都要处理大量的现金。其他的一些企业可以按照周、季度、年度来编制。(年度编制被公认为是一个标准的会计期间。)

    利润表


    先来考虑以下问题:

    资产负债表未记录下来但属于本周发生的事情有哪些?
    告诉了你所售商品的成本了吗?也没有。
    这周你购买存货了吗?那你卖掉商品了吗?
    资产负债表告诉你卖了多少存货吗?
    它告诉你赚了多少钱吗?

    资产负债表展示的是瞬间的状况,就像一张快照,但还需要另一张记账卡告诉我们一个期间内的经营情况。一些交易的发生,譬如购买存货、生产产品、销售产品以及费用的产生都发生在一段时间内。它就是利润表。

    利润表又称为运营报表、损益表。利润表有开始和结束。
    利润表将成本分为两类:商品销售成本,其囊括了产品生产过程中所有的支出;费用,其囊括了企业经营中与产品生产不直接相关的其他支出。对于那些没有有形产品的公司(即服务类行业),这两类称为营业成本(又称服务成本)及费用。

    利润表的编制目的在于记录销售收入减去销售成本而获得企业某段时期的毛利,然后,再剔除所发生的其他费用,得到净利润,又叫纯利润或底线值

    向银行借款而产生的应付票据说明了银行贷给了你现金,杂货店的应付账款说明了杂货店给了你什么?白糖或者说是存货。

    应付票据因收到他人的借款而产生,而应付账款因为赊账购买原材料等物品而产生,这笔欠款需要未来某天偿还。换言之,我们因应付票据而获得现金,因应付账款而获得商品或服务。

    我们称这些鲜柠檬和白糖为什么?原材料。
    那柠檬汁又叫什么?产成品。
    正在制作柠檬汁时,这类存货称为什么?在产品。

    对于制造企业来说,在产品在存货中占有很大的份额。

    权责发生制下,我们都是在交易事项的实际发生时对它们进行会计核算,而不论是否收到或支付现金。权责发生制不是唯一的核算盈利的方法,你能猜到另一种方法吗?是收付实现制。

    收付实现制核算方法下,交易事项以现金结算时才被记录。但需要明确的是,根据权责发生制,只要交易事项涉及盈利、赊欠及耗用,发生时就被记录,无论是否收到或支付现金。

    我们运用两种方法编制它们。得出了不同的结果吗?是的。权责发生制下是10美元的盈利而收付实现制下是4美元的亏损。

    权责发生制在交易事项发生时便记录会更准确地反映交易的发生。
    收付实现制仅仅是税务上的目的

    有些行业能够使用收付实现制进行核算,有些则不行。资产负债表中的一个项目决定了你是否能够运用收付实现制来核算。对于那些拥有存货的公司来说必须使用权责发生制。

    什么样的公司可以使用收付实现制进行核算?服务行业,如诊所、律师行、会计师事务所、培训公司、咨询公司、房地产中介公司以及保洁公司等,是因为它们没有存货。

    对于那些采用收付实现制的服务类行业,他们因现时计入大量费用,可以少缴纳所得税,延期缴税就意味着税收的减少。

    服务成本与提供的服务直接相关,而费用不与提供服务直接相关,而是公司运营的其他所有开支。

    先进来,先出去,即先进先出法(FIFO)。这意味着第一个进入存货的柠檬将第一个被消耗掉,或被卖出去。

    为何又会使用后进先出法呢?出于税收的目的。盈利少,我们缴的所得税也相应减少。那么你认为哪种方法更便于会计核算?先进先出法。当然,它更简单点儿。所以,请记住,公司选择采用后进先出法的唯一目的在于节税!

    注意:在实际生活中,后进先出法较难且坚持采用的代价较大。只有那些有大量存货的公司才会使用这种方法。在选择采用何种方法对存货计价时,最好向经验丰富的会计师咨询。

    现金流量表


    通常,现金流量表记录的是在一个给定期间内现金的流入和流出。

    固定资产指购得的财产、厂房和设备,这类东西一般不用做出售,在商业周期中,能够反复被使用。

    一般说来,价值大的采购支出使资产增加,从而被放入资产负债表中,即资本化。

    折旧是一项非付现费用。

    这不同于我们卖的保险。当我们预付了保费,第一年消耗掉了1美元的保费,我们能将3美元的保费拿回来吗?不能。如果我们将摊位加上洗涤槽销售出去,能够拿回10美元现金吗?有可能,非常有可能。

    记住,报表的左边是站在我们的角度上看到有什么东西流出了,我们的现金、存货等究竟是多少。报表的右边代表了账面上我们所拥有的东西,或者说左边的资产是由谁提供的。负债表明了我们对外的欠款,权益(包括留存收益)仅仅表明了我们对于这些资产占有的份额。

    一个盈利的公司也会陷入困境吗?绝对有可能。

    因为维持日常经营的是什么?是利润吗?不是。一个企业的日常经营依靠的是现金

    现金和利润是一回事吗?不是。
    什么是企业的核心、驱动力及血脉?现金。
    同样,什么使企业得以运转?现金。

    总结


    我们一直围绕着利润讨论,所以你可能会觉得三大财务报表中,利润表最能清楚地反映出利润的产生。但上一章的内容告诉我们,日常经营的运作依靠的是现金而非利润。所以,哪个更重要——现金还是利润?现金保证了公司的运作,利润是公司经营的最终目标。但利润表中甚至不能反映出现金流的状况。所有这一切是否会使人感到疑惑?

    如果你感觉到了,那非常好。请使自己置身于这样一种矛盾的境地并且去体验一会儿这种不舒服的感觉。置身于这样一种自相矛盾的环境并能成功地解决这种冲突,是经营管理过程中领导艺术的体现。

    利润也可以计量,但它却不真实——仅仅存在于理论中。

    利润额能够较容易且可明确计量,所以它在商业中被用做客观衡量商业经营管理效率、生产力及创新能力的指标。同时,利润也非常容易流失,所以公司领导者不断追求公司的利润率并且总是非常渴望招收到那些能够使公司利润获得最大化的员工。

    但许多雇员并未真正理解利润指标,因而不知道采取何种措施来指导其行为和决策。

    销售收入、销售(服务)成本及费用是影响利润的三大因素。利润的定义为销售收入超过提供商品或服务的成本及公司经营费用的差额。公司的销售收入衡量了顾客愿意花费多少(现金)去购买其产品或服务。两大成本项目衡量了公司员工在决策及经营管理方面的动机和效率。


    最后,运用标准比率,参照该趋势分析表,请回答如下问题:

    1.我们盈利了吗?
    2.净利率的变动趋势,是上升还是下降?
    3.如果净利率呈下降趋势,相应地,成本销售收入比率和费用销售收入比率中的一个或二者都会对此有所反映吗?
    4.经营中发生了什么,导致了问题的出现?
    5.作为公司的领导者,你是如何解决问题的?

    展开全文
  • 相信只要是程序员应该都听过nginx服务器了,这个超级优秀nginx一个很重要的功能就是反向代理。那么有小伙伴要问了,有反向代理肯定就有正向代理,那么他们两个有什么区别呢? 先讲一下正向代理,举个例子,最近...

    简介

    爱因斯坦说过:所有的伟大,都产生于简单的细节中。netty为我们提供了如此强大的eventloop、channel通过对这些简单东西的有效利用,可以得到非常强大的应用程序,比如今天要讲的代理。

    代理和反向代理

    相信只要是程序员应该都听过nginx服务器了,这个超级优秀nginx一个很重要的功能就是做反向代理。那么有小伙伴要问了,有反向代理肯定就有正向代理,那么他们两个有什么区别呢?

    先讲一下正向代理,举个例子,最近流量明星备受打击,虽然被打压,但是明星就是明星,一般人是见不到的,如果有人需要跟明星对话的话,需要首先经过明星的经纪人,有经纪人将话转达给明星。这个经纪人就是正向代理。我们通过正向代理来访问要访问的对象。

    那么什么是反向代理呢?比如现在出现了很多人工智能,假如我们跟智能机器人A对话,然后A把我们之间的对话转给了后面的藏着的人,这个人用他的智慧,回答了我们的对话,交由智能机器人A输出,最终实现了人工智能。这个过程就叫做反向代理。

    netty实现代理的原理

    那么在netty中怎么实现这个代理服务器呢?

    首选我们首先代理服务器是一个服务器,所以我们需要在netty中使用ServerBootstrap创建一个服务器:

    EventLoopGroup bossGroup = new NioEventLoopGroup(1);
            EventLoopGroup workerGroup = new NioEventLoopGroup();
            try {
                ServerBootstrap b = new ServerBootstrap();
                b.group(bossGroup, workerGroup)
                 .channel(NioServerSocketChannel.class)
                 .handler(new LoggingHandler(LogLevel.INFO))
                 .childHandler(new SimpleDumpProxyInitializer(REMOTE_HOST, REMOTE_PORT))
                 .childOption(ChannelOption.AUTO_READ, false)
                 .bind(LOCAL_PORT).sync().channel().closeFuture().sync();
    

    在这个local服务器中,我们传入ProxyInitializer。在这个handler初始化器中,我们传入自定义的handler:

        public void initChannel(SocketChannel ch) {
            ch.pipeline().addLast(
                    new LoggingHandler(LogLevel.INFO),
                    new SimpleDumpProxyInboundHandler(remoteHost, remotePort));
        }
    

    在自定义的handler中,我们使用Bootstrap创建一个client,用来连接远程要代理的服务器,我们将这个client端的创建放在channelActive方法中:

    // 开启outbound连接
            Bootstrap b = new Bootstrap();
            b.group(inboundChannel.eventLoop())
             .channel(ctx.channel().getClass())
             .handler(new SimpleDumpProxyOutboundHandler(inboundChannel))
             .option(ChannelOption.AUTO_READ, false);
            ChannelFuture f = b.connect(remoteHost, remotePort);
    

    然后在client建立好连接之后,就可以从inboundChannel中读取数据了:

    outboundChannel = f.channel();
            f.addListener(future -> {
                if (future.isSuccess()) {
                    // 连接建立完毕,读取inbound数据
                    inboundChannel.read();
                } else {
                    // 关闭inbound channel
                    inboundChannel.close();
                }
            });
    

    因为是代理服务,所以需要将inboundChannel读取的数据,转发给outboundChannel,所以在channelRead中我们需要这样写:

        public void channelRead(final ChannelHandlerContext ctx, Object msg) {
            // 将inboundChannel中的消息读取,并写入到outboundChannel
            if (outboundChannel.isActive()) {
                outboundChannel.writeAndFlush(msg).addListener((ChannelFutureListener) future -> {
                    if (future.isSuccess()) {
                        // flush成功,读取下一个消息
                        ctx.channel().read();
                    } else {
                        future.channel().close();
                    }
                });
            }
        }
    

    当outboundChannel写成功之后,再继续inboundChannel的读取工作。

    同样对于client的outboundChannel来说,也有一个handler,在这个handler中,我们需要将outboundChannel读取到的数据反写会inboundChannel中:

        public void channelRead(final ChannelHandlerContext ctx, Object msg) {
            // 将outboundChannel中的消息读取,并写入到inboundChannel中
            inboundChannel.writeAndFlush(msg).addListener((ChannelFutureListener) future -> {
                if (future.isSuccess()) {
                    ctx.channel().read();
                } else {
                    future.channel().close();
                }
            });
        }
    

    当inboundChannel写成功之后,再继续outboundChannel的读取工作。

    如此一个简单的代理服务器就完成了。

    实战

    如果我们将本地的8000端口,代理到www.163.com的80端口,会发生什么情况呢?运行我们的程序,访问http://localhost:8000, 我们会看到下面的页面:

    为什么没有如我们想象的那样展示正常的页面呢?那是因为我们代理过去之后的域名是localhost,而不是正常的www.163.com, 所以服务器端不认识我们的请求,从而报错。

    总结

    本文的代理服务器之间简单的转发请求,并不能够处理上述的场景,那么该怎么解决上面的问题呢? 敬请期待我的后续文章!

    本文的例子可以参考:learn-netty4

    本文已收录于 http://www.flydean.com/35-netty-simple-proxy/

    最通俗的解读,最深刻的干货,最简洁的教程,众多你不知道的小技巧等你来发现!

    欢迎关注我的公众号:「程序那些事」,懂技术,更懂你!

    展开全文
  • 前言 这段时间项目功能写到步进电机这块。...三呆子说人活着要很多很多有意义的,老马问他什么叫有意义的,他嘿嘿一笑,抓了抓头,说有意义的就是好好活。那就好好活吧!如果有需要的人看到这...
  • 最简单直接粗暴的Mothur分析OTU教程

    千次阅读 2020-06-29 16:31:59
    最简单直接粗暴的Mothur分析OTU教程 废话不多说,首先你需要下载Mothur,直接百度去官网下载 第一步:准备需要分析OTU的序列文件(fasta格式) 一般通过载体连接、大肠杆菌克隆、测序得到的16S rRNA序列两侧是有引物...
  • Terraform 使用 - 从最简单例子开始

    万次阅读 2019-04-30 15:40:50
    Terraform 使用 - 从最简单例子开始 https://yanbin.blog/terraform-get-started-with-first-sample/ Terraform 是一个 IT 基础架构自动化编排工具,它的口号是 "Write, Plan, and create Infrastructure as Code...
  • win32开发(最简单的win32代码)

    千次阅读 2017-12-12 08:48:45
     闲话少说,我们今天来学一个最简单的win32代码。如下所示, // tt.cpp : Defines the entry point for the application. // #include "stdafx.h" int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE ...
  • HTML写一个简单网页

    万次阅读 多人点赞 2021-08-18 17:31:32
    最近学习了一点HTML,闲来无写个网页看看,欢迎、改进、留言。 演示地点:跳转到演示地点 一、初始化页面 body,button,dd,dl, dt,form, h1, h2, h3, h4, h5, h6, hr, input, legend, li, ol, p, pre, td, ...
  • 大学计算机系努力的同学都是如何学习的?

    万次阅读 多人点赞 2021-06-21 09:15:04
    经常会被同学们问到这个问题,要怎么努力才能找到好工作? 学习好就能进好公司? 屁! 被学校教育坑的一把鼻涕一把泪的老学长来回答一波。...现在工作近十年,也辗转几个大厂,校招、社招面试也不下于上百场,这
  • 利用Docker镜像确实可以简化编译环境的配置,现在Docker的用处还是挺多的,例如TensorFlow也可以在Docker上玩。有史以来,Android源码编译环境的搭建始终是一件麻烦事儿。...有的童鞋硬着头皮照了,但是由于伟大的G
  • 史上最简单的开发ESP8266物联网小项目的方法

    万次阅读 多人点赞 2019-01-10 18:21:50
    说了要做最简单的,所以我MCU选用51单片机。wifi模块选用ESP8266,服务平台选择iotechn。 第三步:登陆IOTECHN网站 IOTECHN网站 ,登陆后先注册一个账号。 然后点击添加设备 输入你设备的名字和密码...
  • 简单的喜欢长远 平凡中的陪伴心安 懂你的人温暖时间会告诉我们,简单的喜欢长远,平凡中的陪伴心安,懂你的人温暖。看着面带笑容的你,我才发现,生活是这么美好,幸福就在身边。世事如书,我偏爱你这一...
  • 【手把手】制作一个简单的HTML网页

    万次阅读 多人点赞 2020-11-20 19:56:56
    从图中可以看出,body元素分为三层,里面的一层,就是520 x 500的那部分,这个叫做内部真实空间,也就是说,你可以在里面添加其他元素,比如div元素,p元素,a元素等等。然后中间的一层就是paddin
  • 最简单的ssl证书开启HTTPS的方法

    千次阅读 2018-09-01 15:14:58
    最简单的ssl证书开启HTTPS的方法 摘要:在百度云虚拟主机BCH的Nginx环境下将WordPress配置SSL证书将全站开启HTTPS的方法很简单,只要简单的在Wordpress的配置文件wp-config.php里加入一行全站开启HTTPS的代码即可,...
  • 1.简单重复,你就是专家,重复的你用心,你就是赢家;  2.只要你按时到达目的地,很少有人在乎你开的是奔驰还是手扶拖拉机;  3.智者受赞美句句反思,愚者受批评时句句反驳;  4.成功时朋友认识了你,失败...
  • 很多小伙伴问我我是如何同时拿到 阿里、字节跳动、腾讯、京东、和美团百万年薪Offer的。今天我们就来简单的聊聊除了技术外,大厂还会看重哪些技能,从本质上说,除了技术,互联网大厂更看重这些基础能力!
  • 如何用html制作一个简单的网页

    千次阅读 多人点赞 2022-07-09 09:37:53
    如何用html制作一个简单的网页
  • 对很多初学者而言,在树莓派或服务器上搭建网站是一件非常头疼的,不仅要在linux上运行命令行,还需要安装各种环境,稍微出点问题就可能前功尽弃。今天我给大家介绍一种简单粗暴无脑的网站搭建...
  • 正确的和正确的做事

    千次阅读 2018-04-17 18:35:09
    正确的事情 正确的事情 总结 序言 今天参加用户体验的分享,在分享过程中演讲者提到,正确的设计比把设计正确更重要。因为对于用户来说,正确的设计才是能够帮助他们的,才是有价值的。他们并不关心...
  • 简简单单股票读书笔记(4/8)

    千次阅读 2022-02-11 22:15:29
    要想在交易中赚钱,做好3件:赚钱交易的比例尽量高、让亏损只亏小钱、在赚钱交易中赚大钱。 交易系统固定考虑的项目有如下一条:判断当前K线是否是危险K线。只要把握这一条,就不会有意料之外的大亏损。 要想在...
  • 仔细想一想,在每天之中,大脑主动或被动的接受了太多的信息,如果没有给信息分出轻重缓急,整理归类,熵值就会不停的增加,进而更加混乱,12月份的时候,经朋友推荐,看了《重要的,只有一件》这本书,曾持续...
  • 第一幕:缘起 听说阎王爷要个生死簿后台管理系统,我们派去了一个程序员…… ...经常会有外行朋友问:看某网站的不错,功能也简单,你帮忙一下? 而这次,面对这样的需求,这个程序员...
  • 简单的网页设计(HTML篇1)

    万次阅读 多人点赞 2019-07-15 13:18:30
    简单的网页设计(HTML篇1) 本节成型网页框架: 代码: <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>给新月的一封回信</title> </head&...
  • 淘宝客网站比较简单,因为它建立好过后,只要设置好PID,所有的商品可以直接在淘宝上采集。甚至有的淘宝客网站,都不需要自己采集,个人站长要的就是推广网站,让人家通过你的网站的链接去领券,然后去购买,你就...
  • 教你用 Python 自制简单版《我的世界》

    千次阅读 多人点赞 2021-11-08 01:03:43
    国外有位叫fogleman的开发者就用Python了这样的一件——自制《我的世界 Minecraft》,谁能想到,仅仅900行的代码,玩起来竟然还像模像样的: 接下来,我们就带你运行这个项目,并对这个开源的小游戏一下简单的...
  • 回想一下刚才的所,拿到一些数据,填进三个普适的、简单的步骤里,然后得到一个能猜房价的方程。Zillow(美国房价预测网站)面临着严重的威胁! 但是有这么几个激动人心的事实: 过去40年里,很多...
  • 2020 年牛逼的 10 门编程语言

    万次阅读 多人点赞 2020-08-20 14:21:03
    先来个简要的概括: Java,服务器端最好的编程语言 C++,通用的编程语言 C,迄今为止,值得信任的编程语言 Python,AI(人工智能)、机器学习方向最佳的编程语言 JavaScript,客户端常用的脚本语言 C#,微软...
  • 怎么用python简单的制作一个网页

    万次阅读 2021-03-18 08:19:13
    用python简单的制作一个网页的方法和详细的操作步骤如下:1、首先,打开sublime text 3并创建一个新的PY文件,如下图所示。2、其次,import os,因为涉及系统文件的路径,因此首先在此处导入系统模块,如下图所示。3...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 787,250
精华内容 314,900
热门标签
关键字:

做最简单的事