AttributeError: ‘SVC’ object has no attribute ‘_impl’

[Sklearn error: ‘SVR’ object has no attribute ‘_impl’] (https://stackoverflow.com/questions/19089386/sklearn-error-svr-object-has-no-attribute-impl)
0.14.1 SVC issue

Mostly, this error is caused by improper version of scikit-learn.
For example, you trained one model using scikit-learn with version of 0.1. However, you updated your packages to 0.2 after training.
When you using joblib.load to load the model file, it will throws out this error since pickle can’t recognize which version.

AttributeError: Can’t pickle local object ‘SOME_OBJECT_OR_FUNC’

I met this error when I tried to use GridSearchCV to find best hyper-parameter.
I checked my configuration and found when I set the parameter n_jobs to -1 which means run parallelly, it will throw out this error.

gs = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=1, cv=cv)

It seems that when using multiprocessing to run estimator parallely, the pickle cannot serialize the object(e.g nested function).

Can’t pickle nested function in FeatureExtracter
Python: pickling nested functions

机器学习中的概念总结

Cliff & Flat Regions

Cliff and Flat regions in the parameter space of neural network
Cliff and Flat regions in the parameter space of neural network.
θ and γ are two parameters and L(θ, γ) is the loss function. The region with light color is a cliff and the region with dark color is a flat region.

Whiten

在深度学习训练中,白化(Whiten)是加速收敛的一个小Trick,所谓白化是指将图像像素点变化到均值为0,方差为1的正态分布。

Dropout

Batch Normalization

Weight Normalization

Local Minima

局部最小值

Ablation Study

2
消融研究,指通过移除某个模型或者算法的某些特征,来观察这些特征对模型效果的影响
实际上ablation study就是为了研究模型中所提出的一些结构是否有效而设计的实验。比如你提出了某某结构,但是要想确定这个结构是否有利于最终的效果,那就要将去掉该结构的网络与加上该结构的网络所得到的结果进行对比,这就是ablation study

An ablation study typically refers to removing some “feature” of the model or algorithm, and seeing how that affects performance.

Examples:

An LSTM has 4 gates: feature, input, output, forget. We might ask: are all 4 necessary? What if I remove one? Indeed, lots of experimentation has gone into LSTM variants, the GRU being a notable example (which is simpler).
If certain tricks are used to get an algorithm to work, it’s useful to know whether the algorithm is robust to removing these tricks. For example, DeepMind’s original DQN paper reports using (1) only periodically updating the reference network and (2) using a replay buffer rather than updating online. It’s very useful for the research community to know that both these tricks are necessary, in order to build on top of these results.
If an algorithm is a modification of a previous work, and has multiple differences, researchers want to know what the key difference is.
Simpler is better (inductive prior towards simpler model classes). If you can get the same performance with two models, prefer the simpler one.

Sharp Minimal

尖锐最小值
Yoshua Bengio 组在2017年发表文章Sharp Minima Can Generalize For Deep Nets介绍了在深度神经网络中尖锐的最小值也可以让模型具有泛化能力.

Internal Covariate Shift – ICS

Python中的继承机制 MRO 和 C3

继承关系顺序的不同

通过一个例子来说明继承关系顺序的不同.
在两端代码中, 分别使用显示调用父类初始化方法和super机制进行初始化操作.
继承关系图
显示调用父类初始化方法

class A:
    def __init__(self):
        print("Enter A")
        print("Leave A")

class B(A):
    def __init__(self):
        print("Enter B")
        A.__init__(self)
        print("Leave B")

class C(A):
    def __init__(self):
        print("Enter C")
        A.__init__(self)
        print("Leave C")

class D(A):
    def __init__(self):
        print("Enter D")
        A.__init__(self)
        print("Leave D")

class E(B, C, D):
    def __init__(self):
        print("Enter E")
        B.__init__(self)
        C.__init__(self)
        D.__init__(self)
        print("Leave E")

E()

运行上述代码, 得到的输出是

Enter E
Enter B
Enter A
Leave A
Leave B
Enter C
Enter A
Leave A
Leave C
Enter D
Enter A
Leave A
Leave D
Leave E

super机制

class A:
    def __init__(self):
        print("Enter A")
        print("Leave A")

class B(A):
    def __init__(self):
        print("Enter B")
        super(B, self).__init__()
        print("Leave B")

class C(A):
    def __init__(self):
        print("Enter C")
        super(C, self).__init__()
        print("Leave C")

