使用Pylearn2构建一个简单的分类器

http://blog.csdn.net/tangchenyi/article/details/25076093

使用Pylearn2构建一个简单的分类器

标签： Pylearn2Theano分类器Deep Learning

2014-05-05 22:22 1360人阅读 评论(1) 收藏 举报

 分类：

Machine Learning

版权声明：本文为博主原创文章，未经博主允许不得转载。

久闻Pylearn大名，最近由于某些原因，想拿Pylearn2来做做实验。Python这门神奇的语言几年前学过点皮毛，对于一个习惯使用C++/Java的人来说，使用Python简直就是一种折磨，特别是阅读别人的代码。这种弱类型语言最让人纠结的就是不好跟踪代码（应该是我不会跟踪）。不喜欢Python还有一个原因，Python虽有多线程，但是此多线程非彼多线程，不管你开多少个线程，它只使用CPU的一个核，多核对它来说完全没用，而且线程越多速度反而越慢。好了，不废话了，回归正题。

Pylearn2的安装及环境搭建这里就不赘述了，网上资料很多的。对Pylearn2的使用说明中文基本没有（反正我没搜到），英文的还是有一写的。为了节省新手（我也是）的时间，这里简单介绍一下使用Pylearn构建一个简单的分类器的方法，会了一个应该其他的就好办了，入门是关键。

本文基于pylearn2-practice进行介绍（之所以不根据Quick-start example来讲是因为它结构比较复杂，而且只有训练，没有预测部分，看了后还是不知道如何使用自己的数据，可能是本人智商不够）。

pylearn2-practice文件组织如下

├── adult
│   ├── test.csv
│   ├── test_v.csv
│   └── train_v.csv
├── adult_dataset.py
├── adult.yaml
├── predict.py
└── README.md

如何使用见README.md

我们先看看训练的配置文件adult.yaml

!obj:pylearn2.train.Train {   #使用类pylearn2.train.Train的实例来训练
    dataset: &train !obj:adult_dataset.AdultDataset { #使用adult_dataset.AdultDataset来提供训练数据
        path: 'adult/train_v.csv',  #训练数据文件路径
        one_hot: 1
    },
    
    model: !obj:pylearn2.models.softmax_regression.SoftmaxRegression { #选择模型, 可以选择的模型包括RBM, softmax_regression, SVM等等

        #具体参看http://deeplearning.net/software/pylearn2/features.html#features中的Models
        n_classes: 2,
        irange: 0.,
        nvis: 123,
    },


    algorithm: !obj:pylearn2.training_algorithms.bgd.BGD {#选择训练算法,具体参看

      #http://deeplearning.net/software/pylearn2/features.html#features中的Training algorithms
        batch_size: 10000,
        line_search_mode: 'exhaustive',
        conjugate: 1,
        monitoring_dataset:
            {
                'train' : *train,
                'valid' : !obj:adult_dataset.AdultDataset {
                              path: 'adult/test_v.csv',
                              one_hot: 1
                },
                'test'  : !obj:adult_dataset.AdultDataset {
                              path: 'adult/test.csv',
                              one_hot: 1
                }
            },
        termination_criterion: !obj:pylearn2.termination_criteria.MonitorBased {
            channel_name: "valid_y_misclass"
        }
    },
    
    extensions: [
        !obj:pylearn2.train_extensions.best_params.MonitorBasedSaveBest {
             channel_name: 'valid_y_misclass',
             save_path: "softmax_regression_best.pkl"
        },
    ],
    save_path: "softmax_regression.pkl", #训练得到的模型保存到softmax_regression.pkl这个文件
    save_freq: 1
    
}

细心的你可能会发现上面的配置文件其实是给类的构造函数指定参数, 事实上Pylearn2就是使用PyYAML根据上面配置信息实例化一个Train对象.

我们再看看adult_dataset.py

[python] view plain copy

 

1. import csv  
2. import numpy as np  
3. import os  
4.   
5. from pylearn2.datasets.dense_design_matrix import DenseDesignMatrix  
6. from pylearn2.utils import serial  
7. from pylearn2.utils.string_utils import preprocess  
8.   
9. class AdultDataset( DenseDesignMatrix ):  
10.   
11.     def __init__(self,   
12.             path = 'train.csv',  
13.             one_hot = False,  
14.             with_labels = True,  
15.             start = None,  
16.             stop = None,  
17.             preprocessor = None,  
18.             fit_preprocessor = False,  
19.             fit_test_preprocessor = False):  
20.   
21.   
22.         self.no_classes = 2  
23.   
24.         # won't work TODO  
25.         self.test_args = locals()  
26.         self.test_args['which_set'] = 'test'  
27.         self.test_args['fit_preprocessor'] = fit_test_preprocessor  
28.         del self.test_args['start']  
29.         del self.test_args['stop']  
30.         del self.test_args['self']  
31.           
32.         path = preprocess(path)  
33.         X, y = self._load_data( path, with_labels )  
34.   
35.   
36.         if start is not None:  
37.             assert which_set != 'test'  
38.             assert isinstance(start, int)  
39.             assert isinstance(stop, int)  
40.             assert start >= 0  
41.             assert start < stop  
42.             assert stop <= X.shape[0]  
43.             X = X[start:stop, :]  
44.             if y is not None:  
45.                 y = y[start:stop, :]  
46.   
47.   
48.         super(AdultDataset, self).__init__(X=X, y=y)  
49.   
50.         if preprocessor:  
51.             preprocessor.apply(self, can_fit=fit_preprocessor)  
52.   
53.     def _load_data(self, path, expect_labels):  
54.       
55.         assert path.endswith('.csv')  
56.       
57.         data = np.loadtxt( path, delimiter = ',', dtype = 'int' )  
58.           
59.         if expect_labels:  
60.             y = data[:,0]  
61.             X = data[:,1:]  
62.   
63.             # TODO: if one_hot  
64.             # 10 is number of possible y values  
65.             one_hot = np.zeros((y.shape[0], self.no_classes ),dtype='float32')  
66.             for i in xrange( y.shape[0] ):  
67.                 label = y[i]  
68.                 if label == 1:  
69.                     one_hot[i,1] = 1.  
70.                 else:  
71.                     one_hot[i,0] = 1.  
72.                   
73.             y = one_hot  
74.         else:  
75.             X = data  
76.             y = None  
77.   
78.         return X, y  

