当前位置:首页 > 程序设计 > python3电子书网盘下载
深度学习入门:基于Python的理论与实现 深度学习入门:基于Python的理论与实现
k03059164

k03059164 提供上传

资源
49
粉丝
7
喜欢
272
评论
17

    深度学习入门:基于Python的理论与实现 PDF 含源码超清版

    python3电子书
    • 发布时间:

    给大家带来的一篇关于python3相关的电子书资源,介绍了关于深度学习、Python理论方面的内容,本书是由人民邮电出版社出版,格式为PDF,资源大小13.6 MB,斋藤康毅编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:8.4,更多相关的学习资源可以参阅VB微商React NativepyinotifyHCNA技术、等栏目。

  • 深度学习入门:基于Python的理论与实现 PDF 下载
  • 下载地址:https://pan.baidu.com/s/10r2wIUe4MOOxhhfAoYVuJ
  • 提取码:wid7
  • 深度学习入门:基于Python的理论与实现

    深度学习入门:基于Python的理论与实现 电子书封面

    读者评价

    基于python深度学习,从零开始学深度学习的明智之选
    这是真正从0基础,尤其从数学基础比较差的角度去引用读者的书,全书没有冗长的数学公式,从最简单的神经元开始一步一步教你实现深度神经网络,很值得推荐的一本书
    确实讲的不错,核心入门,还全程带基于numpy的亲手实现,不过有点浅显
    科普完成,不太复杂的代码也能达到很高的手写数字识别率,还是挺神奇的。
    想扩宽业务水平,翻了一下,还要补下python,另外好多数学公式。。。还有极限公式

    内容介绍

    本书是深度学习真正意义上的入门书,深入浅出地剖析了深度学习的原理和相关技术。书中使用Python3,尽量不依赖外部库或工具,从基本的数学知识出发,带领读者从零创建一个经典的深度学习网络,使读者在此过程中逐步理解深度学习。书中不仅介绍了深度学习和神经网络的概念、特征等基础知识,对误差反向传播法、卷积神经网络等也有深入讲解,此外还介绍了深度学习相关的实用技巧,自动驾驶、图像生成、强化学习等方面的应用,以及为什么加深层可以提高识别精度等疑难的问题。 本书适合深度学习初学者阅读,也可作为高校教材使用。

    目录

    • 译者序xiii
    • 前言xv
    • 第1 章 Python入门1
    • 第2 章 感知机21
    • 第3章 神经网络37
    • 第4章 神经网络的学习81
    • 第5章 误差反向传播法121
    • 第6章 与学习相关的技巧163
    • 第7章 卷积神经网络201
    • 第8章 深度学习235
    • 附录ASoftmax-with-Loss 层的计算图267
    • 参考文献279

    读书笔记

    深度辨析Python的eval()与exec()的方法

    Python 提供了很多内置的工具函数(Built-in Functions),在最新的 Python 3 官方文档中,它列出了 69 个。

    大部分函数是我们经常使用的,例如 print()、open() 与 dir(),而有一些函数虽然不常用,但它们在某些场景下,却能发挥出不一般的作用。内置函数们能够被“提拔”出来,这就意味着它们皆有独到之处,有用武之地。

    因此,掌握内置函数的用法,就成了我们应该点亮的技能。

    在《Python进阶:如何将字符串常量转为变量? 》这篇文章中,我提到过 eval() 和 exec() ,但对它们并不太了解。为了弥补这方面知识,我就重新学习了下。这篇文章是一份超级详细的学习记录,系统、全面而深入地辨析了这两大函数。

    1、eval 的基本用法

    语法:eval(expression, globals=None, locals=None)

    它有三个参数,其中 expression 是一个字符串类型的表达式或代码对象,用于做运算;globals 与 locals 是可选参数,默认值是 None。

    具体而言,expression 只能是单个表达式,不支持复杂的代码逻辑,例如赋值操作、循环语句等等。(PS:单个表达式并不意味着“简单无害”,参见下文第 4 节)

    globals 用于指定运行时的全局命名空间,类型是字典,缺省时使用的是当前模块的内置命名空间。locals 指定运行时的局部命名空间,类型是字典,缺省时使用 globals 的值。两者都缺省时,则遵循 eval 函数执行时的作用域。值得注意的是,这两者不代表真正的命名空间,只在运算时起作用,运算后则销毁。

    x = 10
    
    def func():
      y = 20
      a = eval('x + y')
      print('a: ', a)
      b = eval('x + y', {'x': 1, 'y': 2})
      print('x: ' + str(x) + ' y: ' + str(y))
      print('b: ', b)
      c = eval('x + y', {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
      print('x: ' + str(x) + ' y: ' + str(y))
      print('c: ', c)
    
    func()

    输出结果:
    a:  30
    x: 10 y: 20
    b:  3
    x: 10 y: 20
    c:  4

    由此可见,当指定了命名空间的时候,变量会在对应命名空间中查找。而且,它们的值不会覆盖实际命名空间中的值。

    2、exec 的基本用法

    语法:exec(object[, globals[, locals]])

    在 Python2 中 exec 是个语句,而 Python3 将其改造成一个函数,就像 print 一样。exec() 与 eval() 高度相似,三个参数的意义和作用相近。

    主要的区别是,exec() 的第一个参数不是表达式,而是代码块,这意味着两点:一是它不能做表达式求值并返回出去,二是它可以执行复杂的代码逻辑,相对而言功能更加强大,例如,当代码块中赋值了新的变量时,该变量可能 在函数外的命名空间中存活下来。

    >>> x = 1
    >>> y = exec('x = 1 + 1')
    >>> print(x)
    >>> print(y)
    2
    None
    

    可以看出,exec() 内外的命名空间是相通的,变量由此传递出去,而不像 eval() 函数,需要一个变量来接收函数的执行结果。

    3、一些细节辨析

    两个函数都很强大,它们将字符串内容当做有效的代码执行。这是一种字符串驱动的事件 ,意义重大。然而,在实际使用过程中,存在很多微小的细节,此处就列出我所知道的几点吧。

    常见用途:将字符串转成相应的对象,例如 string 转成 list ,string 转成 dict,string 转 tuple 等等。

    >>> a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
    >>> print(eval(a))
    [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
    >>> a = "{'name': 'Python猫', 'age': 18}"
    >>> print(eval(a))
    {'name': 'Python猫', 'age': 18}
    
    # 与 eval 略有不同
    >>> a = "my_dict = {'name': 'Python猫', 'age': 18}"
    >>> exec(a)
    >>> print(my_dict)
    {'name': 'Python猫', 'age': 18}

    eval() 函数的返回值是其 expression 的执行结果,在某些情况下,它会是 None,例如当该表达式是 print() 语句,或者是列表的 append() 操作时,这类操作的结果是 None,因此 eval() 的返回值也会是 None。

    >>> result = eval('[].append(2)')
    >>> print(result)
    None

    exec() 函数的返回值只会是 None,与执行语句的结果无关,所以,将 exec() 函数赋值出去,就没有任何必要。所执行的语句中,如果包含 return 或 yield ,它们产生的值也无法在 exec 函数的外部起作用。

    >>> result = exec('1 + 1')
    >>> print(result)
    None

    两个函数中的 globals 和 locals 参数,起到的是白名单的作用,通过限定命名空间的范围,防止作用域内的数据被滥用。

    conpile() 函数编译后的 code 对象,可作为 eval 和 exec 的第一个参数。compile() 也是个神奇的函数,我翻译的上一篇文章《Python骚操作:动态定义函数 》就演示了一个动态定义函数的操作。

    吊诡的局部命名空间:前面讲到了 exec() 函数内的变量是可以改变原有命名空间的,然而也有例外。

    def foo():
      exec('y = 1 + 1\nprint(y)')
      print(locals())
      print(y)
    
    foo()
    

    按照前面的理解,预期的结果是局部变量中会存入变量 y,因此两次的打印结果都会是 2,然而实际上的结果却是:

    2
    {'y': 2}
    Traceback (most recent call last):
    ...(略去部分报错信息)
        print(y)
    NameError: name 'y' is not defined

    明明看到了局部命名空间中有变量 y,为何会报错说它未定义呢?

    原因与 Python 的编译器有关,对于以上代码,编译器会先将 foo 函数解析成一个 ast(抽象语法树),然后将所有变量节点存入栈中,此时 exec() 的参数只是一个字符串,整个就是常量,并没有作为代码执行,因此 y 还不存在。直到解析第二个 print() 时,此时第一次出现变量 y ,但因为没有完整的定义,所以 y 不会被存入局部命名空间。

    在运行期,exec() 函数动态地创建了局部变量 y ,然而由于 Python 的实现机制是“运行期的局部命名空间不可改变 ”,也就是说这时的 y 始终无法成为局部命名空间的一员,当执行 print() 时也就报错了。

    至于为什么 locals() 取出的结果有 y,为什么它不能代表真正的局部命名空间?为什么局部命名空间无法被动态修改?可以查看我之前分享的《Python 动态赋值的陷阱 》,另外,官方的 bug 网站中也有对此问题的讨论,查看地址:https://bugs.python.org/issue4831

    若想把 exec() 执行后的 y 取出来的话,可以这样:z = locals()['y'] ,然而如果不小心写成了下面的代码,则会报错:

    def foo():
      exec('y = 1 + 1')
      y = locals()['y']
      print(y)
    
    foo()
    
    #报错:KeyError: 'y'
    #把变量 y 改为其它变量则不会报错
    
    

    KeyError 指的是在字典中不存在对应的 key 。本例中 y 作了声明,却因为循环引用而无法完成赋值,即 key 值对应的 value 是个无效值,因此读取不到,就报错了。

    此例还有 4 个变种,我想用一套自恰的说法来解释它们,但尝试了很久,未果。留个后话吧,等我想明白,再单独写一篇文章。

    4、为什么要慎用 eval() ?

    很多动态的编程语言中都会有 eval() 函数,作用大同小异,但是,无一例外,人们会告诉你说,避免使用它。

    为什么要慎用 eval() 呢?主要出于安全考虑,对于不可信的数据源,eval 函数很可能会招来代码注入的问题。

    >>> eval("__import__('os').system('whoami')")
    desktop-fa4b888\pythoncat
    >>> eval("__import__('subprocess').getoutput('ls ~')")
    #结果略,内容是当前路径的文件信息

    在以上例子中,我的隐私数据就被暴露了。而更可怕的是,如果将命令改为rm -rf ~ ,那当前目录的所有文件都会被删除干净。

    针对以上例子,有一个限制的办法,即指定 globals 为 {'__builtins__': None} 或者 {'__builtins__': {}} 。

    >>> s = {'__builtins__': None}
    >>> eval("__import__('os').system('whoami')", s)
    #报错:TypeError: 'NoneType' object is not subscriptable

    __builtins__ 包含了内置命名空间中的名称,在控制台中输入 dir(__builtins__) ,就能发现很多内置函数、异常和其它属性的名称。在默认情况下,eval 函数的 globals 参数会隐式地携带__builtins__ ,即使是令 globals 参数为 {} 也如此,所以如果想要禁用它,就得显式地指定它的值。

    上例将它映射成 None,就意味着限定了 eval 可用的内置命名空间为 None,从而限制了表达式调用内置模块或属性的能力。

    但是,这个办法还不是万无一失的,因为仍有手段可以发起攻击。

    某位漏洞挖掘高手在他的博客中分享了一个思路,令人大开眼界。其核心的代码是下面这句,你可以试试执行,看看输出的是什么内容。

    >>> ().__class__.__bases__[0].__subclasses__()

    关于这句代码的解释,以及更进一步的利用手段,详见博客。(地址:https://www.jb51.net/article/158468.htm)

    另外还有一篇博客,不仅提到了上例的手段,还提供了一种新的思路:

    #警告:千万不要执行如下代码,后果自负。
    >>> eval('(lambda fc=(lambda n: [c 1="c" 2="in" 3="().__class__.__bases__[0" language="for"][/c].__subclasses__() if c.__name__ == n][0]):fc("function")(fc("code")(0,0,0,0,"KABOOM",(),(),(),"","",0,""),{})())()', {"__builtins__":None})
    

    这行代码会导致 Python 直接 crash 掉。具体分析在:https://www.jb51.net/article/158470.htm

    除了黑客的手段,简单的内容也能发起攻击。像下例这样的写法, 将在短时间内耗尽服务器的计算资源。

    >>> eval("2 ** 888888888", {"__builtins__":None}, {})

    如上所述,我们直观地展示了 eval() 函数的危害性,然而,即使是 Python 高手们小心谨慎地使用,也不能保证不出错。

    在官方的 dumbdbm 模块中,曾经(2014年)发现一个安全漏洞,攻击者通过伪造数据库文件,可以在调用 eval() 时发起攻击。(详情:https://bugs.python.org/issue22885)

    无独有偶,在上个月(2019.02),有核心开发者针对 Python 3.8 也提出了一个安全问题,提议不在 logging.config 中使用 eval() 函数,目前该问题还是 open 状态。(详情:https://bugs.python.org/issue36022)

    如此种种,足以说明为什么要慎用 eval() 了。同理可证,exec() 函数也得谨慎使用。

    5、安全的替代用法

    既然有种种安全隐患,为什么要创造出这两个内置方法呢?为什么要使用它们呢?

    理由很简单,因为 Python 是一门灵活的动态语言。与静态语言不同,动态语言支持动态地产生代码,对于已经部署好的工程,也可以只做很小的局部修改,就实现 bug 修复。

    那有什么办法可以相对安全地使用它们呢?

    ast 模块的 literal() 是 eval() 的安全替代,与 eval() 不做检查就执行的方式不同,ast.literal() 会先检查表达式内容是否有效合法。它所允许的字面内容如下:

    strings, bytes, numbers, tuples, lists, dicts, sets, booleans, 和 None

    一旦内容非法,则会报错:

    import ast
    ast.literal_eval("__import__('os').system('whoami')")
    

    报错:ValueError: malformed node or string

    不过,它也有缺点:AST 编译器的栈深(stack depth)有限,解析的字符串内容太多或太复杂时,可能导致程序崩溃。

    至于 exec() ,似乎还没有类似的替代方法,毕竟它本身可支持的内容是更加复杂多样的。

    最后是一个建议:搞清楚它们的区别与运行细节(例如前面的局部命名空间内容),谨慎使用,限制可用的命名空间,对数据源作充分校验。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

    上一篇:数据密集型应用系统设计  下一篇:数据的真相:如何在数字时代做出明智决策

    展开 +

    收起 -

     
    python3 相关内容
    Python趣味编程入门与实战

    将Python程序编写中常必须的基本知识、挑选构造、循环系统构造、大海龟制图、文档和文件夹名称实际操作、时间与時间解决、GUI程序运行、tkinter库绘图图型和制作动画、PyGame手机游戏融为一

    查看详情
    Odoo快速入门与实战:Python开发ERP指南 查看详情
    精通Python爬虫框架Scrapy 查看详情
    零基础入门学习Python(含视频、源码)

    本书是一本Python 3.7编程轻松入门教程,前半部分首先讲解基础的Python 3语法知识,后半部分则围绕着Python 3在爬虫、界面开发和游戏开发上的应用,循序渐进,欢迎下载

    查看详情
    Python树莓派编程

    《Python树莓派编程》 将向你展示如何在你新买的、35美元的计算机上通过编程实现一个网络机器人、气象站或是媒体服务器等功能。你将会通过一些简单的实例和有趣的项目学到如何在树莓派

    查看详情
    机器人Python极客编程入门与实战 查看详情
    Python机器学习算法

    这是一本机器学习入门读物,注重理论与实践的结合,以典型的机器学习算法为例,从算法原理出发,由浅入深,详细介绍算法的理论,并配合目前流行的Python语言,从零开始,增强实际的算法实践能力

    查看详情
    Python机器学习

    《Python机器学习》是一本关于Python的电子书资源,涉及Python、机器学习等相关内容,本文提供大小为198MB的超清第2PDF格式电子书下载,希望大家能够喜欢。

    查看详情
    《深度学习入门:基于Python的理论与实现》学习笔记
    网友NO.447811

    10分钟教你用python动画演示深度优先算法搜寻逃出迷宫的路径

    深度优先算法(DFS 算法)是什么? 寻找起始节点与目标节点之间路径的算法,常用于搜索逃出迷宫的路径。主要思想是,从入口开始,依次搜寻周围可能的节点坐标,但不会重复经过同一个节点,且不能通过障碍节点。如果走到某个节点发现无路可走,那么就会回退到上一个节点,重新选择其他路径。直到找到出口,或者退到起点再也无路可走,游戏结束。当然,深度优先算法,只要查找到一条行得通的路径,就会停止搜索;也就是说只要有路可走,深度优先算法就不会回退到上一步。 如果你依然在编程的世界里迷茫,可以加入我们的Python学习扣qun:784758214,看看前辈们是如何学习的!交流经验!自己是一名高级python开发工程师,从基础的python脚本到web开发、爬虫、django、数据挖掘等,零基础到项目实战的资料都有整理。送给每一位python的小伙伴!分享一些学习的方法和需要注意的小细节,点击加入我们的python学习者聚集地 下图是使用 DFS 算法搜寻出来的一条路径: 总结一下: 从起点开始,查询下一步走得通的节点,将这些可能的节点压入堆栈中,已经走过的节点不再尝试。查询完毕之后,从堆栈中取出一个节点,查询该节点周围是否存在走得通的节点。如果不存在可能的节点,就继续从堆栈中取一个节点。重复以上操……

    网友NO.493090

    《Python深度学习》书评、读书笔记

    读者评价一 现阶段最浅显易懂的深度学习新手入门书,由Keras鼻祖落笔。高手不仅技术性能得,文采都不通常,确实就是说以便让尽量多的人可以应用深度学习而写的这这书,包含了深度学习的基本知识、Keras应用方式及其深度学习最好实践活动。 学习培训这书必须具有基本的PHP专业知识,但不用深度学习或是深度学习工作经验,也不用深奥的数学知识,高中数学水准得以看懂这书。 读者评价二 这这书从6月12号那一天老总递到我手上,到今日恰好六周,你在期内我逐字逐句地啃了这这书,并在每星期的星期二和星期五中午给组里的别人讲这这书,每一次讲3个钟头。直至5分钟前不久说完最终一章,写了180页的幻灯片。 感受从何说起呢?先讲Keras吧,这这书的创作者是Keras的创作者,因此这书主要详细介绍Keras在deeplearning中的各种各样使用方法。Keras容易入门,觉得用Keras写deeplearning的编码就跟用PHP相同,能够便捷地把想起的物品用几行编码表达。例如今日想写个convnet+fullyconnectedlayer的model归类一下下MNIST,要是用TensorFlow得话将会要前因后果写许多编码,可是用Keras得话要是不上十行就拿下了,随后就能够跑了,就跟跑HelloWorld相同简易。当你要来个transferlearning,那也非常简单,Keras有许多训炼好的model,立即load1个,再在其上……

    网友NO.613826

    Python直接赋值、浅拷贝与深度拷贝实例分析

    本文实例讲述了Python直接赋值、浅拷贝与深度拷贝。分享给大家供大家参考,具体如下: 直接赋值 :其实就是对象的引用(别名)。 浅拷贝(copy) :拷贝父对象,不会拷贝对象的内部的子对象。 深拷贝(deepcopy) : copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。 字典浅拷贝实例 实例 a = {1: [1,2,3]} b = a.copy() a, b({1: [1, 2, 3]}, {1: [1, 2, 3]}) a[1].append(4) a, b({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]}) 深度拷贝需要引入 copy 模块: 实例 import copy c = copy.deepcopy(a) a, c({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]}) a[1].append(5) a, c({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]}) 解析 1、 b = a : 赋值引用,a 和 b 都指向同一个对象。 2、 b = a.copy() : 浅拷贝, a 和 b 是一个独立的对象,但他们的子对象还是指向统一对象(是引用)。 b = copy.deepcopy(a) : 深度拷贝, a 和 b 完全拷贝了父对象及其子对象,两者是完全独立的。 更多实例 以下实例是使用 copy 模块的 copy.copy( 浅拷贝 )和(copy.deepcopy ): 实例 #!/usr/bin/python# -*-coding:utf-8 -*-import copya = [1, 2, 3, 4, ['a', 'b']] #原始对象b = a #赋值,传对象的引用c = copy.copy(a) #对象拷贝,浅拷贝d = copy.deepcopy(a) #对象拷贝,深拷贝a.append(5) #修改对象aa[4].append('c') #修改对象a中的['a', 'b']数组对象print( 'a = ', a )print( 'b = ', b )print( 'c = ', c )print( 'd = ', d ) 以上实例……

    网友NO.20032
    网友NO.20032

    pyc文件三大作用
    创建时间,py文件比pyc文件新,则从新生成pyc
    magic num做运行前版本检测,版本不同从新生成pyc
    PyCodeObject 对象
    在运行期间,编译结果也就是 PyCodeObject 对象,只会存在于内存中,而当这个模块的 Python 代码执行完后,就会将编译结果保存到了 pyc 文件中,这样下次就不用编译,直接加载到内存中。
    这个 PyCodeObject 对象包含了 Python 源代码中的字符串,常量值,以及通过语法解析后编译生成的字节码指令。PyCodeObject 对象还会存储这些字节码指令与原始代码行号的对应关系,这样当出现异常时,就能指明位于哪一行的代码。

    网友NO.38019
    网友NO.38019

    1. 过程概述
    Python先把代码(.py文件)编译成字节码,交给字节码虚拟机,然后虚拟机一条一条执行字节码指令,从而完成程序的执行。
    2. 字节码
    字节码在Python虚拟机程序里对应的是PyCodeObject对象。
    .pyc文件是字节码在磁盘上的表现形式。
    3. pyc文件
    PyCodeObject对象的创建时机是模块加载的时候,即import。
    Python test.py会对test.py进行编译成字节码并解释执行,但是不会生成test.pyc。
    如果test.py加载了其他模块,如import util,Python会对util.py进行编译成字节码,生成util.pyc,然后对字节码解释执行。
    如果想生成test.pyc,我们可以使用Python内置模块py_compile来编译。
    加载模块时,如果同时存在.py和.pyc,Python会尝试使用.pyc,如果.pyc的编译时间早于.py的修改时间,则重新编译.py并更新.pyc。

    Copyright 2018-2020 xz577.com 码农之家

    本站所有电子书资源不再提供下载地址,只分享来路

    免责声明:网站所有作品均由会员网上搜集共同更新,仅供读者预览及学习交流使用,下载后请24小时内删除

    版权投诉 / 书籍推广 / 赞助:QQ:520161757