class D(A):
    def __init__(self):
        print("Enter D")
        super(D, self).__init__()
        print("Leave D")

class E(B, C, D):
    def __init__(self):
        print("Enter E")
        super(E, self).__init__()
        print("Leave E")

E()

运行上述代码, 得到的输出是

Enter E
Enter B
Enter C
Enter D
Enter A
Leave A
Leave D
Leave C
Leave B
Leave E

由上述的例子可以得出, 在涉及多继承时, super机制可以保证公共父类仅被执行一次,至于执行的顺序,是按照mro进行的(E.mro).

Python 多重继承mro
文档 : The Python 2.3 Method Resolution Order
Python Tutorial: Understanding Python MRO – Class search path

什么是MRO?

MROmethod resolution order,主要用于在多继承时判断调的属性的路径(来自于哪个类). 在Python2.3之前是基于此算法,但从Python2.3起应用了新算法:C3算法。

为什么采用C3算法

C3算法最早被提出是用于Lisp的,应用在Python中是为了解决原来基于深度优先搜索算法不满足本地优先级,和单调性的问题。
本地优先级:指声明时父类的顺序,比如C(A,B),如果访问C类对象属性时,应该根据声明顺序,优先查找A类,然后再查找B类。
单调性:如果在C的解析顺序中,A排在B的前面,那么在C的所有子类里,也必须满足这个顺序。
在Python官网的The Python 2.3 Method Resolution Order中作者举了例子,说明这一情况。

F=type(‘Food’, (), {remember2buy:’spam’})
E=type(‘Eggs’, (F,), {remember2buy:’eggs’})
G=type(‘GoodFood’, (F,E), {})
根据本地优先级在调用G类对象属性时应该优先查找F类,而在Python2.3之前的算法给出的顺序是G E F O,而在心得C3算法中通过阻止类层次不清晰的声明来解决这一问题,以上声明在C3算法中就是非法的。

C3算法

判断mro要先确定一个线性序列,然后查找路径由由序列中类的顺序决定。所以C3算法就是生成一个线性序列。
如果继承至一个基类:
class B(A)
这时B的mro序列为[B,A]

如果继承至多个基类
class B(A1,A2,A3 …)
这时B的mro序列 mro(B) = [B] + merge(mro(A1), mro(A2), mro(A3) …, [A1,A2,A3])
merge操作就是C3算法的核心。
遍历执行merge操作的序列,如果一个序列的第一个元素,在其他序列中也是第一个元素,或不在其他序列出现,则从所有执行merge操作序列中删除这个元素,合并到当前的mro中。
merge操作后的序列,继续执行merge操作,直到merge操作的序列为空。
如果merge操作的序列无法为空,则说明不合法。

例子:
class A(O):pass
class B(O):pass
class C(O):pass
class E(A,B):pass
class F(B,C):pass
class G(E,F):pass

A、B、C都继承至一个基类,所以mro序列依次为[A,O]、[B,O]、[C,O]
mro(E) = [E] + merge(mro(A), mro(B), [A,B])
= [E] + merge([A,O], [B,O], [A,B])
执行merge操作的序列为[A,O]、[B,O]、[A,B]
A是序列[A,O]中的第一个元素,在序列[B,O]中不出现,在序列[A,B]中也是第一个元素,所以从执行merge操作的序列([A,O]、[B,O]、[A,B])中删除A,合并到当前mro,[E]中。
mro(E) = [E,A] + merge([O], [B,O], [B])
再执行merge操作,O是序列[O]中的第一个元素,但O在序列[B,O]中出现并且不是其中第一个元素。继续查看[B,O]的第一个元素B,B满足条件,所以从执行merge操作的序列中删除B,合并到[E, A]中。
mro(E) = [E,A,B] + merge([O], [O])
= [E,A,B,O]

同理
mro(F) = [F] + merge(mro(B), mro(C), [B,C])
= [F] + merge([B,O], [C,O], [B,C])
= [F,B] + merge([O], [C,O], [C])
= [F,B,C] + merge([O], [O])
= [F,B,C,O]

mro(G) = [G] + merge(mro[E], mro[F], [E,F])
= [G] + merge([E,A,B,O], [F,B,C,O], [E,F])
= [G,E] + merge([A,B,O], [F,B,C,O], [F])
= [G,E,A] + merge([B,O], [F,B,C,O], [F])
= [G,E,A,F] + merge([B,O], [B,C,O])
= [G,E,A,F,B] + merge([O], [C,O])
= [G,E,A,F,B,C] + merge([O], [O])
= [G,E,A,F,B,C,O]

