Posted 2019-03-21Updated 2019-02-17Python / Kerasa few seconds read (About 54 words)

Keras 安装配置

Keras配置文件

`$HOME/.keras/keras.json`

{
	"image_data_format": "channel_last",
		# 指定Keras将要使用数据维度顺序
	"epsilon": 1e-07,
		# 防止除0错误数字
	"flaotx": "float32",
		# 浮点数精度
	"backend": "tensorflow"
		# 指定Keras所使用后端
}

Posted 2019-03-21Updated 2019-02-17Pythona few seconds read (About 62 words)

Matplotlib约定

函数书写声明

函数书写声明同Python全局
以下常用参数如不特殊注明，按照此解释

Pyplot

data=dict/pd.DataFrame
- 其他
  - 属于kwargs中参数
  - 传参时，相应键值对替代对应参数

Posted 2019-03-21Updated 2020-09-09Python / Matplotlib5 minutes read (About 776 words)

Matplotlib 配置

配置文件`matplotlibrc`

配置文件路径

/current/dir/matplotplibrc
$MATPLOTLIBRC/matplotlibrc
~/.config/matplotlib/matplotlibrc(~/.matplotlib/matplotlibrc)
/path/to/matlabplot/mpl-data/matplotlibrc

查看实际路径

1	$ python -c 'import matplotlib as mpl; print(mpl.matplotlib_fname())'

中文问题

字符编码问题

python2中默认字符编码方案是ascii，需要更改为utf-8
1
2
3
import sys
reload(sys)
sys.setdefaultencoding("utf8")
python3则默认为utf-8编码，无需其他操作

字体文件缺失

mpl不兼容ttc文件，只能识别ttf文件
mpl默认使用/path/to/matplotlib/mpl-data/fonts中的字体文件

ttc和ttf格式参见cs_program/character

管理单个图表

通过mpl字体管理器管理单个图表元素字体
- 对每个需要使用该字体的图表元素，都需要传递相应的参数
- 无需字体都不需要安装

1 2	ch=mpl.font_manager.FontProperties(fname=/path/to/font.ttf) ax.set_title(name, fontproperties=ch)

运行时配置MPL默认字体

 # 必须在`plt.plot()`类似的绘图语句执行之前执行
 # `font-name`为已安装字体名称而不是字体文件名
mpl.rcParams['font.default-font-family'].insert(0, font-name)
 # 查看当前默认font-family
mpl.font_manager.FontProperties().get_family()
 # 一般默认字体族是"sans-serif"，所以应该将字体名称插入其首位
mpl.rcParams['font.sans-serif'].insert(0, font-name)

运行时指定“已安装”字体给当前执行mpl配置中默认字体
- 系统中已安装ttf字体，即fc-查找目录
  - /usr/share/fonts/
  - $HOME/.local/share/fonts/
  - $HOME/.fonts/
- /path/to/matplotlib/mpl-data/fonts/中字体文件对应字体

已安装字体指mpl.font_manager.FontManager能找到字体，但不是所有系统已安装字体，mpl均可找到、使用
1
2
# 获取mpl所有可用字体并排序
sorted([i.name for i in mpl.font_manager.FontManger().ttflist])
- 字体文件问题：mpl不兼容ttc字体文件
- 缓存问题：mpl可能在~/.cache/matplotlib/下有cache 文件，mpl会直接从中获取可用字体列表，新字体可能需删除才能在mpl中生效
  1
  2
  # 获取mpl缓存文件夹
  mpl.get_cachedir()

修改MPL配置文件

修改配置文件更改全局默认字体
- 将字体名称添加在默认字体族首位，作为最优先候选字体
  1
  font.sans-serif : font-name,
同样要求mpl能够找到、使用相应的字体文件

图片显示

X11依赖

mpl一般在常用于包含有X11的图形化界面中，所以若X11不可用则需修改mpl配置

对生成pdf、png、svg等，可以修改后端为Agg

运行时修改

import matplotlib as mpl
# 须在导入`pyplot`前执行
mpl.use("Agg")
from matplotlib import pyplot as plt

修改配置文件
1
backend: TkAgg

By default, matplotlib ships configured to work with a graphical user interface which may require an X11 connection. Since many barebones application servers don’t have X11 enabled, you may get errors if you don’t configure matplotlib for use in these environments. Most importantly, you need to decide what kinds of images you want to generate(PNG, PDF, SVG) and configure the appropriate default backend. For 99% of users, this will be the Agg backend, which uses the C++ antigrain rendering engine to make nice PNGs

Posted 2019-03-21Updated 2019-02-17Python / Matplotlib3 minutes read (About 404 words)

Matplotlib.plot笔记

图像元素

Figure

整个窗口（句柄）

1 2	fig=plt.figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True)

Axes

图像（子图）（句柄）

None=plt.subplot(*arg, **karg)
	// 创建并激活axes
