├── README.md ├── README.md~ ├── docs ├── acknowledgement.md ├── backend.md ├── backend.md~ ├── for_beginners │ ├── FAQ.md │ ├── concepts.md │ ├── introduction.md │ ├── keras_linux.md │ ├── keras_windows.md │ └── trap.md ├── getting_started │ ├── functional_API.md │ ├── functional_API.md~ │ ├── sequential_model.md │ └── sequential_model.md~ ├── images │ ├── Thumbs.db │ ├── autoencoder_schema.jpg │ ├── basic_ae_32.png │ ├── cat_data_augmentation.png │ ├── cats_and_dogs.png │ ├── conv5_1_filter_0.png │ ├── conv5_2_stitched_filters_8x3.png │ ├── deep_ae_32.png │ ├── deep_conv_ae_128.png │ ├── denoised_digits.png │ ├── dual_lstm.png │ ├── encoded_representations.png │ ├── filter_dream.jpg │ ├── jigsaw-puzzle.png │ ├── keras-tensorflow-logo.jpg │ ├── keras_ubuntu_1.png │ ├── keras_ubuntu_2.png │ ├── keras_windows_1.png │ ├── keras_windows_2.png │ ├── keras_windows_3.png │ ├── magpie.jpg │ ├── moyan.png │ ├── multi-input-multi-output-graph.png │ ├── noisy_digits.png │ ├── regular_stacked_lstm.png │ ├── scp_173.png │ ├── seasnake.jpg │ ├── sparse_ae_32.png │ ├── tb_curves.png │ ├── two_branches_sequential_model.png │ ├── vae_classes_plane.png │ ├── vae_digits_manifold.png │ ├── vgg16_filters_overview.jpg │ ├── vgg16_modified.png │ └── vgg16_original.png ├── index.md ├── index.md~ ├── layers │ ├── about_layer.md │ ├── advanced_activation_layer.md │ ├── convolutional_layer.md │ ├── core_layer.md │ ├── embedding_layer.md │ ├── locally_connected_layer.md │ ├── merge.md │ ├── noise_layer.md │ ├── normalization_layer.md │ ├── pooling_layer.md │ ├── recurrent_layer.md │ ├── wrapper.md │ └── writting_layer.md ├── legacy │ ├── acknowledgement.md │ ├── backend.md │ ├── blog │ │ ├── autoencoder.md │ │ ├── autoencoder.md~ │ │ ├── cnn_see_world.md │ │ ├── cnn_see_world.md~ │ │ ├── image_classification_using_very_little_data.md │ │ ├── keras_and_tensorflow.md │ │ └── word_embedding.md │ ├── getting_started │ │ ├── FAQ.md │ │ ├── FAQ.md~ │ │ ├── concepts.md │ │ ├── concepts.md~ │ │ ├── examples.md │ │ ├── examples.md~ │ │ ├── functional_API.md │ │ ├── functional_API.md~ │ │ ├── keras_linux.md │ │ ├── keras_windows.md │ │ ├── sequential_model.md │ │ ├── sequential_model.md~ │ │ └── trap.md │ ├── images │ │ ├── Thumbs.db │ │ ├── autoencoder_schema.jpg │ │ ├── basic_ae_32.png │ │ ├── cat_data_augmentation.png │ │ ├── cats_and_dogs.png │ │ ├── conv5_1_filter_0.png │ │ ├── conv5_2_stitched_filters_8x3.png │ │ ├── deep_ae_32.png │ │ ├── deep_conv_ae_128.png │ │ ├── denoised_digits.png │ │ ├── dual_lstm.png │ │ ├── encoded_representations.png │ │ ├── filter_dream.jpg │ │ ├── jigsaw-puzzle.png │ │ ├── keras-tensorflow-logo.jpg │ │ ├── keras_linux_cuda.png │ │ ├── keras_linux_ubuntu.png │ │ ├── keras_windows_os.png │ │ ├── keras_windows_vs.png │ │ ├── magpie.jpg │ │ ├── moyan.png │ │ ├── multi-input-multi-output-graph.png │ │ ├── noisy_digits.png │ │ ├── regular_stacked_lstm.png │ │ ├── scp_173.png │ │ ├── seasnake.jpg │ │ ├── sparse_ae_32.png │ │ ├── tb_curves.png │ │ ├── two_branches_sequential_model.png │ │ ├── vae_classes_plane.png │ │ ├── vae_digits_manifold.png │ │ ├── vgg16_filters_overview.jpg │ │ ├── vgg16_modified.png │ │ └── vgg16_original.png │ ├── index.md │ ├── layers │ │ ├── about_layer.md │ │ ├── advanced_activation_layer.md │ │ ├── convolutional_layer.md │ │ ├── core_layer.md │ │ ├── embedding_layer.md │ │ ├── locally_connected_layer.md │ │ ├── noise_layer.md │ │ ├── normalization_layer.md │ │ ├── pooling_layer.md │ │ ├── recurrent_layer.md │ │ ├── wrapper.md │ │ └── writting_layer.md │ ├── models │ │ ├── about_model.md │ │ ├── model.md │ │ └── sequential.md │ ├── no_use.md │ ├── other │ │ ├── activations.md │ │ ├── application.md │ │ ├── application.md~ │ │ ├── callbacks.md │ │ ├── constraints.md │ │ ├── datasets.md │ │ ├── initializations.md │ │ ├── metrices.md~ │ │ ├── metrics.md │ │ ├── objectives.md │ │ ├── objectives.md~ │ │ ├── optimizers.md │ │ ├── regularizers.md │ │ └── visualization.md │ ├── preprocessing │ │ ├── image.md │ │ ├── image.md~ │ │ ├── sequence.md │ │ └── text.md │ ├── scikit-learn_API.md │ └── utils │ │ ├── data_utils.md │ │ ├── data_utils~ │ │ ├── io_utils.md │ │ ├── layer_utils.md │ │ ├── layer_utils~ │ │ ├── np_utils.md │ │ └── np_utils~ ├── models │ ├── about_model.md │ ├── model.md │ └── sequential.md ├── other │ ├── activations.md │ ├── application.md │ ├── application.md~ │ ├── callbacks.md │ ├── constraints.md │ ├── datasets.md │ ├── initializations.md │ ├── metrics.md │ ├── objectives.md │ ├── objectives.md~ │ ├── optimizers.md │ ├── regularizers.md │ └── visualization.md ├── preprocessing │ ├── image.md │ ├── image.md~ │ ├── sequence.md │ └── text.md ├── scikit-learn_API.md └── utils.md ├── mkdocs.yml └── mkdocs.yml~ /README.md: -------------------------------------------------------------------------------- 1 | # keras-cn 2 | 3 | 本项目由BigMoyan于2016-4-29发起，旨在建立一个[keras.io](keras.io)的中文版文档，并提供更多用户友好的支持与建议。 4 | 5 | 本项目目前已完成2.x版本，文档网址为[keras-cn](http://keras-cn.readthedocs.io/en/latest/) 6 | 7 | 如果你在使用keras和keras-cn的过程中有任何问题，请发在issue中，我会定时检查和回复，在issue中你也可以和志同道合的好基友们一起聊天~ 8 | 9 | 项目基于Mkdocs生成静态网页，如果你想为文档做出贡献，请使用Markdown编写文档并遵守以下约定。 10 | 11 | ## 0.字体颜色 12 | 13 | 保持默认的字体颜色和字号，锚点的颜色为默认，超链接的颜色为默认 14 | 15 | 当使用``````来设置锚点时，可能引起字体颜色改变，如果颜色发生改变，需要使用font修正字体，默认字体的颜色是#404040 16 | 17 | ## 1.标题级别 18 | 19 | 页面大标题为一级，一般每个文件只有一个一级标题 # 20 | 页面内的小节是二级标题 ## 21 | 小节的小节，如examples里各个example是三级标题 ### 22 | 23 | ## 2.代码块规则 24 | 25 | 成块的代码使用 26 | 27 | \`\`\`python 28 | 29 | code 30 | 31 | \`\`\` 32 | 33 | 的形式显式指明 34 | 段中代码使用\`\`\`code\`\`\`的形式指明 35 | 36 | ## 3. 超链接 37 | 38 | 链接到本项目其他页面的超链接使用相对路径，一个例子是 39 | ```[text](../models/about_model.md)``` 40 | 链接到其他外站的链接形式与此相同，只不过圆括号中是绝对地址 41 | 42 | ## 4.图片 43 | 44 | 图片保存在docs/images中，插入的例子是： 45 | 46 | ``` 47 | 48 | ![text](../images/image_name.png) 49 | 50 | ``` 51 | 52 | ## 5.分割线 53 | 54 | 每个二级标题之间使用 55 | \*\*\* 56 | 产生一个分割线 57 | 58 | # 参考网站 59 | 60 | ## Markdown简明教程 61 | 62 | [Markdown](http://wowubuntu.com/markdown/) 63 | 64 | ## MkDocs中文教程 65 | 66 | [MkDocs](http://markdown-docs-zh.readthedocs.io/zh_CN/latest/) 67 | 68 | ## Keras文档 69 | 70 | [Keras](http://keras.io/) 71 | 72 | 感谢参与！ 73 | 74 | -------------------------------------------------------------------------------- /README.md~: -------------------------------------------------------------------------------- 1 | # keras-cn 2 | -------------------------------------------------------------------------------- /docs/acknowledgement.md: -------------------------------------------------------------------------------- 1 |  2 | # 致谢 3 | 4 | 本项目由以下贡献者贡献： 5 | 6 | ## 文档贡献 7 | 8 | | 贡献者 | 页面 | 章节 | 类型 | 9 | |:------:|:----:|:---:|:---:| 10 | |Bigmoyan|keras.io的全部正文| - |翻译| 11 | |Bigmoyan|深度学习与Keras|CNN眼中的世界|翻译| 12 | |Bigmoyan|深度学习与Keras|花式自动编码器|翻译| 13 | |Bigmoyan|快速开始|一些基本概念|编写| 14 | |SCP-173|快速开始|Keras安装和配置指南(Linux)|编写| 15 | |SCP-173|快速开始|Keras安装和配置指南(Windows)|编写| 16 | |Bigmoyan|深度学习与Keras|面向小数据集构建图像分类模型|翻译| 17 | |leo-nlp|深度学习与Keras|在Keras模型中使用预训练的词向量|翻译| 18 | |zhourunlai|工具|I/O工具|翻译| 19 | 20 | ## Tips 21 | 22 | | 贡献者 | 页面 | 23 | |:------:|:---:| 24 | |Bigmoyan|Tips处标注| 25 | |3rduncle|Tips处标注| 26 | |白菜|Tips处标记| 27 | |我是小将|Tips处标记| 28 | |zhourunlai|可视化| 29 | 30 | ## Keras陷阱提示 31 | 32 | | 贡献者 | 页面 | 33 | |:------:|:---:| 34 | |Bigmoyan|tf与th卷积核陷阱| 35 | |Bigmoyan|向BN层载入权重陷阱| 36 | |Yin|validation_spilit与shuffle陷阱| 37 | |Hui Liu|merge与Merge的区别| 38 | ## Reviewers 39 | 40 | | Reviewer | 页面 | 章节 | 41 | |:--------:|:----:|:----:| 42 | |白菜|快速开始泛型模型|共享层| 43 | |白菜|常用数据库|IMDB影评倾向分类| 44 | |doudou|关于模型|关于Keras模型| 45 | |doudou|常用层|Dense层| 46 | |艾子|常用层|Merge层| 47 | |NUDT-小超人、、|快速开始Sequential模型|Merge层| 48 | |毛毛熊|常用数据库|cifar-10| 49 | |迷川浩浩|回调函数|callback| 50 | |tadakey|一些基本概念|张量| 51 | |方渺渺|递归层|recurrent层| 52 | |leo-nlp|快速开始泛型模型|共享层| 53 | |单车|常用层|Masking层| 54 | |张涛|快速开始泛型模型|多输入和多输出模型| 55 | |白菜|FAQ|如何观察中间层的输出| 56 | |毒液|文本预处理|one-hot| 57 | |毒液|回调函数|EarlyStopping| 58 | |毒液|目标函数|可用的目标函数| 59 | |毛毛熊|正则项|缩写| 60 | |木子天一|局部连接层LocallyConnceted|LocallyConnected2D层| 61 | |QiaXi|Pooling层|GlobalMax/GlobalAve| 62 | |shawn|Callback|ModelCheckpoint| 63 | |smallYoki|快速开始|泛型模型| 64 | 65 | ## 示例程序 66 | 67 | * 虚位以待 68 | -------------------------------------------------------------------------------- /docs/for_beginners/concepts.md: -------------------------------------------------------------------------------- 1 | # 一些基本概念 2 | 3 | 在开始学习Keras之前，我们希望传递一些关于Keras，关于深度学习的基本概念和技术，我们建议新手在使用Keras之前浏览一下本页面提到的内容，这将减少你学习中的困惑 4 | 5 | ## 符号计算 6 | 7 | Keras的底层库使用Theano或TensorFlow，这两个库也称为Keras的后端。无论是Theano还是TensorFlow，都是一个“符号式”的库。 8 | 9 | 因此，这也使得Keras的编程与传统的Python代码有所差别。笼统的说，符号主义的计算首先定义各种变量，然后建立一个“计算图”，计算图规定了各个变量之间的计算关系。建立好的计算图需要编译以确定其内部细节，然而，此时的计算图还是一个“空壳子”，里面没有任何实际的数据，只有当你把需要运算的输入放进去后，才能在整个模型中形成数据流，从而形成输出值。 10 | 11 | 就像用管道搭建供水系统，当你在拼水管的时候，里面是没有水的。只有所有的管子都接完了，才能送水。 12 | 13 | Keras的模型搭建形式就是这种方法，在你搭建Keras模型完毕后，你的模型就是一个空壳子，只有实际生成可调用的函数后（K.function），输入数据，才会形成真正的数据流。 14 | 15 | 使用计算图的语言，如Theano，以难以调试而闻名，当Keras的Debug进入Theano这个层次时，往往也令人头痛。没有经验的开发者很难直观的感受到计算图到底在干些什么。尽管很让人头痛，但大多数的深度学习框架使用的都是符号计算这一套方法，因为符号计算能够提供关键的计算优化、自动求导等功能。 16 | 17 | 我们建议你在使用前稍微了解一下Theano或TensorFlow，Bing/Google一下即可。 18 | 19 | ## 张量 20 | 21 | 张量，或tensor，是本文档会经常出现的一个词汇，在此稍作解释。 22 | 23 | 使用这个词汇的目的是为了表述统一，张量可以看作是向量、矩阵的自然推广，我们用张量来表示广泛的数据类型。 24 | 25 | 规模最小的张量是0阶张量，即标量，也就是一个数。 26 | 27 | 当我们把一些数有序的排列起来，就形成了1阶张量，也就是一个向量 28 | 29 | 如果我们继续把一组向量有序的排列起来，就形成了2阶张量，也就是一个矩阵 30 | 31 | 把矩阵摞起来，就是3阶张量，我们可以称为一个立方体，具有3个颜色通道的彩色图片就是一个这样的立方体 32 | 33 | 把立方体摞起来，好吧这次我们真的没有给它起别名了，就叫4阶张量了，不要去试图想像4阶张量是什么样子，它就是个数学上的概念。 34 | 35 | 张量的阶数有时候也称为维度，或者轴，轴这个词翻译自英文axis。譬如一个矩阵[[1,2],[3,4]]，是一个2阶张量，有两个维度或轴，沿着第0个轴（为了与python的计数方式一致，本文档维度和轴从0算起）你看到的是[1,2]，[3,4]两个向量，沿着第1个轴你看到的是[1,3]，[2,4]两个向量。 36 | 37 | 要理解“沿着某个轴”是什么意思，不妨试着运行一下下面的代码： 38 | 39 | ```python 40 | import numpy as np 41 | 42 | a = np.array([[1,2],[3,4]]) 43 | sum0 = np.sum(a, axis=0) 44 | sum1 = np.sum(a, axis=1) 45 | 46 | print sum0 47 | print sum1 48 | ``` 49 | 50 | 关于张量，目前知道这么多就足够了。事实上我也就知道这么多 51 | 52 | ## data_format 53 | 54 | 这是一个无可奈何的问题，在如何表示一组彩色图片的问题上，Theano和TensorFlow发生了分歧，'th'模式，也即Theano模式会把100张RGB三通道的16×32（高为16宽为32）彩色图表示为下面这种形式（100,3,16,32），Caffe采取的也是这种方式。第0个维度是样本维，代表样本的数目，第1个维度是通道维，代表颜色通道数。后面两个就是高和宽了。这种theano风格的数据组织方法，称为“channels_first”，即通道维靠前。 55 | 56 | 而TensorFlow，的表达形式是（100,16,32,3），即把通道维放在了最后，这种数据组织方式称为“channels_last”。 57 | 58 | Keras默认的数据组织形式在~/.keras/keras.json中规定，可查看该文件的`image_data_format`一项查看，也可在代码中通过K.image_data_format()函数返回，请在网络的训练和测试中保持维度顺序一致。 59 | 60 | 唉，真是蛋疼，你们商量好不行吗？ 61 | 62 | 63 | 64 | 65 | 66 | ## 函数式模型 67 | 68 | 69 | 70 | 函数式模型算是本文档比较原创的词汇了，所以这里要说一下 71 | 72 | 在Keras 0.x中，模型其实有两种，一种叫Sequential，称为序贯模型，也就是单输入单输出，一条路通到底，层与层之间只有相邻关系，跨层连接统统没有。这种模型编译速度快，操作上也比较简单。第二种模型称为Graph，即图模型，这个模型支持多输入多输出，层与层之间想怎么连怎么连，但是编译速度慢。可以看到，Sequential其实是Graph的一个特殊情况。 73 | 74 | 在Keras1和Keras2中，图模型被移除，而增加了了“functional model API”，这个东西，更加强调了Sequential是特殊情况这一点。一般的模型就称为Model，然后如果你要用简单的Sequential，OK，那还有一个快捷方式Sequential。 75 | 76 | 由于functional model API在使用时利用的是“函数式编程”的风格，我们这里将其译为函数式模型。总而言之，只要这个东西接收一个或一些张量作为输入，然后输出的也是一个或一些张量，那不管它是什么鬼，统统都称作“模型”。 77 | 78 | 79 | 80 | ## batch 81 | 82 | 83 | 这个概念与Keras无关，老实讲不应该出现在这里的，但是因为它频繁出现，而且不了解这个技术的话看函数说明会很头痛，这里还是简单说一下。 84 | 85 | 深度学习的优化算法，说白了就是梯度下降。每次的参数更新有两种方式。 86 | 87 | 第一种，遍历全部数据集算一次损失函数，然后算函数对各个参数的梯度，更新梯度。这种方法每更新一次参数都要把数据集里的所有样本都看一遍，计算量开销大，计算速度慢，不支持在线学习，这称为Batch gradient descent，批梯度下降。 88 | 89 | 另一种，每看一个数据就算一下损失函数，然后求梯度更新参数，这个称为随机梯度下降，stochastic gradient descent。这个方法速度比较快，但是收敛性能不太好，可能在最优点附近晃来晃去，hit不到最优点。两次参数的更新也有可能互相抵消掉，造成目标函数震荡的比较剧烈。 90 | 91 | 为了克服两种方法的缺点，现在一般采用的是一种折中手段，mini-batch gradient decent，小批的梯度下降，这种方法把数据分为若干个批，按批来更新参数，这样，一个批中的一组数据共同决定了本次梯度的方向，下降起来就不容易跑偏，减少了随机性。另一方面因为批的样本数与整个数据集相比小了很多，计算量也不是很大。 92 | 93 | 基本上现在的梯度下降都是基于mini-batch的，所以Keras的模块中经常会出现batch_size，就是指这个。 94 | 95 | 顺便说一句，Keras中用的优化器SGD是stochastic gradient descent的缩写，但不代表是一个样本就更新一回，还是基于mini-batch的。 96 | 97 | 98 | ## epochs 99 | 100 | 真的不是很想解释这个词，但是新手问的还挺多的…… 101 | 简单说，epochs指的就是训练过程中数据将被“轮”多少次，就这样。 102 | 103 | ## 对新手友好的小说明 104 | 105 | 虽然这不是我们应该做的工作，但为了体现本教程对新手的友好，我们在这里简单列一下使用keras需要的先行知识。稍有经验的研究者或开发者请忽略本节，对于新手，我们建议在开始之前，确保你了解下面提到的术语的基本概念。如果你确实对某项内容不了解，请首先查阅相关资料，以免在未来使用中带来困惑。 106 | 107 | ### 关于Python 108 | 109 | * 显然你应对Python有一定的熟悉，包括其基本语法，数据类型，语言特点等，如果你还不能使用Python进行程序设计，或不能避免Python中常见的一些小陷阱，或许你应该先去找个教程补充一下。这里推一个快速学习Python的教程[廖雪峰的Python教程](http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000) 110 | 111 | * 你应该有面向对象的概念，知道类、对象、封装、多态、继承、作用域等术语的含义。 112 | 113 | * 你应该对Python的科学计算包和深度学习包有一定了解，这些包包含但不限于numpy, scipy, scikit-learn, pandas... 114 | 115 | * 特别地，你需要了解什么是生成器函数（generator），以及如何编写生成器函数。什么是匿名函数（lambda） 116 | 117 | ### 关于深度学习 118 | 119 | 由于Keras是为深度学习设计的工具，我们这里只列举深度学习中的一些基本概念。请确保你对下面的概念有一定理解。 120 | 121 | * 有监督学习，无监督学习，分类，聚类，回归 122 | 123 | * 神经元模型，多层感知器，BP算法 124 | 125 | * 目标函数（损失函数），激活函数，梯度下降法 126 | 127 | * 全连接网络、卷积神经网络、递归神经网络 128 | 129 | * 训练集，测试集，交叉验证，欠拟合，过拟合 130 | 131 | * 数据规范化 132 | 133 | * 其他我还没想到的东西……想到再补充 134 | 135 | 136 | ## 其他 137 | 138 | 其他需要注意的概念，我们将使用[Tips]标注出来，如果该概念反复出现又比较重要，我们会写到这里。就酱，玩的愉快哟。 139 | 140 | -------------------------------------------------------------------------------- /docs/for_beginners/introduction.md: -------------------------------------------------------------------------------- 1 | # 一份简短的Keras介绍 2 | 3 | -------------------------------------------------------------------------------- /docs/for_beginners/keras_linux.md: -------------------------------------------------------------------------------- 1 | **本教程不得用于任何形式的商业用途，如果需要转载请与作者SCP-173联系，如果发现未经允许复制转载，将保留追求其法律责任的权利。** 2 | 3 | 4 | 5 | --- 6 | # 关于计算机的硬件配置说明 7 | ## **推荐配置** 8 | 如果您是高校学生或者高级研究人员，并且实验室或者个人资金充沛，建议您采用如下配置： 9 | 10 | - 主板：X299型号或Z270型号 11 | - CPU: i7-6950X或i7-7700K 及其以上高级型号 12 | - 内存：品牌内存，总容量32G以上，根据主板组成4通道或8通道 13 | - SSD： 品牌固态硬盘，容量256G以上 14 | - 显卡：NVIDIA GTX TITAN(XP) NVIDIA GTX 1080ti、NVIDIA GTX TITAN、NVIDIA GTX 1080、NVIDIA GTX 1070、NVIDIA GTX 1060 (顺序为优先建议，并且建议同一显卡，可以根据主板插槽数量购买多块，例如X299型号主板最多可以采用×4的显卡) 15 | - 电源：由主机机容量的确定，一般有显卡总容量后再加200W即可 16 | ## **最低配置** 17 | 如果您是仅仅用于自学或代码调试，亦或是条件所限仅采用自己现有的设备进行开发，那么您的电脑至少满足以下几点： 18 | 19 | - CPU：Intel第三代i5和i7以上系列产品或同性能AMD公司产品 20 | - 内存：总容量4G以上 21 | 22 | ## CPU说明 23 | - 大多数CPU目前支持多核多线程，那么如果您采用CPU加速，就可以使用多线程运算。这方面的优势对于服务器CPU志强系列尤为关键 24 | ## 显卡说明 25 | - 如果您的显卡是非NVIDIA公司的产品或是NVIDIA GTX系列中型号的第一个数字低于6或NVIDIA的GT系列，都不建议您采用此类显卡进行加速计算，例如`NVIDIA GT 910`、`NVIDIA GTX 460` 等等。 26 | - 如果您的显卡为笔记本上的GTX移动显卡（型号后面带有标识M），那么请您慎重使用显卡加速，因为移动版GPU容易发生过热烧毁现象。 27 | - 如果您的显卡，显示的是诸如 `HD5000`,`ATI 5650` 等类型的显卡，那么您只能使用CPU加速 28 | - 如果您的显卡芯片为Pascal架构（`NVIDIA GTX 1080`,`NVIDIA GTX 1070`等），您只能在之后的配置中选择`CUDA 8.0` 29 | --- 30 | 31 | # 基本开发环境搭建 32 | ## 1. Linux 发行版 33 | linux有很多发行版，本文强烈建议读者采用新版的`Ubuntu 16.04 LTS` 34 | 一方面，对于大多数新手来说Ubuntu具有很好的图形界面，与乐观的开源社区；另一方面，Ubuntu是Nvidia官方以及绝大多数深度学习框架默认开发环境。 35 | 个人不建议使用Ubuntu其他版本，由于GCC编译器版本不同，会导致很多依赖无法有效安装。 36 | Ubuntu 16.04 LTS下载地址：http://www.ubuntu.org.cn/download/desktop 37 | ![](../images/keras_ubuntu_1.png) 38 | 通过U盘安装好后，进行初始化环境设置。 39 | ## 2. Ubuntu初始环境设置 40 | 41 | - 安装开发包 42 | 打开`终端`输入： 43 | ```bash 44 | # 系统升级 45 | >>> sudo apt update 46 | >>> sudo apt upgrade 47 | # 安装python基础开发包 48 | >>> sudo apt install -y python-dev python-pip python-nose gcc g++ git gfortran vim 49 | ``` 50 | 51 | - 安装运算加速库 52 | 打开`终端`输入： 53 | ``` 54 | >>> sudo apt install -y libopenblas-dev liblapack-dev libatlas-base-dev 55 | ``` 56 | 57 | ## 3. CUDA开发环境的搭建(CPU加速跳过) 58 | ***如果您的仅仅采用cpu加速，可跳过此步骤*** 59 | - 下载CUDA8.0 60 | 61 | 下载地址：https://developer.nvidia.com/cuda-downloads 62 | ![](../images/keras_ubuntu_2.png) 63 | 64 | 之后打开`终端`输入： 65 | 66 | ``` 67 | >>> sudo dpkg -i cuda-repo-ubuntu1604-8-0-local-ga2_8.0.61-1_amd64.deb 68 | >>> sudo apt update 69 | >>> sudo apt -y install cuda 70 | ``` 71 | 自动配置成功就好。 72 | 73 | - 将CUDA路径添加至环境变量 74 | 在`终端`输入： 75 | ``` 76 | >>> sudo gedit /etc/profile 77 | ``` 78 | 在`profile`文件中添加： 79 | ```bash 80 | export CUDA_HOME=/usr/local/cuda-8.0 81 | export PATH=/usr/local/cuda-8.0/bin${PATH:+:${PATH}} 82 | export LD_LIBRARY_PATH=/usr/local/cuda-8.0/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}} 83 | ``` 84 | 之后`source /etc/profile`即可 85 | 86 | - 测试 87 | 在`终端`输入： 88 | ``` 89 | >>> nvcc -V 90 | ``` 91 | 会得到相应的nvcc编译器相应的信息，那么CUDA配置成功了。(**记得重启系统**) 92 | 93 | 如果要进行`cuda性能测试`，可以进行： 94 | ```shell 95 | >>> cd /usr/local/cuda/samples 96 | >>> sudo make -j8 97 | ``` 98 | 编译完成后，可以进`samples/bin/.../.../...`的底层目录，运行各类实例。 99 | 100 | 101 | ## 4. 加速库cuDNN（可选） 102 | 从官网下载需要注册账号申请，两三天批准。网盘搜索一般也能找到最新版。 103 | Linux目前最新的版本是cudnn V6，但对于tensorflow的预编译版本还不支持这个最近版本，建议采用5.1版本，即是cudnn-8.0-win-x64-v5.1-prod.zip。 104 | 下载解压出来是名为cuda的文件夹，里面有bin、include、lib，将三个文件夹复制到安装CUDA的地方覆盖对应文件夹，在终端中输入： 105 | ```shell 106 | >>> sudo cp include/cudnn.h /usr/local/cuda/include/ 107 | >>> sudo cp lib64/* /usr/local/cuda/lib64/ 108 | >>> cd /usr/local/cuda/lib64 109 | >>> sudo ln -sf libcudnn.so.5.1.10 libcudnn.so.5 110 | >>> sudo ln -sf libcudnn.so.5 libcudnn.so 111 | >>> sudo ldconfig -v 112 | ``` 113 | 114 | # Keras框架搭建 115 | 116 | ## 相关开发包安装 117 | 在`终端`中输入: 118 | ```shell 119 | >>> sudo pip install -U --pre pip setuptools wheel 120 | >>> sudo pip install -U --pre numpy scipy matplotlib scikit-learn scikit-image 121 | >>> sudo pip install -U --pre tensorflow-gpu 122 | # >>> sudo pip install -U --pre tensorflow ## CPU版本 123 | >>> sudo pip install -U --pre keras 124 | ``` 125 | 安装完毕后，输入`python`，然后输入： 126 | ```python 127 | >>> import tensorflow 128 | >>> import keras 129 | ``` 130 | 无错输出即可 131 | 132 | 133 | ## Keras中mnist数据集测试 134 | 下载Keras开发包 135 | ```shell 136 | >>> git clone https://github.com/fchollet/keras.git 137 | >>> cd keras/examples/ 138 | >>> python mnist_mlp.py 139 | ``` 140 | 程序无错进行，至此，keras安装完成。 141 | 142 | 143 | ## 声明与联系方式 ## 144 | 145 | 由于作者水平和研究方向所限，无法对所有模块都非常精通，因此文档中不可避免的会出现各种错误、疏漏和不足之处。如果您在使用过程中有任何意见、建议和疑问，欢迎发送邮件到scp173.cool@gmail.com与作者取得联系. 146 | 147 | **本教程不得用于任何形式的商业用途，如果需要转载请与作者或中文文档作者联系，如果发现未经允许复制转载，将保留追求其法律责任的权利。** 148 | 149 | 作者：[SCP-173](https://github.com/KaiwenXiao) 150 | E-mail ：scp173.cool@gmail.com 151 | **如果您需要及时得到指导帮助，可以加微信：SCP173-cool，酌情打赏即可** 152 | ![微信](../images/scp_173.png) 153 | -------------------------------------------------------------------------------- /docs/for_beginners/keras_windows.md: -------------------------------------------------------------------------------- 1 | *这里需要说明一下，笔者**不建议在Windows环境下进行深度学习的研究**，一方面是因为Windows所对应的框架搭建的依赖过多，社区设定不完全；另一方面，Linux系统下对显卡支持、内存释放以及存储空间调整等硬件功能支持较好。如果您对Linux环境感到陌生，并且大多数开发环境在Windows下更方便操作的话，希望这篇文章对您会有帮助。* 2 | 3 | 4 | **由于Keras默认以Tensorflow为后端，且Theano后端更新缓慢，本文默认采用Tensorflow1.0作为Keras后端，Theano版安装方式请访问[www.scp-173.top**](http://www.scp-173.top) 5 | 6 | --- 7 | # 关于计算机的硬件配置说明 8 | ## **推荐配置** 9 | 如果您是高校学生或者高级研究人员，并且实验室或者个人资金充沛，建议您采用如下配置： 10 | 11 | - 主板：X299型号或Z270型号 12 | - CPU: i7-6950X或i7-7700K 及其以上高级型号 13 | - 内存：品牌内存，总容量32G以上，根据主板组成4通道或8通道 14 | - SSD： 品牌固态硬盘，容量256G以上 15 | - 显卡：NVIDIA GTX TITAN(XP) NVIDIA GTX 1080ti、NVIDIA GTX TITAN、NVIDIA GTX 1080、NVIDIA GTX 1070、NVIDIA GTX 1060 (顺序为优先建议，并且建议同一显卡，可以根据主板插槽数量购买多块，例如X299型号主板最多可以采用×4的显卡) 16 | - 电源：由主机机容量的确定，一般有显卡总容量后再加200W即可 17 | ## **最低配置** 18 | 如果您是仅仅用于自学或代码调试，亦或是条件所限仅采用自己现有的设备进行开发，那么您的电脑至少满足以下几点： 19 | 20 | - CPU：Intel第三代i5和i7以上系列产品或同性能AMD公司产品 21 | - 内存：总容量4G以上 22 | 23 | ## CPU说明 24 | - 大多数CPU目前支持多核多线程，那么如果您采用CPU加速，就可以使用多线程运算。这方面的优势对于服务器CPU志强系列尤为关键 25 | ## 显卡说明 26 | - 如果您的显卡是非NVIDIA公司的产品或是NVIDIA GTX系列中型号的第一个数字低于6或NVIDIA的GT系列，都不建议您采用此类显卡进行加速计算，例如`NVIDIA GT 910`、`NVIDIA GTX 460` 等等。 27 | - 如果您的显卡为笔记本上的GTX移动显卡（型号后面带有标识M），那么请您慎重使用显卡加速，因为移动版GPU容易发生过热烧毁现象。 28 | - 如果您的显卡，显示的是诸如 `HD5000`,`ATI 5650` 等类型的显卡，那么您只能使用CPU加速 29 | - 如果您的显卡芯片为Pascal架构（`NVIDIA GTX 1080`,`NVIDIA GTX 1070`等），您只能在之后的配置中选择`CUDA 8.0` 30 | --- 31 | 32 | # 基本开发环境搭建 33 | ## 1. Microsoft Windows 版本 34 | 关于Windows的版本选择，本人强烈建议对于部分高性能的新机器采用`Windows 10`作为基础环境，部分老旧笔记本或低性能机器采用`Windows 7`即可，本文环境将以`Windows 10`作为开发环境进行描述。对于Windows 10的发行版本选择，笔者建议采用`Windows_10_enterprise_2016_ltsb_x64`作为基础环境。 35 | 36 | 这里推荐到[MSDN我告诉你](http://msdn.itellyou.cn/)下载，也感谢作者国内优秀作者[雪龙狼前辈](http://weibo.com/207156000?is_hot=1)所做出的贡献与牺牲。 37 | 38 | ![](../images/keras_windows_1.png) 39 | 40 | 直接贴出热链，复制粘贴迅雷下载： 41 | 42 | ed2k://|file|cn_windows_10_enterprise_2016_ltsb_x64_dvd_9060409.iso|3821895680|FF17FF2D5919E3A560151BBC11C399D1|/ 43 | 44 | 45 | ## 2. 编译环境Microsoft Visual Studio 2015 Update 3 46 | *(安装CPU版本非必须安装)* 47 | 48 | CUDA编译器为Microsoft Visual Studio，版本从2010-2015，`cuda8.0`仅支持2015版本，暂不支持VS2017，本文采用`Visual Studio 2015 Update 3`。 49 | 同样直接贴出迅雷热链： 50 | 51 | ed2k://|file|cn_visual_studio_professional_2015_with_update_3_x86_x64_dvd_8923256.iso|7745202176|DD35D3D169D553224BE5FB44E074ED5E|/ 52 | ![MSDN](../images/keras_windows_2.png) 53 | 54 | ## 3. Python环境 55 | python环境建设推荐使用科学计算集成python发行版**Anaconda**，Anaconda是Python众多发行版中非常适用于科学计算的版本，里面已经集成了很多优秀的科学计算Python库。 56 | 建议安装`Anconda3 4.2.0`版本，目前新出的python3.6存在部分不兼容问题，所以建议安装历史版本4.2.0 57 | **注意：windows版本下的tensorflow暂时不支持python2.7** 58 | 59 | 下载地址： [Anaconda](https://repo.continuum.io/archive/index.html) 60 | 61 | 62 | ## 4. CUDA 63 | *(安装CPU版本非必须安装)* 64 | CUDA Toolkit是NVIDIA公司面向GPU编程提供的基础工具包，也是驱动显卡计算的核心技术工具。 65 | 直接安装CUDA8.0即可 66 | 下载地址：[https://developer.nvidia.com/cuda-downloads](https://developer.nvidia.com/cuda-downloads) 67 | ![](../images/keras_windows_3.png) 68 | 在下载之后，按照步骤安装，**不建议新手修改安装目录**，同上，环境不需要配置，安装程序会自动配置好。 69 | 70 | ## 6. 加速库CuDNN 71 | 从官网下载需要注册 Nvidia 开发者账号，网盘搜索一般也能找到。 72 | Windows目前最新版v6.0，但是keras尚未支持此版本，请下载v5.1版本，即 cudnn-8.0-win-x64-v5.1.zip。 73 | 下载解压出来是名为cuda的文件夹，里面有bin、include、lib，将三个文件夹复制到安装CUDA的地方覆盖对应文件夹，默认文件夹在：`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\8.0` 74 | 75 | --- 76 | 77 | # Keras 框架搭建 78 | ## 安装 79 | 80 | 在CMD命令行或者Powershell中输入： 81 | ``` powershell 82 | # GPU 版本 83 | >>> pip install --upgrade tensorflow-gpu 84 | 85 | # CPU 版本 86 | >>> pip install --upgrade tensorflow 87 | 88 | # Keras 安装 89 | >>> pip install keras -U --pre 90 | ``` 91 | 92 | 之后可以验证keras是否安装成功,在命令行中输入Python命令进入Python变成命令行环境： 93 | ```python 94 | >>> import keras 95 | 96 | Using Tensorflow backend. 97 | I c:\tf_jenkins\home\workspace\release-win\device\gpu\os\windows\tensorflow\stream_executor\dso_loader.cc:135] successfully opened CUDA library cublas64_80.dll locally 98 | I c:\tf_jenkins\home\workspace\release-win\device\gpu\os\windows\tensorflow\stream_executor\dso_loader.cc:135] successfully opened CUDA library cudnn64_5.dll locally 99 | I c:\tf_jenkins\home\workspace\release-win\device\gpu\os\windows\tensorflow\stream_executor\dso_loader.cc:135] successfully opened CUDA library cufft64_80.dll locally 100 | I c:\tf_jenkins\home\workspace\release-win\device\gpu\os\windows\tensorflow\stream_executor\dso_loader.cc:135] successfully opened CUDA library nvcuda.dll locally 101 | I c:\tf_jenkins\home\workspace\release-win\device\gpu\os\windows\tensorflow\stream_executor\dso_loader.cc:135] successfully opened CUDA library curand64_80.dll locally 102 | 103 | >>> 104 | ``` 105 | 没有报错，那么Keras就已经**成功安装**了 106 | 107 | 108 | - Keras中mnist数据集测试 109 | 下载Keras开发包 110 | ``` 111 | >>> conda install git 112 | >>> git clone https://github.com/fchollet/keras.git 113 | >>> cd keras/examples/ 114 | >>> python mnist_mlp.py 115 | ``` 116 | 程序无错进行，至此，keras安装完成。 117 | 118 | [Keras中文文档地址](http://keras-cn.readthedocs.io/) 119 | 120 | ## 声明与联系方式 ## 121 | 122 | 由于作者水平和研究方向所限，无法对所有模块都非常精通，因此文档中不可避免的会出现各种错误、疏漏和不足之处。如果您在使用过程中有任何意见、建议和疑问，欢迎发送邮件到scp173.cool@gmail.com与中文文档作者取得联系. 123 | 124 | **本教程不得用于任何形式的商业用途，如果需要转载请与作者或中文文档作者联系，如果发现未经允许复制转载，将保留追求其法律责任的权利。** 125 | 126 | 作者：[SCP-173](https://github.com/KaiwenXiao) 127 | E-mail ：scp173.cool@gmail.com 128 | **如果您需要及时得到指导帮助，可以加微信：SCP173-cool，酌情打赏即可** 129 | ![微信](../images/scp_173.png) 130 | -------------------------------------------------------------------------------- /docs/for_beginners/trap.md: -------------------------------------------------------------------------------- 1 | # Keras使用陷阱 2 | 3 | 这里归纳了Keras使用过程中的一些常见陷阱和解决方法，如果你的模型怎么调都搞不对，或许你有必要看看是不是掉进了哪个猎人的陷阱，成为了一只嗷嗷待宰（？）的猎物 4 | 5 | Keras陷阱不多，我们保持更新，希望能做一个陷阱大全 6 | 7 | 内有恶犬，小心哟 8 | 9 | ## TF卷积核与TH卷积核 10 | 11 | Keras提供了两套后端，Theano和Tensorflow，这是一件幸福的事，就像手中拿着馒头，想蘸红糖蘸红糖，想蘸白糖蘸白糖 12 | 13 | 如果你从无到有搭建自己的一套网络，则大可放心。但如果你想使用一个已有网络，或把一个用th/tf 14 | 训练的网络以另一种后端应用，在载入的时候你就应该特别小心了。 15 | 16 | 卷积核与所使用的后端不匹配，不会报任何错误，因为它们的shape是完全一致的，没有方法能够检测出这种错误。 17 | 18 | 在使用预训练模型时，一个建议是首先找一些测试样本，看看模型的表现是否与预计的一致。 19 | 20 | 如需对卷积核进行转换，可以使用utils.convert_all_kernels_in_model对模型的所有卷积核进行转换 21 | 22 | ## 向BN层中载入权重 23 | 如果你不知道从哪里淘来一个预训练好的BN层，想把它的权重载入到Keras中，要小心参数的载入顺序。 24 | 25 | 一个典型的例子是，将caffe的BN层参数载入Keras中，caffe的BN由两部分构成，bn层的参数是mean，std，scale层的参数是gamma，beta 26 | 27 | 按照BN的文章顺序，似乎载入Keras BN层的参数应该是[mean, std, gamma, beta] 28 | 29 | 然而不是的，Keras的BN层参数顺序应该是[gamma, beta, mean, std]，这是因为gamma和beta是可训练的参数，而mean和std不是 30 | 31 | Keras的可训练参数在前，不可训练参数在后 32 | 33 | 错误的权重顺序不会引起任何报错，因为它们的shape完全相同 34 | 35 | ## shuffle和validation_split的顺序 36 | 37 | 模型的fit函数有两个参数，shuffle用于将数据打乱，validation_split用于在没有提供验证集的时候，按一定比例从训练集中取出一部分作为验证集 38 | 39 | 这里有个陷阱是，程序是先执行validation_split，再执行shuffle的，所以会出现这种情况： 40 | 41 | 假如你的训练集是有序的，比方说正样本在前负样本在后，又设置了validation_split，那么你的验证集中很可能将全部是负样本 42 | 43 | 同样的，这个东西不会有任何错误报出来，因为Keras不可能知道你的数据有没有经过shuffle，保险起见如果你的数据是没shuffle过的，最好手动shuffle一下 44 | 45 | ## Merge层的层对象与函数方法 46 | 47 | Keras定义了一套用于融合张量的方法，位于keras.layers.Merge，里面有两套工具，以大写字母开头的是Keras Layer类，使用这种工具是需要实例化一个Layer对象，然后再使用。以小写字母开头的是张量函数方法，本质上是对Merge Layer对象的一个包装，但使用更加方便一些。注意辨析。 48 | 49 | 50 | ## 未完待续 51 | 52 | 如果你在使用Keras中遇到难以察觉的陷阱，请发信到moyan_work@foxmail.com说明~赠人玫瑰，手有余香，前人踩坑，后人沾光，有道是我不入地狱谁入地狱，愿各位Keras使用者积极贡献Keras陷阱。老规矩，陷阱贡献者将被列入致谢一栏 53 | -------------------------------------------------------------------------------- /docs/images/Thumbs.db: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/Thumbs.db -------------------------------------------------------------------------------- /docs/images/autoencoder_schema.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/autoencoder_schema.jpg -------------------------------------------------------------------------------- /docs/images/basic_ae_32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/basic_ae_32.png -------------------------------------------------------------------------------- /docs/images/cat_data_augmentation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/cat_data_augmentation.png -------------------------------------------------------------------------------- /docs/images/cats_and_dogs.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/cats_and_dogs.png -------------------------------------------------------------------------------- /docs/images/conv5_1_filter_0.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/conv5_1_filter_0.png -------------------------------------------------------------------------------- /docs/images/conv5_2_stitched_filters_8x3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/conv5_2_stitched_filters_8x3.png -------------------------------------------------------------------------------- /docs/images/deep_ae_32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/deep_ae_32.png -------------------------------------------------------------------------------- /docs/images/deep_conv_ae_128.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/deep_conv_ae_128.png -------------------------------------------------------------------------------- /docs/images/denoised_digits.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/denoised_digits.png -------------------------------------------------------------------------------- /docs/images/dual_lstm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/dual_lstm.png -------------------------------------------------------------------------------- /docs/images/encoded_representations.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/encoded_representations.png -------------------------------------------------------------------------------- /docs/images/filter_dream.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/filter_dream.jpg -------------------------------------------------------------------------------- /docs/images/jigsaw-puzzle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/jigsaw-puzzle.png -------------------------------------------------------------------------------- /docs/images/keras-tensorflow-logo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/keras-tensorflow-logo.jpg -------------------------------------------------------------------------------- /docs/images/keras_ubuntu_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/keras_ubuntu_1.png -------------------------------------------------------------------------------- /docs/images/keras_ubuntu_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/keras_ubuntu_2.png -------------------------------------------------------------------------------- /docs/images/keras_windows_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/keras_windows_1.png -------------------------------------------------------------------------------- /docs/images/keras_windows_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/keras_windows_2.png -------------------------------------------------------------------------------- /docs/images/keras_windows_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/keras_windows_3.png -------------------------------------------------------------------------------- /docs/images/magpie.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/magpie.jpg -------------------------------------------------------------------------------- /docs/images/moyan.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/moyan.png -------------------------------------------------------------------------------- /docs/images/multi-input-multi-output-graph.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/multi-input-multi-output-graph.png -------------------------------------------------------------------------------- /docs/images/noisy_digits.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/noisy_digits.png -------------------------------------------------------------------------------- /docs/images/regular_stacked_lstm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/regular_stacked_lstm.png -------------------------------------------------------------------------------- /docs/images/scp_173.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/scp_173.png -------------------------------------------------------------------------------- /docs/images/seasnake.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/seasnake.jpg -------------------------------------------------------------------------------- /docs/images/sparse_ae_32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/sparse_ae_32.png -------------------------------------------------------------------------------- /docs/images/tb_curves.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/tb_curves.png -------------------------------------------------------------------------------- /docs/images/two_branches_sequential_model.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/two_branches_sequential_model.png -------------------------------------------------------------------------------- /docs/images/vae_classes_plane.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/vae_classes_plane.png -------------------------------------------------------------------------------- /docs/images/vae_digits_manifold.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/vae_digits_manifold.png -------------------------------------------------------------------------------- /docs/images/vgg16_filters_overview.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/vgg16_filters_overview.jpg -------------------------------------------------------------------------------- /docs/images/vgg16_modified.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/vgg16_modified.png -------------------------------------------------------------------------------- /docs/images/vgg16_original.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/images/vgg16_original.png -------------------------------------------------------------------------------- /docs/layers/about_layer.md: -------------------------------------------------------------------------------- 1 | # 关于Keras的“层”（Layer） 2 | 3 | 所有的Keras层对象都有如下方法： 4 | 5 | * ```layer.get_weights()```：返回层的权重（numpy array） 6 | 7 | * ```layer.set_weights(weights)```：从numpy array中将权重加载到该层中，要求numpy array的形状与* ```layer.get_weights()```的形状相同 8 | 9 | * ```layer.get_config()```：返回当前层配置信息的字典，层也可以借由配置信息重构: 10 | ```python 11 | layer = Dense(32) 12 | config = layer.get_config() 13 | reconstructed_layer = Dense.from_config(config) 14 | ``` 15 | 16 | 或者： 17 | 18 | ```python 19 | from keras import layers 20 | 21 | config = layer.get_config() 22 | layer = layers.deserialize({'class_name': layer.__class__.__name__, 23 | 'config': config}) 24 | ``` 25 | 26 | 如果层仅有一个计算节点（即该层不是共享层），则可以通过下列方法获得输入张量、输出张量、输入数据的形状和输出数据的形状： 27 | 28 | * ```layer.input``` 29 | 30 | * ```layer.output``` 31 | 32 | * ```layer.input_shape``` 33 | 34 | * ```layer.output_shape``` 35 | 36 | 如果该层有多个计算节点（参考[层计算节点和共享层](../getting_started/functional_API/#node)）。可以使用下面的方法 37 | 38 | * ```layer.get_input_at(node_index)``` 39 | 40 | * ```layer.get_output_at(node_index)``` 41 | 42 | * ```layer.get_input_shape_at(node_index)``` 43 | 44 | * ```layer.get_output_shape_at(node_index)``` -------------------------------------------------------------------------------- /docs/layers/advanced_activation_layer.md: -------------------------------------------------------------------------------- 1 | # 高级激活层Advanced Activation 2 | 3 | ## LeakyReLU层 4 | ```python 5 | keras.layers.advanced_activations.LeakyReLU(alpha=0.3) 6 | ``` 7 | LeakyRelU是修正线性单元（Rectified Linear Unit，ReLU）的特殊版本，当不激活时，LeakyReLU仍然会有非零输出值，从而获得一个小梯度，避免ReLU可能出现的神经元“死亡”现象。即，```f(x)=alpha * x for x < 0```, ```f(x) = x for x>=0``` 8 | 9 | ### 参数 10 | 11 | * alpha：大于0的浮点数，代表激活函数图像中第三象限线段的斜率 12 | 13 | ### 输入shape 14 | 15 | 任意，当使用该层为模型首层时需指定```input_shape```参数 16 | 17 | ### 输出shape 18 | 19 | 与输入相同 20 | 21 | ### 参考文献 22 | 23 | [Rectifier Nonlinearities Improve Neural Network Acoustic Models](https://web.stanford.edu/~awni/papers/relu_hybrid_icml2013_final.pdf) 24 | 25 | *** 26 | 27 | ## PReLU层 28 | ```python 29 | keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None, alpha_constraint=None, shared_axes=None) 30 | ``` 31 | 该层为参数化的ReLU（Parametric ReLU），表达式是：```f(x) = alpha * x for x < 0```, ```f(x) = x for x>=0```，此处的```alpha```为一个与xshape相同的可学习的参数向量。 32 | 33 | ### 参数 34 | 35 | * alpha_initializer：alpha的初始化函数 36 | * alpha_regularizer：alpha的正则项 37 | * alpha_constraint：alpha的约束项 38 | * shared_axes：该参数指定的轴将共享同一组科学系参数，例如假如输入特征图是从2D卷积过来的，具有形如`(batch, height, width, channels)`这样的shape，则或许你会希望在空域共享参数，这样每个filter就只有一组参数，设定`shared_axes=[1,2]`可完成该目标 39 | 40 | ### 输入shape 41 | 42 | 任意，当使用该层为模型首层时需指定```input_shape```参数 43 | 44 | ### 输出shape 45 | 46 | 与输入相同 47 | 48 | ### 参考文献 49 | 50 | * [Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification](http://arxiv.org/pdf/1502.01852v1.pdf) 51 | 52 | *** 53 | 54 | ## ELU层 55 | ```python 56 | keras.layers.advanced_activations.ELU(alpha=1.0) 57 | ``` 58 | ELU层是指数线性单元（Exponential Linera Unit），表达式为： 59 | 该层为参数化的ReLU（Parametric ReLU），表达式是：```f(x) = alpha * (exp(x) - 1.) for x < 0```, ```f(x) = x for x>=0``` 60 | 61 | ### 参数 62 | 63 | * alpha：控制负因子的参数 64 | 65 | ### 输入shape 66 | 67 | 任意，当使用该层为模型首层时需指定```input_shape```参数 68 | 69 | ### 输出shape 70 | 71 | 与输入相同 72 | 73 | ### 参考文献 74 | 75 | * [>Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)](http://arxiv.org/pdf/1511.07289v1.pdf) 76 | 77 | *** 78 | 79 | ## ThresholdedReLU层 80 | ```python 81 | keras.layers.advanced_activations.ThresholdedReLU(theta=1.0) 82 | ``` 83 | 该层是带有门限的ReLU，表达式是：```f(x) = x for x > theta```,```f(x) = 0 otherwise``` 84 | 85 | ### 参数 86 | 87 | * theata：大或等于0的浮点数，激活门限位置 88 | 89 | ### 输入shape 90 | 91 | 任意，当使用该层为模型首层时需指定```input_shape```参数 92 | 93 | ### 输出shape 94 | 95 | 与输入相同 96 | 97 | ### 参考文献 98 | 99 | * [Zero-Bias Autoencoders and the Benefits of Co-Adapting Features](http://arxiv.org/pdf/1402.3337.pdf) 100 | 101 | *** -------------------------------------------------------------------------------- /docs/layers/embedding_layer.md: -------------------------------------------------------------------------------- 1 | # 嵌入层 Embedding 2 | 3 | ## Embedding层 4 | 5 | ```python 6 | keras.layers.embeddings.Embedding(input_dim, output_dim, embeddings_initializer='uniform', embeddings_regularizer=None, activity_regularizer=None, embeddings_constraint=None, mask_zero=False, input_length=None) 7 | ``` 8 | 嵌入层将正整数（下标）转换为具有固定大小的向量，如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]] 9 | 10 | Embedding层只能作为模型的第一层 11 | 12 | ### 参数 13 | 14 | * input_dim：大或等于0的整数，字典长度，即输入数据最大下标+1 15 | 16 | * output_dim：大于0的整数，代表全连接嵌入的维度 17 | 18 | * embeddings_initializer: 嵌入矩阵的初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考[initializers](../other/initializations) 19 | 20 | * embeddings_regularizer: 嵌入矩阵的正则项，为[Regularizer](../other/regularizers)对象 21 | 22 | * embeddings_constraint: 嵌入矩阵的约束项，为[Constraints](../other/constraints)对象 23 | 24 | * mask_zero：布尔值，确定是否将输入中的‘0’看作是应该被忽略的‘填充’（padding）值，该参数在使用[递归层](recurrent_layer)处理变长输入时有用。设置为```True```的话，模型中后续的层必须都支持masking，否则会抛出异常。如果该值为True，则下标0在字典中不可用，input_dim应设置为|vocabulary| + 1。 25 | 26 | * input_length：当输入序列的长度固定时，该值为其长度。如果要在该层后接```Flatten```层，然后接```Dense```层，则必须指定该参数，否则```Dense```层的输出维度无法自动推断。 27 | 28 | 29 | ### 输入shape 30 | 31 | 形如（samples，sequence_length）的2D张量 32 | 33 | ### 输出shape 34 | 35 | 形如(samples, sequence_length, output_dim)的3D张量 36 | 37 | ### 例子 38 | ```python 39 | model = Sequential() 40 | model.add(Embedding(1000, 64, input_length=10)) 41 | # the model will take as input an integer matrix of size (batch, input_length). 42 | # the largest integer (i.e. word index) in the input should be no larger than 999 (vocabulary size). 43 | # now model.output_shape == (None, 10, 64), where None is the batch dimension. 44 | 45 | input_array = np.random.randint(1000, size=(32, 10)) 46 | 47 | model.compile('rmsprop', 'mse') 48 | output_array = model.predict(input_array) 49 | assert output_array.shape == (32, 10, 64) 50 | ``` 51 | 52 | ### 参考文献 53 | 54 | * [A Theoretically Grounded Application of Dropout in Recurrent Neural Networks](http://arxiv.org/abs/1512.05287) -------------------------------------------------------------------------------- /docs/layers/locally_connected_layer.md: -------------------------------------------------------------------------------- 1 | # 局部连接层LocallyConnceted 2 | 3 | ## LocallyConnected1D层 4 | ```python 5 | keras.layers.local.LocallyConnected1D(filters, kernel_size, strides=1, padding='valid', data_format=None, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None) 6 | ``` 7 | ```LocallyConnected1D```层与```Conv1D```工作方式类似，唯一的区别是不进行权值共享。即施加在不同输入位置的滤波器是不一样的。 8 | 9 | ### 参数 10 | 11 | * filters：卷积核的数目（即输出的维度） 12 | 13 | * kernel_size：整数或由单个整数构成的list/tuple，卷积核的空域或时域窗长度 14 | 15 | * strides：整数或由单个整数构成的list/tuple，为卷积的步长。任何不为1的strides均与任何不为1的dilation_rata均不兼容 16 | 17 | * padding：补0策略，目前仅支持`valid`（大小写敏感），`same`可能会在将来支持。 18 | 19 | * activation：激活函数，为预定义的激活函数名（参考[激活函数](../other/activations)），或逐元素（element-wise）的Theano函数。如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x） 20 | 21 | * dilation_rate：整数或由单个整数构成的list/tuple，指定dilated convolution中的膨胀比例。任何不为1的dilation_rata均与任何不为1的strides均不兼容。 22 | 23 | * use_bias:布尔值，是否使用偏置项 24 | 25 | * kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考[initializers](../other/initializations) 26 | 27 | * bias_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考[initializers](../other/initializations) 28 | 29 | * kernel_regularizer：施加在权重上的正则项，为[Regularizer](../other/regularizers)对象 30 | 31 | * bias_regularizer：施加在偏置向量上的正则项，为[Regularizer](../other/regularizers)对象 32 | 33 | * activity_regularizer：施加在输出上的正则项，为[Regularizer](../other/regularizers)对象 34 | 35 | * kernel_constraints：施加在权重上的约束项，为[Constraints](../other/constraints)对象 36 | 37 | * bias_constraints：施加在偏置上的约束项，为[Constraints](../other/constraints)对象 38 | 39 | ### 输入shape 40 | 41 | 形如（samples，steps，input_dim）的3D张量 42 | 43 | ### 输出shape 44 | 45 | 形如（samples，new_steps，nb_filter）的3D张量，因为有向量填充的原因，```steps```的值会改变 46 | 47 | 48 | *** 49 | 50 | ## LocallyConnected2D层 51 | ```python 52 | keras.layers.local.LocallyConnected2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None) 53 | ``` 54 | ```LocallyConnected2D```层与```Convolution2D```工作方式类似，唯一的区别是不进行权值共享。即施加在不同输入patch的滤波器是不一样的，当使用该层作为模型首层时，需要提供参数```input_dim```或```input_shape```参数。参数含义参考```Convolution2D```。 55 | 56 | ### 参数 57 | 58 | * filters：卷积核的数目（即输出的维度） 59 | 60 | * kernel_size：单个整数或由两个整数构成的list/tuple，卷积核的宽度和长度。如为单个整数，则表示在各个空间维度的相同长度。 61 | 62 | * strides：单个整数或由两个整数构成的list/tuple，为卷积的步长。如为单个整数，则表示在各个空间维度的相同步长。 63 | 64 | * padding：补0策略，目前仅支持`valid`（大小写敏感），`same`可能会在将来支持。 65 | 66 | * activation：激活函数，为预定义的激活函数名（参考[激活函数](../other/activations)），或逐元素（element-wise）的Theano函数。如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x） 67 | 68 | * data_format：字符串，“channels_first”或“channels_last”之一，代表图像的通道维的位置。该参数是Keras 1.x中的image_dim_ordering，“channels_last”对应原本的“tf”，“channels_first”对应原本的“th”。以128x128的RGB图像为例，“channels_first”应将数据组织为（3,128,128），而“channels_last”应将数据组织为（128,128,3）。该参数的默认值是```~/.keras/keras.json```中设置的值，若从未设置过，则为“channels_last”。 69 | 70 | * use_bias:布尔值，是否使用偏置项 71 | 72 | * kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考[initializers](../other/initializations) 73 | 74 | * bias_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考[initializers](../other/initializations) 75 | 76 | * kernel_regularizer：施加在权重上的正则项，为[Regularizer](../other/regularizers)对象 77 | 78 | * bias_regularizer：施加在偏置向量上的正则项，为[Regularizer](../other/regularizers)对象 79 | 80 | * activity_regularizer：施加在输出上的正则项，为[Regularizer](../other/regularizers)对象 81 | 82 | * kernel_constraints：施加在权重上的约束项，为[Constraints](../other/constraints)对象 83 | 84 | * bias_constraints：施加在偏置上的约束项，为[Constraints](../other/constraints)对象 85 | 86 | ### 输入shape 87 | 88 | ‘channels_first’模式下，输入形如（samples,channels，rows，cols）的4D张量 89 | 90 | ‘channels_last’模式下，输入形如（samples，rows，cols，channels）的4D张量 91 | 92 | 注意这里的输入shape指的是函数内部实现的输入shape，而非函数接口应指定的```input_shape```，请参考下面提供的例子。 93 | 94 | ### 输出shape 95 | 96 | ‘channels_first’模式下，为形如（samples，nb_filter, new_rows, new_cols）的4D张量 97 | 98 | ‘channels_last’模式下，为形如（samples，new_rows, new_cols，nb_filter）的4D张量 99 | 100 | 输出的行列数可能会因为填充方法而改变 101 | 102 | ### 例子 103 | 104 | ```python 105 | # apply a 3x3 unshared weights convolution with 64 output filters on a 32x32 image 106 | # with `data_format="channels_last"`: 107 | model = Sequential() 108 | model.add(LocallyConnected2D(64, (3, 3), input_shape=(32, 32, 3))) 109 | # now model.output_shape == (None, 30, 30, 64) 110 | # notice that this layer will consume (30*30)*(3*3*3*64) + (30*30)*64 parameters 111 | 112 | # add a 3x3 unshared weights convolution on top, with 32 output filters: 113 | model.add(LocallyConnected2D(32, (3, 3))) 114 | # now model.output_shape == (None, 28, 28, 32) 115 | ``` 116 | -------------------------------------------------------------------------------- /docs/layers/merge.md: -------------------------------------------------------------------------------- 1 | #Merge层 2 | 3 | Merge层提供了一系列用于融合两个层或两个张量的层对象和方法。以大写首字母开头的是Layer类，以小写字母开头的是张量的函数。小写字母开头的张量函数在内部实际上是调用了大写字母开头的层。 4 | 5 | ## Add 6 | ```python 7 | keras.layers.Add() 8 | ``` 9 | 添加输入列表的图层。 10 | 11 | 该层接收一个相同shape列表张量，并返回它们的和，shape不变。 12 | 13 | ### Example 14 | 15 | ```python 16 | import keras 17 | 18 | input1 = keras.layers.Input(shape=(16,)) 19 | x1 = keras.layers.Dense(8, activation='relu')(input1) 20 | input2 = keras.layers.Input(shape=(32,)) 21 | x2 = keras.layers.Dense(8, activation='relu')(input2) 22 | added = keras.layers.Add()([x1, x2]) # equivalent to added = keras.layers.add([x1, x2]) 23 | 24 | out = keras.layers.Dense(4)(added) 25 | model = keras.models.Model(inputs=[input1, input2], outputs=out) 26 | ``` 27 | 28 | ## SubStract 29 | ```python 30 | keras.layers.Subtract() 31 | ``` 32 | 两个输入的层相减。 33 | 34 | 它将大小至少为2，相同Shape的列表张量作为输入，并返回一个张量（输入[0] - 输入[1]），也是相同的Shape。 35 | 36 | 37 | ### Example 38 | 39 | ```python 40 | import keras 41 | 42 | input1 = keras.layers.Input(shape=(16,)) 43 | x1 = keras.layers.Dense(8, activation='relu')(input1) 44 | input2 = keras.layers.Input(shape=(32,)) 45 | x2 = keras.layers.Dense(8, activation='relu')(input2) 46 | # Equivalent to subtracted = keras.layers.subtract([x1, x2]) 47 | subtracted = keras.layers.Subtract()([x1, x2]) 48 | 49 | out = keras.layers.Dense(4)(subtracted) 50 | model = keras.models.Model(inputs=[input1, input2], outputs=out) 51 | ``` 52 | 53 | ## Multiply 54 | ```python 55 | keras.layers.Multiply() 56 | ``` 57 | 该层接收一个列表的同shape张量，并返回它们的逐元素积的张量，shape不变。 58 | 59 | ## Average 60 | ```python 61 | keras.layers.Average() 62 | ``` 63 | 该层接收一个列表的同shape张量，并返回它们的逐元素均值，shape不变。 64 | 65 | 66 | ## Maximum 67 | ```python 68 | keras.layers.Maximum() 69 | ``` 70 | 该层接收一个列表的同shape张量，并返回它们的逐元素最大值，shape不变。 71 | 72 | ## Concatenate 73 | ```python 74 | keras.layers.Concatenate(axis=-1) 75 | ``` 76 | 该层接收一个列表的同shape张量，并返回它们的按照给定轴相接构成的向量。 77 | 78 | ### 参数 79 | 80 | * axis: 想接的轴 81 | * **kwargs: 普通的Layer关键字参数 82 | 83 | ## Dot 84 | ```python 85 | keras.layers.Dot(axes, normalize=False) 86 | ``` 87 | 计算两个tensor中样本的张量乘积。例如，如果两个张量```a```和```b```的shape都为（batch_size, n），则输出为形如（batch_size,1）的张量，结果张量每个batch的数据都是a[i,:]和b[i,:]的矩阵（向量）点积。 88 | 89 | 90 | ### 参数 91 | 92 | * axes: 整数或整数的tuple，执行乘法的轴。 93 | * normalize: 布尔值，是否沿执行成绩的轴做L2规范化，如果设为True，那么乘积的输出是两个样本的余弦相似性。 94 | * **kwargs: 普通的Layer关键字参数 95 | 96 | 97 | ## add 98 | ```python 99 | keras.layers.add(inputs) 100 | ``` 101 | Add层的函数式包装 102 | 103 | ###参数： 104 | 105 | * inputs: 长度至少为2的张量列表A 106 | * **kwargs: 普通的Layer关键字参数 107 | ###返回值 108 | 109 | 输入列表张量之和 110 | 111 | ### Example 112 | ```python 113 | import keras 114 | 115 | input1 = keras.layers.Input(shape=(16,)) 116 | x1 = keras.layers.Dense(8, activation='relu')(input1) 117 | input2 = keras.layers.Input(shape=(32,)) 118 | x2 = keras.layers.Dense(8, activation='relu')(input2) 119 | added = keras.layers.add([x1, x2]) 120 | 121 | out = keras.layers.Dense(4)(added) 122 | model = keras.models.Model(inputs=[input1, input2], outputs=out) 123 | ``` 124 | 125 | 126 | ## subtract 127 | ```python 128 | keras.layers.subtract(inputs) 129 | ``` 130 | Subtract层的函数式包装 131 | 132 | ###参数： 133 | 134 | * inputs: 长度至少为2的张量列表A 135 | * **kwargs: 普通的Layer关键字参数 136 | ###返回值 137 | 138 | 输入张量列表的差别 139 | 140 | ### Example 141 | ```python 142 | import keras 143 | 144 | input1 = keras.layers.Input(shape=(16,)) 145 | x1 = keras.layers.Dense(8, activation='relu')(input1) 146 | input2 = keras.layers.Input(shape=(32,)) 147 | x2 = keras.layers.Dense(8, activation='relu')(input2) 148 | subtracted = keras.layers.subtract([x1, x2]) 149 | 150 | out = keras.layers.Dense(4)(subtracted) 151 | model = keras.models.Model(inputs=[input1, input2], outputs=out) 152 | ``` 153 | 154 | ## multiply 155 | ```python 156 | keras.layers.multiply(inputs) 157 | ``` 158 | Multiply的函数式包装 159 | 160 | ###参数： 161 | 162 | * inputs: 长度至少为2的张量列表 163 | * **kwargs: 普通的Layer关键字参数 164 | ###返回值 165 | 166 | 输入列表张量之逐元素积 167 | 168 | ## average 169 | ```python 170 | keras.layers.average(inputs) 171 | ``` 172 | Average的函数包装 173 | 174 | ###参数： 175 | 176 | * inputs: 长度至少为2的张量列表 177 | * **kwargs: 普通的Layer关键字参数 178 | ###返回值 179 | 180 | 输入列表张量之逐元素均值 181 | 182 | ## maximum 183 | ```python 184 | keras.layers.maximum(inputs) 185 | ``` 186 | Maximum的函数包装 187 | 188 | ###参数： 189 | 190 | * inputs: 长度至少为2的张量列表 191 | * **kwargs: 普通的Layer关键字参数 192 | ###返回值 193 | 194 | 输入列表张量之逐元素均值 195 | 196 | 197 | ## concatenate 198 | ```python 199 | keras.layers.concatenate(inputs, axis=-1) 200 | ``` 201 | Concatenate的函数包装 202 | 203 | ### 参数 204 | * inputs: 长度至少为2的张量列 205 | * axis: 相接的轴 206 | * **kwargs: 普通的Layer关键字参数 207 | 208 | ## dot 209 | ```python 210 | keras.layers.dot(inputs, axes, normalize=False) 211 | ``` 212 | Dot的函数包装 213 | 214 | 215 | ### 参数 216 | * inputs: 长度至少为2的张量列 217 | * axes: 整数或整数的tuple，执行乘法的轴。 218 | * normalize: 布尔值，是否沿执行成绩的轴做L2规范化，如果设为True，那么乘积的输出是两个样本的余弦相似性。 219 | * **kwargs: 普通的Layer关键字参数 220 | -------------------------------------------------------------------------------- /docs/layers/noise_layer.md: -------------------------------------------------------------------------------- 1 | # 噪声层Noise 2 | 3 | ## GaussianNoise层 4 | ```python 5 | keras.layers.noise.GaussianNoise(stddev) 6 | ``` 7 | 8 | 为数据施加0均值，标准差为```stddev```的加性高斯噪声。该层在克服过拟合时比较有用，你可以将它看作是随机的数据提升。高斯噪声是需要对输入数据进行破坏时的自然选择。 9 | 10 | 11 | 因为这是一个起正则化作用的层，该层只在训练时才有效。 12 | 13 | ### 参数 14 | 15 | * stddev：浮点数，代表要产生的高斯噪声标准差 16 | 17 | ### 输入shape 18 | 19 | 任意，当使用该层为模型首层时需指定```input_shape```参数 20 | 21 | ### 输出shape 22 | 23 | 与输入相同 24 | 25 | *** 26 | 27 | ## GaussianDropout层 28 | ```python 29 | keras.layers.noise.GaussianDropout(rate) 30 | ``` 31 | 为层的输入施加以1为均值，标准差为```sqrt(rate/(1-rate)```的乘性高斯噪声 32 | 33 | 因为这是一个起正则化作用的层，该层只在训练时才有效。 34 | 35 | ### 参数 36 | 37 | * rate：浮点数，断连概率，与[Dropout层](core_layer/#dropout)相同 38 | 39 | ### 输入shape 40 | 41 | 任意，当使用该层为模型首层时需指定```input_shape```参数 42 | 43 | ### 输出shape 44 | 45 | 与输入相同 46 | 47 | ### 参考文献 48 | 49 | * [Dropout: A Simple Way to Prevent Neural Networks from Overfitting](http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf) 50 | 51 | 52 | 53 | ## AlphaDropout 54 | ```python 55 | keras.layers.noise.AlphaDropout(rate, noise_shape=None, seed=None) 56 | ``` 57 | 对输入施加Alpha Dropout 58 | 59 | Alpha Dropout是一种保持输入均值和方差不变的Dropout，该层的作用是即使在dropout时也保持数据的自规范性。 通过随机对负的饱和值进行激活，Alphe Drpout与selu激活函数配合较好。 60 | 61 | 62 | ### 参数 63 | 64 | * rate: 浮点数，类似Dropout的Drop比例。乘性mask的标准差将保证为`sqrt(rate / (1 - rate))`. 65 | * seed: 随机数种子 66 | 67 | ### 输入shape 68 | 69 | 任意，当使用该层为模型首层时需指定```input_shape```参数 70 | 71 | ### 输出shape 72 | 73 | 与输入相同 74 | 75 | ### 参考文献 76 | 77 | [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515) -------------------------------------------------------------------------------- /docs/layers/normalization_layer.md: -------------------------------------------------------------------------------- 1 | # （批）规范化BatchNormalization 2 | 3 | ## BatchNormalization层 4 | ```python 5 | keras.layers.normalization.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None) 6 | ``` 7 | 该层在每个batch上将前一层的激活值重新规范化，即使得其输出数据的均值接近0，其标准差接近1 8 | 9 | ### 参数 10 | 11 | 12 | * axis: 整数，指定要规范化的轴，通常为特征轴。例如在进行```data_format="channels_first```的2D卷积后，一般会设axis=1。 13 | * momentum: 动态均值的动量 14 | * epsilon：大于0的小浮点数，用于防止除0错误 15 | * center: 若设为True，将会将beta作为偏置加上去，否则忽略参数beta 16 | * scale: 若设为True，则会乘以gamma，否则不使用gamma。当下一层是线性的时，可以设False，因为scaling的操作将被下一层执行。 17 | * beta_initializer：beta权重的初始方法 18 | * gamma_initializer: gamma的初始化方法 19 | * moving_mean_initializer: 动态均值的初始化方法 20 | * moving_variance_initializer: 动态方差的初始化方法 21 | * beta_regularizer: 可选的beta正则 22 | * gamma_regularizer: 可选的gamma正则 23 | * beta_constraint: 可选的beta约束 24 | * gamma_constraint: 可选的gamma约束 25 | 26 | 27 | 28 | ### 输入shape 29 | 30 | 任意，当使用本层为模型首层时，指定```input_shape```参数时有意义。 31 | 32 | ### 输出shape 33 | 34 | 与输入shape相同 35 | 36 | ### 参考文献 37 | 38 | * [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](http://arxiv.org/pdf/1502.03167v3.pdf) 39 | 40 | 【Tips】BN层的作用 41 | 42 | （1）加速收敛 43 | （2）控制过拟合，可以少用或不用Dropout和正则 44 | （3）降低网络对初始化权重不敏感 45 | （4）允许使用较大的学习率 46 | -------------------------------------------------------------------------------- /docs/layers/wrapper.md: -------------------------------------------------------------------------------- 1 | # 包装器Wrapper 2 | 3 | ## TimeDistributed包装器 4 | ```python 5 | keras.layers.wrappers.TimeDistributed(layer) 6 | ``` 7 | 该包装器可以把一个层应用到输入的每一个时间步上 8 | 9 | ### 参数 10 | 11 | * layer：Keras层对象 12 | 13 | 输入至少为3D张量，下标为1的维度将被认为是时间维 14 | 15 | 例如，考虑一个含有32个样本的batch，每个样本都是10个向量组成的序列，每个向量长为16，则其输入维度为```(32,10,16)```，其不包含batch大小的```input_shape```为```(10,16)``` 16 | 17 | 我们可以使用包装器```TimeDistributed```包装```Dense```，以产生针对各个时间步信号的独立全连接： 18 | 19 | ```python 20 | # as the first layer in a model 21 | model = Sequential() 22 | model.add(TimeDistributed(Dense(8), input_shape=(10, 16))) 23 | # now model.output_shape == (None, 10, 8) 24 | 25 | # subsequent layers: no need for input_shape 26 | model.add(TimeDistributed(Dense(32))) 27 | # now model.output_shape == (None, 10, 32) 28 | ``` 29 | 30 | 程序的输出数据shape为```(32,10,8)``` 31 | 32 | 使用```TimeDistributed```包装```Dense```严格等价于```layers.TimeDistribuedDense```。不同的是包装器```TimeDistribued```还可以对别的层进行包装，如这里对```Convolution2D```包装： 33 | 34 | ```python 35 | model = Sequential() 36 | model.add(TimeDistributed(Convolution2D(64, 3, 3), input_shape=(10, 3, 299, 299))) 37 | ``` 38 | 39 | ## Bidirectional包装器 40 | ```python 41 | keras.layers.wrappers.Bidirectional(layer, merge_mode='concat', weights=None) 42 | ``` 43 | 双向RNN包装器 44 | 45 | ### 参数 46 | 47 | * layer：```Recurrent```对象 48 | * merge_mode：前向和后向RNN输出的结合方式，为```sum```,```mul```,```concat```,```ave```和```None```之一，若设为None，则返回值不结合，而是以列表的形式返回 49 | 50 | ### 例子 51 | ```python 52 | model = Sequential() 53 | model.add(Bidirectional(LSTM(10, return_sequences=True), input_shape=(5, 10))) 54 | model.add(Bidirectional(LSTM(10))) 55 | model.add(Dense(5)) 56 | model.add(Activation('softmax')) 57 | model.compile(loss='categorical_crossentropy', optimizer='rmsprop') 58 | ``` -------------------------------------------------------------------------------- /docs/layers/writting_layer.md: -------------------------------------------------------------------------------- 1 | #编写自己的层 2 | 3 | 4 | 对于简单的定制操作，我们或许可以通过使用```layers.core.Lambda```层来完成。但对于任何具有可训练权重的定制层，你应该自己来实现。 5 | 6 | 这里是一个Keras2的层应该具有的框架结构(如果你的版本更旧请升级)，要定制自己的层，你需要实现下面三个方法 7 | 8 | * ```build(input_shape)```：这是定义权重的方法，可训练的权应该在这里被加入列表````self.trainable_weights```中。其他的属性还包括```self.non_trainabe_weights```（列表）和```self.updates```（需要更新的形如（tensor, new_tensor）的tuple的列表）。你可以参考```BatchNormalization```层的实现来学习如何使用上面两个属性。这个方法必须设置```self.built = True```，可通过调用```super([layer],self).build()```实现 9 | 10 | * ```call(x)```：这是定义层功能的方法，除非你希望你写的层支持masking，否则你只需要关心```call```的第一个参数：输入张量 11 | 12 | * ```compute_output_shape(input_shape)```：如果你的层修改了输入数据的shape，你应该在这里指定shape变化的方法，这个函数使得Keras可以做自动shape推断 13 | 14 | ```python 15 | from keras import backend as K 16 | from keras.engine.topology import Layer 17 | import numpy as np 18 | 19 | class MyLayer(Layer): 20 | 21 | def __init__(self, output_dim, **kwargs): 22 | self.output_dim = output_dim 23 | super(MyLayer, self).__init__(**kwargs) 24 | 25 | def build(self, input_shape): 26 | # Create a trainable weight variable for this layer. 27 | self.kernel = self.add_weight(name='kernel', 28 | shape=(input_shape[1], self.output_dim), 29 | initializer='uniform', 30 | trainable=True) 31 | super(MyLayer, self).build(input_shape) # Be sure to call this somewhere! 32 | 33 | def call(self, x): 34 | return K.dot(x, self.kernel) 35 | 36 | def compute_output_shape(self, input_shape): 37 | return (input_shape[0], self.output_dim) 38 | ``` 39 | 40 | 现存的Keras层代码可以为你的实现提供良好参考，阅读源代码吧！ 41 | -------------------------------------------------------------------------------- /docs/legacy/acknowledgement.md: -------------------------------------------------------------------------------- 1 |  2 | # 致谢 3 | 4 | 本项目由以下贡献者贡献： 5 | 6 | ## 文档贡献 7 | 8 | | 贡献者 | 页面 | 章节 | 类型 | 9 | |:------:|:----:|:---:|:---:| 10 | |Bigmoyan|keras.io的全部正文| - |翻译| 11 | |Bigmoyan|深度学习与Keras|CNN眼中的世界|翻译| 12 | |Bigmoyan|深度学习与Keras|花式自动编码器|翻译| 13 | |Bigmoyan|快速开始|一些基本概念|编写| 14 | |SCP-173|快速开始|Keras安装和配置指南(Linux)|编写| 15 | |SCP-173|快速开始|Keras安装和配置指南(Windows)|编写| 16 | |Bigmoyan|深度学习与Keras|面向小数据集构建图像分类模型|翻译| 17 | |leo-nlp|深度学习与Keras|在Keras模型中使用预训练的词向量|翻译| 18 | |zhourunlai|工具|I/O工具|翻译| 19 | 20 | ## Tips 21 | 22 | | 贡献者 | 页面 | 23 | |:------:|:---:| 24 | |Bigmoyan|Tips处标注| 25 | |3rduncle|Tips处标注| 26 | |白菜|Tips处标记| 27 | |我是小将|Tips处标记| 28 | |zhourunlai|可视化| 29 | 30 | ## Keras陷阱提示 31 | 32 | | 贡献者 | 页面 | 33 | |:------:|:---:| 34 | |Bigmoyan|tf与th卷积核陷阱| 35 | |Bigmoyan|向BN层载入权重陷阱| 36 | |Yin|validation_spilit与shuffle陷阱| 37 | |Hui Liu|merge与Merge的区别| 38 | ## Reviewers 39 | 40 | | Reviewer | 页面 | 章节 | 41 | |:--------:|:----:|:----:| 42 | |白菜|快速开始泛型模型|共享层| 43 | |白菜|常用数据库|IMDB影评倾向分类| 44 | |doudou|关于模型|关于Keras模型| 45 | |doudou|常用层|Dense层| 46 | |艾子|常用层|Merge层| 47 | |NUDT-小超人、、|快速开始Sequential模型|Merge层| 48 | |毛毛熊|常用数据库|cifar-10| 49 | |迷川浩浩|回调函数|callback| 50 | |tadakey|一些基本概念|张量| 51 | |方渺渺|递归层|recurrent层| 52 | |leo-nlp|快速开始泛型模型|共享层| 53 | |单车|常用层|Masking层| 54 | |张涛|快速开始泛型模型|多输入和多输出模型| 55 | |白菜|FAQ|如何观察中间层的输出| 56 | |毒液|文本预处理|one-hot| 57 | |毒液|回调函数|EarlyStopping| 58 | |毒液|目标函数|可用的目标函数| 59 | |毛毛熊|正则项|缩写| 60 | |木子天一|局部连接层LocallyConnceted|LocallyConnected2D层| 61 | |QiaXi|Pooling层|GlobalMax/GlobalAve| 62 | |shawn|Callback|ModelCheckpoint| 63 | |smallYoki|快速开始|泛型模型| 64 | 65 | ## 示例程序 66 | 67 | * 虚位以待 68 | -------------------------------------------------------------------------------- /docs/legacy/blog/autoencoder.md~: -------------------------------------------------------------------------------- 1 | # 自动编码器：各种各样的自动编码器 2 | 3 | ## 文章信息 4 | 5 | 本文地址：[http://blog.keras.io/how-convolutional-neural-networks-see-the-world.html](http://blog.keras.io/how-convolutional-neural-networks-see-the-world.html) 6 | 7 | 本文作者：Francois Chollet 8 | 9 | 10 | ### 什么是自动编码器（Autoencoder） 11 | -------------------------------------------------------------------------------- /docs/legacy/getting_started/concepts.md: -------------------------------------------------------------------------------- 1 | # 一些基本概念 2 | 3 | 在开始学习Keras之前，我们希望传递一些关于Keras，关于深度学习的基本概念和技术，我们建议新手在使用Keras之前浏览一下本页面提到的内容，这将减少你学习中的困惑 4 | 5 | ## 符号计算 6 | 7 | Keras的底层库使用Theano或TensorFlow，这两个库也称为Keras的后端。无论是Theano还是TensorFlow，都是一个“符号主义”的库。 8 | 9 | 因此，这也使得Keras的编程与传统的Python代码有所差别。笼统的说，符号主义的计算首先定义各种变量，然后建立一个“计算图”，计算图规定了各个变量之间的计算关系。建立好的计算图需要编译已确定其内部细节，然而，此时的计算图还是一个“空壳子”，里面没有任何实际的数据，只有当你把需要运算的输入放进去后，才能在整个模型中形成数据流，从而形成输出值。 10 | 11 | Keras的模型搭建形式就是这种方法，在你搭建Keras模型完毕后，你的模型就是一个空壳子，只有实际生成可调用的函数后（K.function），输入数据，才会形成真正的数据流。 12 | 13 | 使用计算图的语言，如Theano，以难以调试而闻名，当Keras的Debug进入Theano这个层次时，往往也令人头痛。没有经验的开发者很难直观的感受到计算图到底在干些什么。尽管很让人头痛，但大多数的深度学习框架使用的都是符号计算这一套方法，因为符号计算能够提供关键的计算优化、自动求导等功能。 14 | 15 | 我们建议你在使用前稍微了解一下Theano或TensorFlow，Bing/Google一下即可，如果我们要反baidu，那就从拒绝使用baidu开始，光撂嘴炮是没有用的。 16 | 17 | ## 张量 18 | 19 | 张量，或tensor，是本文档会经常出现的一个词汇，在此稍作解释。 20 | 21 | 使用这个词汇的目的是为了表述统一，张量可以看作是向量、矩阵的自然推广，我们用张量来表示广泛的数据类型。 22 | 23 | 规模最小的张量是0阶张量，即标量，也就是一个数。 24 | 25 | 当我们把一些数有序的排列起来，就形成了1阶张量，也就是一个向量 26 | 27 | 如果我们继续把一组向量有序的排列起来，就形成了2阶张量，也就是一个矩阵 28 | 29 | 把矩阵摞起来，就是3阶张量，我们可以称为一个立方体，具有3个颜色通道的彩色图片就是一个这样的立方体 30 | 31 | 把矩阵摞起来，好吧这次我们真的没有给它起别名了，就叫4阶张量了，不要去试图想像4阶张量是什么样子，它就是个数学上的概念。 32 | 33 | 张量的阶数有时候也称为维度，或者轴，轴这个词翻译自英文axis。譬如一个矩阵[[1,2],[3,4]]，是一个2阶张量，有两个维度或轴，沿着第0个轴（为了与python的计数方式一致，本文档维度和轴从0算起）你看到的是[1,2]，[3,4]两个向量，沿着第1个轴你看到的是[1,3]，[2,4]两个向量。 34 | 35 | 要理解“沿着某个轴”是什么意思，不妨试着运行一下下面的代码： 36 | 37 | ```python 38 | import numpy as np 39 | 40 | a = np.array([[1,2],[3,4]]) 41 | sum0 = np.sum(a, axis=0) 42 | sum1 = np.sum(a, axis=1) 43 | 44 | print sum0 45 | print sum1 46 | ``` 47 | 48 | 关于张量，目前知道这么多就足够了。事实上我也就知道这么多 49 | 50 | ## 'th'与'tf' 51 | 52 | 这是一个无可奈何的问题，在如何表示一组彩色图片的问题上，Theano和TensorFlow发生了分歧，'th'模式，也即Theano模式会把100张RGB三通道的16×32（高为16宽为32）彩色图表示为下面这种形式（100,3,16,32），Caffe采取的也是这种方式。第0个维度是样本维，代表样本的数目，第1个维度是通道维，代表颜色通道数。后面两个就是高和宽了。 53 | 54 | 而TensorFlow，即'tf'模式的表达形式是（100,16,32,3），即把通道维放在了最后。这两个表达方法本质上没有什么区别。 55 | 56 | Keras默认的数据组织形式在~/.keras/keras.json中规定，可查看该文件的`image_dim_ordering`一项查看，也可在代码中通过K.image_dim_ordering()函数返回，请在网络的训练和测试中保持维度顺序一致。 57 | 58 | 唉，真是蛋疼，你们商量好不行吗？ 59 | 60 | 61 | 62 | ## 泛型模型 63 | 64 | 65 | 66 | 泛型模型算是本文档比较原创的词汇了，所以这里要说一下 67 | 68 | 在原本的Keras版本中，模型其实有两种，一种叫Sequential，称为序贯模型，也就是单输入单输出，一条路通到底，层与层之间只有相邻关系，跨层连接统统没有。这种模型编译速度快，操作上也比较简单。第二种模型称为Graph，即图模型，这个模型支持多输入多输出，层与层之间想怎么连怎么连，但是编译速度慢。可以看到，Sequential其实是Graph的一个特殊情况。 69 | 70 | 在现在这版Keras中，图模型被移除，而增加了了“functional model API”，这个东西，更加强调了Sequential是特殊情况这一点。一般的模型就称为Model，然后如果你要用简单的Sequential，OK，那还有一个快捷方式Sequential。 71 | 72 | 由于functional model API表达的是“一般的模型”这个概念，我们这里将其译为泛型模型，即只要这个东西接收一个或一些张量作为输入，然后输出的也是一个或一些张量，那不管它是什么鬼，统统都称作“模型”。如果你有更贴切的译法，也欢迎联系我修改。 73 | 74 | 75 | 76 | ## batch 77 | 78 | 79 | 这个概念与Keras无关，老实讲不应该出现在这里的，但是因为它频繁出现，而且不了解这个技术的话看函数说明会很头痛，这里还是简单说一下。 80 | 81 | 深度学习的优化算法，说白了就是梯度下降。每次的参数更新有两种方式。 82 | 83 | 第一种，遍历全部数据集算一次损失函数，然后算函数对各个参数的梯度，更新梯度。这种方法每更新一次参数都要把数据集里的所有样本都看一遍，计算量开销大，计算速度慢，不支持在线学习，这称为Batch gradient descent，批梯度下降。 84 | 85 | 另一种，每看一个数据就算一下损失函数，然后求梯度更新参数，这个称为随机梯度下降，stochastic gradient descent。这个方法速度比较快，但是收敛性能不太好，可能在最优点附近晃来晃去，hit不到最优点。两次参数的更新也有可能互相抵消掉，造成目标函数震荡的比较剧烈。 86 | 87 | 为了克服两种方法的缺点，现在一般采用的是一种折中手段，mini-batch gradient decent，小批的梯度下降，这种方法把数据分为若干个批，按批来更新参数，这样，一个批中的一组数据共同决定了本次梯度的方向，下降起来就不容易跑偏，减少了随机性。另一方面因为批的样本数与整个数据集相比小了很多，计算量也不是很大。 88 | 89 | 基本上现在的梯度下降都是基于mini-batch的，所以Keras的模块中经常会出现batch_size，就是指这个。 90 | 91 | 顺便说一句，Keras中用的优化器SGD是stochastic gradient descent的缩写，但不代表是一个样本就更新一回，还是基于mini-batch的。 92 | 93 | ## 对新手友好的小说明 94 | 95 | 虽然这不是我们应该做的工作，但为了体现本教程对新手的友好，我们在这里简单列一下使用keras需要的先行知识。稍有经验的研究者或开发者请忽略本节，对于新手，我们建议在开始之前，确保你了解下面提到的术语的基本概念。如果你确实对某项内容不了解，请首先查阅相关资料，以免在未来使用中带来困惑。 96 | 97 | ### 关于Python 98 | 99 | * 显然你应对Python有一定的熟悉，包括其基本语法，数据类型，语言特点等，如果你还不能使用Python进行程序设计，或不能避免Python中常见的一些小陷阱，或许你应该先去找个教程补充一下。这里推一个快速学习Python的教程[廖雪峰的Python教程](http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000) 100 | 101 | * 你应该有面向对象的概念，知道类、对象、封装、多态、继承、作用域等术语的含义。 102 | 103 | * 你应该对Python的科学计算包和深度学习包有一定了解，这些包包含但不限于numpy, scipy, scikit-learn, pandas... 104 | 105 | * 特别地，你需要了解什么是生成器函数（generator），以及如何编写生成器函数。什么是匿名函数（lambda） 106 | 107 | ### 关于深度学习 108 | 109 | 由于Keras是为深度学习设计的工具，我们这里只列举深度学习中的一些基本概念。请确保你对下面的概念有一定理解。 110 | 111 | * 有监督学习，无监督学习，分类，聚类，回归 112 | 113 | * 神经元模型，多层感知器，BP算法 114 | 115 | * 目标函数（损失函数），激活函数，梯度下降法 116 | 117 | * 全连接网络、卷积神经网络、递归神经网络 118 | 119 | * 训练集，测试集，交叉验证，欠拟合，过拟合 120 | 121 | * 数据规范化 122 | 123 | * 其他我还没想到的东西……想到再补充 124 | 125 | 126 | ## 其他 127 | 128 | 其他需要注意的概念，我们将使用[Tips]标注出来，如果该概念反复出现又比较重要，我们会写到这里。就酱，玩的愉快哟。 129 | 130 | -------------------------------------------------------------------------------- /docs/legacy/getting_started/concepts.md~: -------------------------------------------------------------------------------- 1 | # 一些基本概念 2 | 3 | 在开始学习Keras之前，我们希望传递一些关于Keras，关于深度学习的基本概念和技术，我们建议新手在使用Keras之前浏览一下本页面提到的内容，这将减少你学习中的困惑 4 | 5 | ## 符号计算 6 | 7 | Keras的底层库使用Theano或TensorFlow，这两个库也称为Keras的后端。无论是Theano还是TensorFlow，都是一个“符号主义”的库。 8 | 9 | 因此，这也使得Keras的编程与传统的Python代码有所差别。笼统的说，符号主义的计算首先定义各种变量，然后建立一个“计算图”，计算图规定了各个变量之间的计算关系。建立好的计算图需要编译已确定其内部细节，然而，此时的计算图还是一个“空壳子”，里面没有任何实际的数据，只有当你把需要运算的输入输入放进去后，才能在整个模型中形成数据流，从而形成输出值。 10 | 11 | Keras的模型搭建形式就是这种方法，在你搭建Keras模型完毕后，你的模型就是一个空壳子，只有当编译完成，输入数据后，才会形成真正的数据流。 12 | 13 | 使用计算图的语言，如Theano，以难以调试而闻名，当Keras的Debug进入Theano这个层次时，往往也令人头痛。没有经验的开发者很难直观的感受到计算图到底在干些什么。尽管很让人头痛，但大多数的深度学习框架使用的都是符号计算这一套方法，因为符号计算能够提供关键的计算优化、并行计算、自动求导功能。 14 | 15 | 我们建议你在使用前稍微了解一下Theano或TensorFlow，Bing/Google一下即可。 16 | 17 | ## 张量 18 | 19 | 张量，或tensor，是本文档会经常出现的一个词汇，在此稍作解释。 20 | 21 | 使用这个词汇的目的是为了表述统一，而不是为了装逼。张量可以看作是向量、矩阵的自然推广。 22 | 23 | 规模最小的张量是0阶张量，即标量，也就是一个数。 24 | 25 | 当我们把一些数有序的排列起来，就形成了1阶张量，也就是一个向量 26 | 27 | 如果我们继续把一组向量有序的排列起来，就形成了2阶张量，也就是一个矩阵 28 | 29 | 把矩阵摞起来，就是3阶张量，我们可以称为一个立方体，具有3个颜色通道的彩色图片就是一个这样的立方体 30 | 31 | 把矩阵摞起来，好吧这次我们真的没有给它起别名了，就叫4阶张量了，不要去试图想像4阶张量是什么样子，它就是个数学上的概念。 32 | 33 | 张量的阶数有时候也称为维度，或者轴，轴这个词翻译自英文axis。譬如一个矩阵[[1,2],[3,4]]，是一个2阶张量，有两个维度或轴，沿着第0个轴（为了与python的计数方式一致，本文档维度和轴从0算起）你看到的是[1,2]，[3,4]两个向量，沿着第1个轴你看到的是[1,3]，[2,4]两个向量。 34 | 35 | 关于张量，目前知道这么多就足够了。事实上我也就知道这么多 36 | 37 | ## 'th'与'tf' 38 | 39 | 这是一个无可奈何的问题，在如何表示一组彩色图片的问题上，Theano和TensorFlow发生了分歧，'th'模式，也即Theano模式会把100张RGB三通道的16×32（高为16宽为32）彩色图表示为下面这种形式（100,3,16,32），Caffe采取的也是这种方式。第0个维度是样本维，代表样本的数目，第1个维度是通道维，代表颜色通道数。后面两个就是高和宽了。 40 | 41 | 而TensorFlow，即'tf'模式的表达形式是（100,16,32,3），即把通道维放在了最后。这两个表达方法本质上没有什么区别。 42 | 43 | Keras默认的后端是Theano，所以所有层的默认数据组织形式是'th'，你按这个方式组织数据即可。利用Keras自带的数据库模块下载的数据库也长这个样子。但是如果你要使用TensorFlow作为后端，记得把自己数据组织成'tf'模式并在所有需要的地方标明你的数据形式是'tf'。 44 | 45 | 唉，真是蛋疼，你们商量好不行吗？ 46 | 47 | ## 泛型模型 48 | 49 | 泛型模型算是本文档比较原创的词汇了，所以这里要说一下 50 | 51 | 在原本的Keras版本中，模型其实有两种，一种叫Sequential，称为序贯模型，也就是单输入单输出，一条路通到底，层与层之间只有相邻关系，跨层连接统统没有。这种模型编译速度快，操作上也比较简单。第二种模型称为Graph，即图模型，这个模型支持多输入多输出，层与层之间想怎么连怎么连，但是编译速度慢。可以看到，Sequential其实是Graph的一个特殊情况。 52 | 53 | 在现在这版Keras中，图模型被移除，而增加了了“functional model API”，这个东西，更加强调了Sequential是特殊情况这一点。一般的模型就称为Model，然后如果你要用简单的Sequential，OK，那还有一个快捷方式Sequential。 54 | 55 | 由于functional model API表达的是“一般的模型”这个概念，我们这里将其译为泛型模型，即只要这个东西接收一个或一些张量作为输入，然后输出的也是一个或一些张量，那不管它是什么鬼，统统都称作“模型”。如果你有更贴切的译法，也欢迎联系我修改。 56 | 57 | ## batch 58 | 59 | 这个概念与Keras无关，老实讲不应该出现在这里的，但是因为它频繁出现，而且不了解这个技术的话看函数说明会很头痛，这里还是简单说一下。 60 | 61 | 深度学习的优化算法，说白了就是梯度下降。每次的参数更新有两种方式。 62 | 63 | 第一种，遍历全部数据集算一次损失函数，然后算函数对各个参数的梯度，更新梯度。这种方法每更新一次参数都要把数据集里的所有样本都看一遍，计算量十分大，称为Batch gradient descent，批梯度下降。 64 | 65 | 另一种，每看一个数据就算一下损失函数，然后求梯度更新参数，这个称为随机梯度下降，stochastic gradient descent。这个方法速度比较快，但是收敛速度慢，两次参数的更新有可能互相抵消掉。 66 | 67 | 为了克服两种方法的缺点，现在一般采用的是一种折中手段，mini-batch gradient decent，小批的梯度下降，这种方法把数据分为若干个批，按批来更新参数，这样，一个批中的一组数据共同决定了本次梯度的方向，下降起来就不容易跑偏，减少了随机性。另一方面因为批的样本数与整个数据集相比小了很多，计算量也不是很大。 68 | 69 | 基本上现在的梯度下降都是基于mini-batch的，所以Keras的模块中经常会出现batch_size，就是指这个。 70 | 71 | 顺便说一句，Keras中用的优化器SGD是stochastic gradient descent的缩写，但不代表是一个样本就更新一回，还是基于mini-batch的。 72 | 73 | ## 其他 74 | 75 | 其他需要注意的概念，我们将使用[Tips]注在它第一次出现的地方，如果该概念反复出现又比较重要，我们会写到这里。就酱，玩的愉快哟。 76 | 77 | -------------------------------------------------------------------------------- /docs/legacy/getting_started/examples.md: -------------------------------------------------------------------------------- 1 | # Keras 示例程序 2 | 3 | 4 | ## Keras示例程序 5 | 6 | 7 | * addition_rnn.py: 序列到序列学习, 实现两个数的加法 8 | 9 | * antirectifier.py: 展示了如何在Keras中定制自己的层 10 | 11 | * babi_memnn.py: 在bAbI数据集上训练一个记忆网络,用于阅读理解 12 | 13 | * babi_rnn.py: 在bAbI数据集上训练一个循环网络,用于阅读理解 14 | 15 | * cifar10_cnn.py: 在CIFAR10数据集上训练一个简单的深度CNN网络,用于小图片识别 16 | 17 | * conv_filter_visualization.py: 通过在输入空间上梯度上升可视化VGG16的滤波器 18 | 19 | * conv_lstm.py: 展示了一个卷积LSTM网络的应用 20 | 21 | * deep_dream.py: Google DeepDream的Keras实现 22 | 23 | * image_ocr.py:训练了一个卷积+循环网络+CTC logloss来进行OCR 24 | 25 | * imdb_bidirectional_lstm.py: 在IMDB数据集上训练一个双向LSTM网络,用于情感分类. 26 | 27 | * imdb_cnn.py: 展示了如何在文本分类上如何使用Covolution1D 28 | 29 | * imdb_cnn_lstm.py: 训练了一个栈式的卷积网络+循环网络进行IMDB情感分类. 30 | 31 | * imdb_fasttext.py: 训练了一个FastText模型用于IMDB情感分类 32 | 33 | * imdb_lstm.py: 训练了一个LSTM网络用于IMDB情感分类. 34 | 35 | * lstm_benchmark.py: 在IMDB情感分类上比较了LSTM的不同实现的性能 36 | 37 | * lstm_text_generation.py: 从尼采的作品中生成文本 38 | 39 | * mnist_acgan.py：AC-GAN(Auxiliary Classifier GAN)实现的示例 40 | 41 | * mnist_cnn.py: 训练一个用于mnist数据集识别的卷积神经网络 42 | 43 | * mnist_hierarchical_rnn.py: 训练了一个HRNN网络用于MNIST数字识别 44 | 45 | * mnist_irnn.py: 重现了基于逐像素点序列的IRNN实验,文章见Le et al. "A Simple Way to Initialize Recurrent Networks of Rectified Linear Units" 46 | 47 | * mnist_mlp.py: 训练了一个简单的多层感知器用于MNIST分类 48 | 49 | * mnist_net2net.py: 在mnist上重现了文章中的Net2Net实验,文章为"Net2Net: Accelerating Learning via Knowledge Transfer". 50 | 51 | * mnist_siamese_graph.py:基于MNIST训练了一个多层感知器的Siamese网络 52 | 53 | * mnist_sklearn_wrapper.py: 展示了如何使用sklearn包装器 54 | 55 | * mnist_swwae.py: 基于残差网络和MNIST训练了一个栈式的What-Where自动编码器 56 | 57 | * mnist_transfer_cnn.py: 迁移学习的小例子 58 | 59 | * neural_doodle.py:神经网络绘画 60 | 61 | * neural_style_transfer.py: 图像风格转移 62 | 63 | * pretrained_word_embeddings.py: 将GloVe嵌入层载入固化的Keras Embedding层中, 并用以在新闻数据集上训练文本分类模型 64 | 65 | * reuters_mlp.py: 训练并评估一个简单的多层感知器进行路透社新闻主题分类 66 | 67 | * stateful_lstm.py: 展示了如何使用状态RNN对长序列进行建模 68 | 69 | * variational_autoencoder.py: 展示了如何搭建变分编码器 70 | 71 | * variational_autoencoder_deconv.py Demonstrates how to build a variational autoencoder with Keras using deconvolution layers. 72 | -------------------------------------------------------------------------------- /docs/legacy/getting_started/examples.md~: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/getting_started/examples.md~ -------------------------------------------------------------------------------- /docs/legacy/getting_started/keras_linux.md: -------------------------------------------------------------------------------- 1 | # 声明 2 | **本教程不得用于任何形式的商业用途，如果需要转载请与作者SCP-173联系，如果发现未经允许复制转载，将保留追求其法律责任的权利。** 3 | 4 | 5 | 6 | --- 7 | ## 关于计算机的硬件配置说明 8 | ### 推荐配置 9 | 如果您是高校学生或者高级研究人员，并且实验室或者个人资金充沛，建议您采用如下配置： 10 | 11 | - 主板：X99型号或Z170型号 12 | - CPU：i7-5830K或i7-6700K 及其以上高级型号 13 | - 内存：品牌内存，总容量32G以上，根据主板组成4通道或8通道 14 | - SSD：品牌固态硬盘，容量256G以上 15 | - 显卡：**NVIDIA GTX 1080 Ti、NVIDIA GTX 1080、NVIDIA GTX 1070、NVIDIA GTX 1060 (顺序为优先建议，并且建议同一显卡，可以根据主板插槽数量购买多块，例如X99型号主板最多可以采用×4的显卡)** 16 | - 电源：由主机机容量的确定，一般有显卡总容量后再加200W即可 17 | ### 最低配置 18 | 如果您是仅仅用于自学或代码调试，亦或是条件所限仅采用自己现有的设备进行开发，那么您的电脑至少满足以下几点： 19 | 20 | - CPU：Intel第三代i5和i7以上系列产品或同性能AMD公司产品 21 | - 内存：总容量4G以上 22 | 23 | ### CPU说明 24 | - 大多数CPU目前支持多核多线程，那么如果您采用CPU加速，就可以使用多线程运算。这方面的优势对于服务器CPU集群和多核并行CPU尤为关键 25 | ### 显卡说明 26 | - 如果您的显卡是非NVIDIA公司的产品或是NVIDIA GTX系列中型号的第一个数字低于4或NVIDIA的GT系列，都不建议您采用此类显卡进行加速计算，例如`NVIDIA GT 910`、`NVIDIA GTX 450` 等等。 27 | - 如果您的显卡为笔记本上的GTX移动显卡（型号后面带有标识M），那么请您慎重使用显卡加速，因为移动版GPU很容易发生过热烧毁现象。 28 | - 如果您的显卡，显示的是诸如 `HD5000`,`ATI 5650` 等类型的显卡，那么您只能使用CPU加速 29 | - 如果您的显卡为Pascal架构的显卡（`NVIDIA GTX 1080`,`NVIDIA GTX 1070`等），您只能在之后的配置中选择`CUDA 8.0` 30 | --- 31 | 32 | ## 基本开发环境搭建 33 | ### 1. Linux 发行版 34 | linux有很多发行版，本文强烈建议读者采用新版的`Ubuntu 16.04 LTS` 35 | 一方面，对于大多数新手来说Ubuntu具有很好的图形界面，与乐观的开源社区；另一方面，Ubuntu是Nvidia官方以及绝大多数深度学习框架默认开发环境。 36 | 个人不建议使用Ubuntu Kylin，之前提出有部分信息表示，中国官方开发的这个版本有部分功能被“阉割”，你懂得。 37 | Ubuntu 16.04 LTS下载地址： 38 | 39 | [http://www.ubuntu.org.cn/download/desktop](http://www.ubuntu.org.cn/download/desktop) 40 | 41 | ![keras_linux_ubuntu](../images/keras_linux_ubuntu.png) 42 | 43 | 通过U盘安装好后，进行初始化环境设置。 44 | 45 | ### 2. Ubuntu初始环境设置 46 | 47 | - 安装开发包 48 | 打开`终端`输入： 49 | ```bash 50 | # 系统升级 51 | >>> sudo apt update 52 | >>> sudo apt upgrade 53 | # 安装python基础开发包 54 | >>> sudo apt install -y python-dev python-pip python-nose gcc g++ git gfortran vim 55 | ``` 56 | 57 | - 安装运算加速库 58 | 打开`终端`输入： 59 | ``` 60 | >>> sudo apt install -y libopenblas-dev liblapack-dev libatlas-base-dev 61 | ``` 62 | 63 | ### 3. CUDA开发环境的搭建(CPU加速跳过) 64 | ***如果您的仅仅采用cpu加速，可跳过此步骤*** 65 | - 下载CUDA8.0 66 | 67 | 下载地址： 68 | 69 | [https://developer.nvidia.com/cuda-downloads](https://developer.nvidia.com/cuda-downloads) 70 | ![keras_linux_cuda](../images/keras_linux_cuda.png) 71 | 72 | 之后打开`终端`输入： 73 | 74 | ``` 75 | >>> sudo dpkg -i cuda-repo-ubuntu1604-8-0-local_8.0.44-1_amd64.deb 76 | >>> sudo apt update 77 | >>> sudo apt install cuda 78 | ``` 79 | 自动配置成功就好。 80 | 81 | - 将CUDA路径添加至环境变量 82 | 在`终端`输入： 83 | ``` 84 | >>> sudo gedit /etc/bash.bashrc 85 | ``` 86 | 在`bash.bashrc`文件中添加： 87 | ```bash 88 | export CUDA_HOME=/usr/local/cuda-8.0 89 | export PATH=/usr/local/cuda-8.0/bin${PATH:+:${PATH}} 90 | export LD_LIBRARY_PATH=/usr/local/cuda-8.0/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}} 91 | ``` 92 | 之后`source gedit /etc/.bashrc`即可 93 | 同样，在`终端`输入： 94 | ``` 95 | >>> sudo gedit ~/.bashrc 96 | ``` 97 | 在`.bashrc`中添加如上相同内容 98 | （如果您使用的是`zsh`，在`~/.zshrc`添加即可） 99 | 100 | - 测试 101 | 在`终端`输入： 102 | ``` 103 | >>> nvcc -V 104 | ``` 105 | 会得到相应的nvcc编译器相应的信息，那么CUDA配置成功了。 106 | 记得重启系统 107 | 108 | ### 4. 加速库cuDNN（可选） 109 | 从官网下载需要注册账号申请，两三天批准。网盘搜索一般也能找到最新版。 110 | Linux目前就是cudnn-8.0-win-x64-v5.1-prod.zip。 111 | 下载解压出来是名为cuda的文件夹，里面有bin、include、lib，将三个文件夹复制到安装CUDA的地方覆盖对应文件夹，在终端中输入： 112 | ```shell 113 | >>> sudo cp include/cudnn.h /usr/local/cuda-8.0/include/ 114 | >>> sudo cp lib64/* /usr/local/cuda-8.0/lib64/ 115 | ``` 116 | 117 | ## Keras框架搭建 118 | 119 | ### 相关开发包安装 120 | 在`终端`中输入: 121 | ``` 122 | >>> sudo pip install -U --pre pip setuptools wheel 123 | >>> sudo pip install -U --pre numpy scipy matplotlib scikit-learn scikit-image 124 | >>> sudo pip install -U --pre theano 125 | >>> sudo pip install -U --pre keras 126 | ``` 127 | 安装完毕后，输入`python`，然后输入： 128 | ```python 129 | >>> import theano 130 | >>> import keras 131 | ``` 132 | 如果没有任何提示，则表明安装已经成功 133 | 134 | 135 | 136 | ### Keras环境设置 137 | 138 | - 修改默认keras后端 139 | 在`终端`中输入: 140 | ```shell 141 | >>> gedit ~/.keras/keras.json 142 | ``` 143 | - 配置theano文件 144 | 在`终端`中输入: 145 | ``` 146 | >>> gedit ~/.theanorc 147 | ``` 148 | 并写入以下： 149 | ``` 150 | [global] 151 | openmp=False 152 | device = gpu 153 | floatX = float32 154 | allow_input_downcast=True 155 | [lib] 156 | cnmem = 0.8 157 | [blas] 158 | ldflags= -lopenblas 159 | [nvcc] 160 | fastmath = True 161 | ``` 162 | 163 | 如果您的所安装的是CPU加速版本，那么`.theanorc`文件配置如下： 164 | 165 | ``` 166 | [global] 167 | openmp=True 168 | device = cpu 169 | floatX = float32 170 | allow_input_downcast=True 171 | [blas] 172 | ldflags= -lopenblas 173 | ``` 174 | 之后可以验证keras是否安装成功,在命令行中输入Python命令进入Python变成命令行环境： 175 | ```python 176 | >>>import keras 177 | ``` 178 | 没有报错，并且会打印出关于显卡信息以及`cnmem`等信息（CPU版本没有）那么Keras就已经**成功安装**了。 179 | 180 | 181 | ## 加速测试 182 | ### 速度测试 183 | 新建一个文件`test.py`，内容为： 184 | ``` python 185 | from theano import function, config, shared, sandbox 186 | import theano.tensor as T 187 | import numpy 188 | import time 189 | 190 | vlen = 10 * 30 * 768 # 10 x #cores x # threads per core 191 | iters = 1000 192 | 193 | rng = numpy.random.RandomState(22) 194 | x = shared(numpy.asarray(rng.rand(vlen), config.floatX)) 195 | f = function([], T.exp(x)) 196 | print(f.maker.fgraph.toposort()) 197 | t0 = time.time() 198 | for i in range(iters): 199 | r = f() 200 | t1 = time.time() 201 | print("Looping %d times took %f seconds" % (iters, t1 - t0)) 202 | print("Result is %s" % (r,)) 203 | if numpy.any([isinstance(x.op, T.Elemwise) for x in f.maker.fgraph.toposort()]): 204 | print('Used the cpu') 205 | else: 206 | print('Used the gpu') 207 | ``` 208 | 209 | 在GTX 970显卡下，输出结果大概是0.21秒，在一百倍运算量下19秒，可以进行对比。 210 | 理论上，相比较主频为3.3GHz的CPU，加速比应该是75倍，但不同的ssd和内存限制了IO接口传输速度。 211 | 212 | 213 | ### Keras中mnist数据集测试 214 | 下载Keras开发包 215 | ``` 216 | git clone https://github.com/fchollet/keras.git 217 | cd keras/examples/ 218 | python mnist_mlp.py 219 | ``` 220 | 程序无错进行，至此，keras安装完成。 221 | 222 | 223 | ### 声明与联系方式 ## 224 | 225 | 由于作者水平和研究方向所限，无法对所有模块都非常精通，因此文档中不可避免的会出现各种错误、疏漏和不足之处。如果您在使用过程中有任何意见、建议和疑问，欢迎发送邮件到scp173.cool@gmail.com与作者取得联系. 226 | 227 | **本教程不得用于任何形式的商业用途，如果需要转载请与作者或中文文档作者联系，如果发现未经允许复制转载，将保留追求其法律责任的权利。** 228 | 229 | 作者：[SCP-173](https://github.com/KaiwenXiao) 230 | E-mail ：scp173.cool@gmail.com 231 | **如果您需要及时得到指导帮助，可以加微信：SCP173-cool，酌情打赏即可** 232 | 233 | ![微信](../images/scp_173.png) 234 | -------------------------------------------------------------------------------- /docs/legacy/getting_started/trap.md: -------------------------------------------------------------------------------- 1 | # Keras使用陷阱 2 | 3 | 这里归纳了Keras使用过程中的一些常见陷阱和解决方法，如果你的模型怎么调都搞不对，或许你有必要看看是不是掉进了哪个猎人的陷阱，成为了一只嗷嗷待宰（？）的猎物 4 | 5 | Keras陷阱不多，我们保持更新，希望能做一个陷阱大全 6 | 7 | 内有恶犬，小心哟 8 | 9 | ## TF卷积核与TH卷积核 10 | 11 | Keras提供了两套后端，Theano和Tensorflow，这是一件幸福的事，就像手中拿着馒头，想蘸红糖蘸红糖，想蘸白糖蘸白糖 12 | 13 | 如果你从无到有搭建自己的一套网络，则大可放心。但如果你想使用一个已有网络，或把一个用th/tf 14 | 训练的网络以另一种后端应用，在载入的时候你就应该特别小心了。 15 | 16 | 卷积核与所使用的后端不匹配，不会报任何错误，因为它们的shape是完全一致的，没有方法能够检测出这种错误。 17 | 18 | 在使用预训练模型时，一个建议是首先找一些测试样本，看看模型的表现是否与预计的一致。 19 | 20 | 如需对卷积核进行转换，可以使用utils.np_utils.kernel_convert，或使用utils.layer_utils.convert_all_kernels_in_model来对模型的所有卷积核进行转换 21 | 22 | ## 向BN层中载入权重 23 | 如果你不知道从哪里淘来一个预训练好的BN层，想把它的权重载入到Keras中，要小心参数的载入顺序。 24 | 25 | 一个典型的例子是，将caffe的BN层参数载入Keras中，caffe的BN由两部分构成，bn层的参数是mean，std，scale层的参数是gamma，beta 26 | 27 | 按照BN的文章顺序，似乎载入Keras BN层的参数应该是[mean, std, gamma, beta] 28 | 29 | 然而不是的，Keras的BN层参数顺序应该是[gamma, beta, mean, std]，这是因为gamma和beta是可训练的参数，而mean和std不是 30 | 31 | Keras的可训练参数在前，不可训练参数在后 32 | 33 | 错误的权重顺序不会引起任何报错，因为它们的shape完全相同 34 | 35 | ## shuffle和validation_split的顺序 36 | 37 | 模型的fit函数有两个参数，shuffle用于将数据打乱，validation_split用于在没有提供验证集的时候，按一定比例从训练集中取出一部分作为验证集 38 | 39 | 这里有个陷阱是，程序是先执行validation_split，再执行shuffle的，所以会出现这种情况： 40 | 41 | 假如你的训练集是有序的，比方说正样本在前负样本在后，又设置了validation_split，那么你的验证集中很可能将全部是负样本 42 | 43 | 同样的，这个东西不会有任何错误报出来，因为Keras不可能知道你的数据有没有经过shuffle，保险起见如果你的数据是没shuffle过的，最好手动shuffle一下 44 | 45 | ## merge 和 Merge 46 | 47 | Keras有两个很类似的用于张量融合的工具，在这里加以辨析。 48 | 49 | merge是一个函数，接受一个tensor列表，并将列表中的tensor按照给定的方式融合在一起形成输出，多用于以Model作为模型的情况 50 | 51 | Merge是一个层对象，它接收一个层对象的列表，并按照给定的方式将它们的输出tensor融合起来。典型的使用场景是在Sequential中处理多输入的情况 52 | 53 | 54 | 55 | ## 未完待续 56 | 57 | 如果你在使用Keras中遇到难以察觉的陷阱，请发信到moyan_work@foxmail.com说明~赠人玫瑰，手有余香，前人踩坑，后人沾光，有道是我不入地狱谁入地狱，愿各位Keras使用者积极贡献Keras陷阱。老规矩，陷阱贡献者将被列入致谢一栏 58 | -------------------------------------------------------------------------------- /docs/legacy/images/Thumbs.db: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/Thumbs.db -------------------------------------------------------------------------------- /docs/legacy/images/autoencoder_schema.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/autoencoder_schema.jpg -------------------------------------------------------------------------------- /docs/legacy/images/basic_ae_32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/basic_ae_32.png -------------------------------------------------------------------------------- /docs/legacy/images/cat_data_augmentation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/cat_data_augmentation.png -------------------------------------------------------------------------------- /docs/legacy/images/cats_and_dogs.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/cats_and_dogs.png -------------------------------------------------------------------------------- /docs/legacy/images/conv5_1_filter_0.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/conv5_1_filter_0.png -------------------------------------------------------------------------------- /docs/legacy/images/conv5_2_stitched_filters_8x3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/conv5_2_stitched_filters_8x3.png -------------------------------------------------------------------------------- /docs/legacy/images/deep_ae_32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/deep_ae_32.png -------------------------------------------------------------------------------- /docs/legacy/images/deep_conv_ae_128.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/deep_conv_ae_128.png -------------------------------------------------------------------------------- /docs/legacy/images/denoised_digits.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/denoised_digits.png -------------------------------------------------------------------------------- /docs/legacy/images/dual_lstm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/dual_lstm.png -------------------------------------------------------------------------------- /docs/legacy/images/encoded_representations.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/encoded_representations.png -------------------------------------------------------------------------------- /docs/legacy/images/filter_dream.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/filter_dream.jpg -------------------------------------------------------------------------------- /docs/legacy/images/jigsaw-puzzle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/jigsaw-puzzle.png -------------------------------------------------------------------------------- /docs/legacy/images/keras-tensorflow-logo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/keras-tensorflow-logo.jpg -------------------------------------------------------------------------------- /docs/legacy/images/keras_linux_cuda.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/keras_linux_cuda.png -------------------------------------------------------------------------------- /docs/legacy/images/keras_linux_ubuntu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/keras_linux_ubuntu.png -------------------------------------------------------------------------------- /docs/legacy/images/keras_windows_os.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/keras_windows_os.png -------------------------------------------------------------------------------- /docs/legacy/images/keras_windows_vs.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/keras_windows_vs.png -------------------------------------------------------------------------------- /docs/legacy/images/magpie.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/magpie.jpg -------------------------------------------------------------------------------- /docs/legacy/images/moyan.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/moyan.png -------------------------------------------------------------------------------- /docs/legacy/images/multi-input-multi-output-graph.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/multi-input-multi-output-graph.png -------------------------------------------------------------------------------- /docs/legacy/images/noisy_digits.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/noisy_digits.png -------------------------------------------------------------------------------- /docs/legacy/images/regular_stacked_lstm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/regular_stacked_lstm.png -------------------------------------------------------------------------------- /docs/legacy/images/scp_173.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/scp_173.png -------------------------------------------------------------------------------- /docs/legacy/images/seasnake.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/seasnake.jpg -------------------------------------------------------------------------------- /docs/legacy/images/sparse_ae_32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/sparse_ae_32.png -------------------------------------------------------------------------------- /docs/legacy/images/tb_curves.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/tb_curves.png -------------------------------------------------------------------------------- /docs/legacy/images/two_branches_sequential_model.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/two_branches_sequential_model.png -------------------------------------------------------------------------------- /docs/legacy/images/vae_classes_plane.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/vae_classes_plane.png -------------------------------------------------------------------------------- /docs/legacy/images/vae_digits_manifold.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/vae_digits_manifold.png -------------------------------------------------------------------------------- /docs/legacy/images/vgg16_filters_overview.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/vgg16_filters_overview.jpg -------------------------------------------------------------------------------- /docs/legacy/images/vgg16_modified.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/vgg16_modified.png -------------------------------------------------------------------------------- /docs/legacy/images/vgg16_original.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/images/vgg16_original.png -------------------------------------------------------------------------------- /docs/legacy/index.md: -------------------------------------------------------------------------------- 1 | # Keras:基于Theano和TensorFlow的深度学习库 2 | 3 | 4 | 5 | ## 这就是Keras 6 | Keras是一个高层神经网络库，Keras由纯Python编写而成并基Tensorflow或Theano。Keras 7 | 为支持快速实验而生，能够把你的idea迅速转换为结果，如果你有如下需求，请选择Keras： 8 | 9 | * 简易和快速的原型设计（keras具有高度模块化，极简，和可扩充特性） 10 | * 支持CNN和RNN，或二者的结合 11 | * 支持任意的链接方案（包括多输入和多输出训练） 12 | * 无缝CPU和GPU切换 13 | 14 | Keras适用的Python版本是：Python 2.7-3.5 15 | 16 | Keras的设计原则是 17 | 18 | * 模块性：模型可理解为一个独立的序列或图，完全可配置的模块以最少的代价自由组合在一起。具体而言，网络层、损失函数、优化器、初始化策略、激活函数、正则化方法都是独立的模块，你可以使用它们来构建自己的模型。 19 | 20 | * 极简主义：每个模块都应该尽量的简洁。每一段代码都应该在初次阅读时都显得直观易懂。没有黑魔法，因为它将给迭代和创新带来麻烦。 21 | 22 | * 易扩展性：添加新模块超级简单的容易，只需要仿照现有的模块编写新的类或函数即可。创建新模块的便利性使得Keras更适合于先进的研究工作。 23 | 24 | * 与Python协作：Keras没有单独的模型配置文件类型（作为对比，caffe有），模型由python代码描述，使其更紧凑和更易debug，并提供了扩展的便利性。 25 | 26 | Keras从2015年3月开始启动，经过一年多的开发，目前Keras进入了1.0的时代。Keras 1.0依然遵循相同的设计原则，但与之前的版本相比有很大的不同。如果你曾经使用过此前的其他版本Keras。你或许会关心1.0的新特性。 27 | 28 | * 泛型模型：简单和强大的新模块，用于支持复杂深度学习模型的搭建。 29 | 30 | * 更优秀的性能：现在，Keras模型的编译时间得到缩短。所有的RNN现在都可以用两种方式实现，以供用户在不同配置任务和配置环境下取得最大性能。现在，基于Theano的RNN也可以被展开，以获得大概25%的加速计算。 31 | 32 | * 测量指标：现在，你可以提供一系列的测量指标来在Keras的任何监测点观察模型性能。 33 | 34 | * 更优的用户体验：我们面向使用者重新编写了代码，使得函数API更简单易记，同时提供更有效的出错信息。 35 | 36 | * 新版本的Keras提供了Lambda层，以实现一些简单的计算任务。 37 | 38 | * ... 39 | 40 | 如果你已经基于Keras0.3编写了自己的层，那么在升级后，你需要为自己的代码做以下调整，以在Keras1.0上继续运行。请参考[编写自己的层](layers/writting_layer/#adjust) 41 | 42 | *** 43 | 44 | ## 关于Keras-cn 45 | 46 | 本文档是Keras文档的中文版，包括[keras.io](http://keras.io/)的全部内容，以及更多的例子、解释和建议 47 | 48 | 现在，keras-cn的版本号将简单的跟随最新的keras release版本 49 | 50 | 由于作者水平和研究方向所限，无法对所有模块都非常精通，因此文档中不可避免的会出现各种错误、疏漏和不足之处。如果您在使用过程中有任何意见、建议和疑问，欢迎发送邮件到moyan_work@foxmail.com与我取得联系。 51 | 52 | 您对文档的任何贡献，包括文档的翻译、查缺补漏、概念解释、发现和修改问题、贡献示例程序等，均会被记录在[致谢](acknowledgement)，十分感谢您对Keras中文文档的贡献！ 53 | 54 | 55 | 同时，也欢迎您撰文向本文档投稿，您的稿件被录用后将以单独的页面显示在网站中，您有权在您的网页下设置赞助二维码，以获取来自网友的小额赞助。 56 | 57 | 如果你发现本文档缺失了官方文档的部分内容，请积极联系我补充。 58 | 59 | 60 | 本文档相对于原文档有更多的使用指导和概念澄清，请在使用时关注文档中的Tips，特别的，本文档的额外模块还有： 61 | 62 | * 一些基本概念：位于快速开始模块的[一些基本概念](getting_started/concepts)简单介绍了使用Keras前需要知道的一些小知识，新手在使用前应该先阅读本部分的文档。 63 | 64 | * Keras安装和配置指南，提供了详细的Linux和Windows下Keras的安装和配置步骤。 65 | 66 | * 深度学习与Keras：位于导航栏最下方的该模块翻译了来自Keras作者博客[keras.io](http://blog.keras.io/)和其他Keras相关博客的文章，该栏目的文章提供了对深度学习的理解和大量使用Keras的例子，您也可以向这个栏目投稿。 67 | 所有的文章均在醒目位置标志标明来源与作者，本文档对该栏目文章的原文不具有任何处置权。如您仍觉不妥，请联系本人（moyan_work@foxmail.com）删除。 68 | 69 | *** 70 | 71 | ## 当前版本与更新 72 | 73 | 如果你发现本文档提供的信息有误，有两种可能： 74 | 75 | * 你的Keras版本过低：记住Keras是一个发展迅速的深度学习框架，请保持你的Keras与官方最新的release版本相符 76 | 77 | * 我们的中文文档没有及时更新：如果是这种情况，请发邮件给我，我会尽快更新 78 | 79 | 目前文档的版本号是1.2.1，对应于官方的1.2.1 release 版本, 本次更新的主要内容是： 80 | 81 | * 为Application中的图片分类模型增加了`classes`和`input_shape`，但`classes`的说明在原文档中缺失 82 | * 暂时移除了SpatialDropout1D,SpatialDropout2D,SpatialDropout3D的文档，但它们的源代码仍然保留在个keras中，你仍然可以用这些layer 83 | * 1.2.0和当前版本均可使用ConvLSTM2D层，这个层在代码中有说明但没有体现在文档中，我们暂时也不提供这个层的说明，如需使用请查看源代码中的说明 84 | * 增加了AC-GAN的例子 85 | 86 | 注意，keras在github上的master往往要高于当前的release版本，如果你从源码编译keras，可能某些模块与文档说明不相符，请以官方Github代码为准 87 | 88 | *** 89 | 90 | ##快速开始：30s上手Keras 91 | 92 | Keras的核心数据结构是“模型”，模型是一种组织网络层的方式。Keras中主要的模型是Sequential模型，Sequential是一系列网络层按顺序构成的栈。你也可以查看[泛型模型](getting_started/functional_API.md)来学习建立更复杂的模型 93 | 94 | Sequential模型如下 95 | ```python 96 | from keras.models import Sequential 97 | 98 | model = Sequential() 99 | ``` 100 | 将一些网络层通过.add\(\)堆叠起来，就构成了一个模型： 101 | ```python 102 | from keras.layers import Dense, Activation 103 | 104 | model.add(Dense(output_dim=64, input_dim=100)) 105 | model.add(Activation("relu")) 106 | model.add(Dense(output_dim=10)) 107 | model.add(Activation("softmax")) 108 | ``` 109 | 完成模型的搭建后，我们需要使用.compile\(\)方法来编译模型： 110 | ```python 111 | model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) 112 | ``` 113 | 编译模型时必须指明损失函数和优化器，如果你需要的话，也可以自己定制损失函数。Keras的一个核心理念就是简明易用同时，保证用户对Keras的绝对控制力度，用户可以根据自己的需要定制自己的模型、网络层，甚至修改源代码。 114 | ```python 115 | from keras.optimizers import SGD 116 | model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.01, momentum=0.9, nesterov=True)) 117 | ``` 118 | 完成模型编译后，我们在训练数据上按batch进行一定次数的迭代训练，以拟合网络，关于为什么要使用‘batch’，请参考[一些基本概念](getting_started/concepts/#batch) 119 | 120 | 121 | ```python 122 | model.fit(X_train, Y_train, nb_epoch=5, batch_size=32) 123 | ``` 124 | 当然，我们也可以手动将一个个batch的数据送入网络中训练，这时候需要使用： 125 | ```python 126 | model.train_on_batch(X_batch, Y_batch) 127 | ``` 128 | 随后，我们可以使用一行代码对我们的模型进行评估，看看模型的指标是否满足我们的要求： 129 | ```python 130 | loss_and_metrics = model.evaluate(X_test, Y_test, batch_size=32) 131 | ``` 132 | 或者，我们可以使用我们的模型，对新的数据进行预测： 133 | ```python 134 | classes = model.predict_classes(X_test, batch_size=32) 135 | proba = model.predict_proba(X_test, batch_size=32) 136 | ``` 137 | 搭建一个问答系统、图像分类模型，或神经图灵机、word2vec词嵌入器就是这么快。支撑深度学习的基本想法本就是简单的，现在让我们把它的实现也变的简单起来！ 138 | 139 | 为了更深入的了解Keras，我们建议你查看一下下面的两个tutorial 140 | 141 | * [快速开始Sequntial模型](getting_started/sequential_model) 142 | * [快速开始泛型模型](getting_started/functional_API) 143 | 144 | 还有我们对一些概念的解释 145 | 146 | * [一些基本概念](getting_started/concepts) 147 | 148 | 在Keras代码包的examples文件夹里，我们提供了一些更高级的模型：基于记忆网络的问答系统、基于LSTM的文本的文本生成等。 149 | 150 | *** 151 | 152 | ##安装 153 | 154 | Keras使用了下面的依赖包： 155 | 156 | * numpy，scipy 157 | 158 | * pyyaml 159 | 160 | * HDF5, h5py（可选，仅在模型的save/load函数中使用） 161 | 162 | 当使用TensorFlow为后端时： 163 | 164 | * [TensorFlow](https://github.com/tensorflow/tensorflow#download-and-setup) 165 | 166 | 当使用Theano作为后端时： 167 | 168 | * [Theano](http://www.deeplearning.net/software/theano/install.html#install) 169 | 170 | 171 | 【Tips】“后端”翻译自backend，指的是Keras依赖于完成底层的张量运算的软件包。【@Bigmoyan】 172 | 173 | 安装Keras时，请cd到Keras的文件夹中，并运行下面的安装命令： 174 | ```python 175 | sudo python setup.py install 176 | ``` 177 | 你也可以使用PyPI来安装Keras 178 | ```python 179 | sudo pip install keras 180 | ``` 181 | 182 | **详细的Windows和Linux安装教程请参考“快速开始”一节中给出的安装教程，特别鸣谢SCP-173编写了这些教程** 183 | 184 | *** 185 | 186 | ##在Theano和TensorFlow间切换 187 | 188 | Keras默认使用TensorFlow作为后端来进行张量操作，如需切换到Theano，请查看[这里](backend) 189 | 190 | *** 191 | 192 | ##技术支持 193 | 194 | 你可以在下列网址提问或加入Keras开发讨论: 195 | 196 | - [Keras Google group](https://groups.google.com/forum/#!forum/keras-users) 197 | - [Keras Slack channel](https://kerasteam.slack.com/),[点击这里]获得邀请. 198 | 199 | 你也可以在[Github issues](https://github.com/fchollet/keras/issues)里提问或请求新特性。在提问之前请确保你阅读过我们的[指导](https://github.com/fchollet/keras/blob/master/CONTRIBUTING.md) 200 | 201 | 同时，我们也欢迎同学们加我们的QQ群119427073进行讨论（潜水和灌水会被T，入群说明公司/学校-职位/年级） 202 | 203 | *** 204 | 205 | ## 小额赞助 206 | 207 | 如果你觉得本文档对你的研究和使用有所帮助，欢迎扫下面的二维码对作者进行小额赞助，以鼓励作者进一步完善文档内容，提高文档质量。同时，不妨为[本文档的github](https://github.com/MoyanZitto/keras-cn)加颗星哦 208 | 209 | ![付款二维码](images/moyan.png) 210 | 211 | **如果你觉得有用页面下有小额赞助的二维码或微信/支付宝账号，说明该页面由其他作者贡献，要对他们进行小额赞助请使用该页面下的二维码或账号** 212 | 213 | 214 | 215 | 216 | -------------------------------------------------------------------------------- /docs/legacy/layers/about_layer.md: -------------------------------------------------------------------------------- 1 | # 关于Keras的“层”（Layer） 2 | 3 | 所有的Keras层对象都有如下方法： 4 | 5 | * ```layer.get_weights()```：返回层的权重（numpy array） 6 | 7 | * ```layer.set_weights(weights)```：从numpy array中将权重加载到该层中，要求numpy array的形状与* ```layer.get_weights()```的形状相同 8 | 9 | * ```layer.get_config()```：返回当前层配置信息的字典，层也可以借由配置信息重构 10 | 11 | ```python 12 | from keras.utils.layer_utils import layer_from_config 13 | 14 | config = layer.get_config() 15 | layer = layer_from_config(config) 16 | ``` 17 | 18 | 如果层仅有一个计算节点（即该层不是共享层），则可以通过下列方法获得输入张量、输出张量、输入数据的形状和输出数据的形状： 19 | 20 | * ```layer.input``` 21 | 22 | * ```layer.output``` 23 | 24 | * ```layer.input_shape``` 25 | 26 | * ```layer.output_shape``` 27 | 28 | 如果该层有多个计算节点（参考[层计算节点和共享层](../getting_started/functional_API/#node)）。可以使用下面的方法 29 | 30 | * ```layer.get_input_at(node_index)``` 31 | 32 | * ```layer.get_output_at(node_index)``` 33 | 34 | * ```layer.get_input_shape_at(node_index)``` 35 | 36 | * ```layer.get_output_shape_at(node_index)``` -------------------------------------------------------------------------------- /docs/legacy/layers/advanced_activation_layer.md: -------------------------------------------------------------------------------- 1 | # 高级激活层Advanced Activation 2 | 3 | ## LeakyReLU层 4 | ```python 5 | keras.layers.advanced_activations.LeakyReLU(alpha=0.3) 6 | ``` 7 | LeakyRelU是修正线性单元（Rectified Linear Unit，ReLU）的特殊版本，当不激活时，LeakyReLU仍然会有非零输出值，从而获得一个小梯度，避免ReLU可能出现的神经元“死亡”现象。即，```f(x)=alpha * x for x < 0```, ```f(x) = x for x>=0``` 8 | 9 | ### 参数 10 | 11 | * alpha：大于0的浮点数，代表激活函数图像中第三象限线段的斜率 12 | 13 | ### 输入shape 14 | 15 | 任意，当使用该层为模型首层时需指定```input_shape```参数 16 | 17 | ### 输出shape 18 | 19 | 与输入相同 20 | 21 | *** 22 | 23 | ## PReLU层 24 | ```python 25 | keras.layers.advanced_activations.PReLU(init='zero', weights=None, shared_axes=None) 26 | ``` 27 | 该层为参数化的ReLU（Parametric ReLU），表达式是：```f(x) = alpha * x for x < 0```, ```f(x) = x for x>=0```，此处的```alpha```为一个与xshape相同的可学习的参数向量。 28 | 29 | ### 参数 30 | 31 | * init：alpha的初始化函数 32 | 33 | * weights：alpha的初始化值，为具有单个numpy array的list 34 | 35 | - shared_axes：该参数指定的轴将共享同一组科学系参数，例如假如输入特征图是从2D卷积过来的，具有形如`(batch, height, width, channels)`这样的shape，则或许你会希望在空域共享参数，这样每个filter就只有一组参数，设定`shared_axes=[1,2]`可完成该目标 36 | 37 | ### 输入shape 38 | 39 | 任意，当使用该层为模型首层时需指定```input_shape```参数 40 | 41 | ### 输出shape 42 | 43 | 与输入相同 44 | 45 | ### 参考文献 46 | 47 | * [Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification](http://arxiv.org/pdf/1502.01852v1.pdf) 48 | 49 | *** 50 | 51 | ## ELU层 52 | ```python 53 | keras.layers.advanced_activations.ELU(alpha=1.0) 54 | ``` 55 | ELU层是指数线性单元（Exponential Linera Unit），表达式为： 56 | 该层为参数化的ReLU（Parametric ReLU），表达式是：```f(x) = alpha * (exp(x) - 1.) for x < 0```, ```f(x) = x for x>=0``` 57 | 58 | ### 参数 59 | 60 | * alpha：控制负因子的参数 61 | 62 | ### 输入shape 63 | 64 | 任意，当使用该层为模型首层时需指定```input_shape```参数 65 | 66 | ### 输出shape 67 | 68 | 与输入相同 69 | 70 | ### 参考文献 71 | 72 | * [Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)](http://arxiv.org/pdf/1511.07289v1.pdf) 73 | 74 | *** 75 | 76 | ## ParametricSoftplus层 77 | ```python 78 | keras.layers.advanced_activations.ParametricSoftplus(alpha_init=0.2, beta_init=5.0, weights=None, shared_axes=None) 79 | ``` 80 | 该层是参数化的Softplus，表达式是：```f(x) = alpha * log(1 + exp(beta * x))``` 81 | 82 | ### 参数 83 | 84 | * alpha_init：浮点数，alpha的初始值 85 | 86 | * beta_init：浮点数，beta的初始值 87 | 88 | * weights：初始化权重，为含有两个numpy array的list 89 | 90 | - shared_axes：该参数指定的轴将共享同一组科学系参数，例如假如输入特征图是从2D卷积过来的，具有形如`(batch, height, width, channels)`这样的shape，则或许你会希望在空域共享参数，这样每个filter就只有一组参数，设定`shared_axes=[1,2]`可完成该目标 91 | 92 | ### 输入shape 93 | 94 | 任意，当使用该层为模型首层时需指定```input_shape```参数 95 | 96 | ### 输出shape 97 | 98 | 与输入相同 99 | 100 | ### 参考文献 101 | 102 | * [Inferring Nonlinear Neuronal Computation Based on Physiologically Plausible Inputs](http://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1003143) 103 | 104 | *** 105 | 106 | ## ThresholdedReLU层 107 | ```python 108 | keras.layers.advanced_activations.ThresholdedReLU(theta=1.0) 109 | ``` 110 | 该层是带有门限的ReLU，表达式是：```f(x) = x for x > theta```,```f(x) = 0 otherwise``` 111 | 112 | ### 参数 113 | 114 | * theata：大或等于0的浮点数，激活门限位置 115 | 116 | ### 输入shape 117 | 118 | 任意，当使用该层为模型首层时需指定```input_shape```参数 119 | 120 | ### 输出shape 121 | 122 | 与输入相同 123 | 124 | ### 参考文献 125 | 126 | * [Zero-Bias Autoencoders and the Benefits of Co-Adapting Features](http://arxiv.org/pdf/1402.3337.pdf) 127 | 128 | *** 129 | 130 | *** 131 | 132 | ## SReLU层 133 | ```python 134 | keras.layers.advanced_activations.SReLU(t_left_init='zero', a_left_init='glorot_uniform', t_right_init='glorot_uniform', a_right_init='one', shared_axes=None) 135 | ``` 136 | 该层是S形的ReLU 137 | 138 | ### 参数 139 | 140 | * t_left_init：左侧截断初始化函数 141 | 142 | * a_left_init：左侧斜率初始化函数 143 | 144 | * t_right_init：右侧截断初始化函数 145 | 146 | * a_right_init：右侧斜率初始化函数 147 | 148 | - shared_axes：该参数指定的轴将共享同一组科学系参数，例如假如输入特征图是从2D卷积过来的，具有形如`(batch, height, width, channels)`这样的shape，则或许你会希望在空域共享参数，这样每个filter就只有一组参数，设定`shared_axes=[1,2]`可完成该目标 149 | 150 | ### 输入shape 151 | 152 | 任意，当使用该层为模型首层时需指定```input_shape```参数 153 | 154 | ### 输出shape 155 | 156 | 与输入相同 157 | 158 | ### 参考文献 159 | 160 | * [Deep Learning with S-shaped Rectified Linear Activation Units](http://arxiv.org/abs/1512.07030) -------------------------------------------------------------------------------- /docs/legacy/layers/embedding_layer.md: -------------------------------------------------------------------------------- 1 | # 嵌入层 Embedding 2 | 3 | ## Embedding层 4 | 5 | ```python 6 | keras.layers.embeddings.Embedding(input_dim, output_dim, init='uniform', input_length=None, W_regularizer=None, activity_regularizer=None, W_constraint=None, mask_zero=False, weights=None, dropout=0.0) 7 | ``` 8 | 嵌入层将正整数（下标）转换为具有固定大小的向量，如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]] 9 | 10 | Embedding层只能作为模型的第一层 11 | 12 | ### 参数 13 | 14 | * input_dim：大或等于0的整数，字典长度，即输入数据最大下标+1 15 | 16 | * output_dim：大于0的整数，代表全连接嵌入的维度 17 | 18 | * init：初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的Theano函数。该参数仅在不传递```weights```参数时有意义。 19 | 20 | * weights：权值，为numpy array的list。该list应仅含有一个如（input_dim,output_dim）的权重矩阵 21 | 22 | * W_regularizer：施加在权重上的正则项，为[WeightRegularizer](../other/regularizers)对象 23 | 24 | * W_constraints：施加在权重上的约束项，为[Constraints](../other/constraints)对象 25 | 26 | * mask_zero：布尔值，确定是否将输入中的‘0’看作是应该被忽略的‘填充’（padding）值，该参数在使用[递归层](recurrent_layer)处理变长输入时有用。设置为```True```的话，模型中后续的层必须都支持masking，否则会抛出异常 27 | 28 | * input_length：当输入序列的长度固定时，该值为其长度。如果要在该层后接```Flatten```层，然后接```Dense```层，则必须指定该参数，否则```Dense```层的输出维度无法自动推断。 29 | 30 | * dropout：0~1的浮点数，代表要断开的嵌入比例， 31 | 32 | ### 输入shape 33 | 34 | 形如（samples，sequence_length）的2D张量 35 | 36 | ### 输出shape 37 | 38 | 形如(samples, sequence_length, output_dim)的3D张量 39 | 40 | ### 参考文献 41 | 42 | * [A Theoretically Grounded Application of Dropout in Recurrent Neural Networks](http://arxiv.org/abs/1512.05287) -------------------------------------------------------------------------------- /docs/legacy/layers/locally_connected_layer.md: -------------------------------------------------------------------------------- 1 | # 局部连接层LocallyConnceted 2 | 3 | ## LocallyConnected1D层 4 | ```python 5 | keras.layers.local.LocallyConnected1D(nb_filter, filter_length, init='uniform', activation='linear', weights=None, border_mode='valid', subsample_length=1, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True, input_dim=None, input_length=None) 6 | ``` 7 | ```LocallyConnected1D```层与```Convolution1D```工作方式类似，唯一的区别是不进行权值共享。即施加在不同输入patch的滤波器是不一样的，当使用该层作为模型首层时，需要提供参数```input_dim```或```input_shape```参数。参数含义参考```Convolution1D```。注意该层的```input_shape```必须完全指定，不支持```None``` 8 | 9 | ### 参数 10 | 11 | * nb_filter：卷积核的数目（即输出的维度） 12 | 13 | * filter_length：卷积核的空域或时域长度 14 | 15 | * init：初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的Theano函数。该参数仅在不传递```weights```参数时有意义。 16 | 17 | * activation：激活函数，为预定义的激活函数名（参考[激活函数](../other/activations)），或逐元素（element-wise）的Theano函数。如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x） 18 | 19 | * weights：权值，为numpy array的list。该list应含有一个形如（input_dim,output_dim）的权重矩阵和一个形如(output_dim,)的偏置向量。 20 | 21 | * border_mode：边界模式，为“valid”或“same” 22 | 23 | * subsample_length：输出对输入的下采样因子 24 | 25 | * W_regularizer：施加在权重上的正则项，为[WeightRegularizer](../other/regularizers)对象 26 | 27 | * b_regularizer：施加在偏置向量上的正则项，为[WeightRegularizer](../other/regularizers)对象 28 | 29 | * activity_regularizer：施加在输出上的正则项，为[ActivityRegularizer](../other/regularizers)对象 30 | 31 | * W_constraints：施加在权重上的约束项，为[Constraints](../other/constraints)对象 32 | 33 | * b_constraints：施加在偏置上的约束项，为[Constraints](../other/constraints)对象 34 | 35 | * bias：布尔值，是否包含偏置向量（即层对输入做线性变换还是仿射变换） 36 | 37 | * input_dim：整数，输入数据的维度。当该层作为网络的第一层时，必须指定该参数或```input_shape```参数。 38 | 39 | * input_length：当输入序列的长度固定时，该参数为输入序列的长度。当需要在该层后连接```Flatten```层，然后又要连接```Dense```层时，需要指定该参数，否则全连接的输出无法计算出来。 40 | 41 | ### 输入shape 42 | 43 | 形如（samples，steps，input_dim）的3D张量 44 | 45 | ### 输出shape 46 | 47 | 形如（samples，new_steps，nb_filter）的3D张量，因为有向量填充的原因，```steps```的值会改变 48 | 49 | ### 例子 50 | ```python 51 | # apply a unshared weight convolution 1d of length 3 to a sequence with 52 | # 10 timesteps, with 64 output filters 53 | model = Sequential() 54 | model.add(LocallyConnected1D(64, 3, input_shape=(10, 32))) 55 | # now model.output_shape == (None, 8, 64) 56 | # add a new conv1d on top 57 | model.add(LocallyConnected1D(32, 3)) 58 | # now model.output_shape == (None, 6, 32) 59 | ``` 60 | 61 | *** 62 | 63 | ## LocallyConnected2D层 64 | ```python 65 | keras.layers.local.LocallyConnected2D(nb_filter, nb_row, nb_col, init='glorot_uniform', activation='linear', weights=None, border_mode='valid', subsample=(1, 1), dim_ordering='default', W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True) 66 | ``` 67 | ```LocallyConnected2D```层与```Convolution2D```工作方式类似，唯一的区别是不进行权值共享。即施加在不同输入patch的滤波器是不一样的，当使用该层作为模型首层时，需要提供参数```input_dim```或```input_shape```参数。参数含义参考```Convolution2D```。注意该层的```input_shape```必须完全指定，不支持```None``` 68 | 69 | ### 参数 70 | 71 | * nb_filter：卷积核的数目 72 | 73 | * nb_row：卷积核的行数 74 | 75 | * nb_col：卷积核的列数 76 | 77 | * init：初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的Theano函数。该参数仅在不传递```weights```参数时有意义。 78 | 79 | * activation：激活函数，为预定义的激活函数名（参考[激活函数](../other/activations)），或逐元素（element-wise）的Theano函数。如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x） 80 | 81 | * weights：权值，为numpy array的list。该list应含有一个形如（input_dim,output_dim）的权重矩阵和一个形如(output_dim,)的偏置向量。 82 | 83 | * border_mode：边界模式，为“valid”或“same” 84 | 85 | * subsample：长为2的tuple，输出对输入的下采样因子，更普遍的称呼是“strides” 86 | 87 | * W_regularizer：施加在权重上的正则项，为[WeightRegularizer](../other/regularizers)对象 88 | 89 | * b_regularizer：施加在偏置向量上的正则项，为[WeightRegularizer](../other/regularizers)对象 90 | 91 | * activity_regularizer：施加在输出上的正则项，为[ActivityRegularizer](../other/regularizers)对象 92 | 93 | * W_constraints：施加在权重上的约束项，为[Constraints](../other/constraints)对象 94 | 95 | * b_constraints：施加在偏置上的约束项，为[Constraints](../other/constraints)对象 96 | 97 | * dim_ordering：‘th’或‘tf’。‘th’模式中通道维（如彩色图像的3通道）位于第1个位置（维度从0开始算），而在‘tf’模式中，通道维位于第3个位置。例如128*128的三通道彩色图片，在‘th’模式中```input_shape```应写为（3，128，128），而在‘tf’模式中应写为（128，128，3），注意这里3出现在第0个位置，因为```input_shape```不包含样本数的维度，在其内部实现中，实际上是（None，3，128，128）和（None，128，128，3）。默认是```image_dim_ordering```指定的模式，可在```~/.keras/keras.json```中查看，若没有设置过则为'tf'。 98 | 99 | * bias：布尔值，是否包含偏置向量（即层对输入做线性变换还是仿射变换） 100 | 101 | ### 输入shape 102 | 103 | ‘th’模式下，输入形如（samples,channels，rows，cols）的4D张量 104 | 105 | ‘tf’模式下，输入形如（samples，rows，cols，channels）的4D张量 106 | 107 | 注意这里的输入shape指的是函数内部实现的输入shape，而非函数接口应指定的```input_shape```，请参考下面提供的例子。 108 | 109 | ### 输出shape 110 | 111 | ‘th’模式下，为形如（samples，nb_filter, new_rows, new_cols）的4D张量 112 | 113 | ‘tf’模式下，为形如（samples，new_rows, new_cols，nb_filter）的4D张量 114 | 115 | 输出的行列数可能会因为填充方法而改变 116 | 117 | ### 例子 118 | 119 | ```python 120 | # apply a 3x3 unshared weights convolution with 64 output filters on a 32x32 image: 121 | model = Sequential() 122 | model.add(LocallyConnected2D(64, 3, 3, input_shape=(3, 32, 32))) 123 | # now model.output_shape == (None, 64, 30, 30) 124 | # notice that this layer will consume (30*30)*(3*3*3*64) + (30*30)*64 parameters 125 | 126 | # add a 3x3 unshared weights convolution on top, with 32 output filters: 127 | model.add(LocallyConnected2D(32, 3, 3)) 128 | # now model.output_shape == (None, 32, 28, 28) 129 | ``` 130 | -------------------------------------------------------------------------------- /docs/legacy/layers/noise_layer.md: -------------------------------------------------------------------------------- 1 | # 噪声层Noise 2 | 3 | ## GaussianNoise层 4 | ```python 5 | keras.layers.noise.GaussianNoise(sigma) 6 | ``` 7 | 为层的输入施加0均值，标准差为```sigma```的加性高斯噪声。该层在克服过拟合时比较有用，你可以将它看作是随机的数据提升。高斯噪声是需要对输入数据进行破坏时的自然选择。 8 | 9 | 一个使用噪声层的典型案例是构建去噪自动编码器，即Denoising AutoEncoder（DAE）。该编码器试图从加噪的输入中重构无噪信号，以学习到原始信号的鲁棒性表示。 10 | 11 | 因为这是一个起正则化作用的层，该层只在训练时才有效。 12 | 13 | ### 参数 14 | 15 | * sigma：浮点数，代表要产生的高斯噪声标准差 16 | 17 | ### 输入shape 18 | 19 | 任意，当使用该层为模型首层时需指定```input_shape```参数 20 | 21 | ### 输出shape 22 | 23 | 与输入相同 24 | 25 | *** 26 | 27 | ## GaussianDropout层 28 | ```python 29 | keras.layers.noise.GaussianDropout(p) 30 | ``` 31 | 为层的输入施加以1为均值，标准差为```sqrt(p/(1-p)```的乘性高斯噪声 32 | 33 | 因为这是一个起正则化作用的层，该层只在训练时才有效。 34 | 35 | ### 参数 36 | 37 | * p：浮点数，断连概率，与[Dropout层](core_layer/#dropout)相同 38 | 39 | ### 输入shape 40 | 41 | 任意，当使用该层为模型首层时需指定```input_shape```参数 42 | 43 | ### 输出shape 44 | 45 | 与输入相同 46 | 47 | ### 参考文献 48 | 49 | * [Dropout: A Simple Way to Prevent Neural Networks from Overfitting](http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf) -------------------------------------------------------------------------------- /docs/legacy/layers/normalization_layer.md: -------------------------------------------------------------------------------- 1 | # （批）规范化BatchNormalization 2 | 3 | ## BatchNormalization层 4 | ```python 5 | keras.layers.normalization.BatchNormalization(epsilon=1e-06, mode=0, axis=-1, momentum=0.9, weights=None, beta_init='zero', gamma_init='one') 6 | ``` 7 | 该层在每个batch上将前一层的激活值重新规范化，即使得其输出数据的均值接近0，其标准差接近1 8 | 9 | ### 参数 10 | 11 | * epsilon：大于0的小浮点数，用于防止除0错误 12 | 13 | * mode：整数，指定规范化的模式，取0或1 14 | 15 | * 0：按特征规范化，输入的各个特征图将独立被规范化。规范化的轴由参数```axis```指定。注意，如果输入是‘th’格式形状的（samples，channels，rows，cols）的4D图像张量，则应设置规范化的轴为1，即沿着通道轴规范化。在训练阶段，我们使用每个batch数据的统计信息（如：均值、标准差等）来对训练数据进行规范化，而在测试阶段，我们使用训练时得到的统计信息的滑动平均来对测试数据进行规范化。 16 | * 1：按样本规范化，该模式默认输入为2D 17 | * 2: 按特征规范化, 与模式0相似, 但不同之处在于：在训练和测试过程中，均使用每个batch数据的统计信息而分别对训练数据和测试数据进行规范化。 18 | * axis：整数，指定当```mode=0```时规范化的轴。例如输入是形如（samples，channels，rows，cols）的4D图像张量，则应设置规范化的轴为1，意味着对每个特征图进行规范化 19 | 20 | * momentum：在按特征规范化时，计算数据的指数平均数和标准差时的动量 21 | 22 | * weights：初始化权重，为包含2个numpy array的list，其shape为```[(input_shape,),(input_shape)]``` 23 | 24 | * beta_init：beta的初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的Theano函数。该参数仅在不传递```weights```参数时有意义。 25 | 26 | * gamma_init：gamma的初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的Theano函数。该参数仅在不传递```weights```参数时有意义。 27 | 28 | * gamma_regularizer：WeightRegularizer(如L1或L2正则化)的实例，作用在gamma向量上。 29 | 30 | * beta_regularizer：WeightRegularizer的实例，作用在beta向量上。 31 | 32 | 33 | ### 输入shape 34 | 35 | 任意，当使用本层为模型首层时，指定```input_shape```参数时有意义。 36 | 37 | ### 输出shape 38 | 39 | 与输入shape相同 40 | 41 | ### 参考文献 42 | 43 | * [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](http://arxiv.org/pdf/1502.03167v3.pdf) 44 | 45 | 【Tips】统计学习的一个重要假设是源空间与目标空间的数据分布是一致的，而神经网络各层输出的分布不一定与输入一致，尤其当网络越深，这种不一致越明显。BatchNormalization把分布一致弱化为均值与方差一致，然而即使是这种弱化的版本也对学习过程起到了重要效果。另一方面，BN的更重要作用是防止梯度弥散，它通过将激活值规范为统一的均值和方差，将原本会减小的激活值得到放大。【@Bigmoyan】 46 | 47 | -------------------------------------------------------------------------------- /docs/legacy/layers/pooling_layer.md: -------------------------------------------------------------------------------- 1 | # 池化层 2 | 3 | ## MaxPooling1D层 4 | ```python 5 | keras.layers.convolutional.MaxPooling1D(pool_length=2, stride=None, border_mode='valid') 6 | ``` 7 | 对时域1D信号进行最大值池化 8 | 9 | ### 参数 10 | 11 | * pool_length：下采样因子，如取2则将输入下采样到一半长度 12 | 13 | * stride：整数或None，步长值 14 | 15 | * border_mode：‘valid’或者‘same’ 16 | 17 | ### 输入shape 18 | 19 | * 形如（samples，steps，features）的3D张量 20 | 21 | ### 输出shape 22 | 23 | * 形如（samples，downsampled_steps，features）的3D张量 24 | 25 | *** 26 | 27 | ## MaxPooling2D层 28 | ```python 29 | keras.layers.convolutional.MaxPooling2D(pool_size=(2, 2), strides=None, border_mode='valid', dim_ordering='th') 30 | ``` 31 | 为空域信号施加最大值池化 32 | 33 | ### 参数 34 | 35 | * pool_size：长为2的整数tuple，代表在两个方向（竖直，水平）上的下采样因子，如取（2，2）将使图片在两个维度上均变为原长的一半 36 | 37 | * strides：长为2的整数tuple，或者None，步长值。 38 | 39 | * border_mode：‘valid’或者‘same’ 40 | 41 | 42 | * dim_ordering：‘th’或‘tf’。‘th’模式中通道维（如彩色图像的3通道）位于第1个位置（维度从0开始算），而在‘tf’模式中，通道维位于第3个位置。例如128*128的三通道彩色图片，在‘th’模式中```input_shape```应写为（3，128，128），而在‘tf’模式中应写为（128，128，3），注意这里3出现在第0个位置，因为```input_shape```不包含样本数的维度，在其内部实现中，实际上是（None，3，128，128）和（None，128，128，3）。默认是```image_dim_ordering```指定的模式，可在```~/.keras/keras.json```中查看，若没有设置过则为'tf'。 43 | 44 | ### 输入shape 45 | 46 | ‘th’模式下，为形如（samples，channels, rows，cols）的4D张量 47 | 48 | ‘tf’模式下，为形如（samples，rows, cols，channels）的4D张量 49 | 50 | ### 输出shape 51 | 52 | ‘th’模式下，为形如（samples，channels, pooled_rows, pooled_cols）的4D张量 53 | 54 | ‘tf’模式下，为形如（samples，pooled_rows, pooled_cols，channels）的4D张量 55 | 56 | *** 57 | 58 | ## MaxPooling3D层 59 | ```python 60 | keras.layers.convolutional.MaxPooling3D(pool_size=(2, 2, 2), strides=None, border_mode='valid', dim_ordering='th') 61 | ``` 62 | 为3D信号（空域或时空域）施加最大值池化 63 | 64 | 本层目前只能在使用Theano为后端时可用 65 | 66 | ### 参数 67 | 68 | * pool_size：长为3的整数tuple，代表在三个维度上的下采样因子，如取（2，2，2）将使信号在每个维度都变为原来的一半长。 69 | 70 | * strides：长为3的整数tuple，或者None，步长值。 71 | 72 | * border_mode：‘valid’或者‘same’ 73 | 74 | * dim_ordering：‘th’或‘tf’。‘th’模式中通道维（如彩色图像的3通道）位于第1个位置（维度从0开始算），而在‘tf’模式中，通道维位于第4个位置。默认是```image_dim_ordering```指定的模式，可在```~/.keras/keras.json```中查看，若没有设置过则为'tf'。 75 | 76 | ### 输入shape 77 | 78 | ‘th’模式下，为形如（samples, channels, len_pool_dim1, len_pool_dim2, len_pool_dim3）的5D张量 79 | 80 | ‘tf’模式下，为形如（samples, len_pool_dim1, len_pool_dim2, len_pool_dim3，channels, ）的5D张量 81 | 82 | ### 输出shape 83 | 84 | ‘th’模式下，为形如（samples, channels, pooled_dim1, pooled_dim2, pooled_dim3）的5D张量 85 | 86 | ‘tf’模式下，为形如（samples, pooled_dim1, pooled_dim2, pooled_dim3,channels,）的5D张量 87 | 88 | *** 89 | 90 | ## AveragePooling1D层 91 | ```python 92 | keras.layers.convolutional.AveragePooling1D(pool_length=2, stride=None, border_mode='valid') 93 | ``` 94 | 对时域1D信号进行平均值池化 95 | 96 | ### 参数 97 | 98 | * pool_length：下采样因子，如取2则将输入下采样到一半长度 99 | 100 | * stride：整数或None，步长值 101 | 102 | * border_mode：‘valid’或者‘same’ 103 | * 注意，目前‘same’模式只能在TensorFlow作为后端时使用 104 | 105 | ### 输入shape 106 | 107 | * 形如（samples，steps，features）的3D张量 108 | 109 | ### 输出shape 110 | 111 | * 形如（samples，downsampled_steps，features）的3D张量 112 | 113 | *** 114 | 115 | ## AveragePooling2D层 116 | ```python 117 | keras.layers.convolutional.AveragePooling2D(pool_size=(2, 2), strides=None, border_mode='valid', dim_ordering='th') 118 | ``` 119 | 为空域信号施加平均值池化 120 | 121 | ### 参数 122 | 123 | * pool_size：长为2的整数tuple，代表在两个方向（竖直，水平）上的下采样因子，如取（2，2）将使图片在两个维度上均变为原长的一半 124 | 125 | * strides：长为2的整数tuple，或者None，步长值。 126 | 127 | * border_mode：‘valid’或者‘same’ 128 | 129 | dim_ordering：‘th’或‘tf’。‘th’模式中通道维（如彩色图像的3通道）位于第1个位置（维度从0开始算），而在‘tf’模式中，通道维位于第3个位置。例如128*128的三通道彩色图片，在‘th’模式中```input_shape```应写为（3，128，128），而在‘tf’模式中应写为（128，128，3），注意这里3出现在第0个位置，因为```input_shape```不包含样本数的维度，在其内部实现中，实际上是（None，3，128，128）和（None，128，128，3）。默认是```image_dim_ordering```指定的模式，可在```~/.keras/keras.json```中查看，若没有设置过则为'tf'。 130 | 131 | ### 输入shape 132 | 133 | ‘th’模式下，为形如（samples，channels, rows，cols）的4D张量 134 | 135 | ‘tf’模式下，为形如（samples，rows, cols，channels）的4D张量 136 | 137 | ### 输出shape 138 | 139 | ‘th’模式下，为形如（samples，channels, pooled_rows, pooled_cols）的4D张量 140 | 141 | ‘tf’模式下，为形如（samples，pooled_rows, pooled_cols，channels）的4D张量 142 | 143 | *** 144 | 145 | ## AveragePooling3D层 146 | ```python 147 | keras.layers.convolutional.AveragePooling3D(pool_size=(2, 2, 2), strides=None, border_mode='valid', dim_ordering='th') 148 | ``` 149 | 为3D信号（空域或时空域）施加平均值池化 150 | 151 | 本层目前只能在使用Theano为后端时可用 152 | 153 | ### 参数 154 | 155 | * pool_size：长为3的整数tuple，代表在三个维度上的下采样因子，如取（2，2，2）将使信号在每个维度都变为原来的一半长。 156 | 157 | * strides：长为3的整数tuple，或者None，步长值。 158 | 159 | * border_mode：‘valid’或者‘same’ 160 | 161 | * dim_ordering：dim_ordering：‘th’或‘tf’。‘th’模式中通道维（如彩色图像的3通道）位于第1个位置（维度从0开始算），而在‘tf’模式中，通道维位于第4个位置。默认是```image_dim_ordering```指定的模式，可在```~/.keras/keras.json```中查看，若没有设置过则为'tf'。 162 | ### 输入shape 163 | 164 | ‘th’模式下，为形如（samples, channels, len_pool_dim1, len_pool_dim2, len_pool_dim3）的5D张量 165 | 166 | ‘tf’模式下，为形如（samples, len_pool_dim1, len_pool_dim2, len_pool_dim3，channels, ）的5D张量 167 | 168 | ### 输出shape 169 | 170 | ‘th’模式下，为形如（samples, channels, pooled_dim1, pooled_dim2, pooled_dim3）的5D张量 171 | 172 | ‘tf’模式下，为形如（samples, pooled_dim1, pooled_dim2, pooled_dim3,channels,）的5D张量 173 | 174 | *** 175 | 176 | ## GlobalMaxPooling1D层 177 | ```python 178 | keras.layers.pooling.GlobalMaxPooling1D() 179 | ``` 180 | 对于时间信号的全局最大池化 181 | 182 | ### 输入shape 183 | 184 | * 形如（samples，steps，features）的3D张量 185 | 186 | ### 输出shape 187 | 188 | * 形如(samples, features)的2D张量 189 | 190 | *** 191 | 192 | ## GlobalAveragePooling1D层 193 | ```python 194 | keras.layers.pooling.GlobalAveragePooling1D() 195 | ``` 196 | 为时域信号施加全局平均值池化 197 | 198 | ### 输入shape 199 | 200 | * 形如（samples，steps，features）的3D张量 201 | 202 | ### 输出shape 203 | 204 | * 形如(samples, features)的2D张量 205 | 206 | *** 207 | 208 | ## GlobalMaxPooling2D层 209 | ```python 210 | keras.layers.pooling.GlobalMaxPooling2D(dim_ordering='default') 211 | ``` 212 | 为空域信号施加全局最大值池化 213 | 214 | ### 参数 215 | 216 | * dim_ordering：‘th’或‘tf’。‘th’模式中通道维（如彩色图像的3通道）位于第1个位置（维度从0开始算），而在‘tf’模式中，通道维位于第3个位置。例如128*128的三通道彩色图片，在‘th’模式中```input_shape```应写为（3，128，128），而在‘tf’模式中应写为（128，128，3），注意这里3出现在第0个位置，因为```input_shape```不包含样本数的维度，在其内部实现中，实际上是（None，3，128，128）和（None，128，128，3）。默认是```image_dim_ordering```指定的模式，可在```~/.keras/keras.json```中查看，若没有设置过则为'tf'。 217 | 218 | ### 输入shape 219 | 220 | ‘th’模式下，为形如（samples，channels, rows，cols）的4D张量 221 | 222 | ‘tf’模式下，为形如（samples，rows, cols，channels）的4D张量 223 | 224 | ### 输出shape 225 | 226 | 形如(nb_samples, channels)的2D张量 227 | 228 | *** 229 | 230 | ## GlobalAveragePooling2D层 231 | ```python 232 | keras.layers.pooling.GlobalAveragePooling2D(dim_ordering='default') 233 | ``` 234 | 为空域信号施加全局平均值池化 235 | 236 | ### 参数 237 | 238 | * dim_ordering：‘th’或‘tf’。‘th’模式中通道维（如彩色图像的3通道）位于第1个位置（维度从0开始算），而在‘tf’模式中，通道维位于第3个位置。例如128*128的三通道彩色图片，在‘th’模式中```input_shape```应写为（3，128，128），而在‘tf’模式中应写为（128，128，3），注意这里3出现在第0个位置，因为```input_shape```不包含样本数的维度，在其内部实现中，实际上是（None，3，128，128）和（None，128，128，3）。默认是```image_dim_ordering```指定的模式，可在```~/.keras/keras.json```中查看，若没有设置过则为'tf'。 239 | 240 | ### 输入shape 241 | 242 | ‘th’模式下，为形如（samples，channels, rows，cols）的4D张量 243 | 244 | ‘tf’模式下，为形如（samples，rows, cols，channels）的4D张量 245 | 246 | ### 输出shape 247 | 248 | 形如(nb_samples, channels)的2D张量 249 | 250 | -------------------------------------------------------------------------------- /docs/legacy/layers/wrapper.md: -------------------------------------------------------------------------------- 1 | # 包装器Wrapper 2 | 3 | ## TimeDistributed包装器 4 | ```python 5 | keras.layers.wrappers.TimeDistributed(layer) 6 | ``` 7 | 该包装器可以把一个层应用到输入的每一个时间步上 8 | 9 | ### 参数 10 | 11 | * layer：Keras层对象 12 | 13 | 输入至少为3D张量，下标为1的维度将被认为是时间维 14 | 15 | 例如，考虑一个含有32个样本的batch，每个样本都是10个向量组成的序列，每个向量长为16，则其输入维度为```(32,10,16)```，其不包含batch大小的```input_shape```为```(10,16)``` 16 | 17 | 我们可以使用包装器```TimeDistributed```包装```Dense```，以产生针对各个时间步信号的独立全连接： 18 | 19 | ```python 20 | # as the first layer in a model 21 | model = Sequential() 22 | model.add(TimeDistributed(Dense(8), input_shape=(10, 16))) 23 | # now model.output_shape == (None, 10, 8) 24 | 25 | # subsequent layers: no need for input_shape 26 | model.add(TimeDistributed(Dense(32))) 27 | # now model.output_shape == (None, 10, 32) 28 | ``` 29 | 30 | 程序的输出数据shape为```(32,10,8)``` 31 | 32 | 使用```TimeDistributed```包装```Dense```严格等价于```layers.TimeDistribuedDense```。不同的是包装器```TimeDistribued```还可以对别的层进行包装，如这里对```Convolution2D```包装： 33 | 34 | ```python 35 | model = Sequential() 36 | model.add(TimeDistributed(Convolution2D(64, 3, 3), input_shape=(10, 3, 299, 299))) 37 | ``` 38 | 39 | ## Bidirectional包装器 40 | ```python 41 | keras.layers.wrappers.Bidirectional(layer, merge_mode='concat', weights=None) 42 | ``` 43 | 双向RNN包装器 44 | 45 | ### 参数 46 | 47 | * layer：```Recurrent```对象 48 | * merge_mode：前向和后向RNN输出的结合方式，为```sum```,```mul```,```concat```,```ave```和```None```之一，若设为None，则返回值不结合，而是以列表的形式返回 49 | 50 | ### 例子 51 | ```python 52 | model = Sequential() 53 | model.add(Bidirectional(LSTM(10, return_sequences=True), input_shape=(5, 10))) 54 | model.add(Bidirectional(LSTM(10))) 55 | model.add(Dense(5)) 56 | model.add(Activation('softmax')) 57 | model.compile(loss='categorical_crossentropy', optimizer='rmsprop') 58 | ``` -------------------------------------------------------------------------------- /docs/legacy/layers/writting_layer.md: -------------------------------------------------------------------------------- 1 | #编写自己的层 2 | 3 | 4 | 对于简单的定制操作，我们或许可以通过使用```layers.core.Lambda```层来完成。但对于任何具有可训练权重的定制层，你应该自己来实现。 5 | 6 | 这里是一个Keras层应该具有的框架结构(1.1.3以后的版本，如果你的版本更旧请升级)，要定制自己的层，你需要实现下面三个方法 7 | 8 | * ```build(input_shape)```：这是定义权重的方法，可训练的权应该在这里被加入列表````self.trainable_weights```中。其他的属性还包括```self.non_trainabe_weights```（列表）和```self.updates```（需要更新的形如（tensor, new_tensor）的tuple的列表）。你可以参考```BatchNormalization```层的实现来学习如何使用上面两个属性。这个方法必须设置```self.built = True```，可通过调用```super([layer],self).build()```实现 9 | 10 | * ```call(x)```：这是定义层功能的方法，除非你希望你写的层支持masking，否则你只需要关心```call```的第一个参数：输入张量 11 | 12 | * ```get_output_shape_for(input_shape)```：如果你的层修改了输入数据的shape，你应该在这里指定shape变化的方法，这个函数使得Keras可以做自动shape推断 13 | 14 | ```python 15 | from keras import backend as K 16 | from keras.engine.topology import Layer 17 | 18 | class MyLayer(Layer): 19 | def __init__(self, output_dim, **kwargs): 20 | self.output_dim = output_dim 21 | super(MyLayer, self).__init__(**kwargs) 22 | 23 | def build(self, input_shape): 24 | self.W = self.add_weight(shape=(input_shape[1], self.output_dim), 25 | initializer='random_uniform', 26 | trainable=True) 27 | super(MyLayer, self).build() # be sure you call this somewhere! 28 | 29 | def call(self, x, mask=None): 30 | return K.dot(x, self.W) 31 | 32 | def get_output_shape_for(self, input_shape): 33 | return (input_shape[0] + self.output_dim) 34 | ``` 35 | 36 | 37 | ## 调整旧版Keras编写的层以适应Keras1.0 38 | 39 | 40 | 41 | 以下内容是你在将旧版Keras实现的层调整为新版Keras应注意的内容，这些内容对你在Keras1.0中编写自己的层也有所帮助。 42 | 43 | * 你的Layer应该继承自```keras.engine.topology.Layer```，而不是之前的```keras.layers.core.Layer```。另外，```MaskedLayer```已经被移除。 44 | 45 | * ```build```方法现在接受```input_shape```参数，而不是像以前一样通过```self.input_shape```来获得该值，所以请把```build(self)```转为```build(self, input_shape)``` 46 | 47 | * 请正确将```output_shape```属性转换为方法```get_output_shape_for(self, train=False)```，并删去原来的```output_shape``` 48 | 49 | * 新层的计算逻辑现在应实现在```call```方法中，而不是之前的```get_output```。注意不要改动```__call__```方法。将```get_output(self,train=False)```转换为```call(self,x,mask=None)```后请删除原来的```get_output```方法。 50 | 51 | * Keras1.0不再使用布尔值```train```来控制训练状态和测试状态，如果你的层在测试和训练两种情形下表现不同，请在```call```中使用指定状态的函数。如，```x=K.in_train_phase(train_x, test_y)```。例如，在Dropout的```call```方法中你可以看到： 52 | 53 | ```python 54 | return K.in_train_phase(K.dropout(x, level=self.p), x) 55 | ``` 56 | 57 | * ```get_config```返回的配置信息可能会包括类名，请从该函数中将其去掉。如果你的层在实例化时需要更多信息（即使将```config```作为kwargs传入也不能提供足够信息），请重新实现```from_config```。请参考```Lambda```或```Merge```层看看复杂的```from_config```是如何实现的。 58 | 59 | * 如果你在使用Masking，请实现```compute_mas(input_tensor, input_mask)```，该函数将返回```output_mask```。请确保在```__init__()```中设置```self.supports_masking = True``` 60 | 61 | * 如果你希望Keras在你编写的层与Keras内置层相连时进行输入兼容性检查，请在```__init__```设置```self.input_specs```或实现```input_specs()```并包装为属性（@property）。该属性应为```engine.InputSpec```的对象列表。在你希望在```call```中获取输入shape时，该属性也比较有用。 62 | 63 | * 下面的方法和属性是内置的，请不要覆盖它们 64 | 65 | * ```__call__``` 66 | 67 | * ```add_input``` 68 | 69 | * ```assert_input_compatibility``` 70 | 71 | * ```set_input``` 72 | 73 | * ```input``` 74 | 75 | * ```output``` 76 | 77 | * ```input_shape``` 78 | 79 | * ```output_shape``` 80 | 81 | * ```input_mask``` 82 | 83 | * ```output_mask``` 84 | 85 | * ```get_input_at``` 86 | 87 | * ```get_output_at``` 88 | 89 | * ```get_input_shape_at``` 90 | 91 | * ```get_output_shape_at``` 92 | 93 | * ```get_input_mask_at``` 94 | 95 | * ```get_output_mask_at``` 96 | 97 | 98 | 现存的Keras层代码可以为你的实现提供良好参考，阅读源代码吧！ 99 | -------------------------------------------------------------------------------- /docs/legacy/models/about_model.md: -------------------------------------------------------------------------------- 1 | # 关于Keras模型 2 | 3 | Keras有两种类型的模型，[顺序模型（Sequential）](sequential.md)和[泛型模型（Model）](model.md) 4 | 5 | 两类模型有一些方法是相同的： 6 | 7 | * ```model.summary()```：打印出模型概况 8 | 9 | * ```model.get_config()```:返回包含模型配置信息的Python字典。模型也可以从它的config信息中重构回去 10 | 11 | ```python 12 | config = model.get_config() 13 | model = Model.from_config(config) 14 | # or, for Sequential 15 | model = Sequential.from_config(config) 16 | ``` 17 | 18 | * ```model.get_weights()```：返回模型权重张量的列表，类型为numpy array 19 | 20 | * ```model.set_weights()```：从numpy array里将权重载入给模型，要求数组具有与```model.get_weights()```相同的形状。 21 | 22 | * ```model.to_json```：返回代表模型的JSON字符串，仅包含网络结构，不包含权值。可以从JSON字符串中重构原模型： 23 | 24 | ```python 25 | from models import model_from_json 26 | 27 | json_string = model.to_json() 28 | model = model_from_json(json_string) 29 | ``` 30 | 31 | * ```model.to_yaml```：与```model.to_json```类似，同样可以从产生的YAML字符串中重构模型 32 | 33 | ```python 34 | from models import model_from_yaml 35 | 36 | yaml_string = model.to_yaml() 37 | model = model_from_yaml(yaml_string) 38 | ``` 39 | 40 | * ```model.save_weights(filepath)```：将模型权重保存到指定路径，文件类型是HDF5（后缀是.h5） 41 | 42 | * ```model.load_weights(filepath, by_name=False)```：从HDF5文件中加载权重到当前模型中, 默认情况下模型的结构将保持不变。如果想将权重载入不同的模型（有些层相同）中，则设置```by_name=True```，只有名字匹配的层才会载入权重 43 | -------------------------------------------------------------------------------- /docs/legacy/models/model.md: -------------------------------------------------------------------------------- 1 | # 泛型模型接口 2 | 3 | 为什么叫“泛型模型”，请查看[一些基本概念](../getting_started/concepts/#functional) 4 | 5 | Keras的泛型模型为```Model```，即广义的拥有输入和输出的模型，我们使用```Model```来初始化一个泛型模型 6 | 7 | ```python 8 | from keras.models import Model 9 | from keras.layers import Input, Dense 10 | 11 | a = Input(shape=(32,)) 12 | b = Dense(32)(a) 13 | model = Model(input=a, output=b) 14 | ``` 15 | 16 | 在这里，我们的模型以```a```为输入，以```b```为输出，同样我们可以构造拥有多输入和多输出的模型 17 | 18 | ```python 19 | model = Model(input=[a1, a2], output=[b1, b3, b3]) 20 | ``` 21 | 22 | ## 常用Model属性 23 | 24 | * ```model.layers```：组成模型图的各个层 25 | * ```model.inputs```：模型的输入张量列表 26 | * ```model.outputs```：模型的输出张量列表 27 | 28 | *** 29 | 30 | ## Model模型方法 31 | 32 | ### compile 33 | 34 | ```python 35 | compile(self, optimizer, loss, metrics=[], loss_weights=None, sample_weight_mode=None) 36 | ``` 37 | 本函数编译模型以供训练，参数有 38 | 39 | * optimizer：优化器，为预定义优化器名或优化器对象，参考[优化器](../other/optimizers.md) 40 | 41 | * loss：目标函数，为预定义损失函数名或一个目标函数，参考[目标函数](../other/objectives.md) 42 | 43 | * metrics：列表，包含评估模型在训练和测试时的性能的指标，典型用法是```metrics=['accuracy']```如果要在多输出模型中为不同的输出指定不同的指标，可像该参数传递一个字典，例如```metrics={'ouput_a': 'accuracy'}``` 44 | 45 | * sample_weight_mode：如果你需要按时间步为样本赋权（2D权矩阵），将该值设为“temporal”。默认为“None”，代表按样本赋权（1D权）。如果模型有多个输出，可以向该参数传入指定sample_weight_mode的字典或列表。在下面```fit```函数的解释中有相关的参考内容。 46 | 47 | * kwargs：使用TensorFlow作为后端请忽略该参数，若使用Theano作为后端，kwargs的值将会传递给 K.function 48 | 49 | 【Tips】如果你只是载入模型并利用其predict，可以不用进行compile。在Keras中，compile主要完成损失函数和优化器的一些配置，是为训练服务的。predict会在内部进行符号函数的编译工作（通过调用_make_predict_function生成函数）【@白菜，@我是小将】 50 | *** 51 | 52 | ### fit 53 | 54 | ```python 55 | fit(self, x, y, batch_size=32, nb_epoch=10, verbose=1, callbacks=[], validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None) 56 | ``` 57 | 本函数用以训练模型，参数有： 58 | 59 | * x：输入数据。如果模型只有一个输入，那么x的类型是numpy array，如果模型有多个输入，那么x的类型应当为list，list的元素是对应于各个输入的numpy array。如果模型的每个输入都有名字，则可以传入一个字典，将输入名与其输入数据对应起来。 60 | 61 | * y：标签，numpy array。如果模型有多个输出，可以传入一个numpy array的list。如果模型的输出拥有名字，则可以传入一个字典，将输出名与其标签对应起来。 62 | 63 | * batch_size：整数，指定进行梯度下降时每个batch包含的样本数。训练时一个batch的样本会被计算一次梯度下降，使目标函数优化一步。 64 | 65 | * nb_epoch：整数，训练的轮数，训练数据将会被遍历nb_epoch次。Keras中nb开头的变量均为"number of"的意思 66 | 67 | * verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录 68 | 69 | * callbacks：list，其中的元素是```keras.callbacks.Callback```的对象。这个list中的回调函数将会在训练过程中的适当时机被调用，参考[回调函数](../other/callbacks.md) 70 | 71 | * validation_split：0~1之间的浮点数，用来指定训练集的一定比例数据作为验证集。验证集将不参与训练，并在每个epoch结束后测试的模型的指标，如损失函数、精确度等。 72 | 73 | * validation_data：形式为（X，y）或（X，y，sample_weights）的tuple，是指定的验证集。此参数将覆盖validation_spilt。 74 | 75 | * shuffle：布尔值，表示是否在训练过程中每个epoch前随机打乱输入样本的顺序。 76 | 77 | * class_weight：字典，将不同的类别映射为不同的权值，该参数用来在训练过程中调整损失函数（只能用于训练）。该参数在处理非平衡的训练数据（某些类的训练样本数很少）时，可以使得损失函数对样本数不足的数据更加关注。 78 | 79 | * sample_weight：权值的numpy array，用于在训练时调整损失函数（仅用于训练）。可以传递一个1D的与样本等长的向量用于对样本进行1对1的加权，或者在面对时序数据时，传递一个的形式为（samples，sequence_length）的矩阵来为每个时间步上的样本赋不同的权。这种情况下请确定在编译模型时添加了```sample_weight_mode='temporal'```。 80 | 81 | ```fit```函数返回一个```History```的对象，其```History.history```属性记录了损失函数和其他指标的数值随epoch变化的情况，如果有验证集的话，也包含了验证集的这些指标变化情况 82 | 83 | *** 84 | 85 | 86 | 87 | ### evaluate 88 | 89 | 90 | 91 | ```python 92 | evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None) 93 | ``` 94 | 本函数按batch计算在某些输入数据上模型的误差，其参数有： 95 | 96 | * x：输入数据，与```fit```一样，是numpy array或numpy array的list 97 | 98 | * y：标签，numpy array 99 | 100 | * batch_size：整数，含义同```fit```的同名参数 101 | 102 | * verbose：含义同```fit```的同名参数，但只能取0或1 103 | 104 | * sample_weight：numpy array，含义同```fit```的同名参数 105 | 106 | 本函数返回一个测试误差的标量值（如果模型没有其他评价指标），或一个标量的list（如果模型还有其他的评价指标）。```model.metrics_names```将给出list中各个值的含义。 107 | 108 | 如果没有特殊说明，以下函数的参数均保持与```fit```的同名参数相同的含义 109 | 110 | 如果没有特殊说明，以下函数的verbose参数（如果有）均只能取0或1 111 | 112 | *** 113 | 114 | ### predict 115 | 116 | ```python 117 | predict(self, x, batch_size=32, verbose=0) 118 | ``` 119 | 本函数按batch获得输入数据对应的输出，其参数有： 120 | 121 | 函数的返回值是预测值的numpy array 122 | 123 | *** 124 | 125 | ### train_on_batch 126 | ```python 127 | train_on_batch(self, x, y, class_weight=None, sample_weight=None) 128 | ``` 129 | 本函数在一个batch的数据上进行一次参数更新 130 | 131 | 函数返回训练误差的标量值或标量值的list，与[evaluate](#evaluate)的情形相同。 132 | 133 | *** 134 | 135 | ### test_on_batch 136 | ```python 137 | test_on_batch(self, x, y, sample_weight=None) 138 | ``` 139 | 本函数在一个batch的样本上对模型进行评估 140 | 141 | 函数的返回与[evaluate](#evaluate)的情形相同 142 | 143 | *** 144 | 145 | ### predict_on_batch 146 | ```python 147 | predict_on_batch(self, x) 148 | ``` 149 | 本函数在一个batch的样本上对模型进行测试 150 | 151 | 函数返回模型在一个batch上的预测结果 152 | 153 | *** 154 | 155 | ### fit_generator 156 | ```python 157 | fit_generator(self, generator, samples_per_epoch, nb_epoch, verbose=1, callbacks=[], validation_data=None, nb_val_samples=None, class_weight={}, max_q_size=10) 158 | ``` 159 | 利用Python的生成器，逐个生成数据的batch并进行训练。生成器与模型将并行执行以提高效率。例如，该函数允许我们在CPU上进行实时的数据提升，同时在GPU上进行模型训练 160 | 161 | 函数的参数是： 162 | 163 | * generator：生成器函数，生成器的输出应该为： 164 | * 一个形如（inputs，targets）的tuple 165 | 166 | * 一个形如（inputs, targets,sample_weight）的tuple。所有的返回值都应该包含相同数目的样本。生成器将无限在数据集上循环。每个epoch以经过模型的样本数达到```samples_per_epoch```时，记一个epoch结束 167 | 168 | * samples_per_epoch：整数，当模型处理的样本达到此数目时计一个epoch结束，执行下一个epoch 169 | 170 | * verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录 171 | 172 | * validation_data：具有以下三种形式之一 173 | * 生成验证集的生成器 174 | 175 | * 一个形如（inputs,targets）的tuple 176 | 177 | * 一个形如（inputs,targets，sample_weights）的tuple 178 | 179 | * nb_val_samples：仅当```validation_data```是生成器时使用，用以限制在每个epoch结束时用来验证模型的验证集样本数，功能类似于```samples_per_epoch``` 180 | 181 | * max_q_size：生成器队列的最大容量 182 | 183 | 函数返回一个```History```对象 184 | 185 | 例子 186 | 187 | ```python 188 | def generate_arrays_from_file(path): 189 | while 1: 190 | f = open(path) 191 | for line in f: 192 | # create numpy arrays of input data 193 | # and labels, from each line in the file 194 | x, y = process_line(line) 195 | yield (x, y) 196 | f.close() 197 | 198 | model.fit_generator(generate_arrays_from_file('/my_file.txt'), 199 | samples_per_epoch=10000, nb_epoch=10) 200 | ``` 201 | 202 | *** 203 | 204 | ### evaluate_generator 205 | ```python 206 | evaluate_generator(self, generator, val_samples, max_q_size=10) 207 | ``` 208 | 本函数使用一个生成器作为数据源，来评估模型，生成器应返回与```test_on_batch```的输入数据相同类型的数据。 209 | 210 | 函数的参数是： 211 | 212 | * generator：生成输入batch数据的生成器 213 | 214 | * val_samples：生成器应该返回的总样本数 215 | 216 | * max_q_size：生成器队列的最大容量 217 | 218 | * nb_worker：使用基于进程的多线程处理时的进程数 219 | 220 | * pickle_safe：若设置为True，则使用基于进程的线程。注意因为它的实现依赖于多进程处理，不可传递不可pickle的参数到生成器中，因为它们不能轻易的传递到子进程中。 221 | 222 | *** 223 | 224 | ### predict_generator 225 | ```python 226 | predict_generator(self, generator, val_samples, max_q_size=10, nb_worker=1, pickle_safe=False) 227 | ``` 228 | 从一个生成器上获取数据并进行预测，生成器应返回与```predict_on_batch```输入类似的数据 229 | 230 | 函数的参数是： 231 | 232 | * generator：生成输入batch数据的生成器 233 | 234 | * val_samples：生成器应该返回的总样本数 235 | 236 | * max_q_size：生成器队列的最大容量 237 | 238 | * nb_worker：使用基于进程的多线程处理时的进程数 239 | 240 | * pickle_safe：若设置为True，则使用基于进程的线程。注意因为它的实现依赖于多进程处理，不可传递不可pickle的参数到生成器中，因为它们不能轻易的传递到子进程中。 241 | 242 | *** 243 | 244 | ### get_layer 245 | ```python 246 | get_layer(self, name=None, index=None) 247 | ``` 248 | 本函数依据模型中层的下标或名字获得层对象，泛型模型中层的下标依据自底向上，水平遍历的顺序。 249 | 250 | * name：字符串，层的名字 251 | 252 | * index： 整数，层的下标 253 | 254 | 函数的返回值是层对象 -------------------------------------------------------------------------------- /docs/legacy/models/sequential.md: -------------------------------------------------------------------------------- 1 | # Sequential模型接口 2 | 3 | 如果刚开始学习Sequential模型，请首先移步[这里](../getting_started/sequential_model.md)阅读文档 4 | 5 | ## 常用Sequential属性 6 | 7 | * ```model.layers```是添加到模型上的层的list 8 | 9 | *** 10 | 11 | ## Sequential模型方法 12 | 13 | ### compile 14 | 15 | ```python 16 | compile(self, optimizer, loss, metrics=[], sample_weight_mode=None) 17 | ``` 18 | 编译用来配置模型的学习过程，其参数有 19 | 20 | * optimizer：字符串（预定义优化器名）或优化器对象，参考[优化器](../other/optimizers.md) 21 | 22 | * loss：字符串（预定义损失函数名）或目标函数，参考[目标函数](../other/objectives.md) 23 | 24 | * metrics：列表，包含评估模型在训练和测试时的网络性能的指标，典型用法是```metrics=['accuracy']``` 25 | 26 | * sample_weight_mode：如果你需要按时间步为样本赋权（2D权矩阵），将该值设为“temporal”。默认为“None”，代表按样本赋权（1D权）。在下面```fit```函数的解释中有相关的参考内容。 27 | 28 | * kwargs：使用TensorFlow作为后端请忽略该参数，若使用Theano作为后端，kwargs的值将会传递给 K.function 29 | 30 | ```python 31 | model = Sequential() 32 | model.add(Dense(32, input_shape=(500,))) 33 | model.add(Dense(10, activation='softmax')) 34 | model.compile(optimizer='rmsprop', 35 | loss='categorical_crossentropy', 36 | metrics=['accuracy']) 37 | ``` 38 | 39 | ### fit 40 | 41 | ```python 42 | fit(self, x, y, batch_size=32, nb_epoch=10, verbose=1, callbacks=[], validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None) 43 | ``` 44 | 本函数将模型训练```nb_epoch```轮，其参数有： 45 | 46 | * x：输入数据。如果模型只有一个输入，那么x的类型是numpy array，如果模型有多个输入，那么x的类型应当为list，list的元素是对应于各个输入的numpy array 47 | 48 | * y：标签，numpy array 49 | 50 | * batch_size：整数，指定进行梯度下降时每个batch包含的样本数。训练时一个batch的样本会被计算一次梯度下降，使目标函数优化一步。 51 | 52 | * nb_epoch：整数，训练的轮数，训练数据将会被遍历nb_epoch次。Keras中nb开头的变量均为"number of"的意思 53 | 54 | * verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录 55 | 56 | * callbacks：list，其中的元素是```keras.callbacks.Callback```的对象。这个list中的回调函数将会在训练过程中的适当时机被调用，参考[回调函数](../other/callbacks.md) 57 | 58 | * validation_split：0~1之间的浮点数，用来指定训练集的一定比例数据作为验证集。验证集将不参与训练，并在每个epoch结束后测试的模型的指标，如损失函数、精确度等。 59 | 60 | * validation_data：形式为（X，y）的tuple，是指定的验证集。此参数将覆盖validation_spilt。 61 | 62 | * shuffle：布尔值或字符串，一般为布尔值，表示是否在训练过程中随机打乱输入样本的顺序。若为字符串“batch”，则是用来处理HDF5数据的特殊情况，它将在batch内部将数据打乱。 63 | 64 | * class_weight：字典，将不同的类别映射为不同的权值，该参数用来在训练过程中调整损失函数（只能用于训练） 65 | 66 | * sample_weight：权值的numpy array，用于在训练时调整损失函数（仅用于训练）。可以传递一个1D的与样本等长的向量用于对样本进行1对1的加权，或者在面对时序数据时，传递一个的形式为（samples，sequence_length）的矩阵来为每个时间步上的样本赋不同的权。这种情况下请确定在编译模型时添加了```sample_weight_mode='temporal'```。 67 | 68 | ```fit```函数返回一个```History```的对象，其```History.history```属性记录了损失函数和其他指标的数值随epoch变化的情况，如果有验证集的话，也包含了验证集的这些指标变化情况 69 | 70 | *** 71 | 72 | 73 | ### evaluate 74 | 75 | 76 | ```python 77 | evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None) 78 | ``` 79 | 本函数按batch计算在某些输入数据上模型的误差，其参数有： 80 | 81 | * x：输入数据，与```fit```一样，是numpy array或numpy array的list 82 | 83 | * y：标签，numpy array 84 | 85 | * batch_size：整数，含义同```fit```的同名参数 86 | 87 | * verbose：含义同```fit```的同名参数，但只能取0或1 88 | 89 | * sample_weight：numpy array，含义同```fit```的同名参数 90 | 91 | 本函数返回一个测试误差的标量值（如果模型没有其他评价指标），或一个标量的list（如果模型还有其他的评价指标）。```model.metrics_names```将给出list中各个值的含义。 92 | 93 | 如果没有特殊说明，以下函数的参数均保持与```fit```的同名参数相同的含义 94 | 95 | 如果没有特殊说明，以下函数的verbose参数（如果有）均只能取0或1 96 | 97 | 98 | *** 99 | 100 | ### predict 101 | 102 | ```python 103 | predict(self, x, batch_size=32, verbose=0) 104 | ``` 105 | 本函数按batch获得输入数据对应的输出，其参数有： 106 | 107 | 函数的返回值是预测值的numpy array 108 | 109 | *** 110 | 111 | ### predict_classes 112 | 113 | ```python 114 | predict_classes(self, x, batch_size=32, verbose=1) 115 | ``` 116 | 本函数按batch产生输入数据的类别预测结果 117 | 118 | 函数的返回值是类别预测结果的numpy array或numpy 119 | 120 | *** 121 | 122 | ### predict_proba 123 | ```python 124 | predict_proba(self, x, batch_size=32, verbose=1) 125 | ``` 126 | 本函数按batch产生输入数据属于各个类别的概率 127 | 128 | 函数的返回值是类别概率的numpy array 129 | 130 | *** 131 | 132 | ### train_on_batch 133 | ```python 134 | train_on_batch(self, x, y, class_weight=None, sample_weight=None) 135 | ``` 136 | 本函数在一个batch的数据上进行一次参数更新 137 | 138 | 函数返回训练误差的标量值或标量值的list，与[evaluate](#evaluate)的情形相同。 139 | 140 | *** 141 | 142 | ### test_on_batch 143 | ```python 144 | test_on_batch(self, x, y, sample_weight=None) 145 | ``` 146 | 本函数在一个batch的样本上对模型进行评估 147 | 148 | 函数的返回与[evaluate](#evaluate)的情形相同 149 | 150 | *** 151 | 152 | ### predict_on_batch 153 | ```python 154 | predict_on_batch(self, x) 155 | ``` 156 | 本函数在一个batch的样本上对模型进行测试 157 | 158 | 函数返回模型在一个batch上的预测结果 159 | 160 | *** 161 | 162 | ### fit_generator 163 | ```python 164 | fit_generator(self, generator, samples_per_epoch, nb_epoch, verbose=1, callbacks=[], validation_data=None, nb_val_samples=None, class_weight=None, max_q_size=10) 165 | ``` 166 | 利用Python的生成器，逐个生成数据的batch并进行训练。生成器与模型将并行执行以提高效率。例如，该函数允许我们在CPU上进行实时的数据提升，同时在GPU上进行模型训练 167 | 168 | 函数的参数是： 169 | 170 | * generator：生成器函数，生成器的输出应该为： 171 | * 一个形如（inputs，targets）的tuple 172 | 173 | * 一个形如（inputs, targets,sample_weight）的tuple。所有的返回值都应该包含相同数目的样本。生成器将无限在数据集上循环。每个epoch以经过模型的样本数达到```samples_per_epoch```时，记一个epoch结束 174 | 175 | * samples_per_epoch：整数，当模型处理的样本达到此数目时计一个epoch结束，执行下一个epoch 176 | 177 | * verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录 178 | 179 | * validation_data：具有以下三种形式之一 180 | * 生成验证集的生成器 181 | 182 | * 一个形如（inputs,targets）的tuple 183 | 184 | * 一个形如（inputs,targets，sample_weights）的tuple 185 | 186 | * nb_val_samples：仅当```validation_data```是生成器时使用，用以限制在每个epoch结束时用来验证模型的验证集样本数，功能类似于```samples_per_epoch``` 187 | 188 | * max_q_size：生成器队列的最大容量 189 | 190 | 函数返回一个```History```对象 191 | 192 | 例子： 193 | 194 | ```python 195 | def generate_arrays_from_file(path): 196 | while 1: 197 | f = open(path) 198 | for line in f: 199 | # create numpy arrays of input data 200 | # and labels, from each line in the file 201 | x, y = process_line(line) 202 | yield (x, y) 203 | f.close() 204 | 205 | model.fit_generator(generate_arrays_from_file('/my_file.txt'), 206 | samples_per_epoch=10000, nb_epoch=10) 207 | ``` 208 | 209 | *** 210 | 211 | ### evaluate_generator 212 | ```python 213 | evaluate_generator(self, generator, val_samples, max_q_size=10) 214 | ``` 215 | 本函数使用一个生成器作为数据源评估模型，生成器应返回与```test_on_batch```的输入数据相同类型的数据。该函数的参数与```fit_generator```同名参数含义相同 216 | -------------------------------------------------------------------------------- /docs/legacy/no_use.md: -------------------------------------------------------------------------------- 1 | ## SpatialDropout1D层 2 | 3 | ```python 4 | keras.layers.core.SpatialDropout1D(p) 5 | ``` 6 | SpatialDropout1D与Dropout的作用类似，但它断开的是整个1D特征图，而不是单个神经元。如果一张特征图的相邻像素之间有很强的相关性（通常发生在低层的卷积层中），那么普通的dropout无法正则化其输出，否则就会导致明显的学习率下降。这种情况下，SpatialDropout1D能够帮助提高特征图之间的独立性，应该用其取代普通的Dropout 7 | 8 | ### 参数 9 | 10 | * p：0~1的浮点数，控制需要断开的链接的比例 11 | 12 | ### 输入shape 13 | 14 | 输入形如（samples，timesteps，channels）的3D张量 15 | 16 | ### 输出shape 17 | 18 | 与输入相同 19 | 20 | ### 参考文献 21 | 22 | * [Efficient Object Localization Using Convolutional Networks](https://arxiv.org/pdf/1411.4280.pdf) 23 | 24 | 25 | *** 26 | ## SpatialDropout2D层 27 | 28 | ```python 29 | keras.layers.core.SpatialDropout2D(p, dim_ordering='default') 30 | ``` 31 | SpatialDropout2D与Dropout的作用类似，但它断开的是整个2D特征图，而不是单个神经元。如果一张特征图的相邻像素之间有很强的相关性（通常发生在低层的卷积层中），那么普通的dropout无法正则化其输出，否则就会导致明显的学习率下降。这种情况下，SpatialDropout2D能够帮助提高特征图之间的独立性，应该用其取代普通的Dropout 32 | 33 | ### 参数 34 | 35 | * p：0~1的浮点数，控制需要断开的链接的比例 36 | * dim_ordering:'th'或'tf'，默认为```~/.keras/keras.json```配置的```image_dim_ordering```值 37 | 38 | ### 输入shape 39 | 40 | ‘th’模式下，输入形如（samples，channels，rows，cols）的4D张量 41 | 42 | ‘tf’模式下，输入形如（samples，rows，cols，channels）的4D张量 43 | 44 | 注意这里的输入shape指的是函数内部实现的输入shape，而非函数接口应指定的```input_shape```，请参考下面提供的例子。 45 | 46 | ### 输出shape 47 | 48 | 与输入相同 49 | 50 | ### 参考文献 51 | 52 | * [Efficient Object Localization Using Convolutional Networks](https://arxiv.org/pdf/1411.4280.pdf) 53 | 54 | *** 55 | 56 | ## SpatialDropout3D层 57 | 58 | ```python 59 | keras.layers.core.SpatialDropout3D(p, dim_ordering='default') 60 | ``` 61 | SpatialDropout3D与Dropout的作用类似，但它断开的是整个3D特征图，而不是单个神经元。如果一张特征图的相邻像素之间有很强的相关性（通常发生在低层的卷积层中），那么普通的dropout无法正则化其输出，否则就会导致明显的学习率下降。这种情况下，SpatialDropout3D能够帮助提高特征图之间的独立性，应该用其取代普通的Dropout 62 | 63 | ### 参数 64 | 65 | * p：0~1的浮点数，控制需要断开的链接的比例 66 | * dim_ordering:'th'或'tf'，默认为```~/.keras/keras.json```配置的```image_dim_ordering```值 67 | 68 | ### 输入shape 69 | 70 | ‘th’模式下，输入应为形如（samples，channels，input_dim1，input_dim2, input_dim3）的5D张量 71 | 72 | ‘tf’模式下，输入应为形如（samples，input_dim1，input_dim2, input_dim3，channels）的5D张量 73 | 74 | ### 输出shape 75 | 76 | 与输入相同 77 | 78 | ### 参考文献 79 | 80 | * [Efficient Object Localization Using Convolutional Networks](https://arxiv.org/pdf/1411.4280.pdf) 81 | 82 | *** 83 | 84 | *** 85 | 86 | ## TimeDisributedDense层 87 | ```python 88 | keras.layers.core.TimeDistributedDense(output_dim, init='glorot_uniform', activation='linear', weights=None, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True, input_dim=None, input_length=None) 89 | ``` 90 | 为输入序列的每个时间步信号（即维度1）建立一个全连接层，当RNN网络设置为```return_sequence=True```时尤其有用 91 | 92 | * 注意：该层已经被弃用，请使用其包装器```TImeDistributed```完成此功能 93 | 94 | ```python 95 | model.add(TimeDistributed(Dense(32))) 96 | ``` 97 | 98 | ### 参数 99 | 100 | * output_dim：大于0的整数，代表该层的输出维度。模型中非首层的全连接层其输入维度可以自动推断，因此非首层的全连接定义时不需要指定输入维度。 101 | 102 | * init：初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的Theano函数。该参数仅在不传递```weights```参数时有意义。 103 | 104 | * activation：激活函数，为预定义的激活函数名（参考[激活函数](../other/activations)），或逐元素（element-wise）的Theano函数。如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x） 105 | 106 | * weights：权值，为numpy array的list。该list应含有一个形如（input_dim,output_dim）的权重矩阵和一个形如(output_dim,)的偏置向量。 107 | 108 | * W_regularizer：施加在权重上的正则项，为[WeightRegularizer](../other/regularizers)对象 109 | 110 | * b_regularizer：施加在偏置向量上的正则项，为[WeightRegularizer](../other/regularizers)对象 111 | 112 | * activity_regularizer：施加在输出上的正则项，为[ActivityRegularizer](../other/regularizers)对象 113 | 114 | * W_constraints：施加在权重上的约束项，为[Constraints](../other/constraints)对象 115 | 116 | * b_constraints：施加在偏置上的约束项，为[Constraints](../other/constraints)对象 117 | 118 | * bias：布尔值，是否包含偏置向量（即层对输入做线性变换还是仿射变换） 119 | 120 | * input_dim：整数，输入数据的维度。当该层作为网络的第一层时，必须指定该参数或```input_shape```参数。 121 | 122 | * input_length：输入序列的长度，为整数或None，若为None则代表输入序列是变长序列 123 | 124 | ### 输入shape 125 | 126 | 形如 ```(nb_sample, time_dimension, input_dim)```的3D张量 127 | 128 | ### 输出shape 129 | 130 | 形如 ```(nb_sample, time_dimension, output_dim)```的3D张量 131 | -------------------------------------------------------------------------------- /docs/legacy/other/activations.md: -------------------------------------------------------------------------------- 1 | # 激活函数Activations 2 | 3 | 激活函数可以通过设置单独的[激活层](../layers/core_layer/#activation)实现，也可以在构造层对象时通过传递```activation```参数实现。 4 | 5 | ```python 6 | from keras.layers.core import Activation, Dense 7 | 8 | model.add(Dense(64)) 9 | model.add(Activation('tanh')) 10 | ``` 11 | 12 | 等价于 13 | 14 | ```python 15 | model.add(Dense(64, activation='tanh')) 16 | ``` 17 | 18 | 也可以通过传递一个逐元素运算的Theano/TensorFlow函数来作为激活函数： 19 | ```python 20 | from keras import backend as K 21 | 22 | def tanh(x): 23 | return K.tanh(x) 24 | 25 | model.add(Dense(64, activation=tanh)) 26 | model.add(Activation(tanh) 27 | ``` 28 | 29 | *** 30 | 31 | ## 预定义激活函数 32 | 33 | * softmax：对输入数据的最后一维进行softmax，输入数据应形如```(nb_samples, nb_timesteps, nb_dims)```或```(nb_samples,nb_dims)``` 34 | 35 | * softplus 36 | 37 | * softsign 38 | 39 | * relu 40 | 41 | * tanh 42 | 43 | * sigmoid 44 | 45 | * hard_sigmoid 46 | 47 | * linear 48 | 49 | ## 高级激活函数 50 | 51 | 对于简单的Theano/TensorFlow不能表达的复杂激活函数，如含有可学习参数的激活函数，可通过[高级激活函数](../layers/advanced_activation_layer)实现，如PReLU，LeakyReLU等 52 | 53 | 【Tips】待会儿（大概几天吧）我们将把各个激活函数的表达式、图形和特点总结一下。请大家持续关注~ 54 | 55 | -------------------------------------------------------------------------------- /docs/legacy/other/constraints.md: -------------------------------------------------------------------------------- 1 | # 约束项 2 | 3 | 来自```constraints```模块的函数在优化过程中为网络的参数施加约束 4 | 5 | 惩罚项基于层进行惩罚，目前惩罚项的接口与层有关，但```Dense, TimeDistributedDense, MaxoutDense, Covolution1D, Covolution2D, Convolution3D```具有共同的接口。 6 | 7 | 这些层通过一下关键字施加约束项 8 | 9 | * ```W_constraint```：对主权重矩阵进行约束 10 | 11 | * ```b_constraint```：对偏置向量进行约束 12 | 13 | ```python 14 | from keras.constraints import maxnorm 15 | model.add(Dense(64, W_constraint = maxnorm(2))) 16 | ``` 17 | 18 | ## 预定义约束项 19 | 20 | * maxnorm(m=2)：最大模约束 21 | 22 | * nonneg()：非负性约束 23 | 24 | * unitnorm()：单位范数约束, 强制矩阵沿最后一个轴拥有单位范数 -------------------------------------------------------------------------------- /docs/legacy/other/datasets.md: -------------------------------------------------------------------------------- 1 | # 常用数据库 2 | 3 | ## CIFAR10 小图片分类数据集 4 | 5 | 该数据库具有50,000个32*32的彩色图片作为训练集，10,000个图片作为测试集。图片一共有10个类别。 6 | 7 | ### 使用方法 8 | ```python 9 | from keras.datasets import cifar10 10 | 11 | (X_train, y_train), (X_test, y_test) = cifar10.load_data() 12 | ``` 13 | 14 | ### 返回值： 15 | 16 | 两个Tuple 17 | 18 | ```X_train```和```X_test```是形如（nb_samples, 3, 32, 32）的RGB三通道图像数据，数据类型是无符号8位整形（uint8） 19 | 20 | ```Y_train```和 ```Y_test```是形如（nb_samples,）标签数据，标签的范围是0~9 21 | 22 | *** 23 | 24 | ## CIFAR100 小图片分类数据库 25 | 26 | 该数据库具有50,000个32*32的彩色图片作为训练集，10,000个图片作为测试集。图片一共有100个类别，每个类别有600张图片。这100个类别又分为20个大类。 27 | 28 | ### 使用方法 29 | ```python 30 | from keras.datasets import cifar100 31 | 32 | (X_train, y_train), (X_test, y_test) = cifar100.load_data(label_mode='fine') 33 | ``` 34 | 35 | ### 参数 36 | 37 | * label_mode：为‘fine’或‘coarse’之一，控制标签的精细度，‘fine’获得的标签是100个小类的标签，‘coarse’获得的标签是大类的标签 38 | 39 | ### 返回值 40 | 41 | 两个Tuple,```(X_train, y_train), (X_test, y_test)```，其中 42 | 43 | * X_train和X_test：是形如（nb_samples, 3, 32, 32）的RGB三通道图像数据，数据类型是无符号8位整形（uint8） 44 | 45 | * y_train和y_test：是形如（nb_samples,）标签数据，标签的范围是0~9 46 | 47 | *** 48 | 49 | ## IMDB影评倾向分类 50 | 51 | 本数据库含有来自IMDB的25,000条影评，被标记为正面/负面两种评价。影评已被预处理为词下标构成的[序列](../preprocessing/sequence)。方便起见，单词的下标基于它在数据集中出现的频率标定，例如整数3所编码的词为数据集中第3常出现的词。这样的组织方法使得用户可以快速完成诸如“只考虑最常出现的10,000个词，但不考虑最常出现的20个词”这样的操作 52 | 53 | 按照惯例，0不代表任何特定的词，而用来编码任何未知单词 54 | 55 | ### 使用方法 56 | ```python 57 | from keras.datasets import imdb 58 | 59 | (X_train, y_train), (X_test, y_test) = imdb.load_data(path="imdb_full.pkl", 60 | nb_words=None, 61 | skip_top=0, 62 | maxlen=None, 63 | test_split=0.1) 64 | seed=113, 65 | start_char=1, 66 | oov_char=2, 67 | index_from=3) 68 | ``` 69 | 70 | ### 参数 71 | 72 | * path：如果你在本机上已有此数据集（位于```'~/.keras/datasets/'+path```），则载入。否则数据将下载到该目录下 73 | 74 | * nb_words：整数或None，要考虑的最常见的单词数，任何出现频率更低的单词将会被编码到0的位置。 75 | 76 | * skip_top：整数，忽略最常出现的若干单词，这些单词将会被编码为0 77 | 78 | * maxlen：整数，最大序列长度，任何长度大于此值的序列将被截断 79 | 80 | * seed：整数，用于数据重排的随机数种子 81 | 82 | * start_char：字符，序列的起始将以该字符标记，默认为1因为0通常用作padding 83 | 84 | * oov_char：字符，因```nb_words```或```skip_top```限制而cut掉的单词将被该字符代替 85 | 86 | * index_from：整数，真实的单词（而不是类似于```start_char```的特殊占位符）将从这个下标开始 87 | 88 | ### 返回值 89 | 90 | 两个Tuple,```(X_train, y_train), (X_test, y_test)```，其中 91 | 92 | * X_train和X_test：序列的列表，每个序列都是词下标的列表。如果指定了```nb_words```，则序列中可能的最大下标为```nb_words-1```。如果指定了```maxlen```，则序列的最大可能长度为```maxlen``` 93 | 94 | * y_train和y_test：为序列的标签，是一个二值list 95 | 96 | *** 97 | 98 | ## 路透社新闻主题分类 99 | 100 | 本数据库包含来自路透社的11,228条新闻，分为了46个主题。与IMDB库一样，每条新闻被编码为一个词下标的序列。 101 | 102 | ### 使用方法 103 | ```python 104 | from keras.datasets import reuters 105 | 106 | 107 | (X_train, y_train), (X_test, y_test) = reuters.load_data(path="reuters.pkl", 108 | nb_words=None, 109 | skip_top=0, 110 | maxlen=None, 111 | test_split=0.2, 112 | seed=113, 113 | start_char=1, 114 | oov_char=2, 115 | index_from=3) 116 | ``` 117 | 118 | 参数的含义与IMDB同名参数相同，唯一多的参数是： 119 | ```test_split```，用于指定从原数据中分割出作为测试集的比例。该数据库支持获取用于编码序列的词下标： 120 | ```python 121 | word_index = reuters.get_word_index(path="reuters_word_index.pkl") 122 | ``` 123 | 上面代码的返回值是一个以单词为关键字，以其下标为值的字典。例如，```word_index['giraffe']```的值可能为```1234``` 124 | 125 | 数据库将会被下载到```'~/.keras/datasets/'+path``` 126 | 127 | *** 128 | 129 | ## MNIST手写数字识别 130 | 131 | 本数据库有60,000个用于训练的28*28的灰度手写数字图片，10,000个测试图片 132 | 133 | ### 使用方法 134 | ```python 135 | from keras.datasets import mnist 136 | 137 | (X_train, y_train), (X_test, y_test) = mnist.load_data() 138 | ``` 139 | 140 | ### 返回值 141 | 142 | 两个Tuple,```(X_train, y_train), (X_test, y_test)```，其中 143 | 144 | * X_train和X_test：是形如（nb_samples, 28, 28）的灰度图片数据，数据类型是无符号8位整形（uint8） 145 | 146 | * y_train和y_test：是形如（nb_samples,）标签数据，标签的范围是0~9 147 | 148 | 数据库将会被下载到```'~/.keras/datasets/'+path``` 149 | 150 | *** 151 | -------------------------------------------------------------------------------- /docs/legacy/other/initializations.md: -------------------------------------------------------------------------------- 1 | # 初始化方法 2 | 3 | 初始化方法定义了对Keras层设置初始化权重的方法 4 | 5 | 不同的层可能使用不同的关键字来传递初始化方法，一般来说指定初始化方法的关键字是```init```，例如： 6 | ```python 7 | model.add(Dense(64, init='uniform')) 8 | ``` 9 | 10 | ## 预定义初始化方法 11 | 12 | * uniform 13 | 14 | * lecun_uniform: 即有输入节点数之平方根放缩后的均匀分布初始化（[LeCun 98](http://yann.lecun.com/exdb/publis/pdf/lecun-98b.pdf)）. 15 | 16 | * normal 17 | 18 | * identity：仅用于权值矩阵为方阵的2D层（```shape[0]=shape[1]```） 19 | 20 | * orthogonal：仅用于权值矩阵为方阵的2D层（```shape[0]=shape[1]```），参考[Saxe et al.](http://arxiv.org/abs/1312.6120) 21 | 22 | * zero 23 | 24 | * glorot_normal：由扇入扇出放缩后的高斯初始化（[Glorot 2010](http://machinelearning.wustl.edu/mlpapers/paper_files/AISTATS2010_GlorotB10.pdf)） 25 | 26 | * glorot_uniform 27 | 28 | * he_normal：由扇入放缩后的高斯初始化（[He et al.,2014](http://arxiv.org/abs/1502.01852)） 29 | 30 | * he_uniform 31 | 32 | 指定初始化方法传入的可以是一个字符串(必须与上面某种预定义方法匹配),也可以是一个可调用的对象.如果传入可调用的对象,则该对象必须包含两个参数:```shape```(待初始化的变量的shape)和```name```(该变量的名字),该可调用对象必须返回一个(Keras)变量,例如```K.variable()```返回的就是这种变量,下面是例子: 33 | ```python 34 | from keras import backend as K 35 | import numpy as np 36 | 37 | def my_init(shape, name=None): 38 | value = np.random.random(shape) 39 | return K.variable(value, name=name) 40 | 41 | model.add(Dense(64, init=my_init)) 42 | ``` 43 | 你也可以按这种方法使用```keras.initializations```中的函数: 44 | ```python 45 | from keras import initializations 46 | 47 | def my_init(shape, name=None): 48 | return initializations.normal(shape, scale=0.01, name=name) 49 | 50 | model.add(Dense(64, init=my_init)) 51 | ``` 52 | 53 | 【Tips】稍后（一两周吧……）我们希望将各个初始化方法的特点总结一下，请继续关注 54 | -------------------------------------------------------------------------------- /docs/legacy/other/metrices.md~: -------------------------------------------------------------------------------- 1 | # 性能评估 2 | 3 | ## 使用方法 4 | 5 | 性能评估模块提供了一系列用于模型性能评估的函数,这些函数在模型编译时由`metrices`关键字设置 6 | 7 | 性能评估函数类似与[目标函数](objectives.md), 只不过该性能的评估结果讲不会用于训练. 8 | 9 | 可以通过字符串来使用域定义的性能评估函数,也可以自定义一个Theano/TensorFlow函数病使用之 10 | 11 | ### 参数 12 | 13 | * y_true:真实标签,theano/tensorflow张量 14 | * y_pred:预测值, 与y_true形式相同的theano/tensorflow张量 15 | 16 | ### 返回值 17 | 18 | 单个用以代表输出各个数据点上均值的值 19 | 20 | ### 可用预定义张量 21 | 22 | 除fbeta_score额外拥有默认参数beta=1外,其他各个性能指标的参数均为y_true和y_pred 23 | 24 | * binary_accuracy: 对二分类问题,计算在所有预测值上的平均正确率 25 | * categorical_accuracy:对多分类问题,计算再所有预测值上的平均正确率 26 | * sparse_categorical_accuracy:与`categorical_accuracy`相同,在对稀疏的目标值预测时有用 27 | * top_k_categorical_accracy: 计算top-k正确率,当预测值的前k个值中存在目标类别即认为预测正确 28 | * mean_squared_error:计算预测值与真值的均方差 29 | * mean_absolute_error:计算预测值与真值的平均绝对误差 30 | * mean_absolute_percentage_error:计算预测值与真值的平均绝对误差率 31 | * mean_squared_logarithmic_error:计算预测值与真值的平均指数误差 32 | * hinge:计算预测值与真值的hinge loss 33 | * squared_hinge:计算预测值与真值的平方hinge loss 34 | * categorical_crossentropy:计算预测值与真值的多类交叉熵(输入值为二值矩阵,而不是向量) 35 | * sparse_categorical_crossentropy:与多类交叉熵相同,适用于稀疏情况 36 | * binary_crossentropy:计算预测值与真值的交叉熵 37 | * poisson:计算预测值与真值的泊松函数值 38 | * cosine_proximity:计算预测值与真值的余弦相似性 39 | * matthews_correlation:计算预测值与真值的马氏距离 40 | * fbeta_score:计算F值,即召回率与准确率的加权调和平均,该函数在多标签分类(一个样本有多个标签)时有用,如果只使用准确率作为度量,模型只要把所有输入分类为"所有类别"就可以获得完美的准确率,为了避免这种情况,度量指标应该对错误的选择进行惩罚. F-beta分值(0到1之间)通过准确率和召回率的加权调和平均来更好的度量.当beta为1时,该指标等价于F-measure,beta<1时,模型选对正确的标签更加重要,而beta>1时,模型对选错标签有更大的惩罚. 41 | 42 | 43 | ### 定制评估函数 44 | 45 | 定制的评估函数可以在模型编译时传入,该函数应该以`(y_true, y_pred)`为参数,并返回单个张量,或从`metric_name`映射到`metric_value`的字典,下面是一个示例: 46 | 47 | ```python 48 | # for custom metrics 49 | import keras.backend as K 50 | 51 | def mean_pred(y_true, y_pred): 52 | return K.mean(y_pred) 53 | 54 | def false_rates(y_true, y_pred): 55 | false_neg = ... 56 | false_pos = ... 57 | return { 58 | 'false_neg': false_neg, 59 | 'false_pos': false_pos, 60 | } 61 | 62 | model.compile(optimizer='rmsprop', 63 | loss='binary_crossentropy', 64 | metrics=['accuracy', mean_pred, false_rates]) 65 | ``` 66 | -------------------------------------------------------------------------------- /docs/legacy/other/metrics.md: -------------------------------------------------------------------------------- 1 | # 性能评估 2 | 3 | ## 使用方法 4 | 5 | 性能评估模块提供了一系列用于模型性能评估的函数,这些函数在模型编译时由`metrics`关键字设置 6 | 7 | 性能评估函数类似与[目标函数](objectives.md), 只不过该性能的评估结果讲不会用于训练. 8 | 9 | 可以通过字符串来使用域定义的性能评估函数,也可以自定义一个Theano/TensorFlow函数并使用之 10 | 11 | ### 参数 12 | 13 | * y_true:真实标签,theano/tensorflow张量 14 | * y_pred:预测值, 与y_true形式相同的theano/tensorflow张量 15 | 16 | ### 返回值 17 | 18 | 单个用以代表输出各个数据点上均值的值 19 | 20 | ## 可用预定义张量 21 | 22 | 除fbeta_score额外拥有默认参数beta=1外,其他各个性能指标的参数均为y_true和y_pred 23 | 24 | * binary_accuracy: 对二分类问题,计算在所有预测值上的平均正确率 25 | * categorical_accuracy:对多分类问题,计算再所有预测值上的平均正确率 26 | * sparse_categorical_accuracy:与`categorical_accuracy`相同,在对稀疏的目标值预测时有用 27 | * top_k_categorical_accracy: 计算top-k正确率,当预测值的前k个值中存在目标类别即认为预测正确 28 | * mean_squared_error:计算预测值与真值的均方差 29 | * mean_absolute_error:计算预测值与真值的平均绝对误差 30 | * mean_absolute_percentage_error:计算预测值与真值的平均绝对误差率 31 | * mean_squared_logarithmic_error:计算预测值与真值的平均指数误差 32 | * hinge:计算预测值与真值的hinge loss 33 | * squared_hinge:计算预测值与真值的平方hinge loss 34 | * categorical_crossentropy:计算预测值与真值的多类交叉熵(输入值为二值矩阵,而不是向量) 35 | * sparse_categorical_crossentropy:与多类交叉熵相同,适用于稀疏情况 36 | * binary_crossentropy:计算预测值与真值的交叉熵 37 | * poisson:计算预测值与真值的泊松函数值 38 | * cosine_proximity:计算预测值与真值的余弦相似性 39 | * matthews_correlation:计算预测值与真值的马氏距离 40 | * precision：计算精确度，注意percision跟accuracy是不同的。percision用于评价多标签分类中有多少个选中的项是正确的 41 | * recall：召回率，计算多标签分类中有多少正确的项被选中 42 | * fbeta_score:计算F值,即召回率与准确率的加权调和平均,该函数在多标签分类(一个样本有多个标签)时有用,如果只使用准确率作为度量,模型只要把所有输入分类为"所有类别"就可以获得完美的准确率,为了避免这种情况,度量指标应该对错误的选择进行惩罚. F-beta分值(0到1之间)通过准确率和召回率的加权调和平均来更好的度量.当beta为1时,该指标等价于F-measure,beta<1时,模型选对正确的标签更加重要,而beta>1时,模型对选错标签有更大的惩罚. 43 | * fmeasure：计算f-measure，即percision和recall的调和平均 44 | 45 | ## 定制评估函数 46 | 47 | 定制的评估函数可以在模型编译时传入,该函数应该以`(y_true, y_pred)`为参数,并返回单个张量,或从`metric_name`映射到`metric_value`的字典,下面是一个示例: 48 | 49 | ```python 50 | # for custom metrics 51 | import keras.backend as K 52 | 53 | def mean_pred(y_true, y_pred): 54 | return K.mean(y_pred) 55 | 56 | def false_rates(y_true, y_pred): 57 | false_neg = ... 58 | false_pos = ... 59 | return { 60 | 'false_neg': false_neg, 61 | 'false_pos': false_pos, 62 | } 63 | 64 | model.compile(optimizer='rmsprop', 65 | loss='binary_crossentropy', 66 | metrics=['accuracy', mean_pred, false_rates]) 67 | ``` 68 | -------------------------------------------------------------------------------- /docs/legacy/other/objectives.md: -------------------------------------------------------------------------------- 1 | # 目标函数objectives 2 | 3 | 目标函数，或称损失函数，是编译一个模型必须的两个参数之一： 4 | 5 | ```python 6 | model.compile(loss='mean_squared_error', optimizer='sgd') 7 | ``` 8 | 9 | 可以通过传递预定义目标函数名字指定目标函数，也可以传递一个Theano/TensroFlow的符号函数作为目标函数，该函数对每个数据点应该只返回一个标量值，并以下列两个参数为参数： 10 | 11 | * y_true：真实的数据标签，Theano/TensorFlow张量 12 | 13 | * y_pred：预测值，与y_true相同shape的Theano/TensorFlow张量 14 | 15 | 真实的优化目标函数是在各个数据点得到的损失函数值之和的均值 16 | 17 | 请参考[目标实现代码](https://github.com/fchollet/keras/blob/master/keras/objectives.py)获取更多信息 18 | 19 | ## 可用的目标函数 20 | 21 | * mean_squared_error或mse 22 | 23 | * mean_absolute_error或mae 24 | 25 | * mean_absolute_percentage_error或mape 26 | 27 | * mean_squared_logarithmic_error或msle 28 | 29 | * squared_hinge 30 | 31 | * hinge 32 | 33 | * binary_crossentropy（亦称作对数损失，logloss） 34 | 35 | * categorical_crossentropy：亦称作多类的对数损失，注意使用该目标函数时，需要将标签转化为形如```(nb_samples, nb_classes)```的二值序列 36 | 37 | * sparse_categorical_crossentrop：如上，但接受稀疏标签。注意，使用该函数时仍然需要你的标签与输出值的维度相同，你可能需要在标签数据上增加一个维度：```np.expand_dims(y,-1)``` 38 | 39 | * kullback_leibler_divergence:从预测值概率分布Q到真值概率分布P的信息增益,用以度量两个分布的差异. 40 | 41 | * poisson：即```(predictions - targets * log(predictions))```的均值 42 | 43 | * cosine_proximity：即预测值与真实标签的余弦距离平均值的相反数 44 | 45 | 46 | **注意**: 当使用"categorical_crossentropy"作为目标函数时,标签应该为多类模式,即one-hot编码的向量,而不是单个数值. 可以使用工具中的`to_categorical`函数完成该转换.示例如下: 47 | ```python 48 | from keras.utils.np_utils import to_categorical 49 | 50 | categorical_labels = to_categorical(int_labels, nb_classes=None) 51 | ``` 52 | 53 | 54 | 55 | 【Tips】过一段时间（等我或者谁有时间吧……）我们将把各种目标函数的表达式和常用场景总结一下。 56 | -------------------------------------------------------------------------------- /docs/legacy/other/objectives.md~: -------------------------------------------------------------------------------- 1 | # 目标函数objectives 2 | 3 | 目标函数，或称损失函数，是编译一个模型必须的两个参数之一： 4 | 5 | ```python 6 | model.compile(loss='mean_squared_error', optimizer='sgd') 7 | ``` 8 | 9 | 可以通过传递预定义目标函数名字指定目标函数，也可以传递一个Theano/TensroFlow的符号函数作为目标函数，该函数对每个数据点应该只返回一个标量值，并以下列两个参数为参数： 10 | 11 | * y_true：真实的数据标签，Theano/TensorFlow张量 12 | 13 | * y_pred：预测值，与y_true相同shape的Theano/TensorFlow张量 14 | 15 | 真实的优化目标函数是在各个数据点得到的损失函数值之和的均值 16 | 17 | 请参考[目标实现代码](https://github.com/fchollet/keras/blob/master/keras/objectives.py)获取更多信息 18 | 19 | ## 可用的目标函数 20 | 21 | * mean_squared_error或mse 22 | 23 | * mean_absolute_error或mae 24 | 25 | * mean_absolute_percentage_error或mape 26 | 27 | * mean_squared_logarithmic_error或msle 28 | 29 | * squared_hinge 30 | 31 | * hinge 32 | 33 | * binary_crossentropy（亦称作对数损失，logloss） 34 | 35 | * categorical_crossentropy：亦称作多类的对数损失，注意使用该目标函数时，需要将标签转化为形如```(nb_samples, nb_classes)```的二值序列 36 | 37 | * sparse_categorical_crossentrop：如上，但接受稀疏标签。注意，使用该函数时仍然需要你的标签与输出值的维度相同，你可能需要在标签数据上增加一个维度：```np.expand_dims(y,-1)``` 38 | 39 | * kullback_leibler_divergence:从预测值概率分布Q到真值概率分布P的信息增益,用以度量两个分布的差异. 40 | 41 | * poisson：即```(predictions - targets * log(predictions))```的均值 42 | 43 | * cosine_proximity：即预测值与真实标签的余弦距离平均值的相反数 44 | 45 | ## 注意 46 | 47 | 48 | 【Tips】过一段时间（等我或者谁有时间吧……）我们将把各种目标函数的表达式和常用场景总结一下。 49 | -------------------------------------------------------------------------------- /docs/legacy/other/optimizers.md: -------------------------------------------------------------------------------- 1 | # 优化器optimizers 2 | 3 | 优化器是编译Keras模型必要的两个参数之一 4 | ```python 5 | model = Sequential() 6 | model.add(Dense(64, init='uniform', input_dim=10)) 7 | model.add(Activation('tanh')) 8 | model.add(Activation('softmax')) 9 | 10 | sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) 11 | model.compile(loss='mean_squared_error', optimizer=sgd) 12 | ``` 13 | 14 | 可以在调用```model.compile()```之前初始化一个优化器对象，然后传入该函数（如上所示），也可以在调用```model.compile()```时传递一个预定义优化器名。在后者情形下，优化器的参数将使用默认值。 15 | ```python 16 | # pass optimizer by name: default parameters will be used 17 | model.compile(loss='mean_squared_error', optimizer='sgd') 18 | ``` 19 | ## 所有优化器都可用的参数 20 | 参数```clipnorm```和```clipvalue```是所有优化器都可以使用的参数,用于对梯度进行裁剪.示例如下: 21 | ```python 22 | # all parameter gradients will be clipped to 23 | # a maximum norm of 1. 24 | sgd = SGD(lr=0.01, clipnorm=1.) 25 | ``` 26 | ```python 27 | # all parameter gradients will be clipped to 28 | # a maximum value of 0.5 and 29 | # a minimum value of -0.5. 30 | sgd = SGD(lr=0.01, clipvalue=0.5) 31 | ``` 32 | 33 | ## SGD 34 | ```python 35 | keras.optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0, nesterov=False) 36 | ``` 37 | 随机梯度下降法，支持动量参数，支持学习衰减率，支持Nesterov动量 38 | 39 | ### 参数 40 | 41 | * lr：大于0的浮点数，学习率 42 | 43 | * momentum：大于0的浮点数，动量参数 44 | 45 | * decay：大于0的浮点数，每次更新后的学习率衰减值 46 | 47 | * nesterov：布尔值，确定是否使用Nesterov动量 48 | 49 | *** 50 | 51 | ## RMSprop 52 | ```python 53 | keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-06) 54 | ``` 55 | 除学习率可调整外，建议保持优化器的其他默认参数不变 56 | 57 | 该优化器通常是面对递归神经网络时的一个良好选择 58 | 59 | ### 参数 60 | 61 | * lr：大于0的浮点数，学习率 62 | 63 | * rho：大于0的浮点数 64 | 65 | * epsilon：大于0的小浮点数，防止除0错误 66 | 67 | *** 68 | 69 | ## Adagrad 70 | ```python 71 | keras.optimizers.Adagrad(lr=0.01, epsilon=1e-06) 72 | ``` 73 | 建议保持优化器的默认参数不变 74 | 75 | ### Adagrad 76 | 77 | * lr：大于0的浮点数，学习率 78 | 79 | * epsilon：大于0的小浮点数，防止除0错误 80 | 81 | *** 82 | 83 | ## Adadelta 84 | ```python 85 | keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=1e-06) 86 | ``` 87 | 建议保持优化器的默认参数不变 88 | 89 | ### 参数 90 | 91 | * lr：大于0的浮点数，学习率 92 | 93 | * rho：大于0的浮点数 94 | 95 | * epsilon：大于0的小浮点数，防止除0错误 96 | 97 | ### 参考文献 98 | 99 | *** 100 | 101 | * [Adadelta - an adaptive learning rate method](http://arxiv.org/abs/1212.5701) 102 | 103 | ## Adam 104 | ```python 105 | keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08) 106 | ``` 107 | 108 | 该优化器的默认值来源于参考文献 109 | 110 | ### 参数 111 | 112 | * lr：大于0的浮点数，学习率 113 | 114 | * beta_1/beta_2：浮点数， 0Adam - A Method for Stochastic Optimization](http://arxiv.org/abs/1412.6980v8) 121 | 122 | *** 123 | 124 | ## Adamax 125 | ```python 126 | keras.optimizers.Adamax(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=1e-08) 127 | ``` 128 | 129 | Adamax优化器来自于Adam的论文的Section7，该方法是基于无穷范数的Adam方法的变体。 130 | 131 | 默认参数由论文提供 132 | 133 | ### 参数 134 | 135 | * lr：大于0的浮点数，学习率 136 | 137 | * beta_1/beta_2：浮点数， 0Adam - A Method for Stochastic Optimization](http://arxiv.org/abs/1412.6980v8) 144 | 145 | *** 146 | 147 | ## Nadam 148 | 149 | ```python 150 | keras.optimizers.Nadam(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=1e-08, schedule_decay=0.004) 151 | ``` 152 | 153 | Nesterov Adam optimizer: Adam本质上像是带有动量项的RMSprop，Nadam就是带有Nesterov 动量的Adam RMSprop 154 | 155 | 默认参数来自于论文，推荐不要对默认参数进行更改。 156 | 157 | ### 参数 158 | 159 | * lr：大于0的浮点数，学习率 160 | 161 | * beta_1/beta_2：浮点数， 0Nadam report](http://cs229.stanford.edu/proj2015/054_report.pdf) 168 | 169 | * [On the importance of initialization and momentum in deep learning](http://www.cs.toronto.edu/~fritz/absps/momentum.pdf) 170 | 171 | 【Tips】很快（过两天）我们会将各种优化器的算法及特点总结一下，敬请关注 172 | -------------------------------------------------------------------------------- /docs/legacy/other/regularizers.md: -------------------------------------------------------------------------------- 1 | # 正则项 2 | 3 | 正则项在优化过程中层的参数或层的激活值添加惩罚项，这些惩罚项将与损失函数一起作为网络的最终优化目标 4 | 5 | 惩罚项基于层进行惩罚，目前惩罚项的接口与层有关，但```Dense, TimeDistributedDense, MaxoutDense, Covolution1D, Covolution2D, Convolution3D```具有共同的接口。 6 | 7 | 这些层有三个关键字参数以施加正则项： 8 | 9 | * ```W_regularizer```：施加在权重上的正则项，为```WeightRegularizer```对象 10 | 11 | * ```b_regularizer```：施加在偏置向量上的正则项，为```WeightRegularizer```对象 12 | 13 | * ```activity_regularizer```：施加在输出上的正则项，为```ActivityRegularizer```对象 14 | 15 | ## 例子 16 | ```python 17 | from keras.regularizers import l2, activity_l2 18 | model.add(Dense(64, input_dim=64, W_regularizer=l2(0.01), activity_regularizer=activity_l2(0.01))) 19 | ``` 20 | 21 | ## 预定义正则项 22 | 23 | ```python 24 | keras.regularizers.WeightRegularizer(l1=0., l2=0.) 25 | ``` 26 | 27 | ```python 28 | keras.regularizers.ActivityRegularizer(l1=0., l2=0.) 29 | ``` 30 | 31 | ## 缩写 32 | 33 | ```keras.regularizers```支持以下缩写 34 | 35 | * l1(l=0.01)：L1正则项，又称LASSO 36 | 37 | * l2(l=0.01)：L2正则项，又称权重衰减或Ridge 38 | 39 | * l1l2(l1=0.01, l2=0.01)： L1-L2混合正则项, 又称ElasticNet 40 | 41 | * activity_l1(l=0.01)： L1激活值正则项 42 | 43 | * activity_l2(l=0.01)： L2激活值正则项 44 | 45 | * activity_l1l2(l1=0.01, l2=0.01)： L1+L2激活值正则项 46 | 47 | 【Tips】正则项通常用于对模型的训练施加某种约束，L1正则项即L1范数约束，该约束会使被约束矩阵/向量更稀疏。L2正则项即L2范数约束，该约束会使被约束的矩阵/向量更平滑，因为它对脉冲型的值有很大的惩罚。【@Bigmoyan】 -------------------------------------------------------------------------------- /docs/legacy/other/visualization.md: -------------------------------------------------------------------------------- 1 | # 模型可视化 2 | 3 | ```keras.utils.visualize_util```模块提供了画出Keras模型的函数（利用graphviz） 4 | 5 | 该函数将画出模型结构图，并保存成图片： 6 | 7 | ```python 8 | from keras.utils.visualize_util import plot 9 | plot(model, to_file='model.png') 10 | ``` 11 | 12 | ```plot```接收两个可选参数： 13 | 14 | * ```show_shapes```：指定是否显示输出数据的形状，默认为```False``` 15 | * ```show_layer_names```:指定是否显示层名称,默认为```True``` 16 | 17 | 我们也可以直接获取一个```pydot.Graph```对象，然后按照自己的需要配置它，例如，如果要在ipython中展示图片 18 | ```python 19 | from IPython.display import SVG 20 | from keras.utils.visualize_util import model_to_dot 21 | 22 | SVG(model_to_dot(model).create(prog='dot', format='svg')) 23 | ``` 24 | 25 | 【Tips】依赖 pydot-ng 和 graphviz，命令行输入```pip install pydot-ng & brew install graphviz``` 26 | -------------------------------------------------------------------------------- /docs/legacy/preprocessing/image.md~: -------------------------------------------------------------------------------- 1 | # 图片预处理 2 | 3 | ## 图片生成器ImageDataGenerator 4 | ```python 5 | keras.preprocessing.image.ImageDataGenerator(featurewise_center=False, 6 | samplewise_center=False, 7 | featurewise_std_normalization=False, 8 | samplewise_std_normalization=False, 9 | zca_whitening=False, 10 | rotation_range=0., 11 | width_shift_range=0., 12 | height_shift_range=0., 13 | shear_range=0., 14 | zoom_range=0., 15 | channel_shift_range=0., 16 | fill_mode='nearest', 17 | cval=0., 18 | horizontal_flip=False, 19 | vertical_flip=False, 20 | rescale=None, 21 | dim_ordering=K.image_dim_ordering()) 22 | ``` 23 | 用以生成一个batch的图像数据，支持实时数据提升。训练时该函数会无限生成数据，直到达到规定的epoch次数为止。 24 | 25 | ### 参数 26 | 27 | * featurewise_center：布尔值，使输入数据集去中心化（均值为0） 28 | 29 | * samplewise_center：布尔值，使输入数据的每个样本均值为0 30 | 31 | * featurewise_std_normalization：布尔值，将输入除以数据集的标准差以完成标准化 32 | 33 | * samplewise_std_normalization：布尔值，将输入的每个样本除以其自身的标准差 34 | 35 | * zca_whitening：布尔值，对输入数据施加ZCA白化 36 | 37 | * rotation_range：整数，数据提升时图片随机转动的角度 38 | 39 | * width_shift_range：浮点数，图片宽度的某个比例，数据提升时图片水平偏移的幅度 40 | 41 | * height_shift_range：浮点数，图片高度的某个比例，数据提升时图片竖直偏移的幅度 42 | 43 | * shear_range：浮点数，剪切强度（逆时针方向的剪切变换角度） 44 | 45 | * zoom_range：浮点数或形如```[lower,upper]```的列表，随机缩放的幅度，若为浮点数，则相当于```[lower,upper] = [1 - zoom_range, 1+zoom_range]``` 46 | 47 | * channel_shift_range：浮点数，随机通道偏移的幅度 48 | 49 | * fill_mode：；‘constant’，‘nearest’，‘reflect’或‘wrap’之一，当进行变换时超出边界的点将根据本参数给定的方法进行处理 50 | 51 | * cval：浮点数或整数，当```fill_mode=constant```时，指定要向超出边界的点填充的值 52 | 53 | * horizontal_flip：布尔值，进行随机水平翻转 54 | 55 | * vertical_flip：布尔值，进行随机竖直翻转 56 | 57 | * rescale: 重放缩因子,默认为None. 如果为None或0则不进行放缩,否则会将该数值乘到数据上(在应用其他变换之前) 58 | 59 | * dim_ordering：‘tf’和‘th’之一，规定数据的维度顺序。‘tf’模式下数据的形状为```samples, width, height, channels```，‘th’下形状为```(samples, channels, width, height).```该参数的默认值是Keras配置文件```~/.keras/keras.json```的```image_dim_ordering```值,如果你从未设置过的话,就是'tf' 60 | 61 | *** 62 | 63 | ### 方法 64 | 65 | * fit(X, augment=False, rounds=1)：计算依赖于数据的变换所需要的统计信息(均值方差等),只有使用```featurewise_center```，```featurewise_std_normalization```或```zca_whitening```时需要此函数。 66 | 67 | * X：numpy array，样本数据 68 | 69 | * augment：布尔值，确定是否使用随即提升过的数据 70 | 71 | * round：若设```augment=True```，确定要在数据上进行多少轮数据提升，默认值为1 72 | 73 | * seed: 整数,随机数种子 74 | 75 | * flow(self, X, y, batch_size=32, shuffle=True, seed=None, save_to_dir=None, save_prefix='', save_format='jpeg')：接收numpy数组和标签为参数,生成经过数据提升或标准化后的batch数据,并在一个无限循环中不断的返回batch数据 76 | 77 | * X：数据 78 | 79 | * y：标签 80 | 81 | * batch_size：整数，默认32 82 | 83 | * shuffle：布尔值，是否随机打乱数据，默认为True 84 | 85 | * save_to_dir：None或字符串，该参数能让你将提升后的图片保存起来，用以可视化 86 | 87 | * save_prefix：字符串，保存提升后图片时使用的前缀, 仅当设置了```save_to_dir```时生效 88 | 89 | * save_format："png"或"jpeg"之一，指定保存图片的数据格式,默认"jpeg" 90 | 91 | * _yields:形如(x,y)的tuple,x是代表图像数据的numpy数组.y是代表标签的numpy数组.该迭代器无限循环. 92 | 93 | * seed: 整数,随机数种子 94 | 95 | * flow_from_directory(directory): 以文件夹路径为参数,生成经过数据提升/归一化后的数据,在一个无限循环中无限产生batch数据 96 | 97 | * directory: 目标文件夹路径,对于每一个类,该文件夹都要包含一个子文件夹.子文件夹应只包含JPG或PNG格式的图片.详情请查看[此脚本](https://gist.github.com/fchollet/0830affa1f7f19fd47b06d4cf89ed44d) 98 | * target_size: 整数tuple,默认为(256, 256). 图像将被resize成该尺寸 99 | * color_mode: 颜色模式,为"grayscale","rgb"之一,默认为"rgb".代表这些图片是否会被转换为单通道或三通道的图片. 100 | * classes: 可选参数,为子文件夹的列表,如['dogs','cats']默认为None. 若未提供,则该类别列表将自动推断(类别的顺序将按照字母表顺序映射到标签值) 101 | * class_mode: "categorical", "binary", "sparse"或None之一. 默认为"categorical. 该参数决定了返回的标签数组的形式, "categorical"会返回2D的one-hot编码标签,"binary"返回1D的二值标签."sparse"返回1D的整数标签,如果为None则不返回任何标签, 生成器将仅仅生成batch数据, 这种情况在使用```model.predict_generator()```和```model.evaluate_generator()```等函数时会用到. 102 | * batch_size: batch数据的大小,默认32 103 | * shuffle: 是否打乱数据,默认为True 104 | * seed: 可选参数,打乱数据和进行变换时的随机数种子 105 | * save_to_dir: None或字符串，该参数能让你将提升后的图片保存起来，用以可视化 106 | * save_prefix：字符串，保存提升后图片时使用的前缀, 仅当设置了```save_to_dir```时生效 107 | * save_format："png"或"jpeg"之一，指定保存图片的数据格式,默认"jpeg" 108 | 109 | 110 | 111 | ### 例子 112 | 113 | 使用```.flow()```的例子 114 | ```python 115 | (X_train, y_train), (X_test, y_test) = cifar10.load_data() 116 | Y_train = np_utils.to_categorical(y_train, nb_classes) 117 | Y_test = np_utils.to_categorical(y_test, nb_classes) 118 | 119 | datagen = ImageDataGenerator( 120 | featurewise_center=True, 121 | featurewise_std_normalization=True, 122 | rotation_range=20, 123 | width_shift_range=0.2, 124 | height_shift_range=0.2, 125 | horizontal_flip=True) 126 | 127 | # compute quantities required for featurewise normalization 128 | # (std, mean, and principal components if ZCA whitening is applied) 129 | datagen.fit(X_train) 130 | 131 | # fits the model on batches with real-time data augmentation: 132 | model.fit_generator(datagen.flow(X_train, Y_train, batch_size=32), 133 | samples_per_epoch=len(X_train), nb_epoch=nb_epoch) 134 | 135 | # here's a more "manual" example 136 | for e in range(nb_epoch): 137 | print 'Epoch', e 138 | batches = 0 139 | for X_batch, Y_batch in datagen.flow(X_train, Y_train, batch_size=32): 140 | loss = model.train(X_batch, Y_batch) 141 | batches += 1 142 | if batches >= len(X_train) / 32: 143 | # we need to break the loop by hand because 144 | # the generator loops indefinitely 145 | break 146 | ``` 147 | 148 | 使用```.flow_from_directory(directory)```的例子 149 | ```python 150 | train_datagen = ImageDataGenerator( 151 | rescale=1./255, 152 | shear_range=0.2, 153 | zoom_range=0.2, 154 | horizontal_flip=True) 155 | 156 | test_datagen = ImageDataGenerator(rescale=1./255) 157 | 158 | train_generator = train_datagen.flow_from_directory( 159 | 'data/train', 160 | target_size=(150, 150), 161 | batch_size=32, 162 | class_mode='binary') 163 | 164 | validation_generator = test_datagen.flow_from_directory( 165 | 'data/validation', 166 | target_size=(150, 150), 167 | batch_size=32, 168 | class_mode='binary') 169 | 170 | model.fit_generator( 171 | train_generator, 172 | samples_per_epoch=2000, 173 | nb_epoch=50, 174 | validation_data=validation_generator, 175 | nb_val_samples=800) 176 | ``` 177 | -------------------------------------------------------------------------------- /docs/legacy/preprocessing/sequence.md: -------------------------------------------------------------------------------- 1 | # 序列预处理 2 | 3 | ## 填充序列pad_sequences 4 | ```python 5 | keras.preprocessing.sequence.pad_sequences(sequences, maxlen=None, dtype='int32'，padding='pre', truncating='pre', value=0) 6 | ``` 7 | 将长为```nb_samples```的序列（标量序列）转化为形如```(nb_samples,nb_timesteps)```2D numpy array。如果提供了参数```maxlen```，```nb_timesteps=maxlen```，否则其值为最长序列的长度。其他短于该长度的序列都会在后部填充0以达到该长度。长于`nb_timesteps`的序列将会被截断，以使其匹配目标长度。padding和截断发生的位置分别取决于`padding`和`truncating`. 8 | 9 | ### 参数 10 | 11 | * sequences：浮点数或整数构成的两层嵌套列表 12 | 13 | * maxlen：None或整数，为序列的最大长度。大于此长度的序列将被截短，小于此长度的序列将在后部填0. 14 | 15 | * dtype：返回的numpy array的数据类型 16 | 17 | * padding：‘pre’或‘post’，确定当需要补0时，在序列的起始还是结尾补 18 | 19 | * truncating：‘pre’或‘post’，确定当需要截断序列时，从起始还是结尾截断 20 | 21 | * value：浮点数，此值将在填充时代替默认的填充值0 22 | 23 | ### 返回值 24 | 25 | 返回形如```(nb_samples,nb_timesteps)```的2D张量 26 | 27 | *** 28 | 29 | ## 跳字skipgrams 30 | ```python 31 | keras.preprocessing.sequence.skipgrams(sequence, vocabulary_size, 32 | window_size=4, negative_samples=1., shuffle=True, 33 | categorical=False, sampling_table=None) 34 | ``` 35 | skipgrams将一个词向量下标的序列转化为下面的一对tuple： 36 | 37 | * 对于正样本，转化为（word，word in the same window） 38 | 39 | * 对于负样本，转化为（word，random word from the vocabulary） 40 | 41 | 【Tips】根据维基百科，n-gram代表在给定序列中产生连续的n项，当序列句子时，每项就是单词，此时n-gram也称为shingles。而skip-gram的推广，skip-gram产生的n项子序列中，各个项在原序列中不连续，而是跳了k个字。例如，对于句子： 42 | 43 | “the rain in Spain falls mainly on the plain” 44 | 45 | 其 2-grams为子序列集合： 46 | 47 | the rain，rain in，in Spain，Spain falls，falls mainly，mainly on，on the，the plain 48 | 49 | 其 1-skip-2-grams为子序列集合： 50 | 51 | the in, rain Spain, in falls, Spain mainly, falls on, mainly the, on plain. 52 | 53 | 更多详情请参考[Efficient Estimation of Word Representations in Vector Space](http://arxiv.org/pdf/1301.3781v3.pdf)【@BigMoyan】 54 | 55 | ### 参数 56 | 57 | * sequence：下标的列表，如果使用sampling_tabel，则某个词的下标应该为它在数据库中的顺序。（从1开始） 58 | 59 | * vocabulary_size：整数，字典大小 60 | 61 | * window_size：整数，正样本对之间的最大距离 62 | 63 | * negative_samples：大于0的浮点数，等于0代表没有负样本，等于1代表负样本与正样本数目相同，以此类推（即负样本的数目是正样本的```negative_samples```倍） 64 | 65 | * shuffle：布尔值，确定是否随机打乱样本 66 | 67 | * categorical：布尔值，确定是否要使得返回的标签具有确定类别 68 | 69 | * sampling_table：形如```(vocabulary_size,)```的numpy array，其中```sampling_table[i]```代表没有负样本或随机负样本。等于1为与正样本的数目相同 70 | 采样到该下标为i的单词的概率（假定该单词是数据库中第i常见的单词） 71 | 72 | ### 输出 73 | 74 | 函数的输出是一个```(couples,labels)```的元组，其中： 75 | 76 | * ```couples```是一个长为2的整数列表：```[word_index,other_word_index]``` 77 | 78 | * ```labels```是一个仅由0和1构成的列表，1代表```other_word_index```在```word_index```的窗口，0代表```other_word_index```是词典里的随机单词。 79 | 80 | * 如果设置```categorical```为```True```，则标签将以one-hot的方式给出，即1变为\[0,1\]，0变为\[1,0\] 81 | 82 | *** 83 | 84 | ## 获取采样表make_sampling_table 85 | ```python 86 | keras.preprocessing.sequence.make_sampling_table(size, sampling_factor=1e-5) 87 | ``` 88 | 该函数用以产生```skipgrams```中所需要的参数```sampling_table```。这是一个长为```size```的向量，```sampling_table[i]```代表采样到数据集中第i常见的词的概率（为平衡期起见，对于越经常出现的词，要以越低的概率采到它） 89 | 90 | ### 参数 91 | 92 | * size：词典的大小 93 | 94 | * sampling_factor：此值越低，则代表采样时更缓慢的概率衰减（即常用的词会被以更低的概率被采到），如果设置为1，则代表不进行下采样，即所有样本被采样到的概率都是1。 95 | 96 | 97 | -------------------------------------------------------------------------------- /docs/legacy/preprocessing/text.md: -------------------------------------------------------------------------------- 1 | # 文本预处理 2 | 3 | ## 句子分割text_to_word_sequence 4 | ```python 5 | keras.preprocessing.text.text_to_word_sequence(text, 6 | filters=base_filter(), lower=True, split=" ") 7 | ``` 8 | 本函数将一个句子拆分成单词构成的列表 9 | 10 | ### 参数 11 | 12 | * text：字符串，待处理的文本 13 | 14 | * filters：需要滤除的字符的列表或连接形成的字符串，例如标点符号。默认值为```base_filter()```，包含标点符号，制表符和换行符等 15 | 16 | * lower：布尔值，是否将序列设为小写形式 17 | 18 | * split：字符串，单词的分隔符，如空格 19 | 20 | ### 返回值 21 | 22 | 字符串列表 23 | 24 | *** 25 | 26 | ## one-hot编码 27 | ```python 28 | keras.preprocessing.text.one_hot(text, n, 29 | filters=base_filter(), lower=True, split=" ") 30 | ``` 31 | 本函数将一段文本编码为one-hot形式的码，即仅记录词在词典中的下标。 32 | 33 | 【Tips】 34 | 从定义上，当字典长为n时，每个单词应形成一个长为n的向量，其中仅有单词本身在字典中下标的位置为1，其余均为0，这称为one-hot。【@Bigmoyan】 35 | 36 | 为了方便起见，函数在这里仅把“1”的位置，即字典中词的下标记录下来。 37 | 38 | ### 参数 39 | 40 | * n：整数，字典长度 41 | 42 | ### 返回值 43 | 44 | 整数列表，每个整数是\[1,n\]之间的值，代表一个单词（不保证唯一性，即如果词典长度不够，不同的单词可能会被编为同一个码）。 45 | 46 | *** 47 | 48 | ## 分词器Tokenizer 49 | ```python 50 | keras.preprocessing.text.Tokenizer(nb_words=None, filters=base_filter(), 51 | lower=True, split=" ") 52 | ``` 53 | Tokenizer是一个用于向量化文本，或将文本转换为序列（即单词在字典中的下标构成的列表，从1算起）的类。 54 | 55 | ### 构造参数 56 | 57 | * 与```text_to_word_sequence```同名参数含义相同 58 | 59 | * nb_words：None或整数，处理的最大单词数量。若被设置为整数，则分词器将被限制为处理数据集中最常见的```nb_words```个单词 60 | 61 | ### 类方法 62 | 63 | * fit_on_texts(texts) 64 | 65 | * texts：要用以训练的文本列表 66 | 67 | * texts_to_sequences(texts) 68 | 69 | * texts：待转为序列的文本列表 70 | 71 | * 返回值：序列的列表，列表中每个序列对应于一段输入文本 72 | 73 | * texts_to_sequences_generator(texts) 74 | 75 | * 本函数是```texts_to_sequences```的生成器函数版 76 | 77 | * texts：待转为序列的文本列表 78 | 79 | * 返回值：每次调用返回对应于一段输入文本的序列 80 | 81 | * texts_to_matrix(texts, mode)： 82 | 83 | * texts：待向量化的文本列表 84 | 85 | * mode：‘binary’，‘count’，‘tfidf’，‘freq’之一，默认为‘binary’ 86 | 87 | * 返回值：形如```(len(texts), nb_words)```的numpy array 88 | 89 | * fit_on_sequences(sequences): 90 | 91 | * sequences：要用以训练的序列列表 92 | 93 | * sequences_to_matrix(sequences): 94 | 95 | * sequences：待向量化的序列列表 96 | 97 | * mode：‘binary’，‘count’，‘tfidf’，‘freq’之一，默认为‘binary’ 98 | 99 | * 返回值：形如```(len(sequences), nb_words)```的numpy array 100 | 101 | ### 属性 102 | * word_counts:字典，将单词（字符串）映射为它们在训练期间出现的次数。仅在调用fit_on_texts之后设置。 103 | * word_docs: 字典，将单词（字符串）映射为它们在训练期间所出现的文档或文本的数量。仅在调用fit_on_texts之后设置。 104 | * word_index: 字典，将单词（字符串）映射为它们的排名或者索引。仅在调用fit_on_texts之后设置。 105 | * document_count: 整数。分词器被训练的文档（文本或者序列）数量。仅在调用fit_on_texts或fit_on_sequences之后设置。 106 | 107 | -------------------------------------------------------------------------------- /docs/legacy/scikit-learn_API.md: -------------------------------------------------------------------------------- 1 | # Scikit-Learn接口包装器 2 | 3 | 我们可以通过包装器将```Sequential```模型（仅有一个输入）作为Scikit-Learn工作流的一部分，相关的包装器定义在```keras.wrappers.scikit_learn.py```中 4 | 5 | 目前，有两个包装器可用： 6 | 7 | ```keras.wrappers.scikit_learn.KerasClassifier(build_fn=None, **sk_params)```实现了sklearn的分类器接口 8 | 9 | 10 | ```keras.wrappers.scikit_learn.KerasRegressor(build_fn=None, **sk_params)```实现了sklearn的回归器接口 11 | 12 | ## 参数 13 | 14 | * build_fn：可调用的函数或类对象 15 | 16 | * sk_params：模型参数和训练参数 17 | 18 | ```build_fn```应构造、编译并返回一个Keras模型，该模型将稍后用于训练/测试。```build_fn```的值可能为下列三种之一： 19 | 20 | 1. 一个函数 21 | 22 | 2. 一个具有```call```方法的类对象 23 | 24 | 3. None，代表你的类继承自```KerasClassifier```或```KerasRegressor```，其```call```方法为其父类的```call```方法 25 | 26 | ```sk_params```以模型参数和训练（超）参数作为参数。合法的模型参数为```build_fn```的参数。注意，‘build_fn’应提供其参数的默认值。所以我们不传递任何值给```sk_params```也可以创建一个分类器/回归器 27 | 28 | ```sk_params```还接受用于调用```fit```，```predict```，```predict_proba```和```score```方法的参数，如```nb_epoch```，```batch_size```等。这些用于训练或预测的参数按如下顺序选择： 29 | 30 | 1. 传递给```fit```，```predict```，```predict_proba```和```score```的字典参数 31 | 32 | 2. 传递个```sk_params```的参数 33 | 34 | 3. ```keras.models.Sequential```，```fit```，```predict```，```predict_proba```和```score```的默认值 35 | 36 | 当使用scikit-learn的```grid_search```接口时，合法的可转换参数是你可以传递给```sk_params```的参数，包括训练参数。即，你可以使用```grid_search```来搜索最佳的```batch_size```或```nb_epoch```以及其他模型参数 37 | 38 | 【Tips】过段时间（几周？）我们希望能提供一些Scikit-learn与Keras联合作业的例子，这个先别太期待…… 39 | -------------------------------------------------------------------------------- /docs/legacy/utils/data_utils.md: -------------------------------------------------------------------------------- 1 | # 数据工具 2 | 3 | ## get_file 4 | 5 | ```python 6 | get_file(fname, origin, untar=False, md5_hash=None, cache_subdir='datasets') 7 | ``` 8 | 9 | 从给定的URL中下载文件, 可以传递MD5值用于数据校验(下载后或已经缓存的数据均可) 10 | 11 | ### 参数 12 | 13 | * fname: 文件名 14 | 15 | * origin: 文件的URL地址 16 | 17 | * untar: 布尔值,是否要进行解压 18 | 19 | * md5_hash: MD5哈希值,用于数据校验 20 | 21 | * cache_subdir: 用于缓存数据的文件夹 22 | 23 | ### 返回值 24 | 25 | 下载后的文件地址 26 | -------------------------------------------------------------------------------- /docs/legacy/utils/data_utils~: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/utils/data_utils~ -------------------------------------------------------------------------------- /docs/legacy/utils/io_utils.md: -------------------------------------------------------------------------------- 1 | # I/O工具 2 | 3 | ## HDF5矩阵 4 | 5 | ```python 6 | keras.utils.io_utils.HDF5Matrix(datapath, dataset, start=0, end=None, normalizer=None) 7 | ``` 8 | 9 | 这是一个使用HDF5数据集代替Numpy数组的方法。 10 | 11 | ### 例子 12 | ```python 13 | X_data = HDF5Matrix('input/file.hdf5', 'data') 14 | model.predict(X_data) 15 | ``` 16 | 17 | 提供start和end参数可以使用数据集的切片。 18 | 19 | 可选的，可以给出归一化函数（或lambda表达式）。 这将在每个检索的数据集的切片上调用。 20 | 21 | ### 参数 22 | 23 | * datapath：字符串，HDF5文件的路径 24 | 25 | * dataset：字符串，在datapath中指定的文件中的HDF5数据集的名称 26 | 27 | * start：整数，指定数据集的所需切片的开始 28 | 29 | * end：整数，指定数据集的所需切片的结尾 30 | 31 | * normalizer：数据集在被检索时的调用函数 32 | -------------------------------------------------------------------------------- /docs/legacy/utils/layer_utils.md: -------------------------------------------------------------------------------- 1 | # Keras层工具 2 | 3 | ## layer_from_config 4 | 5 | ```python 6 | layer_from_config(config, custom_objects={}) 7 | ``` 8 | 从配置生成Keras层对象 9 | 10 | ### 参数 11 | 12 | * config:形如{'class_name':str, 'config':dict}的字典 13 | 14 | * custom_objects: 字典,用以将定制的非Keras对象之类名/函数名映射为类/函数对象 15 | 16 | ### 返回值 17 | 18 | 层对象,包含Model,Sequential和其他Layer 19 | -------------------------------------------------------------------------------- /docs/legacy/utils/layer_utils~: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/utils/layer_utils~ -------------------------------------------------------------------------------- /docs/legacy/utils/np_utils.md: -------------------------------------------------------------------------------- 1 | # numpy工具 2 | 3 | 4 | 5 | ## to_categorical 6 | ```python 7 | to_categorical(y, nb_classes=None) 8 | ``` 9 | 10 | 将类别向量(从0到nb_classes的整数向量)映射为二值类别矩阵, 用于应用到以`categorical_crossentropy`为目标函数的模型中. 11 | 12 | ###参数 13 | 14 | * y: 类别向量 15 | * nb_classes:总共类别数 16 | 17 | 18 | ## convert_kernel 19 | ```python 20 | convert_kernel(kernel, dim_ordering='default') 21 | ``` 22 | 23 | 将卷积核矩阵(numpy数组)从Theano形式转换为Tensorflow形式,或转换回来(该转化时自可逆的) 24 | -------------------------------------------------------------------------------- /docs/legacy/utils/np_utils~: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MoyanZitto/keras-cn/9e73527feb6fb3179c0c94088e9b9a83f4e9910f/docs/legacy/utils/np_utils~ -------------------------------------------------------------------------------- /docs/models/about_model.md: -------------------------------------------------------------------------------- 1 | # 关于Keras模型 2 | 3 | Keras有两种类型的模型，[序贯模型（Sequential）](sequential.md)和[函数式模型（Model）](model.md)，函数式模型应用更为广泛，序贯模型是函数式模型的一种特殊情况。 4 | 5 | 两类模型有一些方法是相同的： 6 | 7 | * ```model.summary()```：打印出模型概况，它实际调用的是keras.utils.print_summary 8 | 9 | * ```model.get_config()```:返回包含模型配置信息的Python字典。模型也可以从它的config信息中重构回去 10 | 11 | 12 | ```python 13 | config = model.get_config() 14 | model = Model.from_config(config) 15 | # or, for Sequential: 16 | model = Sequential.from_config(config) 17 | ``` 18 | 19 | * ```model.get_layer()```：依据层名或下标获得层对象 20 | 21 | * ```model.get_weights()```：返回模型权重张量的列表，类型为numpy array 22 | 23 | * ```model.set_weights()```：从numpy array里将权重载入给模型，要求数组具有与```model.get_weights()```相同的形状。 24 | 25 | * ```model.to_json```：返回代表模型的JSON字符串，仅包含网络结构，不包含权值。可以从JSON字符串中重构原模型： 26 | 27 | ```python 28 | from models import model_from_json 29 | 30 | json_string = model.to_json() 31 | model = model_from_json(json_string) 32 | ``` 33 | 34 | * ```model.to_yaml```：与```model.to_json```类似，同样可以从产生的YAML字符串中重构模型 35 | 36 | ```python 37 | from models import model_from_yaml 38 | 39 | yaml_string = model.to_yaml() 40 | model = model_from_yaml(yaml_string) 41 | ``` 42 | 43 | * ```model.save_weights(filepath)```：将模型权重保存到指定路径，文件类型是HDF5（后缀是.h5） 44 | 45 | * ```model.load_weights(filepath, by_name=False)```：从HDF5文件中加载权重到当前模型中, 默认情况下模型的结构将保持不变。如果想将权重载入不同的模型（有些层相同）中，则设置```by_name=True```，只有名字匹配的层才会载入权重 46 | -------------------------------------------------------------------------------- /docs/other/activations.md: -------------------------------------------------------------------------------- 1 | # 激活函数Activations 2 | 3 | 激活函数可以通过设置单独的[激活层](../layers/core_layer/#activation)实现，也可以在构造层对象时通过传递```activation```参数实现。 4 | 5 | ```python 6 | from keras.layers import Activation, Dense 7 | 8 | model.add(Dense(64)) 9 | model.add(Activation('tanh')) 10 | ``` 11 | 12 | 等价于 13 | 14 | ```python 15 | model.add(Dense(64, activation='tanh')) 16 | ``` 17 | 18 | 也可以通过传递一个逐元素运算的Theano/TensorFlow/CNTK函数来作为激活函数： 19 | ```python 20 | from keras import backend as K 21 | 22 | def tanh(x): 23 | return K.tanh(x) 24 | 25 | model.add(Dense(64, activation=tanh)) 26 | model.add(Activation(tanh)) 27 | ``` 28 | 29 | *** 30 | 31 | ## 预定义激活函数 32 | 33 | * softmax：对输入数据的最后一维进行softmax，输入数据应形如```(nb_samples, nb_timesteps, nb_dims)```或```(nb_samples,nb_dims)``` 34 | 35 | * elu 36 | 37 | * selu: 可伸缩的指数线性单元（Scaled Exponential Linear Unit），参考[Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515) 38 | 39 | * softplus 40 | 41 | * softsign 42 | 43 | * relu 44 | 45 | * tanh 46 | 47 | * sigmoid 48 | 49 | * hard_sigmoid 50 | 51 | * linear 52 | 53 | ## 高级激活函数 54 | 55 | 对于简单的Theano/TensorFlow/CNTK不能表达的复杂激活函数，如含有可学习参数的激活函数，可通过[高级激活函数](../layers/advanced_activation_layer)实现，如PReLU，LeakyReLU等 56 | 57 | 58 | 59 | -------------------------------------------------------------------------------- /docs/other/constraints.md: -------------------------------------------------------------------------------- 1 | # 约束项 2 | 3 | 来自```constraints```模块的函数在优化过程中为网络的参数施加约束 4 | 5 | 惩罚项基于层进行惩罚，目前惩罚项的接口与层有关，但```Dense, Conv1D, Conv2D, Conv3D```具有共同的接口。 6 | 7 | 这些层通过一下关键字施加约束项 8 | 9 | * ```kernel_constraint```：对主权重矩阵进行约束 10 | 11 | * ```bias_constraint```：对偏置向量进行约束 12 | 13 | ```python 14 | from keras.constraints import maxnorm 15 | model.add(Dense(64, kernel_constraint=max_norm(2.))) 16 | ``` 17 | 18 | ## 预定义约束项 19 | 20 | * max_norm(m=2)：最大模约束 21 | 22 | * non_neg()：非负性约束 23 | 24 | * unit_norm()：单位范数约束, 强制矩阵沿最后一个轴拥有单位范数 25 | 26 | * min_max_norm(min_value=0.0, max_value=1.0, rate=1.0, axis=0): 最小/最大范数约束 -------------------------------------------------------------------------------- /docs/other/datasets.md: -------------------------------------------------------------------------------- 1 | # 常用数据库 2 | 3 | ## CIFAR10 小图片分类数据集 4 | 5 | 该数据库具有50,000个32*32的彩色图片作为训练集，10,000个图片作为测试集。图片一共有10个类别。 6 | 7 | ### 使用方法 8 | ```python 9 | from keras.datasets import cifar10 10 | 11 | (X_train, y_train), (X_test, y_test) = cifar10.load_data() 12 | ``` 13 | 14 | ### 返回值： 15 | 16 | 两个Tuple 17 | 18 | ```X_train```和```X_test```是形如（nb_samples, 3, 32, 32）的RGB三通道图像数据，数据类型是无符号8位整形（uint8） 19 | 20 | ```Y_train```和 ```Y_test```是形如（nb_samples,）标签数据，标签的范围是0~9 21 | 22 | *** 23 | 24 | ## CIFAR100 小图片分类数据库 25 | 26 | 该数据库具有50,000个32*32的彩色图片作为训练集，10,000个图片作为测试集。图片一共有100个类别，每个类别有600张图片。这100个类别又分为20个大类。 27 | 28 | ### 使用方法 29 | ```python 30 | from keras.datasets import cifar100 31 | 32 | (X_train, y_train), (X_test, y_test) = cifar100.load_data(label_mode='fine') 33 | ``` 34 | 35 | ### 参数 36 | 37 | * label_mode：为‘fine’或‘coarse’之一，控制标签的精细度，‘fine’获得的标签是100个小类的标签，‘coarse’获得的标签是大类的标签 38 | 39 | ### 返回值 40 | 41 | 两个Tuple,```(X_train, y_train), (X_test, y_test)```，其中 42 | 43 | * X_train和X_test：是形如（nb_samples, 3, 32, 32）的RGB三通道图像数据，数据类型是无符号8位整形（uint8） 44 | 45 | * y_train和y_test：是形如（nb_samples,）标签数据，标签的范围是0~9 46 | 47 | *** 48 | 49 | ## IMDB影评倾向分类 50 | 51 | 本数据库含有来自IMDB的25,000条影评，被标记为正面/负面两种评价。影评已被预处理为词下标构成的[序列](../preprocessing/sequence)。方便起见，单词的下标基于它在数据集中出现的频率标定，例如整数3所编码的词为数据集中第3常出现的词。这样的组织方法使得用户可以快速完成诸如“只考虑最常出现的10,000个词，但不考虑最常出现的20个词”这样的操作 52 | 53 | 按照惯例，0不代表任何特定的词，而用来编码任何未知单词 54 | 55 | ### 使用方法 56 | ```python 57 | from keras.datasets import imdb 58 | 59 | (X_train, y_train), (X_test, y_test) = imdb.load_data(path="imdb.npz", 60 | nb_words=None, 61 | skip_top=0, 62 | maxlen=None, 63 | test_split=0.1) 64 | seed=113, 65 | start_char=1, 66 | oov_char=2, 67 | index_from=3) 68 | ``` 69 | 70 | ### 参数 71 | 72 | * path：如果你在本机上已有此数据集（位于```'~/.keras/datasets/'+path```），则载入。否则数据将下载到该目录下 73 | 74 | * nb_words：整数或None，要考虑的最常见的单词数，序列中任何出现频率更低的单词将会被编码为`oov_char`的值。 75 | 76 | * skip_top：整数，忽略最常出现的若干单词，这些单词将会被编码为`oov_char`的值 77 | 78 | * maxlen：整数，最大序列长度，任何长度大于此值的序列将被截断 79 | 80 | * seed：整数，用于数据重排的随机数种子 81 | 82 | * start_char：字符，序列的起始将以该字符标记，默认为1因为0通常用作padding 83 | 84 | * oov_char：整数，因```nb_words```或```skip_top```限制而cut掉的单词将被该字符代替 85 | 86 | * index_from：整数，真实的单词（而不是类似于```start_char```的特殊占位符）将从这个下标开始 87 | 88 | ### 返回值 89 | 90 | 两个Tuple,```(X_train, y_train), (X_test, y_test)```，其中 91 | 92 | * X_train和X_test：序列的列表，每个序列都是词下标的列表。如果指定了```nb_words```，则序列中可能的最大下标为```nb_words-1```。如果指定了```maxlen```，则序列的最大可能长度为```maxlen``` 93 | 94 | * y_train和y_test：为序列的标签，是一个二值list 95 | 96 | *** 97 | 98 | ## 路透社新闻主题分类 99 | 100 | 本数据库包含来自路透社的11,228条新闻，分为了46个主题。与IMDB库一样，每条新闻被编码为一个词下标的序列。 101 | 102 | ### 使用方法 103 | ```python 104 | from keras.datasets import reuters 105 | 106 | 107 | (X_train, y_train), (X_test, y_test) = reuters.load_data(path="reuters.npz", 108 | nb_words=None, 109 | skip_top=0, 110 | maxlen=None, 111 | test_split=0.2, 112 | seed=113, 113 | start_char=1, 114 | oov_char=2, 115 | index_from=3) 116 | ``` 117 | 118 | 参数的含义与IMDB同名参数相同，唯一多的参数是： 119 | ```test_split```，用于指定从原数据中分割出作为测试集的比例。该数据库支持获取用于编码序列的词下标： 120 | ```python 121 | word_index = reuters.get_word_index(path="reuters_word_index.json") 122 | ``` 123 | 上面代码的返回值是一个以单词为关键字，以其下标为值的字典。例如，```word_index['giraffe']```的值可能为```1234``` 124 | 125 | ### 参数 126 | 127 | * path：如果你在本机上已有此数据集（位于```'~/.keras/datasets/'+path```），则载入。否则数据将下载到该目录下 128 | 129 | *** 130 | 131 | ## MNIST手写数字识别 132 | 133 | 本数据库有60,000个用于训练的28*28的灰度手写数字图片，10,000个测试图片 134 | 135 | ### 使用方法 136 | ```python 137 | from keras.datasets import mnist 138 | 139 | (X_train, y_train), (X_test, y_test) = mnist.load_data() 140 | ``` 141 | ### 参数 142 | 143 | * path：如果你在本机上已有此数据集（位于```'~/.keras/datasets/'+path```），则载入。否则数据将下载到该目录下 144 | 145 | ### 返回值 146 | 147 | 两个Tuple,```(X_train, y_train), (X_test, y_test)```，其中 148 | 149 | * X_train和X_test：是形如（nb_samples, 28, 28）的灰度图片数据，数据类型是无符号8位整形（uint8） 150 | 151 | * y_train和y_test：是形如（nb_samples,）标签数据，标签的范围是0~9 152 | 153 | 数据库将会被下载到```'~/.keras/datasets/'+path``` 154 | 155 | *** 156 | 157 | ## Fashion-MNIST数据集 158 | 159 | 本数据集包含60,000个28x28灰度图像，共10个时尚分类作为训练集。测试集包含10,000张图片。该数据集可作为MNIST数据集的进化版本，10个类别标签分别是： 160 | 161 | |类别|描述| 162 | |:-:|:-:| 163 | |0|T恤/上衣| 164 | |1|裤子| 165 | |2|套头衫| 166 | |3|连衣裙| 167 | |4|大衣| 168 | |5|凉鞋| 169 | |6|衬衫| 170 | |7|帆布鞋| 171 | |8|包| 172 | |9|短靴| 173 | 174 | ### 使用方法 175 | ```python 176 | from keras.datasets import fashion_mnist 177 | 178 | (x_train, y_train), (x_test, y_test) = fashion_mnist.load_data() 179 | ``` 180 | ### 参数 181 | 182 | * path：如果你在本机上已有此数据集（位于```'~/.keras/datasets/'+path```），则载入。否则数据将下载到该目录下 183 | 184 | ### 返回值 185 | 186 | 两个Tuple,```(X_train, y_train), (X_test, y_test)```，其中 187 | 188 | * X_train和X_test：是形如（nb_samples, 28, 28）的灰度图片数据，数据类型是无符号8位整形（uint8） 189 | 190 | * y_train和y_test：是形如（nb_samples,）标签数据，标签的范围是0~9 191 | 192 | 数据库将会被下载到```'~/.keras/datasets/'+path``` 193 | 194 | *** 195 | 196 | ## Boston房屋价格回归数据集 197 | 198 | 本数据集由StatLib库取得，由CMU维护。每个样本都是1970s晚期波士顿郊区的不同位置，每条数据含有13个属性，目标值是该位置房子的房价中位数（千dollar）。 199 | 200 | 201 | ### 使用方法 202 | ```python 203 | from keras.datasets import boston_housing 204 | 205 | (x_train, y_train), (x_test, y_test) = boston_housing.load_data() 206 | ``` 207 | 208 | ### 参数 209 | 210 | * path：数据存放位置，默认```'~/.keras/datasets/'+path``` 211 | 212 | * seed：随机数种子 213 | 214 | * test_split：分割测试集的比例 215 | 216 | ### 返回值 217 | 218 | 两个Tuple,```(X_train, y_train), (X_test, y_test)``` 219 | 220 | -------------------------------------------------------------------------------- /docs/other/initializations.md: -------------------------------------------------------------------------------- 1 | # 初始化方法 2 | 3 | 初始化方法定义了对Keras层设置初始化权重的方法 4 | 5 | 不同的层可能使用不同的关键字来传递初始化方法，一般来说指定初始化方法的关键字是```kernel_initializer``` 和 ```bias_initializer```，例如： 6 | ```python 7 | model.add(Dense(64, 8 | kernel_initializer='random_uniform', 9 | bias_initializer='zeros')) 10 | ``` 11 | 12 | 一个初始化器可以由字符串指定（必须是下面的预定义初始化器之一），或一个callable的函数，例如 13 | ```python 14 | from keras import initializers 15 | 16 | model.add(Dense(64, kernel_initializer=initializers.random_normal(stddev=0.01))) 17 | 18 | # also works; will use the default parameters. 19 | model.add(Dense(64, kernel_initializer='random_normal')) 20 | ``` 21 | 22 | ## Initializer 23 | 24 | Initializer是所有初始化方法的父类，不能直接使用，如果想要定义自己的初始化方法，请继承此类。 25 | 26 | ## 预定义初始化方法 27 | 28 | ### Zeros 29 | ```python 30 | keras.initializers.Zeros() 31 | ``` 32 | 全零初始化 33 | 34 | ### Ones 35 | ```python 36 | keras.initializers.Ones() 37 | ``` 38 | 全1初始化 39 | 40 | ### Constant 41 | ```python 42 | keras.initializers.Constant(value=0) 43 | ``` 44 | 初始化为固定值value 45 | 46 | ### RandomNormal 47 | 48 | ```python 49 | keras.initializers.RandomNormal(mean=0.0, stddev=0.05, seed=None)) 50 | ``` 51 | 正态分布初始化 52 | 53 | * mean：均值 54 | * stddev：标准差 55 | * seed：随机数种子 56 | 57 | ### RandomUniform 58 | ```python 59 | keras.initializers.RandomUniform(minval=-0.05, maxval=0.05, seed=None) 60 | ``` 61 | 均匀分布初始化 62 | * minval：均匀分布下边界 63 | * maxval：均匀分布上边界 64 | * seed：随机数种子 65 | 66 | 67 | ### TruncatedNormal 68 | ```python 69 | keras.initializers.TruncatedNormal(mean=0.0, stddev=0.05, seed=None) 70 | ``` 71 | 截尾高斯分布初始化，该初始化方法与RandomNormal类似，但位于均值两个标准差以外的数据将会被丢弃并重新生成，形成截尾分布。该分布是神经网络权重和滤波器的推荐初始化方法。 72 | 73 | * mean：均值 74 | * stddev：标准差 75 | * seed：随机数种子 76 | 77 | ### VarianceScaling 78 | ```python 79 | keras.initializers.VarianceScaling(scale=1.0, mode='fan_in', distribution='normal', seed=None) 80 | ``` 81 | 82 | 83 | 该初始化方法能够自适应目标张量的shape。 84 | 85 | 当```distribution="normal"```时，样本从0均值，标准差为sqrt(scale / n)的截尾正态分布中产生。其中： 86 | 87 | * 当```mode = "fan_in"```时，权重张量的输入单元数。 88 | * 当```mode = "fan_out"```时，权重张量的输出单元数 89 | * 当```mode = "fan_avg"```时，权重张量的输入输出单元数的均值 90 | 91 | 当```distribution="uniform"```时，权重从[-limit, limit]范围内均匀采样，其中limit = limit = sqrt(3 * scale / n) 92 | 93 | * scale: 放缩因子，正浮点数 94 | * mode: 字符串，“fan_in”，“fan_out”或“fan_avg”fan_in", "fan_out", "fan_avg". 95 | * distribution: 字符串，“normal”或“uniform”. 96 | * seed: 随机数种子 97 | 98 | ### Orthogonal 99 | ```python 100 | keras.initializers.Orthogonal(gain=1.0, seed=None) 101 | ``` 102 | 103 | 用随机正交矩阵初始化 104 | 105 | * gain: 正交矩阵的乘性系数 106 | * seed：随机数种子 107 | 108 | 参考文献：[Saxe et al.](http://arxiv.org/abs/1312.6120) 109 | 110 | ### Identiy 111 | ```python 112 | keras.initializers.Identity(gain=1.0) 113 | ``` 114 | 使用单位矩阵初始化，仅适用于2D方阵 115 | 116 | * gain：单位矩阵的乘性系数 117 | 118 | ### lecun_uniform 119 | ```python 120 | lecun_uniform(seed=None) 121 | ``` 122 | 123 | LeCun均匀分布初始化方法，参数由[-limit, limit]的区间中均匀采样获得，其中limit=sqrt(3 / fan_in), fin_in是权重向量的输入单元数（扇入） 124 | 125 | * seed：随机数种子 126 | 127 | 参考文献：[LeCun 98, Efficient Backprop](http://yann.lecun.com/exdb/publis/pdf/lecun-98b.pdf) 128 | 129 | ### lecun_normal 130 | ```python 131 | lecun_normal(seed=None) 132 | ``` 133 | LeCun正态分布初始化方法，参数由0均值，标准差为stddev = sqrt(1 / fan_in)的正态分布产生，其中fan_in和fan_out是权重张量的扇入扇出（即输入和输出单元数目） 134 | 135 | * seed：随机数种子 136 | 137 | 参考文献： 138 | 139 | [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515) 140 | [Efficient Backprop](http://yann.lecun.com/exdb/publis/pdf/lecun-98b.pdf) 141 | 142 | 143 | 144 | ### glorot_normal 145 | ```python 146 | glorot_normal(seed=None) 147 | ``` 148 | 149 | Glorot正态分布初始化方法，也称作Xavier正态分布初始化，参数由0均值，标准差为sqrt(2 / (fan_in + fan_out))的正态分布产生，其中fan_in和fan_out是权重张量的扇入扇出（即输入和输出单元数目） 150 | 151 | * seed：随机数种子 152 | 153 | 参考文献：[Glorot & Bengio, AISTATS 2010](http://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.pdf) 154 | 155 | ###glorot_uniform 156 | 157 | ```python 158 | glorot_uniform(seed=None) 159 | ``` 160 | Glorot均匀分布初始化方法，又成Xavier均匀初始化，参数从[-limit, limit]的均匀分布产生，其中limit为`sqrt(6 / (fan_in + fan_out))`。fan_in为权值张量的输入单元数，fan_out是权重张量的输出单元数。 161 | 162 | * seed：随机数种子 163 | 164 | 参考文献：[Glorot & Bengio, AISTATS 2010](http://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.pdf) 165 | 166 | ### he_normal 167 | ```python 168 | he_normal(seed=None) 169 | ``` 170 | 171 | He正态分布初始化方法，参数由0均值，标准差为sqrt(2 / fan_in) 的正态分布产生，其中fan_in权重张量的扇入 172 | 173 | * seed：随机数种子 174 | 175 | 参考文献：[He et al](http://arxiv.org/abs/1502.01852) 176 | 177 | 178 | ### he_uniform 179 | ```python 180 | he_normal(seed=None) 181 | ``` 182 | 183 | LeCun均匀分布初始化方法，参数由[-limit, limit]的区间中均匀采样获得，其中limit=sqrt(6 / fan_in), fin_in是权重向量的输入单元数（扇入） 184 | 185 | * seed：随机数种子 186 | 187 | 参考文献：[He et al](http://arxiv.org/abs/1502.01852) 188 | 189 | ## 自定义初始化器 190 | 如果需要传递自定义的初始化器，则该初始化器必须是callable的，并且接收```shape```（将被初始化的张量shape）和```dtype```（数据类型）两个参数，并返回符合```shape```和```dtype```的张量。 191 | 192 | 193 | ```python 194 | from keras import backend as K 195 | 196 | def my_init(shape, dtype=None): 197 | return K.random_normal(shape, dtype=dtype) 198 | 199 | model.add(Dense(64, init=my_init)) 200 | ``` -------------------------------------------------------------------------------- /docs/other/metrics.md: -------------------------------------------------------------------------------- 1 | # 性能评估 2 | 3 | ## 使用方法 4 | 5 | 性能评估模块提供了一系列用于模型性能评估的函数,这些函数在模型编译时由`metrics`关键字设置 6 | 7 | 性能评估函数类似与[目标函数](objectives.md), 只不过该性能的评估结果讲不会用于训练. 8 | 9 | 可以通过字符串来使用域定义的性能评估函数 10 | ```python 11 | model.compile(loss='mean_squared_error', 12 | optimizer='sgd', 13 | metrics=['mae', 'acc']) 14 | ``` 15 | 也可以自定义一个Theano/TensorFlow函数并使用之 16 | ```python 17 | from keras import metrics 18 | 19 | model.compile(loss='mean_squared_error', 20 | optimizer='sgd', 21 | metrics=[metrics.mae, metrics.categorical_accuracy]) 22 | ``` 23 | ### 参数 24 | 25 | * y_true:真实标签,theano/tensorflow张量 26 | * y_pred:预测值, 与y_true形式相同的theano/tensorflow张量 27 | 28 | ### 返回值 29 | 30 | 单个用以代表输出各个数据点上均值的值 31 | 32 | ## 可用预定义张量 33 | 34 | 除fbeta_score额外拥有默认参数beta=1外,其他各个性能指标的参数均为y_true和y_pred 35 | 36 | * binary_accuracy: 对二分类问题,计算在所有预测值上的平均正确率 37 | * categorical_accuracy:对多分类问题,计算再所有预测值上的平均正确率 38 | * sparse_categorical_accuracy:与`categorical_accuracy`相同,在对稀疏的目标值预测时有用 39 | * top_k_categorical_accracy: 计算top-k正确率,当预测值的前k个值中存在目标类别即认为预测正确 40 | * sparse_top_k_categorical_accuracy：与top_k_categorical_accracy作用相同，但适用于稀疏情况 41 | 42 | ## 定制评估函数 43 | 44 | 定制的评估函数可以在模型编译时传入,该函数应该以`(y_true, y_pred)`为参数,并返回单个张量,或从`metric_name`映射到`metric_value`的字典,下面是一个示例: 45 | 46 | ```python 47 | (y_true, y_pred) as arguments and return a single tensor value. 48 | 49 | import keras.backend as K 50 | 51 | def mean_pred(y_true, y_pred): 52 | return K.mean(y_pred) 53 | 54 | model.compile(optimizer='rmsprop', 55 | loss='binary_crossentropy', 56 | metrics=['accuracy', mean_pred]) 57 | 58 | ``` 59 | -------------------------------------------------------------------------------- /docs/other/objectives.md: -------------------------------------------------------------------------------- 1 | # 目标函数objectives 2 | 3 | 目标函数，或称损失函数，是编译一个模型必须的两个参数之一： 4 | 5 | ```python 6 | model.compile(loss='mean_squared_error', optimizer='sgd') 7 | ``` 8 | 9 | 可以通过传递预定义目标函数名字指定目标函数，也可以传递一个Theano/TensroFlow的符号函数作为目标函数，该函数对每个数据点应该只返回一个标量值，并以下列两个参数为参数： 10 | 11 | * y_true：真实的数据标签，Theano/TensorFlow张量 12 | 13 | * y_pred：预测值，与y_true相同shape的Theano/TensorFlow张量 14 | ```python 15 | from keras import losses 16 | 17 | model.compile(loss=losses.mean_squared_error, optimizer='sgd') 18 | ``` 19 | 真实的优化目标函数是在各个数据点得到的损失函数值之和的均值 20 | 21 | 请参考[目标实现代码](https://github.com/fchollet/keras/blob/master/keras/objectives.py)获取更多信息 22 | 23 | ## 可用的目标函数 24 | 25 | * mean_squared_error或mse 26 | 27 | * mean_absolute_error或mae 28 | 29 | * mean_absolute_percentage_error或mape 30 | 31 | * mean_squared_logarithmic_error或msle 32 | 33 | * squared_hinge 34 | 35 | * hinge 36 | 37 | * categorical_hinge 38 | 39 | * binary_crossentropy（亦称作对数损失，logloss） 40 | 41 | * logcosh 42 | 43 | * categorical_crossentropy：亦称作多类的对数损失，注意使用该目标函数时，需要将标签转化为形如```(nb_samples, nb_classes)```的二值序列 44 | 45 | * sparse_categorical_crossentrop：如上，但接受稀疏标签。注意，使用该函数时仍然需要你的标签与输出值的维度相同，你可能需要在标签数据上增加一个维度：```np.expand_dims(y,-1)``` 46 | 47 | * kullback_leibler_divergence:从预测值概率分布Q到真值概率分布P的信息增益,用以度量两个分布的差异. 48 | 49 | * poisson：即```(predictions - targets * log(predictions))```的均值 50 | 51 | * cosine_proximity：即预测值与真实标签的余弦距离平均值的相反数 52 | 53 | 54 | **注意**: 当使用"categorical_crossentropy"作为目标函数时,标签应该为多类模式,即one-hot编码的向量,而不是单个数值. 可以使用工具中的`to_categorical`函数完成该转换.示例如下: 55 | ```python 56 | from keras.utils.np_utils import to_categorical 57 | 58 | categorical_labels = to_categorical(int_labels, num_classes=None) 59 | ``` 60 | 61 | -------------------------------------------------------------------------------- /docs/other/objectives.md~: -------------------------------------------------------------------------------- 1 | # 目标函数objectives 2 | 3 | 目标函数，或称损失函数，是编译一个模型必须的两个参数之一： 4 | 5 | ```python 6 | model.compile(loss='mean_squared_error', optimizer='sgd') 7 | ``` 8 | 9 | 可以通过传递预定义目标函数名字指定目标函数，也可以传递一个Theano/TensroFlow的符号函数作为目标函数，该函数对每个数据点应该只返回一个标量值，并以下列两个参数为参数： 10 | 11 | * y_true：真实的数据标签，Theano/TensorFlow张量 12 | 13 | * y_pred：预测值，与y_true相同shape的Theano/TensorFlow张量 14 | 15 | 真实的优化目标函数是在各个数据点得到的损失函数值之和的均值 16 | 17 | 请参考[目标实现代码](https://github.com/fchollet/keras/blob/master/keras/objectives.py)获取更多信息 18 | 19 | ## 可用的目标函数 20 | 21 | * mean_squared_error或mse 22 | 23 | * mean_absolute_error或mae 24 | 25 | * mean_absolute_percentage_error或mape 26 | 27 | * mean_squared_logarithmic_error或msle 28 | 29 | * squared_hinge 30 | 31 | * hinge 32 | 33 | * binary_crossentropy（亦称作对数损失，logloss） 34 | 35 | * categorical_crossentropy：亦称作多类的对数损失，注意使用该目标函数时，需要将标签转化为形如```(nb_samples, nb_classes)```的二值序列 36 | 37 | * sparse_categorical_crossentrop：如上，但接受稀疏标签。注意，使用该函数时仍然需要你的标签与输出值的维度相同，你可能需要在标签数据上增加一个维度：```np.expand_dims(y,-1)``` 38 | 39 | * kullback_leibler_divergence:从预测值概率分布Q到真值概率分布P的信息增益,用以度量两个分布的差异. 40 | 41 | * poisson：即```(predictions - targets * log(predictions))```的均值 42 | 43 | * cosine_proximity：即预测值与真实标签的余弦距离平均值的相反数 44 | 45 | ## 注意 46 | 47 | 48 | 【Tips】过一段时间（等我或者谁有时间吧……）我们将把各种目标函数的表达式和常用场景总结一下。 49 | -------------------------------------------------------------------------------- /docs/other/optimizers.md: -------------------------------------------------------------------------------- 1 | # 优化器optimizers 2 | 3 | 优化器是编译Keras模型必要的两个参数之一 4 | ```python 5 | from keras import optimizers 6 | 7 | model = Sequential() 8 | model.add(Dense(64, kernel_initializer='uniform', input_shape=(10,))) 9 | model.add(Activation('tanh')) 10 | model.add(Activation('softmax')) 11 | 12 | sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) 13 | model.compile(loss='mean_squared_error', optimizer=sgd) 14 | ``` 15 | 16 | 可以在调用```model.compile()```之前初始化一个优化器对象，然后传入该函数（如上所示），也可以在调用```model.compile()```时传递一个预定义优化器名。在后者情形下，优化器的参数将使用默认值。 17 | ```python 18 | # pass optimizer by name: default parameters will be used 19 | model.compile(loss='mean_squared_error', optimizer='sgd') 20 | ``` 21 | ## 所有优化器都可用的参数 22 | 参数```clipnorm```和```clipvalue```是所有优化器都可以使用的参数,用于对梯度进行裁剪.示例如下: 23 | ```python 24 | from keras import optimizers 25 | 26 | # All parameter gradients will be clipped to 27 | # a maximum norm of 1. 28 | sgd = optimizers.SGD(lr=0.01, clipnorm=1.) 29 | ``` 30 | ```python 31 | from keras import optimizers 32 | 33 | # All parameter gradients will be clipped to 34 | # a maximum value of 0.5 and 35 | # a minimum value of -0.5. 36 | sgd = optimizers.SGD(lr=0.01, clipvalue=0.5) 37 | ``` 38 | 39 | ## SGD 40 | ```python 41 | keras.optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0, nesterov=False) 42 | ``` 43 | 随机梯度下降法，支持动量参数，支持学习衰减率，支持Nesterov动量 44 | 45 | ### 参数 46 | 47 | * lr：大或等于0的浮点数，学习率 48 | 49 | * momentum：大或等于0的浮点数，动量参数 50 | 51 | * decay：大或等于0的浮点数，每次更新后的学习率衰减值 52 | 53 | * nesterov：布尔值，确定是否使用Nesterov动量 54 | 55 | *** 56 | 57 | ## RMSprop 58 | ```python 59 | keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-06) 60 | ``` 61 | 除学习率可调整外，建议保持优化器的其他默认参数不变 62 | 63 | 该优化器通常是面对递归神经网络时的一个良好选择 64 | 65 | ### 参数 66 | 67 | * lr：大或等于0的浮点数，学习率 68 | 69 | * rho：大或等于0的浮点数 70 | 71 | * epsilon：大或等于0的小浮点数，防止除0错误 72 | 73 | *** 74 | 75 | ## Adagrad 76 | ```python 77 | keras.optimizers.Adagrad(lr=0.01, epsilon=1e-06) 78 | ``` 79 | 建议保持优化器的默认参数不变 80 | 81 | ### Adagrad 82 | 83 | * lr：大或等于0的浮点数，学习率 84 | 85 | * epsilon：大或等于0的小浮点数，防止除0错误 86 | 87 | *** 88 | 89 | ## Adadelta 90 | ```python 91 | keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=1e-06) 92 | ``` 93 | 建议保持优化器的默认参数不变 94 | 95 | ### 参数 96 | 97 | * lr：大或等于0的浮点数，学习率 98 | 99 | * rho：大或等于0的浮点数 100 | 101 | * epsilon：大或等于0的小浮点数，防止除0错误 102 | 103 | ### 参考文献 104 | 105 | *** 106 | 107 | * [Adadelta - an adaptive learning rate method](http://arxiv.org/abs/1212.5701) 108 | 109 | ## Adam 110 | ```python 111 | keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08) 112 | ``` 113 | 114 | 该优化器的默认值来源于参考文献 115 | 116 | ### 参数 117 | 118 | * lr：大或等于0的浮点数，学习率 119 | 120 | * beta_1/beta_2：浮点数， 0此脚本](https://gist.github.com/fchollet/0830affa1f7f19fd47b06d4cf89ed44d) 98 | * target_size: 整数tuple,默认为(256, 256). 图像将被resize成该尺寸 99 | * color_mode: 颜色模式,为"grayscale","rgb"之一,默认为"rgb".代表这些图片是否会被转换为单通道或三通道的图片. 100 | * classes: 可选参数,为子文件夹的列表,如['dogs','cats']默认为None. 若未提供,则该类别列表将自动推断(类别的顺序将按照字母表顺序映射到标签值) 101 | * class_mode: "categorical", "binary", "sparse"或None之一. 默认为"categorical. 该参数决定了返回的标签数组的形式, "categorical"会返回2D的one-hot编码标签,"binary"返回1D的二值标签."sparse"返回1D的整数标签,如果为None则不返回任何标签, 生成器将仅仅生成batch数据, 这种情况在使用```model.predict_generator()```和```model.evaluate_generator()```等函数时会用到. 102 | * batch_size: batch数据的大小,默认32 103 | * shuffle: 是否打乱数据,默认为True 104 | * seed: 可选参数,打乱数据和进行变换时的随机数种子 105 | * save_to_dir: None或字符串，该参数能让你将提升后的图片保存起来，用以可视化 106 | * save_prefix：字符串，保存提升后图片时使用的前缀, 仅当设置了```save_to_dir```时生效 107 | * save_format："png"或"jpeg"之一，指定保存图片的数据格式,默认"jpeg" 108 | 109 | 110 | 111 | ### 例子 112 | 113 | 使用```.flow()```的例子 114 | ```python 115 | (X_train, y_train), (X_test, y_test) = cifar10.load_data() 116 | Y_train = np_utils.to_categorical(y_train, nb_classes) 117 | Y_test = np_utils.to_categorical(y_test, nb_classes) 118 | 119 | datagen = ImageDataGenerator( 120 | featurewise_center=True, 121 | featurewise_std_normalization=True, 122 | rotation_range=20, 123 | width_shift_range=0.2, 124 | height_shift_range=0.2, 125 | horizontal_flip=True) 126 | 127 | # compute quantities required for featurewise normalization 128 | # (std, mean, and principal components if ZCA whitening is applied) 129 | datagen.fit(X_train) 130 | 131 | # fits the model on batches with real-time data augmentation: 132 | model.fit_generator(datagen.flow(X_train, Y_train, batch_size=32), 133 | samples_per_epoch=len(X_train), nb_epoch=nb_epoch) 134 | 135 | # here's a more "manual" example 136 | for e in range(nb_epoch): 137 | print 'Epoch', e 138 | batches = 0 139 | for X_batch, Y_batch in datagen.flow(X_train, Y_train, batch_size=32): 140 | loss = model.train(X_batch, Y_batch) 141 | batches += 1 142 | if batches >= len(X_train) / 32: 143 | # we need to break the loop by hand because 144 | # the generator loops indefinitely 145 | break 146 | ``` 147 | 148 | 使用```.flow_from_directory(directory)```的例子 149 | ```python 150 | train_datagen = ImageDataGenerator( 151 | rescale=1./255, 152 | shear_range=0.2, 153 | zoom_range=0.2, 154 | horizontal_flip=True) 155 | 156 | test_datagen = ImageDataGenerator(rescale=1./255) 157 | 158 | train_generator = train_datagen.flow_from_directory( 159 | 'data/train', 160 | target_size=(150, 150), 161 | batch_size=32, 162 | class_mode='binary') 163 | 164 | validation_generator = test_datagen.flow_from_directory( 165 | 'data/validation', 166 | target_size=(150, 150), 167 | batch_size=32, 168 | class_mode='binary') 169 | 170 | model.fit_generator( 171 | train_generator, 172 | samples_per_epoch=2000, 173 | nb_epoch=50, 174 | validation_data=validation_generator, 175 | nb_val_samples=800) 176 | ``` 177 | -------------------------------------------------------------------------------- /docs/preprocessing/sequence.md: -------------------------------------------------------------------------------- 1 | # 序列预处理 2 | 3 | ## 填充序列pad_sequences 4 | ```python 5 | keras.preprocessing.sequence.pad_sequences(sequences, maxlen=None, dtype='int32', 6 | padding='pre', truncating='pre', value=0.) 7 | ``` 8 | 将长为```nb_samples```的序列（标量序列）转化为形如```(nb_samples,nb_timesteps)```2D numpy array。如果提供了参数```maxlen```，```nb_timesteps=maxlen```，否则其值为最长序列的长度。其他短于该长度的序列都会在后部填充0以达到该长度。长于`nb_timesteps`的序列将会被截断，以使其匹配目标长度。padding和截断发生的位置分别取决于`padding`和`truncating`. 9 | 10 | ### 参数 11 | 12 | * sequences：浮点数或整数构成的两层嵌套列表 13 | 14 | * maxlen：None或整数，为序列的最大长度。大于此长度的序列将被截短，小于此长度的序列将在后部填0. 15 | 16 | * dtype：返回的numpy array的数据类型 17 | 18 | * padding：‘pre’或‘post’，确定当需要补0时，在序列的起始还是结尾补 19 | 20 | * truncating：‘pre’或‘post’，确定当需要截断序列时，从起始还是结尾截断 21 | 22 | * value：浮点数，此值将在填充时代替默认的填充值0 23 | 24 | ### 返回值 25 | 26 | 返回形如```(nb_samples,nb_timesteps)```的2D张量 27 | 28 | *** 29 | 30 | ## 跳字skipgrams 31 | ```python 32 | keras.preprocessing.sequence.skipgrams(sequence, vocabulary_size, 33 | window_size=4, negative_samples=1., shuffle=True, 34 | categorical=False, sampling_table=None) 35 | ``` 36 | skipgrams将一个词向量下标的序列转化为下面的一对tuple： 37 | 38 | * 对于正样本，转化为（word，word in the same window） 39 | 40 | * 对于负样本，转化为（word，random word from the vocabulary） 41 | 42 | 【Tips】根据维基百科，n-gram代表在给定序列中产生连续的n项，当序列句子时，每项就是单词，此时n-gram也称为shingles。而skip-gram的推广，skip-gram产生的n项子序列中，各个项在原序列中不连续，而是跳了k个字。例如，对于句子： 43 | 44 | “the rain in Spain falls mainly on the plain” 45 | 46 | 其 2-grams为子序列集合： 47 | 48 | the rain，rain in，in Spain，Spain falls，falls mainly，mainly on，on the，the plain 49 | 50 | 其 1-skip-2-grams为子序列集合： 51 | 52 | the in, rain Spain, in falls, Spain mainly, falls on, mainly the, on plain. 53 | 54 | 更多详情请参考[Efficient Estimation of Word Representations in Vector Space](http://arxiv.org/pdf/1301.3781v3.pdf) 55 | 56 | ### 参数 57 | 58 | * sequence：下标的列表，如果使用sampling_tabel，则某个词的下标应该为它在数据库中的顺序。（从1开始） 59 | 60 | * vocabulary_size：整数，字典大小 61 | 62 | * window_size：整数，正样本对之间的最大距离 63 | 64 | * negative_samples：大于0的浮点数，等于0代表没有负样本，等于1代表负样本与正样本数目相同，以此类推（即负样本的数目是正样本的```negative_samples```倍） 65 | 66 | * shuffle：布尔值，确定是否随机打乱样本 67 | 68 | * categorical：布尔值，确定是否要使得返回的标签具有确定类别 69 | 70 | * sampling_table：形如```(vocabulary_size,)```的numpy array，其中```sampling_table[i]```代表没有负样本或随机负样本。等于1为与正样本的数目相同 71 | 采样到该下标为i的单词的概率（假定该单词是数据库中第i常见的单词） 72 | 73 | ### 输出 74 | 75 | 函数的输出是一个```(couples,labels)```的元组，其中： 76 | 77 | * ```couples```是一个长为2的整数列表：```[word_index,other_word_index]``` 78 | 79 | * ```labels```是一个仅由0和1构成的列表，1代表```other_word_index```在```word_index```的窗口，0代表```other_word_index```是词典里的随机单词。 80 | 81 | * 如果设置```categorical```为```True```，则标签将以one-hot的方式给出，即1变为\[0,1\]，0变为\[1,0\] 82 | 83 | *** 84 | 85 | ## 获取采样表make_sampling_table 86 | ```python 87 | keras.preprocessing.sequence.make_sampling_table(size, sampling_factor=1e-5) 88 | ``` 89 | 该函数用以产生```skipgrams```中所需要的参数```sampling_table```。这是一个长为```size```的向量，```sampling_table[i]```代表采样到数据集中第i常见的词的概率（为平衡期起见，对于越经常出现的词，要以越低的概率采到它） 90 | 91 | ### 参数 92 | 93 | * size：词典的大小 94 | 95 | * sampling_factor：此值越低，则代表采样时更缓慢的概率衰减（即常用的词会被以更低的概率被采到），如果设置为1，则代表不进行下采样，即所有样本被采样到的概率都是1。 96 | 97 | 98 | -------------------------------------------------------------------------------- /docs/preprocessing/text.md: -------------------------------------------------------------------------------- 1 | # 文本预处理 2 | 3 | ## 句子分割text_to_word_sequence 4 | ```python 5 | keras.preprocessing.text.text_to_word_sequence(text, 6 | filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n', 7 | lower=True, 8 | split=" ") 9 | ``` 10 | 本函数将一个句子拆分成单词构成的列表 11 | 12 | ### 参数 13 | 14 | * text：字符串，待处理的文本 15 | 16 | * filters：需要滤除的字符的列表或连接形成的字符串，例如标点符号。默认值为 '!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n'，包含标点符号，制表符和换行符等 17 | 18 | * lower：布尔值，是否将序列设为小写形式 19 | 20 | * split：字符串，单词的分隔符，如空格 21 | 22 | ### 返回值 23 | 24 | 字符串列表 25 | 26 | *** 27 | 28 | ## one-hot编码 29 | ```python 30 | keras.preprocessing.text.one_hot(text, 31 | n, 32 | filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n', 33 | lower=True, 34 | split=" ") 35 | ``` 36 | 本函数将一段文本编码为one-hot形式的码，即仅记录词在词典中的下标。 37 | 38 | 39 | 【Tips】 40 | 从定义上，当字典长为n时，每个单词应形成一个长为n的向量，其中仅有单词本身在字典中下标的位置为1，其余均为0，这称为one-hot。 41 | 42 | 为了方便起见，函数在这里仅把“1”的位置，即字典中词的下标记录下来。 43 | 44 | ### 参数 45 | 46 | * n：整数，字典长度 47 | 48 | ### 返回值 49 | 50 | 整数列表，每个整数是\[1,n\]之间的值，代表一个单词（不保证唯一性，即如果词典长度不够，不同的单词可能会被编为同一个码）。 51 | 52 | *** 53 | 54 | ## 特征哈希hashing_trick 55 | ```python 56 | keras.preprocessing.text.hashing_trick(text, 57 | n, 58 | hash_function=None, 59 | filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n', 60 | lower=True, 61 | split=' ') 62 | ``` 63 | 将文本转换为固定大小的哈希空间中的索引序列 64 | 65 | ### 参数 66 | 67 | * n: 哈希空间的维度 68 | 69 | * hash_function: 默认为 python `hash` 函数, 可以是 'md5' 或任何接受输入字符串, 并返回 int 的函数. 注意 `hash` 不是一个稳定的哈希函数, 因此在不同执行环境下会产生不同的结果, 作为对比, 'md5' 是一个稳定的哈希函数. 70 | 71 | ### 返回值 72 | 73 | 整数列表 74 | 75 | ## 分词器Tokenizer 76 | ```python 77 | keras.preprocessing.text.Tokenizer(num_words=None, 78 | filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n', 79 | lower=True, 80 | split=" ", 81 | char_level=False) 82 | ``` 83 | Tokenizer是一个用于向量化文本，或将文本转换为序列（即单词在字典中的下标构成的列表，从1算起）的类。 84 | 85 | ### 构造参数 86 | 87 | * 与```text_to_word_sequence```同名参数含义相同 88 | 89 | * num_words：None或整数，处理的最大单词数量。若被设置为整数，则分词器将被限制为待处理数据集中最常见的```num_words```个单词 90 | 91 | * char_level: 如果为 True, 每个字符将被视为一个标记 92 | 93 | ### 类方法 94 | 95 | * fit_on_texts(texts) 96 | 97 | * texts：要用以训练的文本列表 98 | 99 | * texts_to_sequences(texts) 100 | 101 | * texts：待转为序列的文本列表 102 | 103 | * 返回值：序列的列表，列表中每个序列对应于一段输入文本 104 | 105 | * texts_to_sequences_generator(texts) 106 | 107 | * 本函数是```texts_to_sequences```的生成器函数版 108 | 109 | * texts：待转为序列的文本列表 110 | 111 | * 返回值：每次调用返回对应于一段输入文本的序列 112 | 113 | * texts_to_matrix(texts, mode)： 114 | 115 | * texts：待向量化的文本列表 116 | 117 | * mode：‘binary’，‘count’，‘tfidf’，‘freq’之一，默认为‘binary’ 118 | 119 | * 返回值：形如```(len(texts), nb_words)```的numpy array 120 | 121 | * fit_on_sequences(sequences): 122 | 123 | * sequences：要用以训练的序列列表 124 | 125 | * sequences_to_matrix(sequences): 126 | 127 | * sequences：待向量化的序列列表 128 | 129 | * mode：‘binary’，‘count’，‘tfidf’，‘freq’之一，默认为‘binary’ 130 | 131 | * 返回值：形如```(len(sequences), nb_words)```的numpy array 132 | 133 | ### 属性 134 | * word_counts:字典，将单词（字符串）映射为它们在训练期间出现的次数。仅在调用fit_on_texts之后设置。 135 | * word_docs: 字典，将单词（字符串）映射为它们在训练期间所出现的文档或文本的数量。仅在调用fit_on_texts之后设置。 136 | * word_index: 字典，将单词（字符串）映射为它们的排名或者索引。仅在调用fit_on_texts之后设置。 137 | * document_count: 整数。分词器被训练的文档（文本或者序列）数量。仅在调用fit_on_texts或fit_on_sequences之后设置。 138 | 139 | -------------------------------------------------------------------------------- /docs/scikit-learn_API.md: -------------------------------------------------------------------------------- 1 | # Scikit-Learn接口包装器 2 | 3 | 我们可以通过包装器将```Sequential```模型（仅有一个输入）作为Scikit-Learn工作流的一部分，相关的包装器定义在```keras.wrappers.scikit_learn.py```中 4 | 5 | 目前，有两个包装器可用： 6 | 7 | ```keras.wrappers.scikit_learn.KerasClassifier(build_fn=None, **sk_params)```实现了sklearn的分类器接口 8 | 9 | 10 | ```keras.wrappers.scikit_learn.KerasRegressor(build_fn=None, **sk_params)```实现了sklearn的回归器接口 11 | 12 | ## 参数 13 | 14 | * build_fn：可调用的函数或类对象 15 | 16 | * sk_params：模型参数和训练参数 17 | 18 | ```build_fn```应构造、编译并返回一个Keras模型，该模型将稍后用于训练/测试。```build_fn```的值可能为下列三种之一： 19 | 20 | 1. 一个函数 21 | 22 | 2. 一个具有```call```方法的类对象 23 | 24 | 3. None，代表你的类继承自```KerasClassifier```或```KerasRegressor```，其```call```方法为其父类的```call```方法 25 | 26 | ```sk_params```以模型参数和训练（超）参数作为参数。合法的模型参数为```build_fn```的参数。注意，‘build_fn’应提供其参数的默认值。所以我们不传递任何值给```sk_params```也可以创建一个分类器/回归器 27 | 28 | ```sk_params```还接受用于调用```fit```，```predict```，```predict_proba```和```score```方法的参数，如```nb_epoch```，```batch_size```等。这些用于训练或预测的参数按如下顺序选择： 29 | 30 | 1. 传递给```fit```，```predict```，```predict_proba```和```score```的字典参数 31 | 32 | 2. 传递个```sk_params```的参数 33 | 34 | 3. ```keras.models.Sequential```，```fit```，```predict```，```predict_proba```和```score```的默认值 35 | 36 | 当使用scikit-learn的```grid_search```接口时，合法的可转换参数是你可以传递给```sk_params```的参数，包括训练参数。即，你可以使用```grid_search```来搜索最佳的```batch_size```或```nb_epoch```以及其他模型参数 37 | 38 | -------------------------------------------------------------------------------- /docs/utils.md: -------------------------------------------------------------------------------- 1 | # utils 工具 2 | 3 | 本模块提供了一系列有用工具 4 | 5 | 6 | ##CustomObjectScope 7 | ```python 8 | keras.utils.generic_utils.CustomObjectScope() 9 | ``` 10 | 提供定制类的作用域，在该作用域内全局定制类能够被更改，但在作用域结束后将回到初始状态。 11 | 以```with```声明开头的代码将能够通过名字访问定制类的实例，在with的作用范围，这些定制类的变动将一直持续，在with作用域结束后，全局定制类的实例将回归其在with作用域前的状态。 12 | 13 | ```python 14 | with CustomObjectScope({"MyObject":MyObject}): 15 | layer = Dense(..., W_regularizer="MyObject") 16 | # save, load, etc. will recognize custom object by name 17 | ``` 18 | *** 19 | 20 | ## HDF5Matrix 21 | 22 | ```python 23 | keras.utils.io_utils.HDF5Matrix(datapath, dataset, start=0, end=None, normalizer=None) 24 | ``` 25 | 26 | 这是一个使用HDF5数据集代替Numpy数组的方法 27 | 28 | 提供```start```和```end```参数可以进行切片，另外，还可以提供一个正规化函数或匿名函数，该函数将会在每片数据检索时自动调用。 29 | 30 | ```python 31 | x_data = HDF5Matrix('input/file.hdf5', 'data') 32 | model.predict(x_data) 33 | ``` 34 | 35 | * datapath: 字符串，HDF5文件的路径 36 | * dataset: 字符串，在datapath路径下HDF5数据库名字 37 | * start: 整数，想要的数据切片起点 38 | * end: 整数，想要的数据切片终点 39 | * normalizer: 在每个切片数据检索时自动调用的函数对象 40 | 41 | *** 42 | 43 | ## Sequence 44 | ``` 45 | keras.utils.data_utils.Sequence() 46 | ``` 47 | 序列数据的基类，例如一个数据集。 48 | 每个Sequence必须实现`__getitem__`和`__len__`方法 49 | 50 | 下面是一个例子： 51 | ```python 52 | from skimage.io import imread 53 | from skimage.transform import resize 54 | import numpy as np 55 | 56 | __Here, `x_set` is list of path to the images__ 57 | 58 | # and `y_set` are the associated classes. 59 | 60 | class CIFAR10Sequence(Sequence): 61 | def __init__(self, x_set, y_set, batch_size): 62 | self.X,self.y = x_set,y_set 63 | self.batch_size = batch_size 64 | 65 | def __len__(self): 66 | return len(self.X) // self.batch_size 67 | 68 | def __getitem__(self,idx): 69 | batch_x = self.X[idx*self.batch_size:(idx+1)*self.batch_size] 70 | batch_y = self.y[idx*self.batch_size:(idx+1)*self.batch_size] 71 | 72 | return np.array([ 73 | resize(imread(file_name), (200,200)) 74 | for file_name in batch_x]), np.array(batch_y) 75 | 76 | ``` 77 | 78 | *** 79 | 80 | ## to_categorical 81 | ```python 82 | to_categorical(y, num_classes=None) 83 | ``` 84 | 85 | 将类别向量(从0到nb_classes的整数向量)映射为二值类别矩阵, 用于应用到以`categorical_crossentropy`为目标函数的模型中. 86 | 87 | ###参数 88 | 89 | * y: 类别向量 90 | * num_classes:总共类别数 91 | 92 | *** 93 | 94 | ## normalize 95 | ```python 96 | normalize(x, axis=-1, order=2) 97 | ``` 98 | 99 | 对numpy数组规范化，返回规范化后的数组 100 | 101 | ###参数 102 | * x：待规范化的数据 103 | * axis: 规范化的轴 104 | * order：规范化方法，如2为L2范数 105 | 106 | *** 107 | 108 | ### custom_object_scope 109 | ```python 110 | custom_object_scope() 111 | ``` 112 | 提供定制类的作用域，在该作用域内全局定制类能够被更改，但在作用域结束后将回到初始状态。 113 | 以```with```声明开头的代码将能够通过名字访问定制类的实例，在with的作用范围，这些定制类的变动将一直持续，在with作用域结束后，全局定制类的实例将回归其在with作用域前的状态。 114 | 115 | 本函数返回```CustomObjectScope```对象 116 | 117 | ```python 118 | with custom_object_scope({"MyObject":MyObject}): 119 | layer = Dense(..., W_regularizer="MyObject") 120 | # save, load, etc. will recognize custom object by name 121 | ``` 122 | 123 | *** 124 | 125 | ### get_custom_objects 126 | ```python 127 | get_custom_objects() 128 | ``` 129 | 130 | 检索全局定制类，推荐利用custom_object_scope更新和清理定制对象，但```get_custom_objects```可被直接用于访问```_GLOBAL_CUSTOM_OBJECTS```。本函数返回从名称到类别映射的全局字典。 131 | 132 | ```python 133 | get_custom_objects().clear() 134 | get_custom_objects()["MyObject"] = MyObject 135 | ``` 136 | *** 137 | 138 | ## convert_all_kernels_in_model 139 | ```python 140 | convert_all_kernels_in_model(model) 141 | ``` 142 | 143 | 将模型中全部卷积核在Theano和TensorFlow模式中切换 144 | 145 | *** 146 | 147 | ### plot_model 148 | ```python 149 | plot_model(model, to_file='model.png', show_shapes=False, show_layer_names=True) 150 | ``` 151 | 绘制模型的结构图 152 | 153 | *** 154 | 155 | ### serialize_keras_object 156 | ```python 157 | serialize_keras_object(instance) 158 | ``` 159 | 将keras对象序列化 160 | 161 | *** 162 | 163 | ### deserialize_keras_object 164 | ```python 165 | eserialize_keras_object(identifier, module_objects=None, custom_objects=None, printable_module_name='object') 166 | ``` 167 | 从序列中恢复keras对象 168 | 169 | *** 170 | 171 | ### get_file 172 | 173 | ```python 174 | get_file(fname, origin, untar=False, md5_hash=None, file_hash=None, cache_subdir='datasets', hash_algorithm='auto', extract=False, archive_format='auto', cache_dir=None) 175 | ``` 176 | 177 | 从给定的URL中下载文件, 可以传递MD5值用于数据校验(下载后或已经缓存的数据均可) 178 | 179 | 默认情况下文件会被下载到`~/.keras`中的`cache_subdir`文件夹，并将其文件名设为`fname`，因此例如一个文件`example.txt`最终将会被存放在`~/.keras/datasets/example.txt~ 180 | 181 | tar,tar.gz.tar.bz和zip格式的文件可以被提取，提供哈希码可以在下载后校验文件。命令喊程序`shasum`和`sha256sum`可以计算哈希值。 182 | 183 | 184 | ### 参数 185 | 186 | * fname: 文件名，如果指定了绝对路径`/path/to/file.txt`,则文件将会保存到该位置。 187 | 188 | * origin: 文件的URL地址 189 | 190 | * untar: 布尔值,是否要进行解压 191 | 192 | * md5_hash: MD5哈希值,用于数据校验，支持`sha256`和`md5`哈希 193 | 194 | * cache_subdir: 用于缓存数据的文件夹，若指定绝对路径`/path/to/folder`则将存放在该路径下。 195 | 196 | * hash_algorithm: 选择文件校验的哈希算法，可选项有'md5', 'sha256', 和'auto'. 默认'auto'自动检测使用的哈希算法 197 | * extract: 若为True则试图提取文件，例如tar或zip tries extracting the file as an Archive, like tar or zip. 198 | * archive_format: 试图提取的文件格式，可选为'auto', 'tar', 'zip', 和None. 'tar' 包括tar, tar.gz, tar.bz文件. 默认'auto'是['tar', 'zip']. None或空列表将返回没有匹配。 199 | * cache_dir: 缓存文件存放地在，参考[FAQ](for_beginners/FAQ/#where_config) 200 | ### 返回值 201 | 202 | 下载后的文件地址 203 | 204 | 205 | ### multi_gpu_model 206 | ```python 207 | keras.utils.multi_gpu_model(model, gpus) 208 | ``` 209 | 210 | 将模型在多个GPU上复制 211 | 212 | 特别地，该函数用于单机多卡的数据并行支持，它按照下面的方式工作： 213 | 214 | （1）将模型的输入分为多个子batch 215 | （2）在每个设备上调用各自的模型，对各自的数据集运行 216 | （3）将结果连接为一个大的batch（在CPU上） 217 | 218 | 例如，你的batch_size是64而gpus=2，则输入会被分为两个大小为32的子batch，在两个GPU上分别运行，通过连接后返回大小为64的结果。 该函数线性的增加了训练速度，最高支持8卡并行。 219 | 220 | 该函数只能在tf后端下使用 221 | 222 | 参数如下： 223 | 224 | * model: Keras模型对象，为了避免OOM错误（内存不足），该模型应在CPU上构建，参考下面的例子。 225 | * gpus: 大或等于2的整数，要并行的GPU数目。 226 | 227 | 该函数返回Keras模型对象，它看起来跟普通的keras模型一样，但实际上分布在多个GPU上。 228 | 229 | 例子： 230 | ```python 231 | import tensorflow as tf 232 | from keras.applications import Xception 233 | from keras.utils import multi_gpu_model 234 | import numpy as np 235 | 236 | num_samples = 1000 237 | height = 224 238 | width = 224 239 | num_classes = 1000 240 | 241 | # Instantiate the base model 242 | # (here, we do it on CPU, which is optional). 243 | with tf.device('/cpu:0'): 244 | model = Xception(weights=None, 245 | input_shape=(height, width, 3), 246 | classes=num_classes) 247 | 248 | # Replicates the model on 8 GPUs. 249 | # This assumes that your machine has 8 available GPUs. 250 | parallel_model = multi_gpu_model(model, gpus=8) 251 | parallel_model.compile(loss='categorical_crossentropy', 252 | optimizer='rmsprop') 253 | 254 | # Generate dummy data. 255 | x = np.random.random((num_samples, height, width, 3)) 256 | y = np.random.random((num_samples, num_classes)) 257 | 258 | # This `fit` call will be distributed on 8 GPUs. 259 | # Since the batch size is 256, each GPU will process 32 samples. 260 | parallel_model.fit(x, y, epochs=20, batch_size=256) 261 | ``` 262 | -------------------------------------------------------------------------------- /mkdocs.yml: -------------------------------------------------------------------------------- 1 | site_name: Keras中文文档 2 | r"pages": 3 | - ['index.md','主页'] 4 | - ['for_beginners/concepts.md','keras新手指南','一些基本概念'] 5 | - ['for_beginners/FAQ.md','keras新手指南','常见问题与解答'] 6 | - ['for_beginners/keras_linux.md','keras新手指南','Keras安装和配置指南(Linux)'] 7 | - ['for_beginners/keras_windows.md','keras新手指南','Keras安装和配置指南(Windows)'] 8 | - ['for_beginners/trap.md','keras新手指南','Keras使用陷阱'] 9 | - ['getting_started/sequential_model.md','快速开始','序贯模型'] 10 | - ['getting_started/functional_API.md','快速开始','函数式模型'] 11 | - ['models/about_model.md','模型','关于Keras模型'] 12 | - ['models/sequential.md','模型','序贯模型API'] 13 | - ['models/model.md','模型','函数式模型API'] 14 | - ['layers/about_layer.md','网络层','关于Keras层'] 15 | - ['layers/core_layer.md','网络层','常用层Core'] 16 | - ['layers/convolutional_layer.md','网络层','卷积层Convolutional'] 17 | - ['layers/pooling_layer.md','网络层','池化层Pooling'] 18 | - ['layers/locally_connected_layer.md','网络层','局部连接层Locally-connented'] 19 | - ['layers/recurrent_layer.md','网络层','循环层Recurrent'] 20 | - ['layers/embedding_layer.md','网络层','嵌入层Embedding'] 21 | - ['layers/merge.md','网络层','融合层Merge'] 22 | - ['layers/advanced_activation_layer.md','网络层','高级激活层Advanced Activation'] 23 | - ['layers/normalization_layer.md','网络层','规范层BatchNormalization'] 24 | - ['layers/noise_layer.md','网络层','噪声层Noise'] 25 | - ['layers/wrapper.md','网络层','包装器Wrapper'] 26 | - ['layers/writting_layer.md','网络层','编写自己的层'] 27 | - ['preprocessing/sequence.md','数据预处理','序列预处理'] 28 | - ['preprocessing/text.md','数据预处理','文本预处理'] 29 | - ['preprocessing/image.md','数据预处理','图片预处理'] 30 | - ['other/objectives.md','网络配置','损失函数loss'] 31 | - ['other/optimizers.md','网络配置','优化器Optimizer'] 32 | - ['other/activations.md','网络配置','激活函数Activation'] 33 | - ['other/metrics.md','网络配置','性能评估Metrices'] 34 | - ['other/initializations.md','网络配置','初始化方法Initializers'] 35 | - ['other/regularizers.md','网络配置','正则项Regularizer'] 36 | - ['other/constraints.md','网络配置','约束项Constraint'] 37 | - ['other/callbacks.md','网络配置','回调函数Callback'] 38 | - ['other/application.md','协助使用Keras','预训练模型Application'] 39 | - ['other/datasets.md','协助使用Keras','常用数据库Dataset'] 40 | - ['other/visualization.md','协助使用Keras','可视化visualization'] 41 | - ['utils.md','协助使用Keras','工具'] 42 | - ['backend.md','keras后端Backend'] 43 | - ['scikit-learn_API.md','scikit-learn接口'] 44 | - ['acknowledgement.md','致谢'] 45 | theme: readthedocs 46 | site_author: BigMoyan 47 | -------------------------------------------------------------------------------- /mkdocs.yml~: -------------------------------------------------------------------------------- 1 | site_name: keras-cn 2 | pages: 3 | - ['index.md','主页: index.md'] 4 | - ['getting_started/sequential_model.md','快速开始','快速开始Sequential模型'] 5 | - ['getting_started/functional_API.md','快速开始','快速开始泛型模型'] 6 | - ['getting_started/FAQ.md','快速开始','FAQ'] 7 | - ['models/about_model.md','模型','关于Keras模型'] 8 | - ['models/sequential.md','模型','Sequential'] 9 | - ['models/model.md','模型','泛型模型'] 10 | - ['layers/about_layer.md','网络层','关于Keras层'] 11 | - ['layers/core_layer.md','网络层','常用层'] 12 | - ['layers/convolutional_layer.md','网络层','卷积层'] 13 | - ['layers/recurrent_layer.md','网络层','递归层'] 14 | - ['layers/embedding_layer.md','网络层','嵌入层'] 15 | - ['layers/advanced_activation_layer.md','网络层','高级激活层'] 16 | - ['layers/normalization_layer.md','网络层','归一层'] 17 | - ['layers/noise_layer.md','网络层','噪声层'] 18 | - ['layers/wrapper.md','网络层','包装器'] 19 | - ['layers/writting_layer.md','网络层','编写自己的层'] 20 | - ['preprocessing/sequence.md','预处理','序列预处理'] 21 | - ['preprocessing/text.md','预处理','文字预处理'] 22 | - ['preprocessing/image.md','预处理','图片'] 23 | - ['other/objectives.md','其他重要模块','目标函数'] 24 | - ['other/optimizers.md','其他重要模块','优化器'] 25 | - ['other/activations.md','其他重要模块','激活函数'] 26 | - ['other/callbacks.md','其他重要模块','回调函数'] 27 | - ['other/initializations.md','其他重要模块','初始化方法'] 28 | - ['other/regularizers.md','其他重要模块','正则项'] 29 | - ['other/constraints.md','其他重要模块','约束项'] 30 | - ['other/datasets.md','其他重要模块','常用数据库'] 31 | - ['other/visualization.md','其他重要模块','可视化'] 32 | - ['backend.md','keras后端'] 33 | - ['scikit-learn_API.md','scikit-learn接口'] 34 | - ['acknowlegement.md','致谢'] 35 | theme: readthedocs 36 | site_author: BigMoyan 37 | --------------------------------------------------------------------------------