Keras和Tensorflow的区别

Keras 简介

Keras 是一个高级的Python 神经网络框架, 中/英文文档分别在中文文档 英文文档 .
Keras 已经被添加到 TensorFlow 中, 成为其默认的框架, 为TensorFlow 提供更高级的API.

如果读者不想了解TensorFlow 的细节, 只需要模块化, 那么Keras 是一个不错的选择. 如果将TensorFlow 比喻为编程界的Java 或C++, 那么Keras 就是编程界的Python. 它作为 TensorFlow 的高层封装, 可以与TensorFlow 联合使用, 用它很速搭建原型.

另外, Keras 兼容两种后端, 即 TheanoTensorFlow, 并且其接口形式和Torch 有几分相像. 掌握Keras 可以大幅提升对开发效率和网络结构的理解.

Keras 的优点

Keras 是高度封装的, 非常适合新手使用, 代码更新速度比较快, 示例代码也比较多, 文档和讨论区也比较完善. 最重要的是, Keras 是TensorFlow 官方支持的. 当机器上有可用的GPU时, 代码会自动调用GPU 进行并行计算.

Keras 官方网站上描述了它的几个优点, 具体如下.
– 模块化:模型的各个部分, 如神经层、成本函数、优化器、初始化、激活函数、规范化都是独立的模块, 可以组合在一起来创建模型.
– 极简主义:每个模块都保持简短和简单.
– 易扩展性:很容易添加新模块, 因此Keras 适于做进一步的高级研究.
– 使用Python 语言:模型用Python 实现, 非常易于调试和扩展.

Keras 的模型

Keras 的核心数据结构是模型. 模型是用来组织网络层的方式. 模型有两种, 一种叫 Sequential, 另一种叫 Model.

Sequential 模型是一系列网络层按顺序构成的栈, 是单 输入和单输出的, 层与层之间只有相邻关系, 是最简单的一种模型.
Model 模型可以用来建立更复杂的模型.

这里先介绍简单的Sequential 模型的使用(后面将会以一个示例来介绍Model 模型).

首先是加载数据, 这里我们假设数据已经加载完毕, 是X_train, Y_train 和X_test, Y_test. 然后构建模型:

from keras.models import Sequential
from keras.layers import Dense, Activation
model = Sequential()
model.add(Dense(output_dim=64, input_dim=100))
model.add(Activation(“relu”))
model.add(Dense(output_dim=10))
model.add(Activation(“softmax”))

然后, 编译模型, 同时指明损失函数和优化器:

model.compile(loss=’categorical_crossentropy’, optimizer=’sgd’, metrics=[‘accuracy’])

最后, 训练模型和评估模型:

model.fit(X_train, Y_train, nb_epoch=5, batch_size=32)
loss_and_metrics = model.evaluate(X_test, Y_test, batch_size=32)

这就是一个最简单的模型的使用.
如果要搭建复杂的网络, 可以使用Keras 的 Model 模型, 它能定义多输出模型、含有共享层的模型、共享视觉模型、图片问答模型、视觉问答模型等.

在Keras 的源代码的 examples 文件夹里还有更多的例子, 有兴趣的读者可以参参.

Keras 的使用

我们下载Keras 代码到本地目录, 将下载后的目录命名为keras.

Keras 源代码中包含很多示例, 例如:
– CIFAR10—图片分类(使用CNN 和实时数据)
– IMDB—电影评论观点分类(使用LSTM);
– Reuters—新闻主题分类(使用多层感知器);
– MNIST—手写数字识别(使用多层感知器和CNN);
– OCR—识别字符级文本生成(使用LSTM).

这里我们主要用MNIST 示例进行讲解.

安装

Keras 的安装非常简单, 不依赖操作系统, 建议大家直接通过pip 命令安装:

pip install keras

安装完成后, 需要选择依赖的后端, 在~/.keras/keras.json 下修改最后一行backend 对应的值即可. 修改后的文件如下:

{
“image_dim_ordering”: “tf”,
“epsilon”: 1e-07,
“floatx”: “float32”,
“backend”: “tensorflow”
}

实现一个网络模型