Adultataset继承于DenseDesignMatrix, 通过函数_load_data将训练/测试数据加载到X, y中, x基本没有变化, 但是y进行了相应的变换, 类别数决定了y的维数, 每一维代表一种类别,假如某条数据属于第N类,则y的第N维为1, 其他维为0(这里第N维从1开始计数,而不是从0开始计数). 然后将X, y赋给父类的X,y, 如果设置了preprocessor还需要执行preprocessor.

再看看predict.py.

[python] view plain copy

 

1. import sys  
2. import os  
3. from pylearn2.utils import serial  
4. from pylearn2.config import yaml_parse  
5. from adult_dataset import AdultDataset  
6.   
7. try:  
8.     model_path = sys.argv[1]  
9.     test_path = sys.argv[2]  
10.     out_path = sys.argv[3]  
11. except IndexError:  
12.     print "Usage: predict.py <model file> <test file> <output file>"  
13.     quit()  
14.   
15. try:  
16.     model = serial.load( model_path )  
17. except Exception, e:  
18.     print model_path + "doesn't seem to be a valid model path, I got this error when trying to load it: "  
19.     print e  
20.   
21.   
22. #dataset = yaml_parse.load( model.dataset_yaml_src )  
23. #dataset = dataset.get_test_set()  
24.   
25. # or maybe specify test in yaml  
26. dataset = AdultDataset( path = test_path, one_hot = True )  
27.   
28. # use smallish batches to avoid running out of memory  
29. batch_size = 100  
30. model.set_batch_size(batch_size)  
31.   
32. # dataset must be multiple of batch size of some batches will have  
33. # different sizes. theano convolution requires a hard-coded batch size  
34. m = dataset.X.shape[0]  
35. extra = batch_size - m % batch_size  
36. assert (m + extra) % batch_size == 0  
37. import numpy as np  
38. if extra > 0:  
39.     dataset.X = np.concatenate((dataset.X, np.zeros((extra, dataset.X.shape[1]),  
40.     dtype=dataset.X.dtype)), axis=0)  
41. assert dataset.X.shape[0] % batch_size == 0  
42.   
43.   
44. X = model.get_input_space().make_batch_theano()  
45. Y = model.fprop(X)  
46.   
47. from theano import tensor as T  
48.   
49. y = T.argmax(Y, axis=1)  
50.   
51. from theano import function  
52.   
53. f = function([X], y)  
54.   
55.   
56. y = []  
57.   
58. for i in xrange(dataset.X.shape[0] / batch_size):  
59.     x_arg = dataset.X[i*batch_size:(i+1)*batch_size,:]  
60.     if X.ndim > 2:  
61.         x_arg = dataset.get_topological_view(x_arg)  
62.     y.append(f(x_arg.astype(X.dtype)))  
63.   
64. y = np.concatenate(y)  
65. assert y.ndim == 1  
66. assert y.shape[0] == dataset.X.shape[0]  
67. # discard any zero-padding that was used to give the batches uniform size  
68. y = y[:m]  
69.   
70. class_mapping = { 0: -1, 1: 1 }  
71.   
72. out = open(out_path, 'w')  
73. for i in xrange(y.shape[0]):  
74.     p = y[i]  
75.     p = class_mapping[p]  
76.     out.write( '%d\n' % ( p ))  
77. out.close()  

第一步从测试数据文件中获取数据dataset = AdultDataset( path = test_path, one_hot = True ), 

然后就是对测试数据分批次(如果测试数据不是特别多, 内存够大的话就没必要分批次), 

接着是构建 Theano function(深入了解见Theano说明文档)

X = model.get_input_space().make_batch_theano()  #X为输入的特征
Y = model.fprop(X)  #fprop(x)使用模型预测

from theano import tensor as T

y = T.argmax(Y, axis=1)
from theano import function

f = function([X], y)

 然后就是调用 f 对 x 进行预测了

到这里,分类器构建完成, 这么看来,其实还是蛮简单的, 虽然简单,但是我可是花了大半天的功夫, 一开始花了大量时间看Quick-start example(结果还是一头雾水).由此说明一篇好的文档非常重要, 不然你就慢慢去摸索吧.

感谢zygmuntz的无私奉献