None=plt.subplot(num=int(row-col-index)
None=plt.subplot(row, col, index)

fig, axs=plt.subplots(rows=int, cols=int)

fig.add_subplot(rows=int, cols=int, index=int)

ax=fig.add_axes(rect=[left,buttom,width,height],
	projection='aitoff'/'hammer'...)
	// 指定地点、大小子图
	// `rect`参数是百分比

Axies

轴

说明

这三个图像元素都是以句柄形式操作，可以理解为每次操作都是在一个“容器”中操作，容器由plt管理，每次 plt.show()将图像全部展示之后，容器被回收，创建新容器
因此plt.show()之后，之前容器中的元素更改无法影响到新容器
plt可以当作当前激活状态的axes元素的句柄使用

绘图

线图


None=ax(*args, **kwargs)
	# `args`
		# [x]=range(len(y))/list
		# y=list
		# [fmt]=str

	# `kwargs`
		# data：类似df、dict的indexable对象，传递时x、y可用
			标签代替
		# linewidth
		# markersize
		# color
		# marker
		# linestyle

# examples
None=ax([x], y, [fmt], [x2], y2, [fmt2], **kwargs）
None=ax('xlabel', 'ylabel', data=indexable_obj)
None=ax(2d-array[0], 2d-array[1:])

柱状图


list=ax.bar(*args, **kwargs)

	# `args`
		# x=list
		# height=num/list
		# [width]=num/list
		# [bottom]=num/list

	# `kwargs`
		# align='center'/'edge'
		# agg_filter=func
		# alpha=None/float
		# capstyle='butt'/'round'/'projecting'
#todo

饼图

list=ax.pie(x, explode=None/list(%), labels=None/list,
	colors=None/list(color), autopct=None/str/func,
	pctdistance=0.6, shadow=False, labeldistance=1.1,
	startangle=None, radius=None/float,
	counterclock=True, textprops=None, center=(0,0),
	frame=False, rotatelables=False, hold=None,
	data=None/dict(param_above))

箱线图

1 2	list=ax.boxplot(x, notch=False, sym=None/str, vert=True, whis=1.5/str/list)

Posted 2019-03-21Updated 2021-08-02Python / Jupyter2 minutes read (About 298 words)

Jupyter 常用基础

配置文件

生成配置文件

1 2	$ jupyter notebook --generate-config # 生成配置文件，默认为`~/jupyter/jupyter-notebook-config.py`

修改配置文件

c.NotebookApp.password = u'sha1:xxxxxxxx'
	# 配置sha1格式密文，需要自己手动生成
c.NotebookApp.ip = "*"
	# 配置运行访问ip地址
c.NotebookApp.open_brower = False
	# 默认启动时不开启浏览器
c.NotebookApp.port = 8888
	# 监听端口，默认
c.NotebookAPp.notebook_dir = u"/path/to/dir"
	# jupyter默认显示羡慕路径
c.NotebookApp.certfile = u"/path/to/ssl_cert_file"
c.NotebookAppp.keyfile = u"/path/to/ssl_keyfile"
	# jupyter使用ssl证书文件
	# 一般只有使用自己生成证书

生成密文

1
2
3

from notebook.auth import passwd
passwd()
	# 输入密码两次，然后就会返回对应密文，写入配置文件

远程访问

jupyter必须使用https登陆、访问

因此服务端必须有ssl证书，
- 自己生成的证书默认浏览器不认可，浏览器访问会高危，高级进入即可
  1
  openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout key_name.key -out cert_name.pem
访问时也必须加上https://前缀，一般默认http://前缀会报服务器无响应（没配置重定向，应该是）

Posted 2019-03-21Updated 2019-02-17Python / Pandas10 minutes read (About 1573 words)

Pandas数据结构

DataFrame

可以看作包含两个Index类（index、columns）、一个二维ndarray类（values）

二维values + 结构化index + 结构化columns
- values自己还有两根只能使用integer indice的轴
结构同数据库表相似：列为属性，行为个体

DF = pd.DataFrame(
	data=ndarray/{col_name: val}/DF/array-like,
	index=Index/array-like,
	columns=Index/array-like,
	dtype=None/dtype,
	copy=False)

	# `data=dict`：可以通过`columns`仅使用部分键值对创建
	# `copy`：仅影响`data`为DF/ndarray时，默认不使用拷贝

DF行列逻辑

可以通过DF = df1.T作转制更改行列逻辑

获取数据

列优先

Ser = df1[col_name]
Ser = df1.col_name
	# 取列
Ser = df1[col_level_0, col_level_1,...]
Ser = df1[(col_level_0, col_level_1,...)]
Ser = df1.col_level_0.col_level_1
	# 对层级索引取列

Val = df1[col_name][index_name]
Val = df1.col_name.index_name
	# 取具体值
	# 属性方式，要求`*_name`为字符串
	# `.`、`[]`应该是覆盖过

Val = df1[col_level_0, col_level_1,...]\
	[index_level_0, index_level_1,...]

Val = df1[(col_level_0, col_level_1,...)]\
	[index_level_0, index_level_1,...]

Val = df1.col_level_0.col_level_1....\
	.index_level_0.index_level_1...
	# 对层级索引取值

DF = df1[cond1 & cond2 &...]
DF = df1[cond1][cond2]...
	# `condX`为Ser(bool)
	# 两种讲道理应该没差

行优先

`.loc[]`

行优先,逻辑和df1[]列优先类似

Ser = df.loc[index_name]
	# 取行
Ser = df.loc[index_level_0, index_level_1,...]
Ser = df.loc[(index_level_0, index_level_1,...)]
	# 层级索引取行Ser/DF

Val = df1.loc[index_name, column_name]
	# 还可以这样的取值
	# 不建议使用，容易照成混淆
 # Val = df1.loc.index_name`
	# 不可

Val = df1.loc[index_level_0, index_level_1,...]\
	[col_level_0, col_level_1,...]
	# 层级索引时，index、col不能混在一起

Val = df1.loc[(index_level_0, index_level_1,...)]\
	[(col_level_0, col_level_1,...)]

`.iloc[]`

indices locate，应视为对value（ndarray）进行操作，index和 columns的结构对其没有任何影响

在层级索引情况下，仍然返回Ser

Ser = df1.iloc[indice]
	# 返回values第indice行Ser对象
Val = df1.iloc[index_indice, col_indice]
	# 取得values第index_indice行、第col_indice列元素

`.ix[]`

.loc、.iloc的封装，不建议使用

优先使用.loc，除非参数为int、且Index不是int类型

1	Ser = df1.ix[index]

行优先快速版本

只能、必须取一个值

不能用于获取切片
对于多重索引必须将Index、Columns所有level全部指定

.iat

1	Val = df1.iat[index_indice, col_indice]

.at

Val = df1.at[index_name, col_name]
	# 单索引
Val = df1.at[(index_level_0, index_level_1,...), (col_level_0, col_level_1,...)]
	# 多重索引必须指定全部level保证只取到一个值

切片

Values切片

切片对象是values

DF = df1.iloc[irow_start: irow_end, icol_start: icol_end]
	# 对values的切片，参数都是indices
	# 这个应该就是ndarray切片操作，不包括上限
	# 如果只对行切片，可以省略`.iloc`，但不建议，因为这个
		# 同时也可以表示Index切片（优先）

Index切片

切片对象是index，包括上限

全切片

DF = df1.loc[
	(index_0, index_1,...): (index_0, index_1,...),
	(col_0, col_1,...): (col_0, col_1,...)]
	# `.loc`可以替换为`.ix`，但不能删除，不建议使用

行切片

DF = df1.loc[[(index_0, index_1,...),...]]
DF = df1.loc[(index_0, index_1,...): (index_0, index_1,...)]
	# index_level可以不用指定到最低level，
	# 同样的，`.loc`可以替换为`.ix`，但不建议使用

列切片

DF = df1[[col_name,...]]
DF = df1.loc[:, (col_0,...): (col_0,...)]
	# `.loc`可以替换为`.ix`，但是不能删除，不建议使用
	# 列切片没有`:`语法，只能通过设置行切片为`:`得到

DF数据共享逻辑

DF数据（values）共享的逻辑

一般尽量共享数据，直至无法处理（数据同时增加/删除行、列）
有些方法会有copy参数，可以显式控制是否拷贝副本
- 如.reindex默认拷贝副本

df1_T = df1.T
	# 两个此时共享数据，对任一的更改会反映在另一者
df1_T["new_col_1"] = [ ]
	# 添加新列后，两者仍然共享公共部分数据，只是`df1`中无法
		# 访问新列
df1["new_col_2"] = [ ]
	# 此时两者数据均独立

	# 类似的`del`删除列也是如此逻辑

Index 索引

使用integer作为index时注意df1.ix[]的逻辑

MultiIndex 层级索引

层级索引允许以低维度形式表示高纬度数据

层级索引可以使用tuple形式表示：(level_0, level_1,...)
- 需要注意区分和tuple本身作为index
  - 打印时可以tuple有括号，而层级索引没有
  - 层级索引有时可以省略括号

`from_arrays`

Index = pd.MultiIndex.from_arrays(
	arrays([[],[]]),
	sortorder=None/int,
	names=None/[])

Index = [
	level_0_list,
	level_1_list,...]
	# 隐式构建层级索引，各list长度相同，其按顺序组合
	# 可以在：DF构造参数、给DF对象Index赋值等使用
	# 应该是可以看作pandas使用`from_arrays`处理

说明：将arrays转换为MultiIndex
参数
- arrays：包含多个list作为各个level索引
  - 各list按照传递顺序决定level
  - 不会自动合并不连续labels（否则需要交换数据位置）
- sortorder：sortedness级别？
- names：level名

`from_tuples`

Index = pd.MultiIndex.from_tuples(
	tuples=[tuple-like],
	sortorder=None/int,
	names=None)

说明：将tuples转换为MultiIndex
参数
- tuples：每个tuple为一个index，按照tuple中元素顺序决定各元素level

`from_product`

Index = pd.MultiIndex.from_product(
	iterables([[]]/[iterables]),
	sortorder=None/int,
	names)

说明：对iterables元素作product（积）作为MultiIndex

Series：可以看作是包含一个Index类（index，存放标签）、一个一维ndarray类（values，存放数据）

a. ser=pd.Series(data=np.darray/dict, index=list)

b. Series对象可以处理标签不一致的数据，但是只有标签的交集才能得到有意义的结果，其余为NaN

c. 其余性质类似于DataFrame对象
Index属性#todo

a. index属性
1. df1.columns=[]：更改列名称，index同
2. df1.columns.names=[]：更改列名，index同
pandas库中的其他一些问题

a. 数据类型转换：Series对象和DF对象在运算过程中dtype类型可能发生”无意义”的转换
1. dtype=i8的对象之间的+、-结果为dtype=f8类型的对象（当然这个可能是保持和\的一致性）
2. SeriesObj.reindex(new_index)会”可能”会改变原有数据类型（由i8->f8）（有增加新index时）

Posted 2019-03-21Updated 2019-02-17Python / TensorFlow10 minutes read (About 1432 words)

TensorFlow Readme

常用参数说明

函数书写声明同Python全局
以下常用参数如不特殊注明，按照此解释

Session

target = ""/str
- 含义：执行引擎
graph = None/tf.Graph
- 含义：Session中加载的图
- 默认：缺省为当前默认图
config = None/tf.ConfigProto
- 含义：包含Session配置的Protocal Buffer
- 默认：None，默认配置
fetches = tf.OPs/[tf.OPs]
- 含义：需要获得/计算的OPs值列表
- 默认：无
feed_dict = None/dict
- 含义：替换/赋值Graph中feedable OPs的tensor字典
- 默认：无
- 说明
  - 键为图中节点名称、值为向其赋的值
  - 可向所有可赋值OPs传递值
  - 常配合tf.placeholder（强制要求）

Operators

name = None/str
- 含义：Operations名
- 默认：None/OP类型，后加上顺序后缀
- 说明
  - 重名时TF自动加上_[num]后缀
axis = None/0/int
- 含义：指定张量轴
- 默认
  - None：大部分，表示在整个张量上运算
  - 0：有些运算难以推广到整个张量，表示在首轴（维）
keepdims=False/True
- 含义：是否保持维度数目
- 默认：False不保持
dtype=tf.int32/tf.float32/...
- 含义：数据类型
- 默认：根据其他参数、函数名推断
shape/dims=(int)/[int]
- 含义：各轴维数
- 默认：None/1???
- 说明
  - -1表示该轴维数由TF计算得到
  - 有些情况下，此参数可省略，由TF隐式计算得到，但显式指明方便debug
start=int
- 含义：起始位置
- 默认：0
stop=int
- 含义：终点位置
- 默认：一般无

TensorFlow基本概念

TensorFlow将计算的定义、执行分开

流程

组合计算图

为输入、标签创建placeholder
创建weigth、bias
指定模型
指定损失函数
创建Opitmizer

在会话中执行图中操作

初始化Variable
运行优化器
使用FileWriter记录log
查看TensorBoard

PyTF 模块

`tf.nn`

tf.nn：神经网络功能支持模块

rnn_cell：构建循环神经网络子模块

`tf.contrib`

tf.contrib：包含易于变动、实验性质的功能

bayesflow：包含贝叶斯计算
cloud：云操作
cluster_resolver：集群求解
compiler：控制TF/XLA JIT编译器
copy_graph：在不同计算图之间复制元素
crf：条件随机场
cudnn_rnn：Cudnn层面循环神经网络
data：构造输入数据流水线
decision_trees：决策树相关模块
deprecated：已经、将被替换的summary函数
distributions：统计分布相关操作
estimator：自定义标签、预测的对错度量方式
factorization：聚类、因子分解
ffmpeg：使用FFmpeg处理声音文件
framework：框架类工具，包含变量操作、命令空间、 checkpoint操作
gan：对抗生成相关
graph_editor：计算图操作
grid_rnn：GridRNN相关
image：图像操作
input_pipeline：输入流水线
integrate：求解常微分方程
keras：Keras相关API
kernel_methods：核映射相关方法
kfac：KFAC优化器
labeled_tensor：有标签的Tensor
layers：类似nn里面的函数，经典CNN方法重构
learn：类似ski-learn的高级API
legacy_seq2seq：经典seq2seq模型
linalg：线性代数
linear_optimizer：训练线性模型、线性优化器
lookup：构建快速查找表
losses：loss相关
memory_stats：设备内存使用情况
meta_graph_transform：计算图转换
metrics：各种度量模型表现的方法
nccl：收集结果的操作
ndlstm：ndlstm相关
nn：tf.nn某些方法的其他版本
opt：某些优化器的其他版本
predictor：构建预测器
reduce_slice_ops：切片规约
remote_fused_graph
resampler：重抽样
rnn：某些循环神经网络其他版本
saved_model：更加易用的模型保存、继续训练、模型转换
seq2seq：seq2seq相关模型
session_bundle
signal：信号处理相关
slim：contrib主模块交互方式、主要入口
solvers：贝叶斯计算
sparsemax：稀疏概率激活函数、相关loss
specs
staging：分段输入
stat_summarizer：查看运行状态
statless：伪随机数
tensor_forest：可视化工具
testing：单元测试工具
tfprof：查看模型细节工具
timeseries：时间序列工具
tpu：TPU配置
training：训练及输入相关工具
util：Tensors处理相关工具

`tf.train`

tf.train：训练模型支持

优化器
- AdadeltaOptimizer：Adadelta优化器
- AdamOptimizer：Adam优化器
- GradientDescentOptimizer：SGD优化器
- MomentumOptimizer：动量优化器
- RMSPropOptimizer：RMSProp优化器
数据处理
- Coordinator：线程管理器
- QueueRunner：管理读写队列线程
- NanTensorHook：loss是否为NaN的捕获器
- create_global_step：创建global step
- match_filenames_once：寻找符合规则文件名称
- start_queue_runners：启动计算图中所有队列
tfrecord数据
- Example：tfrecord生成模板
- batch：生成tensor batch
- shuffle_batch：创建随机tensor batch
模型保存、读取
- Saver：保存模型、变量类
- NewCheckpointReader：checkpoint文件读取
- get_checkpoint_state：从checkpoint文件返回模型状态
- init_from_checkpoint：从checkpoint文件初始化变量
- latest_checkpoint：寻找最后checkpoint文件
- list_variable：返回checkpoint文件变量为列表
- load_variable：返回checkpoint文件某个变量值

`tf.summary`

tf.summary：配合tensorboard展示模型信息

FileWriter：文件生成类
Summary
get_summary_description：获取计算节点信息
histogram：展示变量分布信息
image：展示图片信息
merge：合并某个summary信息
merge_all：合并所有summary信息至默认计算图
scalar：展示标量值
text：展示文本信息

Posted 2019-03-21Updated 2021-08-04Python / TensorFlow2 minutes read (About 317 words)

TensorFlow 安装配置

安装

CUDA、CUDNN、CUDAtookit、NVCC

CUDA：compute unified device architecture，通用并行计算平台和编程模型，方便使用GPU进行通用计算
cuDNN：深度学习加速库，计算设计的库、中间件
- C++STL的thrust的实现
- cublas：GPU版本blas
- cuSparse：稀疏矩阵运算
- cuFFT：快速傅里叶变换
- cuDNN：深度学习网络加速
CUDA Toolkit：包括以下组件
- 编译器nvcc：CUDA-C、CUDA-C++编译器，依赖nvvm 优化器（nvvm本身依赖llvm编译器）
- ·debuggers、profiler等工具
- 科学库、实用程序库
  - cudart
  - cudadevrt
  - cupti
  - nvml
  - nvrtc
  - cublas
  - cublas_device
- 示例
- 驱动：

TensorBoard

TensorBoard是包括在TensorFlow中可视化组件

运行启动了TB的TF项目时，操作都会输出为事件日志文件
TB能够把这些日志文件以可视化的方式展示出来
- 模型图
- 运行时行为、状态

1	$ tensorboard --logdir=/path/to/logdir --port XXXX

问题

指令集

Your CPU supports instructions that this TensorFlow binary was not cmpiled to use: SSE1.4, SSE4.2, AVX AVX2 FMA

没从源代码安装以获取这些指令集的支持
- 从源代码编译安装
- 或者设置log级别
  1
  2
  3
  import os
  os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
  import tensorflow as tf

Posted 2019-03-21Updated 2019-02-17Python / Keras37 minutes read (About 5531 words)

Keras 后端

Keras后端

Keras是一个模型级的库，提供了快速构建深度学习网络的模块

Keras并不处理如张量乘法、卷积等底层操作，而是依赖于某种特定的、优化良好的张量操作库
Keras依赖于处理张量的库就称为“后端引擎”
- [Theano][Theano]：开源的符号主义张量操作框架，由蒙特利尔大学LISA/MILA实验室开发
- [Tensorflow][Tensorflow]：符号主义的张量操作框架，由Google开发
- [CNTK][CNTK]：由微软开发的商业级工具包
Keras将其函数统一封装，使得用户可以以同一个接口调用不同后端引擎的函数

[Theano]: http://deeplearning.net/software/theano/
[TensorFlow]: http://www.tensorflow.org/
[CNTK]: https://www.microsoft.com/en-us/cognitive-toolkit/

切换后端

修改Keras配置文件
定义环境变量KERAS_BACKEND覆盖配置文件中设置（见python 修改环境变量的3中方式）

Keras后端抽象

可以通过Keras后端接口来编写代码，使得Keras模块能够同时在 Theano和TensorFlow两个后端上使用

大多数张量操作都可以通过统一的Keras后端接口完成，不必关心具体执行后端

from keras import backend as K

input = K.placeholder(shape=(2, 4, 5))
input = K.placeholder(shape=(None, 4, 5))
input = K.placeholder(ndim=3)
	# 实例化输出占位符

val = np.random.random((3, 4, 5))
var = K.variable(value=val)
	# 实例化共享变量
	# 等价于`tf.Variable`、`theano.shared`
var = K.zeros(shape=(3, 4, 5))
var = K.ones(shape=(3, 4, 5))

配置相关函数

`backend`

返回当前后端

`epsilon`

1	K.epsilon()

返回数字表达式使用fuzz factor

`set_epsilon`

1	K.set_epsilon(e(float))

设置模糊因子的值

`floatx`

1	K.floatx()

返回默认的浮点数数据类型

float16
float32
float64

`set_floatx`

1
2
3

K.set_floatx(
	floatx="float16"/"float32"/"float64"
)

设置默认的浮点数数据类型（字符串表示）

`cast_to_floatx`

1	K.cast_to_floatx(x)

将NDA转换为默认的Keras floatx类型（的NDA）

例子

K.floatx()
	# "float32"
arr = np.array([1.0, 2.0], dtype="flaot64")
arr.dtype
	# "float64"
new_arr = K.cast_to_float(arr)
new_arr.dtype
	# "float32"

`image_data_format`

1	K.image_data_format()

返回图像的默认维度顺序

channels_last
channels_first

`set_image_data_format`

1
2
3

K.set_image_data_format(
	data_format="channel_first"/"channel_last"
)

设置图像的默认维度顺序

辅助函数

`is_keras_tensor`

判断是否是Keras Tensor对象

np_var = np.array([1, 2])
K.is_keras_tensor(np_var)
	# False
keras_var = K.variable(np_var)
K.is_keras_tensor(keras_var)
	# A variable is not a Tensor.
	# False
keras_placeholder = K.placeholder(shape=(2, 4, 5))
K.is_keras_tensor(keras_placeholder)
	# A placeholder is a Tensor.
	# True

`get_uid`

1	K.get_uid(prefix=''/str)

获得默认计算图的uid

说明
- 依据给定的前缀提供一个唯一的UID
参数
- prefix：图的可选前缀
返回值：图的唯一标识符

`reset_uids`

1	K.reset_uids()

重置图的标识符

`clear_session`

1	K.clear_session()

结束当前的TF计算图，并创建新图

说明
- 有效的避免模型/网络层的混乱

`manual_variable_initialization`

1
2
3

K.manual_variable_initialization(
	value=False/True
)

设置变量手动初始化标志

参数
- value
  - False：默认，变量在实例时出事的（由其默认值初始化）
  - True：用户自行初始化，如 tf.initialize_all_variables()

`learning_phase`

返回学习阶段标致

返回值：布尔张量
- 0：测试模式
- 1：训练模式

`set_learning_phase`

1
2
3

K.set_learning_phase(
	value=0/1
)

设置学习阶段为固定值

参数
- value：学习阶段值
  - 0：测试模式
  - 1：训练模式

OPs、Tensors

`is_sparse`

判断一个Tensor是不是一个稀疏的Tensor

返回值：布尔值

稀不稀疏由Tensor的类型决定，而不是Tensor实际上有多稀疏

from keras import backend as K
a = K.placeholder((2, 2), sparse=False)
print(K.is_sparse(a))
	# False
b = K.placeholder((2, 2), sparse=True)
print(K.is_sparse(b))
	# True

`to_dense`

将一个稀疏tensor转换一个不稀疏的tensor并返回

`variable`

def variable(
	value,
	dtype='float32'/str,
	name=None
)

实例化一个张量，返回之

参数
- value：用来初始化张量的值
- dtype：张量数据类型
- name：张量的名字（可选）

`placeholder`

def placeholder(
	shape=None,
	ndim=None,
	dtype='float32'/str,
	name=None
)

实例化一个占位符

参数
- shape：占位符的shape（整数tuple，可能包含None）
- ndim: 占位符张量的阶数
  - 要初始化占位符，至少指定shape和ndim之一，如果都指定则使用shape
- dtype: 占位符数据类型
- name: 占位符名称（可选）

`shape`

1	def shape(x)

返回张量的符号shape

返回值：OPs（需要执行才能得到值）

from keras import backend as K
tf_session = K.get_session()
val = np.array([[1, 2], [3, 4]])
kvar = K.variable(value=val)
input = keras.backend.placeholder(shape=(2, 4, 5))
K.shape(kvar)
	# <tf.Tensor 'Shape_8:0' shape=(2,) dtype=int32>
K.shape(input)
	# <tf.Tensor 'Shape_9:0' shape=(3,) dtype=int32>
	# To get integer shape (Instead, you can use K.int_shape(x))
K.shape(kvar).eval(session=tf_session)
	# array([2, 2], dtype=int32)
K.shape(input).eval(session=tf_session)
	# array([2, 4, 5], dtype=int32)

`int_shape`

1	def int_shape(x)

返回张量shape

返回值：tuple(int)/None

from keras import backend as K
input = K.placeholder(shape=(2, 4, 5))
K.int_shape(input)
	# (2, 4, 5)
val = np.array([[1, 2], [3, 4]])
kvar = K.variable(value=val)
K.int_shape(kvar)
	# (2, 2)

`ndim`

1	def ndim(x)

返回张量的阶数

返回值：int

from keras import backend as K
input = K.placeholder(shape=(2, 4, 5))
val = np.array([[1, 2], [3, 4]])
kvar = K.variable(value=val)
K.ndim(input)
	# 3
K.ndim(kvar)
	# 2

`dtype`

1	def dtype(x)

返回张量的数据类型

返回值：str
- float32
- float32_ref

from keras import backend as K
K.dtype(K.placeholder(shape=(2,4,5)))
	# 'float32'
K.dtype(K.placeholder(shape=(2,4,5), dtype='float32'))
	# 'float32'
K.dtype(K.placeholder(shape=(2,4,5), dtype='float64'))
	# 'float64'__Keras variable__

kvar = K.variable(np.array([[1, 2], [3, 4]]))
K.dtype(kvar)
	# 'float32_ref'
kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32')
K.dtype(kvar)
	# 'float32_ref'

`eval`

1	def eval(x)

求得张量的值

返回值：NDA

from keras import backend as K
kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32')
K.eval(kvar)
	# array([[ 1.,  2.],
	#	[ 3.,  4.]], dtype=float32)

`zeros

def zeros(
	shape,
	dtype='float32',
	name=None
)

生成shape大小的全0张量

from keras import backend as K
kvar = K.zeros((3,4))
K.eval(kvar)
	# array([[ 0.,  0.,  0.,  0.],
	#	[ 0.,  0.,  0.,  0.],
	#	[ 0.,  0.,  0.,  0.]], dtype=float32)

`ones`

def ones(
	shape,
	dtype='float32',
	name=None
)

生成shape大小的全1张量

`eye`

def eye(
	size,
	dtype='float32',
	name=None
)

生成size大小的单位阵

`zeros_like`

def zeros_like(
	x,
	name=None
)

生成与x shape相同的全0张量

`ones_like`

def ones_like(
	x,
	name=None
)

生成与x shape相同的全1张量

随机常量OPs

`random_uniform_variable`

def random_uniform_variable(
	shape,
	low,
	high,
	dtype=None,
	name=None,
	seed=None
)

初始化均匀分布常量OPs

参数
- low：浮点数，均匀分布之下界
- high：浮点数，均匀分布之上界
- dtype：数据类型
- name：张量名
- seed：随机数种子

`count_params`

1	def count_params(x)

返回张量中标量的个数

`cast`

1	def cast(x, dtype)

改变张量的数据类型

参数
- dtype：float16/float32/float64

`update`

1	def update(x, new_x)

用new_x更新x

`update_add`

1	def update_add(x, increment)

将x增加increment并更新x

`update_sub`

1	def update_sub(x, decrement)

将x减少decrement并更新x

`moving_average_update`

def moving_average_update(
	x,
	value,
	momentum
)

使用移动平均更新x

`dot`

1	def dot(x, y)

求两个张量的点乘

x = K.placeholder(shape=(2, 3))
y = K.placeholder(shape=(3, 4))
xy = K.dot(x, y)
xy
	# <tf.Tensor 'MatMul_9:0' shape=(2, 4) dtype=float32>

当试图计算两个N阶张量的乘积时，与Theano行为相同 (2, 3).(4, 3, 5) = (2, 4, 5))

x = K.placeholder(shape=(32, 28, 3))
y = K.placeholder(shape=(3, 4))
xy = K.dot(x, y)
xy
	# <tf.Tensor 'MatMul_9:0' shape=(32, 28, 4) dtype=float32>

x = K.random_uniform_variable(shape=(2, 3), low=0, high=1)
y = K.ones((4, 3, 5))
xy = K.dot(x, y)
K.int_shape(xy)
	# (2, 4, 5)

`batch_dot`

1	def batch_dot(x, y, axes=None)

按批进行张量x和y的点积

参数
- x：按batch分块的数据
- y；同x
- axes：指定进行点乘的轴

x_batch = K.ones(shape=(32, 20, 1))
y_batch = K.ones(shape=(32, 30, 20))
xy_batch_dot = K.batch_dot(x_batch, y_batch, axes=[1, 2])
K.int_shape(xy_batch_dot)
	# (32, 1, 30)

`transpose`

1	def transpose(x)

张量转置

`gather`

1	def gather(reference, indices)

在给定的张量中检索给定下标的向量

参数
- reference：张量
- indices：整数张量，其元素为要查询的下标
返回值：同reference数据类型相同的张量

`max`

def max(
	x,
	axis=None/int,
	keepdims=False
)

求张量中的最大值

`min`

1	def min(x, axis=None, keepdims=False)

求张量中的最小值

`sum`

1	sum(x, axis=None, keepdims=False)

计算张量中元素之和

`prod`

1	prod(x, axis=None, keepdims=False)

计算张量中元素之积

`cumsum`

1	def cumsum(x, axis=0)

在给定轴上求张量的累积和

`cumprod`

1	cumprod(x, axis=0)

在给定轴上求张量的累积积

`var`

1	def var(x, axis=None, keepdims=False)

在给定轴上计算张量方差

`std`

1	def std(x, axis=None, keepdims=False)

在给定轴上求张量元素之标准差

`mean`

1	def mean(x, axis=None, keepdims=False)

在给定轴上求张量元素之均值

`any`

1	def any(x, axis=None, keepdims=False)

按位或，返回数据类型为uint8的张量（元素为0或1）

`all`

1	def any(x, axis=None, keepdims=False)

按位与，返回类型为uint8de tensor

`argmax`

1	def argmax(x, axis=-1)

在给定轴上求张量之最大元素下标

`argmin`

1	def argmin(x, axis=-1)

在给定轴上求张量之最小元素下标

Element-Wise OPs

`square`

1	def square(x)

逐元素平方

`abs`

1	def abs(x)

逐元素绝对值

`sqrt`

sqrt(x)

逐元素开方

`exp`

1	def exp(x)

逐元素求自然指数

`log`

1	def log(x)

逐元素求自然对数

`logsumexp`

1	def logsumexp(x, axis=None, keepdims=False)

在给定轴上计算log(sum(exp()))

该函数在数值稳定性上超过手动计算log(sum(exp()))，可以避免由exp和log导致的上溢和下溢

`round`

1	def round(x)

逐元素四舍五入

`sign`

1	def sign(x)

逐元素求元素的符号

返回值
- +1
- -1

`pow`

1	def pow(x, a)

逐元素求x的a次方

`clip`

def clip(
	x,
	min_value,
	max_value
)

逐元素clip（将超出指定范围的数强制变为边界值）

`equal`

1	def equal(x, y)

逐元素判相等关系

返回值：布尔张量OP

`not_equal`

1	def not_equal(x, y)

逐元素判不等关系

`greater`

1	def greater(x,y)

逐元素判断x>y关系

`greater_equal`

1	def greater_equal(x,y)

逐元素判断x>=y关系

`lesser`

1	def lesser(x,y)

逐元素判断x<y关系

`lesser_equal`

1	def lesser_equal(x,y)

逐元素判断x<=y关系

`maximum`

1	def maximum(x, y)

逐元素取两个张量的最大值

`minimum`

1	def minimum(x, y)

逐元素取两个张量的最小值

`sin`

1	def sin(x)

逐元素求正弦值

`cos`

1	def cos(x)

逐元素求余弦值

变换OPs

`batch_normalization`

def batch_normalization(
	x,
	mean,
	var,
	beta,
	gamma,
	epsilon=0.0001
)

对batch的数据进行batch_normalization，计算公式为： $output = (x-mean)/(\sqrt(var)+\epsilon)*\gamma+\beta$

手动指定mean、var

`normalize_batch_in_training`

def normalize_batch_in_training(
	x,
	gamma,
	beta,
	reduction_axes,
	epsilon=0.0001
)

对batch数据先计算其均值和方差，然后再进行 batch_normalization

`concatenate`

1	def concatenate(tensors, axis=-1)

在给定轴上将一个列表中的张量串联为一个张量

`reshape`

1	def reshape(x, shape)

将张量的shape变换为指定shape

`permute_dimensions`

def permute_dimensions(
	x,
	pattern(tuple(int))
)

按照给定的模式重排一个张量的轴

参数
- pattern：代表维度下标的tuple如(0, 2, 1)

`resize_images`

def resize_images(
	X,
	height_factor(uint),
	width_factor(uint),
	dim_ordering=None/'th'/'tf'
)

依据给定的缩放因子height_factor、width_factor，改变batch 数据（图片）的shape

参数
- height_factor/width_factor：正整数

`resize_volumes`

def resize_volumes(
	X,
	depth_factor,
	height_factor,
	width_factor,
	dim_ordering
)

依据给定的缩放因子，改变一个5D张量数据的shape

`repeat_elements`

1	def repeat_elements(x, rep, axis)

在给定轴上重复张量元素rep次

与np.repeat类似

`repeat`

1	def repeat(x, n)

重复2D张量

`arange`

def arange(
	start,
	stop=None,
	step=1,
	dtype="int32"
)

生成1D的整数序列张量

参数：同np.arange
- 如果只有一个参数被提供了，则0~stop
返回值：默认数据类型是int32的张量

`tile`

1	def tile(x, n)

将x在各个维度上重复n[i]次

`batch_flatten`

1	def batch_flatten(x)

将n阶张量转变为2阶张量，第一维度保留不变

`expand_dims`

1	def expand_dims(x, dim=-1)

在dim指定轴后增加一维（轴）

`squeeze`

1	def squeeze(x, axis)

将axis指定的轴从张量中移除（保留轴上首组张量切片）

`temporal_padding`

1	def temporal_padding(x, padding=1)

向3D张量中间那个维度的左右两端填充padding个0值

`asymmetric_temporal_padding`

def asymmetric_temporal_padding(
	x,
	left_pad=1,
	right_pad=1
)

向3D张量中间的那个维度的左右分别填充0值

`spatial_2d_padding`

def spatial_2d_padding(
	x,
	padding=(1, 1),
	dim_ordering='th'
)

向4D张量高度、宽度左右两端填充padding[0]和padding[1] 个0值

`spatial_3d_padding`

def spatial_3d_padding(
	x,
	padding=(1, 1, 1),
	dim_ordering='th'
)

向5D张量深度、高度、宽度三个维度上填充0值

`stack`

1	def stack(x, axis=0)

将列表x中张量堆积起来形成维度+1的新张量

`one_hot`

1	def one_hot(indices, nb_classes)

为张量indices进行one_hot编码

参数
- indices：n维的整数张量
- nb_classes：one_hot编码列表
输出：n+1维整数张量，最后维为编码

`reverse`

1	def reverse(x, axes)

将一个张量在给定轴上反转

`get_value`

1	def get_value(x)

以NDA的形式返回张量的值

`batch_get_value`

1	def batch_get_value(x)

以[NDA]的形式返回多个张量的值

`set_value`

1	def set_value(x, value)

从NDA将值载入张量中

`batch_set_value`

1	def batch_set_value(tuples)

将多个值载入多个张量变量中

`print_tensor`

1	def print_tensor(x, message='')

在求值时打印张量的信息，并返回原张量

`function`

1	def function(inputs, outputs, updates=[])

实例化一个Keras函数

参数
- inputs：列表，其元素为占位符或张量变量
- outputs：输出张量的列表
- updates：张量列表

`gradients`

1	def gradients(loss, variables)

返回loss函数关于variables的梯度

`stop_gradient`

1	def stop_gradient(variables)

Returns variables but with zero gradient with respect to every other variables.

`rnn`

def rnn(
	step_function,
	inputs,
	initial_states,
	go_backwards=False,
	mask=None,
	constants=None,
	unroll=False,
	input_length=None
)

在张量的时间维上迭代

参数：
- inputs：时域信号的张量，阶数至少为3
- step_function：每个时间步要执行的函数
  
  参数
  - input：不含时间维张量，代表某时间步batch样本
  - states：张量列表
  返回值
  - output：形如(samples, ...)的张量
  - new_states：张量列表，与states的长度相同
- initial_states：包含step_function状态初始值
- go_backwards：逆向迭代序列
- mask：需要屏蔽的数据元素上值为1
- constants：按时间步传递给函数的常数列表
- unroll
  - 当使用TF时，RNN总是展开的’
  - 当使用Theano时，设置该值为True将展开递归网络
- input_length
  - TF：不需要此值
  - Theano：如果要展开递归网络，必须指定输入序列
返回值：形如(last_output, outputs, new_states)的张量
- last_output：RNN最后的输出
- outputs：每个在[s,t]点的输出对应于样本s在t时间的输出
- new_states: 每个样本的最后一个状态列表

`switch`

def switch(
	condition,
	then_expression,
	else_expression
)

依据给定condition（整数或布尔值）在两个表达式之间切换

参数
- condition：标量张量
- then_expression：TensorFlow表达式
- else_expression: TensorFlow表达式

`in_train_phase`

1	def in_train_phase(x, alt)

如果处于训练模式，则选择x，否则选择alt

注意alt应该与x的shape相同

`in_test_phase`

1	def in_test_phase(x, alt)

如果处于测试模式，则选择x，否则选择alt

注意：alt应该与x的shape相同

预定义（激活）函数

`relu`

def relu(
	x,
	alpha=0.0,
	max_value=None
)

修正线性单元

参数
- alpha：负半区斜率
- max_value: 饱和门限

`elu`

1	def elu(x, alpha=1.0)

指数线性单元

参数
- x：输入张量
- alpha: 标量

`softmax`

1	def softmax(x)

计算张量的softmax值

`softplus`

1	def softplus(x)

返回张量的softplus值

`softsign`

1	def softsign(x)

返回张量的softsign值

`sigmoid`

1	def sigmoid(x)

逐元素计算sigmoid值

`hard_sigmoid`

1	def hard_sigmoid(x)

分段线性近似的sigmoid，计算速度更快

`tanh`

1	def tanh(x)

逐元素计算tanh值

预定义目标函数

`categorical_crossentropy`

def categorical_crossentropy(
	output,
	target,
	from_logits=False
)

计算output、target的Categorical Crossentropy（类别交叉熵）

参数
- output/target：shape相等

`sparse_categorical_crossentropy`

def sparse_categorical_crossentropy(
	output,
	target,
	from_logits=False
)

计算output、target的Categorical Crossentropy（类别交叉熵）

参数
- output
- target：同output shape相等，需为整形张量

`binary_crossentropy`

def binary_crossentropy(
	output,
	target,
	from_logits=False
)

计算输出张量和目标张量的交叉熵

`dropout`

1	def dropout(x, level, seed=None)

随机将x中一定比例的值设置为0，并放缩整个Tensor

`l2_normalize`

1	def l2_normalize(x, axis)

在给定轴上对张量进行L2范数规范化

`in_top_k`

1	def in_top_k(predictions, targets, k)

判断目标是否在predictions的前k大值位置

参数

predictions：预测值张量
targets：真值张量
k：整数

`conv1d`

def conv1d(
	x,
	kernel,
	strides=1,
	border_mode="valid"/"same",
	image_shape=None,
	filter_shape=None
)

1D卷积

参数
- kernel：卷积核张量
- strides：步长，整型
- border_mode
  - “same”：
  - “valid”：

`conv2d`

def conv2d(
	x,
	kernel,
	strides=(1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	image_shape=None,
	filter_shape=None
)

2D卷积

参数
- kernel：卷积核张量
- strides：步长，长为2的tuple

`deconv2d`

def deconv2d(
	x,
	kernel,
	output_shape,
	strides=(1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	image_shape=None,
	filter_shape=None
)

2D反卷积（转置卷积）

参数
- x：输入张量
- kernel：卷积核张量
- output_shape: 输出shape的1D的整数张量
- strides：步长，tuple类型

`conv3d`

def conv3d(
	x,
	kernel,
	strides=(1, 1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	volume_shape=None,
	filter_shape=None
)

3D卷积

`pool2d`

def pool2d(
	x,
	pool_size,
	strides=(1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	pool_mode="max"/"avg"
)

2D池化

参数
- pool_size：含有两个整数的tuple，池的大小
- strides：含有两个整数的tuple，步长
- pool_mode: “max”，“avg”之一，池化方式

`pool3d`

def pool3d(
	x,
	pool_size,
	strides=(1, 1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	pool_mode="max"/"avg"
)

3D池化

`bias_add`

1	def bias_add(x, bias, data_format=None)

为张量增加一个偏置项

`random_normal`

def random_normal(
	shape,
	mean=0.0,
	stddev=1.0,
	dtype=None,
	seed=None
)

生成服从正态分布的张量

参数
- mean：均值
- stddev：标准差

`random_uniform`

def random_uniform(
	shape,
	minval=0.0,
	maxval=1.0,
	dtype=None,
	seed=None
)

生成服从均匀分布值的张量

参数
- minval：上界
- maxval：上界

`random_binomial`

def random_binomial(
	shape,
	p=0.0,
	dtype=None,
	seed=None
)

返回具有二项分布值的张量

参数
- p：二项分布参数

`truncated_normall`

def truncated_normal(
	shape,
	mean=0.0,
	stddev=1.0,
	dtype=None,
	seed=None
)

生成服从截尾正态分布值的张量，即在距离均值两个标准差之外的数据将会被截断并重新生成

`ctc_label_dense_to_sparse`

1	def ctc_label_dense_to_sparse(labels, label_lengths)

将ctc标签从稠密形式转换为稀疏形式

`ctc_batch_cost`

def ctc_batch_cost(
	y_true,
	y_pred,
	input_length,
	label_length
)

在batch上运行CTC损失算法

参数
- y_true：包含标签的真值张量
- y_pred：包含预测值或输出的softmax值的张量
- input_length：包含y_pred中每个batch的序列长
- label_length：包含y_true中每个batch的序列长张量
返回值：包含了每个元素的CTC损失的张量

`ctc_decode`

def ctc_decode(
	y_pred,
	input_length,
	greedy=True,
	beam_width=None,
	dict_seq_lens=None,
	dict_values=None
)

使用贪婪算法或带约束的字典搜索算法解码softmax的输出

参数
- y_pred：包含预测值或输出的softmax值的张量
- input_length：包含y_pred中每个batch序列长的张量
- greedy：使用贪婪算法
- dict_seq_lens：dic_values列表中各元素的长度
- dict_values：列表的列表，代表字典
返回值：包含了路径可能性（以softmax概率的形式）张量
注意仍然需要一个用来取出argmax和处理空白标签的函数

`map_fn`

1	def map_fn(fn, elems, name=None)

元素elems在函数fn上的映射，并返回结果

参数
- fn：函数
- elems：张量
- name：节点的名字
返回值：张量的第一维度等于elems，第二维度取决于fn

`foldl`

def foldl(
	fn,
	elems,
	initializer=None,
	name=None
)

用fn从左到右连接它们，以减少elems值

参数
- fn：函数，例如：lambda acc, x: acc + x
- elems：张量
- initializer：初始化的值(elems[0])
- name：节点名
返回值：与initializer类型和形状一致

`foldr`

def foldr(
	fn,
	elems,
	initializer=None,
	name=None
)

减少elems，用fn从右到左连接它们

参数
- fn：函数，例如：lambda acc, x: acc + x
- elems：张量
- initializer：初始化的值（elems[-1]）
- name：节点名
返回值：与initializer类型和形状一致

_width=None, dict_seq_lens=None, dict_values=None )


使用贪婪算法或带约束的字典搜索算法解码softmax的输出

-	参数

	-	`y_pred`：包含预测值或输出的softmax值的张量
	-	`input_length`：包含`y_pred`中每个batch序列长的张量
	-	`greedy`：使用贪婪算法
	-	`dict_seq_lens`：`dic_values`列表中各元素的长度
	-	`dict_values`：列表的列表，代表字典

-	返回值：包含了路径可能性（以softmax概率的形式）张量

-	注意仍然需要一个用来取出argmax和处理空白标签的函数

####	`map_fn`

```python
def map_fn(fn, elems, name=None)

元素elems在函数fn上的映射，并返回结果

参数
- fn：函数
- elems：张量
- name：节点的名字
返回值：张量的第一维度等于elems，第二维度取决于fn

`foldl`

def foldl(
	fn,
	elems,
	initializer=None,
	name=None
)

用fn从左到右连接它们，以减少elems值

参数
- fn：函数，例如：lambda acc, x: acc + x
- elems：张量
- initializer：初始化的值(elems[0])
- name：节点名
返回值：与initializer类型和形状一致

`foldr`

def foldr(
	fn,
	elems,
	initializer=None,
	name=None
)

减少elems，用fn从右到左连接它们

参数
- fn：函数，例如：lambda acc, x: acc + x
- elems：张量
- initializer：初始化的值（elems[-1]）
- name：节点名
返回值：与initializer类型和形状一致
name：节点名
返回值：与initializer类型和形状一致

Posted 2019-03-21Updated 2019-02-17Python / Pandas33 minutes read (About 4992 words)

Pandas函数目录

“内容结构”变换

合并

`merge`

DF = pd.merge(
	left(DF),
	right(DF),
	on=col_name/[col_names],
	left_on="left_col_name",
	right_on="right_col_name",
	left_index=False/True,
	right_index=False/true,
	how="Inner"/"outer"/"left"/"right")

功能：合并操作，类似于sql的join操作
参数
- on：merge合并基准列，可以是多个列名称的list，df1、 df2仅有一列名称相同时可省略，否则返回空DF对象
- left_on、right_on：df1、df2合并基准列名称不同时使用
- left_index、right_index：默认为False，值为 True时使用索引作为基准进行合并（此时也可以使用 df1.join(df2)）
- how：合并方式，默认是inner join，参数取值：’outer’ 、’left’、’right’（不知道能不能取’inner’，这个应该是默认取值，可以使用）
其他
- df1、df2有多个列名相同且不全是合并基准列时，返回的 DF对象的重复列名称会改变

`join`

DF = df1.join(
	other(DF/Ser/[DF]),
	on=None/[col_names],
	how="Left/right/outer/inner",
	lsuffix=str,
	rsuffix=str,
	sort=False)

说明：和其他DF对象进行join操作
参数
- other
  - 参数为Ser时，必须设置field名称
- on
  - 默认None，按照index-on-index进行join
  - 也可以按照col_name进行join
- how：同上
- lsuffix：df1重名列使用的后缀
- rsuffix：df2重名列使用的后缀
- sort：按照join-key排序

`concat`

Df/Ser = pd.concat(
	objs=[Ser, DF, dict],
	axix=0/1/"index"/"columns",
	join="Outer"/"inner",
	join_axes=None/[index],
	ignore_index=False/True,
	keys=None/[]/[()],
	levels=None/[],
	names=None/[index_names],
	verify_integrity=False,
	copy=True)

说明：以某个轴为方向将多个Series对象或DF对象拼接
参数
- objs
  - dict作为参数值传递，排序后的keys传递给keys
- join：处理其他轴的方式（其他轴长度、命名不同）
- join_axes：指定其他轴的index
- ingore_index：默认False，为True拼接后的DF的 Index将为RangeIndex
- keys：指定构建多级索引最外层Index
- levels：用于构建多重索引的具体层级，默认从keys 推断
- names：返回DF对象索引名称
- verify_integrity：默认False，不检查返回DF对象是否含有重复index copy：默认拷贝数据
其他
- pd.concat只涉及拼接方向，而merge只能沿列数增加的方向“拼接”
- pd.concat()时即使有相同的列名称、index序号也不会重命名
- pd.concat(axis=1,...)和 pd.merge(left_index=True, right_index=True,...)的作用应该是一样的，只是不会将相同的列名称重命名
- pd.merge可以指定合并基准列，而pd.concat只能按 Index“合并”，且只能inner join或时outer join
注意事项
- pd.concat默认会对索引进行排序，所以若索引包含不可比较元素则会报错，尤其是在多重索引情况下
  - 改变索引类型规避
    1
    2
    3
    4
    # 改为categorical索引
    df.index.astype("categorical")
    # 改为str类型
    df.index.astype(str)
  - reset索引规避
    1
    2
    df_new = pd.cancat([df1.reset_index(), df2.reset_index()])
    df_new = df_new.set_index(col_name)
- pd.concat连接会尝试转换数据类型，如： pd.Timestamp可能会被转换为int

`combine_first`

1 2	Ser = ser1.combine_first(other(Ser)) Df = df1.combine_first(other(DF))

说明：和其他DF/Ser进行元素级别的combine，即填充NULL 元素
- 元素级别
- 返回对象包含所有的index

增、删

`drop`

DF/None = df1.drop(
	labels=None/label/[labels],
	axis=0/1/"index"/"columns",
	index=None/index_name/[index_names],
	columns=None/col_name/[col_names],
	level=None/int/level_name,
	inplace=False,
	errors=="Raise/ignore")

说明：删除df1某轴上的labels
参数
- columns/index：替代axis+label指定需要删除的列/行

`[new_col_name]`

1 2	df1[new_col_name] = list df1.loc[new_index_name] = list

说明：添加新列/行
- .iloc[new_index_name]不可用

`append`

DF = df1.append(
	other(DF/Ser/dict/[]),
	ignore_index=False,
	verify_integrity=False)

说明：将other行追加到df1

`del`

1 2	del df1[col_name] # python自身语法直接删除某列

形、态变换

形状

`stack`

1
2
3

DF/Ser = df1.stack(
	level=-1/int,
	dropna=True)

说明：旋转level级列索引
参数
- dropna：默认剔除返回DF/Ser对象中NULL行

`unstack`

1
2
3

DF/Ser = df1.unstack(
	level=-1/int,
	fill_value=None)

说明：旋转level级行索引
参数
- fill_value：替换NaN的值
其他
- 两个函数好像都有排序操作，df1.unstack().stack()会合并层级索引

排序

`sort_index`

DF = df1.sort_index(
	axis=0/1,
	level=None/int/str,
	ascending=True,
	inplace=False,
	kind="Quicksort"/"mergesort"/"heapsort",
	na_position="First"/"last",
	sort_remaining=True/False)

说明：按照labels排序
参数
- kind：排序方法
- na_position：默认将NaN放在开头
  - 对多重索引无效
- sort_remaining：默认依次对剩余层级排序

`sort_value`

DF = df1.sort_value(
	by(label/[labels]),
	axis=0/1,
	ascending=True/False,
	inplace=False,
	kind="Quicksort"/"mergesort"/"heapsort",
	na_position="Last"/"first")

说明：依某labels（行、列）值排列

`rank`

DF = df1.rank(
	axis=0/1,
	method="Average"/"min"/"max"/"first"/"dense",
	numeric_only=None/True/False,
	na_option="Keep"/"top"/"bottom",
	ascending=True,
	pct=False)

说明：沿轴计算数值型数据的rank
- rank值相同者取rank值平均
参数
- method
  - average：组（延轴分组）rank平均
  - min/max：组内最小/大
  - first：label出现顺序优先
  - dense：类似min，但是rank值总是增加1
- numeric_only：默认不考虑含有非数值型数据label
  - 但是文档上确实写默认值为None
- na_option
  - keep：NaN值rank值不变
  - top：NaN作为“小”值
  - bottom：NaN作为“大”值
- ascending：默认小值rank值小
- pct：默认不计算rank值占比

`take`

DF = df1.take(
	indices([indice]),
	axis=0/1,
	covert=True,
	is_copy=True,
	**kwargs)

说明：按照indices对应的labels顺序返回DF
参数
- indices：指明返回indices、及其顺序
  - indices是指行数，不是labels
  - 可以为负值indice，类似list
- convert：是否处理负值indice（将废除，均处理）
- is_copy：默认创建副本返回

`reindex`

DF = df1.reindex(
	labels=None/[labels]/Index,
	index=None/[labels]/Index,
	columns=None/[labels],
	axis=0/1/"index"/"columns",
	method=None/"backfill"/"bfill"/"pad"/"ffill"/"nearest",
	copy=True/False,
	level=None/int/level_name,
	fill_value=NaN/scalar,
	limit=None/limit,
	tolerance=scalar/array-like)

说明：将DF对象转换有其他Index的对象
- 可以包含之前没有的labels
- 类似于labels版本.take，是选择不是重命名
参数
- labels：新Index，配合axis决定替换轴
- index/columns：两根轴的Index
- method：新labels值填补方法
  - 用于填补的值不一定会出现在返回DF对象中，可能是使用原DF对象中未被选择labels
- copy：默认拷贝副本
- fill_value：新labels值填补值
- limit：允许最长连续使用method方法填补值
- tolerance：使用method方法填补新labels值时，用于填补labels和新labels的最大差距
  - 超过tolerance则为默认NaN

数据处理

简单统计


Ser = df1.sum(
	level=None/0/1,
	axis=0/1)

Ser = df1.mean(
	axis=0/1)

Ser = df1.std(
	axis=0/1)

DF = df1.describe()

DF = df1.corr()

DF = df1.cov()

float = ser1.corr(
	ser1)

Ser = df1.corwith(
	other(DF/Ser),
	axis=0/1,
	drop=False/True)
	# `other`为DF对象时计算相同名称相关系数

`value_count`

Ser = pd.value_counts(
	values(ndarray(1d)),
	sort=True/False,
	ascending=False/True,
	normalize=False/True,
	bins=None/int/[num],
	dropna=True/False)

说明：计算hisgram
参数
- sort：默认按值排序
- normalize：默认不正则化（计算相对histgram）
- bins：hisgrams划分bins
  - 默认每个值划分为一个bins
  - 给出int时表示数目，(min, max]均等分
  - 给出[num]计算列表内数量（范围外不考虑）
- dropna：默认不计算NaN值个数

`quantile`

Ser/DF = df1.quantile(
	q=0.5/float/[float],
	axis=0/1/"index"/"columns",
	numeric_only=True,
	interpolation="linear")

说明：计算q分位数
参数
- q：分位，可以是列表，计算多个分位数
- interpolation：分位数计算方式（分位数位i、j间）
  - linear：i+(j-i)*fraction（线性回归）
  - low：i
  - high：i+1
  - nearest：i、i+1中近者
  - midpoint：(i+j)/2

元素级

Apply

`apply`

DF/Ser = df1.apply(
	func(func/{label: func}),
	axis=0/1/"index"/"columns",
	broadcast=False,
	raw=False,
	reduce=None/True/False,
	args=(),
	**kwargs)

说明：对df1沿轴方向labels应用func
- 可以用于DFGB对象
  - 为聚合函数时返回DF对象Index为groupby键，类似于 agg
  - 非聚合函数时返回DF对象为原Index，类似于 transform，但包含用于groupby的label
  - 但是此时其他参数无法使用，func也仅能为单一 function，而agg可以使用各种
参数
- broadcast：仅对aggregation（聚合）函数，默认不保持原shape
  - 0.23.0 deprecated
- raw：默认不是将label作为ndarray对象传递，而是保持 Series对象
  - 如果函数处理nadarry对象，True性能更好
- reduce：默认根据函数判断是否返回DF
  - False：尽量返回DF对象
  - 0.23.0 deprecated
- result_type
  - expand：返回DF对象
  - reduce：尽量返回Ser对象
  - broadcast：保持原shape返回
  - 0.23.0 new
- args：传递给func的VAR_POSITIONs
- kwargs：传递给func的VAR_KEYWORDs

`agg`

DF = df1.agg(
	func(callable/"func_name"(str)/{label:func}/[],
	axis=0/1/"index"/"columns",
	*args,
	**kwargs)

说明：聚合
- 可以用于DFGB，必然返回DF，因此要求函数结果必须聚合
  - 如果分组结果都只有单个label，函数可以非聚合
  - 如果分结果中由多label分组，函数必须聚合
参数
- func
  - dict键应为column labels，值为function

`transform`

DF = df1/dfgb1.transform(
	func(callable/"func_name"(str)/dict/[]),
	*args,
	**kwargs)

说明：返回应用func处理后DF
- 应用于DF对象时，等同于axis=0的agg、apply
- 应用于DFGB对象时，无价值，和应用于原DF对象结果一样，仅剔除groupby label

替换

`replace`

DF = df1.replace(
	to_replace=None/str/regex/num/[]/{}/Series,
	value=None/str/num/[]/{},
	inplace=False,
	limit=None/int,
	regex=False,
	method="pad"/"ffill"/"bfill"/"backfill")

说明：替换
参数
- to_replace：被替换对象
  - str/regex/num：匹配str/regex/num的值被替换为value
  - [ ]
    - value也为list时，长度必须相同
    - str元素可看作regex
  - {}
    - nested dict顶层键匹配列label，然后应用对应子dict进行匹配（此时包含value功能）
    - 非顶层键可以为regex
  - None：此时regex必为str/[]/{}/Ser
- value：替换值
  - str/num：替换值
  - {}：键匹配列label然后替换值，无匹配保持原样
  - [ ]：长度必须和to_replace相同
- limit：允许最长连续bfill、ffill替换
- regex
  - 为True时，to_replace、value将作为regex
  - 代替to_replace作regex替换
- method：to_replace为list时替换方法
说明
- to_replace为{regex:str}时，只替换DF中str匹配的部分，如果需要替换整个str，需要^.*str.*$匹配整个str
- 但为{regex:int}时，不需要^.*str.*$也会匹配整个str 并替换为int

`where`

df = df1.where(
	cond(df(bool)/callable/[]),
	other=num/df/callable,
	inplace=false,
	axis=none,
	level=none,
	errors="raise",
	try_cast=False,
	raise_on_error=None)

说明：mask True，替换False为other值，默认（other 中无法找到对应值）NaN
- cond、other是按照[index][col]对应位置，而不是打印位置
参数
- cond
  - DF(bool)：True保持原值不变，False从other 替换
  - callable：应用在df1上，返回DF(bool)，不应改变 `df
  - cond不提供位置视为被替换1`
- other
  - num：替换为num
  - DF：替换值
  - callable：应用在df1上，返回DF用于替换
- axis：alignment axis if needed
- level：alignemnt level if needed
- errors
  - raise：允许raise exceptions
  - ignore：suppress exceptions，错误时返回原对象
- try_cast：默认不尝试将结果cast为原输入

`mask`

DF = df1.mask(
	cond(DF(bool)/callable/[]),
	other=num/DF/callable,
	inplace=False,
	axis=None,
	level=None,
	errors="raise",
	try_cast=False,
	raise_on_error=None)

说明：True、False mask规则同where相反，其他同

筛选

`isin`

1 2	DF = df1.isin( values(iterable/{}/DF))

说明：判断元素是否存在于values中
参数
- values
  - iterable：元素在iterable中为True
  - {}：df1元素在dict中对应键值中存在为True
  - DF：df1元素在DF对应index、columns labels存在才为True

类型转换

`to_numeric`


Ser = pd.to_numeric(
	arg([]/()/ndarray(1d)/Ser),
	errors="Raise"/"ingore"/"coerce",
	downcast=None/"integer"/"signed"/"unsigned"/"float")

说明：转换为numeric类型
参数
- errors
  - raise：无效值将raise exception
  - coerce：无效值设为NaN
  - ignore：无效值保持原样
- downcast：根据参数downcast值为“最小”类型
  - downcast过程中exception不受errors影响

`to_datetime`

Ser = pd.to_datetime(
	arg(int/float/str/datetime/[]/()/ndarray(1d)/Ser/DF,
	error="Raise"/"ignore"/"coerce",
	dayfirst=False,
	yearfirst=False,
	utc=None/True,
	box=True/False,
	format=None/str,
	exact=True,
	unit="ns"/"D"/"s"/"ms"/"us"/"ns",
	infer_datatime_format=False,
	origin="unit")

说明：转换为datetime
参数
- dayfirst：处理类”10/11/12”，设置day在前
- yearfirst：处理类”10/11/12”，设置year在前
- utc：默认不返回UTC DatatimeIndex
- box
  - True：返回DatetimeIndex
  - False：返回ndarray值
- format：parse格式，如”%d/%m/%y %H:%M:%S”
- exact：默认要求arg精确匹配format
- unit：arg传递数值时作为单位
- infer_datatime_format：在format为None时，尝试猜测格式，并选择最快的方式parse，耗时5~10倍
- origin：决定参考（起始）时间
  - unix：起始时间：1970-01-01
  - julian：4714 BC 1.1（此时unit必须为D）

`infer_objects`

1	DF = df1.infer_objects()

说明：soft转换数据类型，无法转换保持原样

`astype`

DF = df.astype(
	dtype(dtype/{col_name:dtype}),
	copy=True,
	errors="raise"/"ingore",
	**kwargs)

说明：强制转换为dtype类型
参数
- copy：默认返回拷贝
- kwargs：传递给构造函数的参数

Ser

`map`

1
2
3

Ser = ser1.map(
	arg={}/Ser/callable,
	na_action=None/"ignore")

说明：对Ser中元素进行映射
- map对无法配置（dict）返回None而不是保持不变
参数
- arg
  - {}：对Ser中值根据键值对映射
  - callable：对元素应用callable
- no_action：默认对NA也处理，否则忽略
其他
- 好像默认会应用类似于apply(convert_type=True)，如直接取值是np.float64类型，传给函数就变成了float 类型

`apply`

Ser = ser1.apply(
	func(callable/{}/[]),
	convert_type=True/False,
	args=(),
	**kwargs)

说明：在Ser上应用func
参数
- func
  - {}：返回多重索引Ser，键作为顶层索引，不是对不同值应用不同方法
  - [ ]：返回DF对象，列labels根据list元素命令，list 元素不能聚合、非聚合混合
- convert_type：默认转换为合适的类型，否则设为 dtype=object

`agg`

Ser = ser1.agg(
	func(callable/{}/[]),
	axis=0,
	args=(),
	**kwargs)

说明：好像和apply完全相同，只是参数不同，但axis没用

分组

`cut`

Ser = pd.cut(
	x(array-like),
	bins(int/[num]/IntervalIndex),
	right=True,
	labels=None/[],
	retbins=False,
	precision=3/int,
	include_lowest=False)

说明：返回各个元素所属区间，同时也是对应indice
参数
- bins：左开右闭
  - int：将x等分（事实上为了包含最小值，bins 左边界会扩展.1%）
  - [num]：定义bins边界
- right：默认包含right-most边界
- labels：指定生成bins的labels
- retbins：默认不返回bins，设为True将返回tuple
- precision：bins labels显示精度
- include_lowest：第一个bin是否应该包括最小值
  - 应该仅对bins=[]有效
  - 设为True仍然为左开右闭区间，但是左边界会小于 bins=[]中的最小值

`qcut`

Ser = pd.qcut(
	x(array-like),
	q=int/quantile_list,
	labels=None,
	retbins=False,
	precision=3,
	duplicates="Raise"/"drop")

说明：将x按照q划分分位数后进组（即按照数量分组）
参数
- q
  - int：划分int个等分位数
  - [num]：将x元素按照给出分位数分组
- duplicates
  - raise：bins边缘不唯一raise exception
  - drop：bins边缘不唯一则丢弃不唯一值

`groupby`

DFGB = df1.groupby(
	by(col_name),
	axis=0,
	level=None,
	as_index=True,
	sort=True,
	group_keys=True,
	squeeze=False,
	**kwargs)

说明：根据by对DF分组
参数
- by
  - func：应用于DF的Index上，结果作分组依据
  - dict/Ser：对Index作映射，映射结果作分组依据
  - array-like：其值依顺序标记DF行，据此分组，因此要求长度必须和DF行数相同
  - col_name/[col_name]：根据col_name分组
- as_index：默认使用分组依据作为分组Index（labels）
- sort：默认组内各保持原DF顺序，可以关闭获得更好性能
- group_keys：默认在calling apply时，添加group键用于标识各组
- squeeze：为True时尽可能减少返回值维度，否则返回 consistent type

Index

Index值

`pivot`

DF = df1.pivot(
	index=None/str,
	columns=None/str,
	values=None/str)

说明：根据某列值reshape数据（创建一个枢）
参数
- index：用作Index的列名，默认Index
- columns：用作Column的列名
- values：填充进新DF对象的列名，默认所有剩余所有列（列索引为层级索引）
其他
- 但是如果选取的两列元素两两组合有重复回报错

`set_index`

DF = df1.set_index(
	keys(col_name/[ ]/[col_names,[ ]]),
	drop=True,
	append=False,
	inplace=False,
	verify_integrity=False)

说明：用一列/多列作为新DF的Index（row labels）
参数
- keys：列名，列名列表
- drop：默认删除用作Index的列
- append：默认不保留原Index（不以添加方式设置 Index）
- verify_integrity：默认不检查新Index是否唯一，直至必要的时候

`reset_index`

DF = df1.reset_index(
	level=None/int/str/[int, str],
	drop=False,
	inplace=False,
	col_level=0/int/str,
	col_fill='')

说明：
参数
- level：默认所有层级
- drop：默认将Index作为一列添加
- col_level：Index作为列添加进的列索引层次，默认最高层
- col_fill：对于多级索引，Index作为列添加时其他层级的命名，默认xtts
其他
- Index作为新列的名称默认为”index”/“level_0”、 “level_1”等

Index属性

`swaplevel`

DF = df.swaplevel(
	i=-2/int/str,
	j=-1/int/str,
	axis=0)

说明：交换i、j两层索引

`rename`

DF = df.rename(
	mapper=None/dict/func,
	index=None/dict/func,
	columns=None/dict/func,
	axis=0/1/"index"/"columns",
	copy=True,
	inplace=False,
	level=None/int/str)

说明：修改labels（行、列名）
参数
- mapper：labels的重命名规则
- index/columns：行、列labels重命名规则
  - mapper+axis
  - index
  - columns
- copy：默认复制数据
  - inplace为True时，此参数无效
- level：默认重命名所有level

`add_prefix`

1 2	DF = df.add_prefix( prefix(str))

说明：为列labels添加前缀

特殊值

重复

`unique`

bool = ser1.is_unique
	# 无重复元素**属性**为`True`
Ser = ser1.unique()
	# 返回非重复元素

`duplicated`

1
2
3

Ser(bool) = df1.duplicated(
	subset=None/label/[labels],
	keep="First"/"last"/False)

说明：返回标识“副本（元素相同）”行的Ser(bool)
参数
- subset：默认检查所有列，否则检查指定列
- keep
  - first：重复者除第一个外标记为True
  - last：重复者除最后一个外标记为True
  - False：重复者均标记为True

DF = df1.drop_duplicates(
	subset=None/label/[labels],
	keep="First"/"last"/False,
	inplace=False)

空

`null`

1 2	DF(bool) = df1.isnull() DF(bool) = df1.notnull()

`dropna`

DF = df1.dropna(
	axis=0/1,
	how="Any"/"all",
	thresh=None/int,
	subset=None/label/[labels],
	inplace=False)

说明：剔除空labels（及其数据）
参数
- how：默认any NaN值存在剔除label
- thresh：剔除label的NaN值阈值
- subset：指定考虑的labels

`fillna`

DF = df1.fillna(
	value=None/scalar/dict/Ser/DF,
	method=None/"backfill"/"bfill"/"pad"/"ffill",
	axis=0/1/"index"/"columns",
	inplace=False,
	limit=None/int,
	downcast=None/dict,
	**kwargs)

说明：填补NaN值
参数
- value：用于填补NaN的值，dict-like时无法找到的NaN 不被填补
- method
  - “pad”/“ffill”：使用last（前一个）值填补
  - “bfill”/“backfill”：使用next（后一个）值填补
- limit：填补允许的最大连续NaN值，超过部分保留NaN
- downcast：数据类型精度降级dict，或者"infer"由自行推断

其他

`any`

Ser = df1(bool).any(
	axis=0/1/"index"/"columns",
	bool_only=None,
	skipna=True,
	level=None/int/str,
	**kwargs)

说明：label（行、列）对应值存在真返回True
参数
- skipna：默认skip NA，如果全label为NA则结果为NA
- level：默认考虑整个索引
- bool_only：默认将所有转换为bool值再做判断

Keras配置文件

$HOME/.keras/keras.json

函数书写声明

Pyplot

配置文件matplotlibrc

配置文件路径

查看实际路径

中文问题

字符编码问题

字体文件缺失

管理单个图表

运行时配置MPL默认字体

修改MPL配置文件

图片显示

X11依赖

图像元素

Figure

Axes

Axies

说明

绘图

线图

柱状图

饼图

箱线图

配置文件

生成配置文件

修改配置文件

生成密文

远程访问

DataFrame

DF行列逻辑

获取数据

列优先

行优先

.loc[]

.iloc[]

.ix[]

行优先快速版本

切片

Values切片

Index切片

全切片

行切片

列切片

DF数据共享逻辑

Index 索引

MultiIndex 层级索引

from_arrays

from_tuples

from_product

常用参数说明

Session

Operators

TensorFlow基本概念

流程

组合计算图

在会话中执行图中操作

PyTF 模块

tf.nn

tf.contrib

tf.train

tf.summary

安装

CUDA、CUDNN、CUDAtookit、NVCC

TensorBoard

问题

指令集

Keras后端

切换后端

Keras后端抽象

配置相关函数

backend

epsilon

set_epsilon

floatx

set_floatx

cast_to_floatx

image_data_format

set_image_data_format

`$HOME/.keras/keras.json`

配置文件`matplotlibrc`

`.loc[]`

`.iloc[]`

`.ix[]`

`from_arrays`

`from_tuples`

`from_product`

`tf.nn`

`tf.contrib`

`tf.train`

`tf.summary`

`backend`

`epsilon`

`set_epsilon`

`floatx`

`set_floatx`

`cast_to_floatx`

`image_data_format`

`set_image_data_format`

`is_keras_tensor`

`get_uid`

`reset_uids`

`clear_session`

`manual_variable_initialization`

`learning_phase`

`set_learning_phase`

`is_sparse`

`to_dense`

`variable`

`placeholder`

`shape`

`int_shape`

`ndim`

`dtype`

`eval`

`ones`

`eye`

`zeros_like`

`ones_like`

`random_uniform_variable`

`count_params`

`cast`

`update`

`update_add`

`update_sub`

`moving_average_update`

`dot`

`batch_dot`

`transpose`

`gather`

`max`

`min`

`sum`

`prod`

`cumsum`

`cumprod`

`var`

`std`

`mean`

`any`

`all`

`argmax`

`argmin`

`square`

`abs`

`sqrt`

`exp`

`log`

`logsumexp`

`round`

`sign`

`pow`

`clip`

`equal`

`not_equal`