模型主要分为 加载数据、模型构建、模型编译、模型训练、模型评估或者模型预测几步. 下面我们就用最简单的MNIST 示例来看如何用Keras 实现一个卷积神经网络(CNN).

首先, 定义好一参数以及加载数据, 如下:

batch_size = 128
nb_classes = 10 # 分类数
nb_epoch = 12 # 训练轮数
# 输入图片的维度
img_rows, img_cols = 28, 28
# 卷积滤镜的个数
nb_filters = 32
# 最大池化, 池化核大小
pool_size = (2, 2)
# 卷积核大小
kernel_size = (3, 3)
(X_train, y_train), (X_test, y_test) = mnist.load_data()
if K.image_dim_ordering() == ‘th’:
    # 使用Theano 的顺序:(conv_dim1, channels, conv_dim2, conv_dim3)
    X_train = X_train.reshape(X_train.shape[0], 1, img_rows, img_cols)
    X_test = X_test.reshape(X_test.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)
else:
    # 使用TensorFlow 的顺序:(conv_dim1, conv_dim2, conv_dim3, channels)
    X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1)
    X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)

X_train = X_train.astype(‘float32’)
X_test = X_test.astype(‘float32’)
X_train /= 255
X_test /= 255
# 将类向量转换为二进制类矩阵
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)

下面来构建模型, 这里用2 个卷积层、1 个池化层和2 个全连接层来构建, 如下:

model = Sequential()
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1], border_mode=’valid’, nput_shape=input_shape))
model.add(Activation(‘relu’))
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1]))
model.add(Activation(‘relu’))
model.add(MaxPooling2D(pool_size=pool_size))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation(‘relu’))
model.add(Dropout(0.5))
model.add(Dense(nb_classes))
model.add(Activation(‘softmax’))

随后, 用model.compile()函数编译模型, 采用多分类的损失函数, 用Adadelta 算法做优化
方法, 如下:

model.compile(loss=’categorical_crossentropy’, 
                        optimizer=’adadelta’, 
                        metrics=[‘accuracy’])

然后, 开始用model.fit()函数训练模型, 输入训练集和测试数据, 以及batch_size 和nb_epoch 参数, 如下:

model.fit(X_train, Y_train, batch_size=batch_size,
                nb_epoch=nb_epoch, verbose=1, 
                validation_data=(X_test, Y_test))

最后, 用model.evaluate()函数来评估模型, 输出测试集的损失值和准确率, 如下:

score = model.evaluate(X_test, Y_test, verbose=0)
print(‘Test score:’, score[0])
print(‘Test accuracy:’, score[1])

计算出的损失值和准确率如下:

Test score: 0.0327563833317
Test accuracy: 0.9893

这是一个非常简单的例子. 尽管模型架构是不变的, 但是读者要将其应用到自己的开发领域, 一般是先读懂对应的神经网络论文, 然后用这个架构去搭建和训练模型.

模型的加载及保存

Keras 的 save_modelload_model 方法可以将Keras 模型和权重保存在一个HDF5文件中, 这里面包括模型的结构、权重、训练的配置(损失函数、优化器)等. 如果训练因为某种原因中断, 还可以从模型文件中重新加载对应变量和模型结构.

import ...

model = Sequential()
model.add(Dense(2, input_dim=3))
model.add(RepeatVector(3))
model.add(TimeDistributed(Dense(3)))
model.compile(loss=objectives.MSE,
                        optimizer=optimizers.RMSprop(lr=0.0001),
                        metrics[metrics.categorical_accuracy],
                        sample_weight_mode=’temporal’)

x = np.random.random((1, 3))
y = np.random.random((1, 3, 3))
model.train_on_batch(x, y)
out = model.predict(x)
_, fname = tempfile.mkstemp(‘.h5’) # 创建一个HDF5 文件
save_model(model, fname) # 将模型存储在fname文件中.

# 从fname文件中重载模型
new_model = load_model(fname)
os.remove(fname)
out2 = new_model.predict(x) # 预测新结果
assert_allclose(out, out2, atol=1e-05) # 判断新结果和之前结果一致

# 检测新保存的模型和之前定义的模型是否一致
x = np.random.random((1, 3))
y = np.random.random((1, 3, 3))
model.train_on_batch(x, y)
new_model.train_on_batch(x, y)
out = model.predict(x)
out2 = new_model.predict(x)
assert_allclose(out, out2, atol=1e-05)

如果只是希望保存模型的结构, 而不包含其权重及训练的配置(损失函数、优化器), 可 以使用下面的代码将模型序列化成 json 或者 yaml 文件:

json_string = model.to_json()
json_string = model.to_yaml()

保存完成后, 还可以手动编辑, 并且使用如下语句进行加载:

from keras.models import model_from_json
model = model_from_json(json_string)
model = model_from_yaml(yaml_string)

如果仅需要保存模型的权重, 而不包含模型的结构, 可以使用 save_weightsload_weights 语句来保存和加载:

model.save_weights(‘my_model_weights.h5’)
model.load_weights(‘my_model_weights.h5’)

转载自 TensorFlow框架–Keras使用

三体读后感

程心被维德制止的时候, 维德可能知道些什么, 但是仍然没有告诉她, 而是把这个谜团悄悄的塞给了她.
直到最后在冥王星出发的时候, 程心才发现这个爆炸在眼前的谜团.
程心两次称为历史的罪人, 维德都是与之关系密切的人.
可以看出来, 维德是真正了解未来方向的人. 即使他不知道哪条路是对的 ,但是他的直觉很准, 手段很狠.
程心最后还是遇到了比死更难受的事.

Difference between sparse_softmax_cross_entropy_with_logits and softmax_cross_entropy_with_logits

Answer from < Olivier Moindrot >
Having two different functions is a convenience, as they produce the same result.

The difference is simple:
For sparse_softmax_cross_entropy_with_logits, labels must have the shape [batch_size] and the dtype int32 or int64. Each label is an int in range [0, num_classes-1].
For softmax_cross_entropy_with_logits, labels must have the shape [batch_size, num_classes] and dtype float32 or float64.

Labels used in softmax_cross_entropy_with_logits are the one hot version of labels used in sparse_softmax_cross_entropy_with_logits.

Another tiny difference is that with sparse_softmax_cross_entropy_with_logits, you can give -1 as a label to have loss 0 on this label.

Answer from < 全意 >
sparse_softmax_cross_entropy_with_logits中 lables接受直接的数字标签
如[1], [2], [3], [4] (类型只能为int32,int64)
softmax_cross_entropy_with_logits中 labels接受one-hot标签
如[1,0,0,0], [0,1,0,0],[0,0,1,0], [0,0,0,1] (类型为int32, int64)


What does global_step mean in tensorflow ?

global_step refers to the number of batches seen by the graph. Every time a batch is provided, the weights are updated in the direction that minimizes the loss. global_step just keeps track of the number of batches seen so far. When it is passed in the minimize() argument list, the variable is increased by one. Have a look at optimizer.minimize().

You can get the global_step value using tf.train.global_step(). Also handy are the utility methods tf.train.get_global_step or tf.train.get_or_create_global_step.

0 is the initial value of the global step in this context.
Answer from < maddin25 and martianwars >

global_step 指的是 graph 所看到的 batch 的数量. 如果 dataset 中包含100个数据, 而 batch_size 被设置为 10, 则每隔10个 batch 结束一个 epoch.
epoch 指的是遍历一遍 dataset.

FailedPreconditionError: Attempting to use uninitialized in Tensorflow

Web Solution

Answer from < mrry >

The FailedPreconditionError arises because the program is attempting to read a variable (named “Variable_1”) before it has been initialized. In TensorFlow, all variables must be explicitly initialized, by running their “initializer” operations. For convenience, you can run all of the variable initializers in the current session by executing the following statement before your training loop.

Answer from < Salvador Dali >

This exception is most commonly raised when running an operation that reads a tf.Variable before it has been initialized.

My Case

In my case, when I wrote the __init__ func in class Model, I claimed more variables after initialized the saver with tf.gloabl_variables(). It seems like :

import tensorflow as tf

class Model(object):
    def __init__(self, hparmas):
        self.hparams = hparmas
        """ some variables init """
        self.saver = tf.train.Saver(tf.global_variables(), max_to_keep = self.hparams.max_to_keep)
        self.init_embeddings()

    def init_embeddings(self):
        """ some variables init """

When saving variables, the saver does not realize other variable initialized in func init_embedding. Thus after restore step, these variables cannot be restored from ckpt files. When using them, it will throw FailedPreconditionError like tensorflow.python.framework.errors_impl.FailedPreconditionError: Attempting to use uninitialized value beta1_power in which the beta1_power is the unlucky one.