Beispiel #1
0
def predict(theta, input_size, hidden_size, num_classes, netconfig, lambda_,
            data):

    # extract the part which compute the softmax gradient
    softmax_theta = theta[0:hidden_size * num_classes].reshape(
        num_classes, hidden_size)

    # extract out the "stack"
    stack = params2stack(theta[hidden_size * num_classes:], netconfig)

    m = data.shape[1]
    a = [data]
    z = [np.array(0)]
    for s in stack:
        z.append(
            np.dot(s['w'], a[-1]) + np.matlib.repmat(s['b'], m, 1).transpose())
        a.append(sigmoid(z[-1]))

    pred = softmax.predict(softmax_theta, a[-1], num_classes, hidden_size)

    return pred
Beispiel #2
0
def main():
    fnameTrainIm = sys.argv[1]
    fnameTrainLb = sys.argv[2]
    fnameTestIm = sys.argv[3]
    fnameTestLb = sys.argv[4]

    # read training data and labels
    trainData, trainLabel = read(fnameTrainIm, fnameTrainLb)

    # initialize constants and parameters
    inputSize = 28 * 28
    numClasses = 10
    lam = 1e-4
    DEBUG = 0

    if DEBUG == 1:
        # compute difference between numerical gradient and computed grad on the subset
        subData, subLabel, subTheta, subPatchsize = subsample(
            trainData, trainLabel, rows, numClasses)
        subCost, subGrad = softmax.softmaxCost(subTheta, numClasses,
                                               subPatchsize, lam, subData,
                                               subLabel)
        numGrad, diff = numericalgrad(subTheta, numClasses, subPatchsize, lam,
                                      subData, subLabel, subGrad)
        print "The diff is", diff

    # train regression code
    thetaOpt = softmax.train(numClasses, inputSize, lam, trainData, trainLabel)

    # predict labels for test data
    testData, testLabel = read(fnameTestIm, fnameTestLb)
    pred = softmax.predict(thetaOpt, testData, numClasses, inputSize)

    # report accuracy of softmax regression
    accuracy = 100 * np.sum(testLabel == pred) / len(testLabel)
    print "Accuracy is {0:.2f}".format(accuracy)
    unlabeledData, trainData, trainLabels, testData, testLabels = GetDivideSets(
    )

    #step3 用无标签数据集训练自编码的特征
    theta = sparseAutoencoder.initiallize(hiddenSize, inputSize)
    [X,cost,d]=sop.fmin_l_bfgs_b(lambda (x) :sparseAutoencoder.sparseAutoencoderCost(x, inputSize, \
    hiddenSize, la, sparsityParam, beta, unlabeledData),x0=theta,maxiter=400,disp=1)
    W1 = X[0:hiddenSize * inputSize].reshape(hiddenSize, inputSize)
    W1 = W1.T
    opttheta = X

    #step4 获得有标签训练集的激活值并用来训练softmax分类器的权值
    trainImages = feedforward(opttheta, hiddenSize, inputSize, trainData)
    thetaSoftmax = softmax.initiallize(numClasses, hiddenSize)
    la = 1e-4
    [X, cost, d] = sop.fmin_l_bfgs_b(lambda (x): softmax.SoftmaxCost(
        trainImages, trainLabels, x, la, hiddenSize, numClasses),
                                     x0=thetaSoftmax,
                                     maxiter=100,
                                     disp=1)

    #step5 获得有标签测试集的激活值并且给出softmax分类准确率, 5分类的准确率应该在98%附近
    testImages = feedforward(opttheta, hiddenSize, inputSize, testData)
    optthetaSoftmax = X
    accuracy = softmax.predict(optthetaSoftmax, testImages, testLabels,
                               hiddenSize, numClasses)
    print accuracy

    #画出权值图像
    sparseAutoencoder.showimg(W1, hiddenSize, 28)
    hiddenSize = 200
    sparsityParam = 0.1
    la = 3e-3
    beta = 3

    #step2 获取无标签数据集, 有标签训练数据集, 有标签测试数据集
    unlabeledData, trainData, trainLabels, testData, testLabels = GetDivideSets()

    #step3 用无标签数据集训练自编码的特征
    theta = sparseAutoencoder.initiallize(hiddenSize, inputSize)
    [X,cost,d]=sop.fmin_l_bfgs_b(lambda (x) :sparseAutoencoder.sparseAutoencoderCost(x, inputSize, \
    hiddenSize, la, sparsityParam, beta, unlabeledData),x0=theta,maxiter=400,disp=1)
    W1 = X[0:hiddenSize*inputSize].reshape(hiddenSize, inputSize)
    W1 = W1.T
    opttheta = X

    #step4 获得有标签训练集的激活值并用来训练softmax分类器的权值
    trainImages = feedforward(opttheta, hiddenSize, inputSize, trainData)
    thetaSoftmax = softmax.initiallize(numClasses, hiddenSize)
    la = 1e-4
    [X,cost,d] = sop.fmin_l_bfgs_b(lambda (x) :softmax.SoftmaxCost(trainImages, trainLabels,x,la,hiddenSize,numClasses),x0=thetaSoftmax,maxiter=100,disp=1)

    #step5 获得有标签测试集的激活值并且给出softmax分类准确率, 5分类的准确率应该在98%附近
    testImages = feedforward(opttheta, hiddenSize, inputSize,          testData)
    optthetaSoftmax = X
    accuracy = softmax.predict(optthetaSoftmax,testImages,testLabels,hiddenSize,numClasses)
    print accuracy

    #画出权值图像
    sparseAutoencoder.showimg(W1, hiddenSize, 28)
        pooledFeaturesThis = cnnPool(poolDim, convolvedFeaturesThis)
        pooledFeaturesTrain[featureStart:featureEnd, :, :, :] = pooledFeaturesThis
        convolvedFeaturesThis = cnnConvolve(patchDim, stepSize, testImages, Wt, bt, white, meanPatch)
        pooledFeaturesThis = cnnPool(poolDim, convolvedFeaturesThis)
        pooledFeaturesTest[featureStart:featureEnd, :, :, :] = pooledFeaturesThis

    cnnPooledFeatures = {}
    cnnPooledFeatures['pooledFeaturesTrain'] = pooledFeaturesTrain
    cnnPooledFeatures['pooledFeaturesTest'] = pooledFeaturesTest
    sio.savemat('cnnPooledFeatures.mat', cnnPooledFeatures)

    #step7 用卷积特征来进行softmax预测,这个就很快了,十几秒, 正确率为80%左右
    #Mat1 = sio.loadmat('cnnPooledFeatures.mat')
    #pooledFeaturesTrain = Mat1['pooledFeaturesTrain']
    #pooledFeaturesTest = Mat1['pooledFeaturesTest']
    softmaxLambda = 1e-4
    numClasses = 4
    inputSize = int(pooledFeaturesTrain.size/numTrainImages)
    print inputSize
    softmaxX = np.transpose(pooledFeaturesTrain, (0, 2, 3, 1))
    softmaxX = softmaxX.reshape(inputSize, numTrainImages)
    softmaxY = trainLabels
    theta = softmax.initiallize(numClasses, inputSize)
    [X,cost,d] = sop.fmin_l_bfgs_b(lambda (x) :softmax.SoftmaxCost(softmaxX, softmaxY, x, softmaxLambda, inputSize, numClasses),x0=theta,maxiter=200,disp=1)

    softmaxX = np.transpose(pooledFeaturesTest, (0, 2, 3, 1))
    softmaxX = softmaxX.reshape(inputSize, numTestImages)
    softmaxY = testLabels
    accuracy = softmax.predict(X,softmaxX,softmaxY,inputSize,numClasses)
    print accuracy
best_softmax = None
learning_rates = [1e-7, 5e-7]
regularization_strengths = [2.5e4, 5e4]

for lr in learning_rates:
    for rs in regularization_strengths:
        softmax = liner_classifiers_total.Softmax()

        loss_history = softmax.train(X_train,
                                     Y_train,
                                     lr,
                                     rs,
                                     num_iters=1500,
                                     batch_size=100,
                                     verbose=True)
        Y_train_pred = softmax.predict(X_train)
        train_accuracy = np.mean(Y_train == Y_train_pred)

        Y_val_pred = softmax.predict(X_val)
        val_accuracy = np.mean(Y_val == Y_val_pred)

        if val_accuracy > best_val:
            best_val = val_accuracy
            best_softmax = softmax
        results[(lr, rs)] = train_accuracy, val_accuracy

# print out result
for lr, reg in sorted(results):
    train_accuracy, val_accuracy = results[(lr, reg)]
    print('lr %e reg %e train accuracy: %f val accuracy: %f' %
          (lr, reg, train_accuracy, val_accuracy))
    feature, label = loadData(inputfile)
    feature = handleHistogram(feature)
    # print(np.shape(feature), np.shape(label))
    #print(feature)
    k = 256
    w0 = train(feature, label, k, 200000, 0.1)
    saveModel("weights.txt", w0)
    actual_x = []  # 绘制直线的x轴坐标
    predict_x = []  # 绘制预测值的x坐标
    for i in label:
        actual_x.append(int(i[0]))
        predict_x.append(i[0])
    actual_y = actual_x  # 直线的y坐标

    # 得到预测值
    predition = predict(feature, w0)
    m, n = np.shape(predition)
    error = np.mat(np.zeros((m)))
    predict_y = []  # 预测值的y坐标
    for i in predition:
        predict_y.append(i[0])
    color = np.arctan2(predict_y, predict_x)
    # 绘制散点图
    plt.scatter(predict_x, predict_y, s=10, c=color, alpha=1)
    # 设置坐标轴范围
    plt.xlim([0, 150])
    plt.ylim([0, 150])
    error[predict_y == actual_x] = 1
    print("correct rate:", np.sum(error) / m)
    plt.xlabel("actual value")
    plt.ylabel("prediction")
Beispiel #8
0
def main():
    """
    Step 0: Initialize parameter values for sparse autoencoder and softmax regression.
    """

    row_size = 28
    visible_size = row_size**2
    num_labels = 5
    hidden_size = 200
    rho = 0.1
    lambda_ = 3e-3
    beta = 3
    max_iter = 400

    debug = 0
    """
    Step 1: Load data from the MNIST database

    Load the training set data and sort the training data into labeled and unlabeled sets.
    """

    fIm = sys.argv[1]
    fLb = sys.argv[2]

    # read training data and labels
    data, label = read(fIm, fLb)

    # simulate a labeled and unlabeled set
    # set the numbers that will be used for the unlabeled versus labeled sets
    ixu = np.argwhere(label >= 5).flatten()
    ixl = np.argwhere(label < 5).flatten()

    # build a training and test set -> separate half the labeled set to use as test data
    numTrain = round(ixl.shape[0] / 2)  # half the examples in the set

    train_val = ixl[0:numTrain]
    test_val = ixl[numTrain:]

    unlabeled_set = label[ixu]
    unlabeled_data = data[:, ixu]

    train_data = data[:, train_val]
    train_set = label[train_val]

    test_data = data[:, test_val]
    test_set = label[test_val]

    print data.shape
    # output some statistics
    print "# of examples in unlabeled set: {0:6d}".format(len(unlabeled_set))
    print "# of examples in supervised training set: {0:6d}".format(
        len(train_set))
    print "# of examples in supervised test set: {0:6d}".format(len(test_set))
    """
    Optional Step: Test Sparse Autoencoder
    """
    if debug == 1:
        subdata, sublabel, sub_visible, sub_hidden = sparseAuto.subsample(
            train_data, train_set, row_size)

        sub_theta = sparseAuto.initializeParameters(sub_hidden, sub_visible)

        sub_grad, sub_cost = sparseAuto.costfun(sub_theta, sub_visible,
                                                sub_hidden, lambda_, rho, beta,
                                                subdata)

        numGrad, diff = sparseAuto.numgrad(sub_theta, sub_grad, sub_visible,
                                           sub_hidden, lambda_, rho, beta,
                                           subdata)

        print diff
    """
    Step 2: Train Sparse Autoencoder
    """

    print 'Step 2'
    opt_theta = sparseAuto.train(visible_size, hidden_size, lambda_, rho, beta,
                                 unlabeled_data)
    """
    Step 3: Extract Features from the Supervised Data Set
    """
    print 'Step 3'

    train_features = sparseAuto.autoencoder(opt_theta, hidden_size,
                                            visible_size, train_data)

    test_features = sparseAuto.autoencoder(opt_theta, hidden_size,
                                           visible_size, test_data)
    """
    Step 4: Train the softmax classifier
    """
    print 'Step 4'
    lam = 1e-4

    thetaOpt = softmax.train(num_labels, hidden_size, lam, train_features,
                             train_set)
    """
    Step 5: Testing softmax classfier
    """
    print 'Step 5'
    pred = softmax.predict(thetaOpt, test_features, num_labels, hidden_size)

    print pred[0:15]
    print test_set[0:15]
    # report accuracy of softmax regression
    accuracy = 100 * np.sum(test_set == pred) / len(test_set)
    print "Accuracy is {0:.2f}".format(accuracy)
Beispiel #9
0
def main():
    """
    Step 0: Initialization
    """
    # Initialize parameters for the exercise

    image_dim = 64
    image_channels = 3

    patch_dim = 8
    num_patches = 50000

    visible_size = patch_dim * patch_dim * image_channels
    output_size = visible_size
    hidden_size = 400

    epsilon = 0.1
    pool_dim = 19

    debug = 0
    """
    Step 1: Train a sparse autoencoder (with a linear decoder)
    """
    # load data from linear decoder exercise
    opt_theta = np.load('opt_theta.npy')
    zca_white = np.load('zca_white.npy')
    mean_patch = np.load('mean_patch.npy')

    # unpack W and b
    W = opt_theta[0:hidden_size * visible_size].reshape(
        hidden_size, visible_size)
    b = opt_theta[2 * hidden_size *
                  visible_size:2 * hidden_size * visible_size + hidden_size]
    """
    Step 2a: Implement convolution
    """
    # read in train data from mat file
    mat_contents = sio.loadmat('stlTrainSubset.mat')
    train_images = mat_contents['trainImages']
    train_labels = mat_contents['trainLabels']
    num_train_images = mat_contents['numTrainImages'][0][0]

    # read in test data from mat file
    mat_contents = sio.loadmat('stlTestSubset.mat')
    test_images = mat_contents['testImages']
    test_labels = mat_contents['testLabels']
    num_test_images = mat_contents['numTestImages'][0][0]

    # use only the first 8 images for testing
    conv_images = train_images[:, :, :, 0:8]

    # use only the first 8 images to test
    convolved_features = cnn.convolve(patch_dim, hidden_size, conv_images, W,
                                      b, zca_white, mean_patch)
    if debug == 1:
        """
        Step 2b: Check your convolution
        """

        for i in range(1000):
            feature_num = np.random.randint(0, hidden_size)
            image_num = np.random.randint(0, 8)
            image_row = np.random.randint(0, image_dim - patch_dim + 1)
            image_col = np.random.randint(0, image_dim - patch_dim + 1)
            patch = conv_images[image_row:image_row + patch_dim,
                                image_col:image_col + patch_dim, :, image_num]
            patch = np.concatenate(
                (patch[:, :,
                       0].flatten(), patch[:, :,
                                           1].flatten(), patch[:, :,
                                                               2].flatten()))
            patch = np.reshape(patch, (patch.size, 1))
            patch = patch - np.tile(mean_patch,
                                    (patch.shape[1], 1)).transpose()
            patch = zca_white.dot(patch)
            features = sparseAuto.autoencoder(opt_theta, hidden_size,
                                              visible_size, patch)

            if abs(features[feature_num, 0] -
                   convolved_features[feature_num, image_num, image_row,
                                      image_col]) > 1e-9:
                print 'convolved feature does not activation from autoencoder'
                print 'feature number:', feature_num
                print 'image number:', image_num
                print 'image row:', image_row
                print 'image column:', image_col
                print 'convolved feature:', convolved_features[feature_num,
                                                               image_num,
                                                               image_row,
                                                               image_col]
                print 'sparse AE feature:', features[feature_num, 0]
                sys.exit(
                    'convolved feature does not match activation from autoencoder'
                )

        print('congrats! convolution code passed the test')
        """
        Step 2c: Implement Pooling
        """
        # pooled_features = cnn.pooling(pool_dim, convolved_features)
        """
        Step 2d: Checking your pooling
        """
        test_matrix = np.arange(64).reshape(8, 8)
        expected_matrix = np.array(
            [[np.mean(test_matrix[0:4, 0:4]),
              np.mean(test_matrix[0:4, 4:8])],
             [np.mean(test_matrix[4:8, 0:4]),
              np.mean(test_matrix[4:8, 4:8])]])
        test_matrix = test_matrix.reshape(1, 1, 8, 8)
        pooled_features = cnn.pooling(4, test_matrix)

        if not (pooled_features == expected_matrix).all():
            print 'pooling incorrect'
            print 'expected:'
            pprint.pprint(expected_matrix)
            print 'got:'
            pprint.pprint(pooled_features)
        else:
            print "congrats! pooling code passed the test"
    """
    Step 3: Convolve and pool with the data set
    """
    step_size = 50
    assert hidden_size % step_size == 0

    pooled_features_train = np.zeros(
        (hidden_size, num_train_images,
         int(np.floor((image_dim - patch_dim + 1) / pool_dim)),
         int(np.floor((image_dim - patch_dim + 1) / pool_dim))))

    pooled_features_test = np.zeros(
        (hidden_size, num_test_images,
         int(np.floor((image_dim - patch_dim + 1) / pool_dim)),
         int(np.floor((image_dim - patch_dim + 1) / pool_dim))))

    start_time = time.time()

    for conv_part in range(hidden_size / step_size):

        feature_start = conv_part * step_size
        feature_end = (conv_part + 1) * step_size

        print 'Step:', conv_part, 'Features', feature_start, 'to', feature_end
        Wt = W[feature_start:feature_end, :]
        bt = b[feature_start:feature_end]

        print 'Convolving and pooling train images'
        convolved_features_this = cnn.convolve(patch_dim, step_size,
                                               train_images, Wt, bt, zca_white,
                                               mean_patch)
        pooled_features_this = cnn.pooling(pool_dim, convolved_features_this)
        pooled_features_train[
            feature_start:feature_end, :, :, :] = pooled_features_this

        print 'Elapsed time is', str(
            datetime.timedelta(seconds=time.time() - start_time))
        print 'Convolving and pooling test images'

        convolved_features_this = cnn.convolve(patch_dim, step_size,
                                               test_images, Wt, bt, zca_white,
                                               mean_patch)
        pooled_features_this = cnn.pooling(pool_dim, convolved_features_this)
        pooled_features_test[
            feature_start:feature_end, :, :, :] = pooled_features_this

        print 'Elapsed time is', str(
            datetime.timedelta(seconds=time.time() - start_time))

    np.save('pooled_features_train.npy', pooled_features_train)
    np.save('pooled_features_test.npy', pooled_features_test)
    print 'Elapsed time is', str(
        datetime.timedelta(seconds=time.time() - start_time))
    """
    Step 4: Use pooled features for classification
    """
    # set up parameters for softmax
    softmax_lambda = 1e-4
    num_classes = 4

    # reshape the pooled_features to form an input vector for softmax
    softmax_x = np.transpose(pooled_features_train, [0, 2, 3, 1])
    softmax_x = softmax_x.reshape(
        (pooled_features_train.size / num_train_images, num_train_images))
    softmax_y = train_labels.flatten() - 1

    softmax_opt_theta = softmax.train(
        num_classes, pooled_features_train.size / num_train_images,
        softmax_lambda, softmax_x, softmax_y)
    np.save('theta_opt_theta.npy', opt_theta)
    """
    Step 5: Test Classifier
    """
    softmax_x = np.transpose(pooled_features_test, [0, 2, 3, 1])
    softmax_x = softmax_x.reshape(
        (pooled_features_test.size / num_test_images, num_test_images))
    softmax_y = test_labels.flatten() - 1
    pred = softmax.predict(softmax_opt_theta, softmax_x, num_classes,
                           pooled_features_train.size / num_train_images)

    accuracy = 100 * np.sum(softmax_y == pred) / len(softmax_y)
    print "Accuracy is {0:.2f}".format(accuracy)
Beispiel #10
0
softmax = Softmax()  #创建对象,此时W为空
tic = time.time()
loss_hist = softmax.train(x_train,
                          y_train,
                          learning_rate=1e-7,
                          reg=2.5e4,
                          num_iters=1500,
                          verbose=True)  #此时svm对象中有W
toc = time.time()
print('that took %fs' % (toc - tic))
plt.plot(loss_hist)
plt.xlabel('iteration number')
plt.ylabel('loss value')
plt.show()
#训练完成之后,将参数保存,使用参数进行预测,计算准确率
y_train_pred = softmax.predict(x_train)
print('training accuracy: %f' % (np.mean(y_train == y_train_pred)))  #返回条件成立的占比
y_val_pred = softmax.predict(x_val)
print('validation accuracy: %f' % (np.mean(y_val == y_val_pred)))

#在拿到一组数据时一般分为训练集,开发集(验证集),测试集。训练和测试集都知道是干吗的,验证集在除了做验证训练结果外
# 还可以做超参数调优,寻找最优模型。遍历每一种参数组合,训练Softmax模型,然后在验证集上测试,寻找验证集上准确率最高的模型
# 交叉验证很费时间,下面的代码总共循环18次,在9700KCPU上满载运行了十多分钟,自己选择是否运行该段代码。

# 超参数调优(交叉验证)
learning_rates = [1.4e-7, 1.5e-7, 1.6e-7]
# for循环的简化写法12个
regularization_strengths = [(1 + i * 0.1) * 1e4
                            for i in range(-3, 3)] + [(2 + i * 0.1) * 1e4
                                                      for i in range(-3, 3)]
results = {}  # 字典
Beispiel #11
0
def softmaxCostCallback(x):
    return softmax.cost(x, numClasses, inputSize, lambdaParam, trainData,
                        trainLabels)


# Randomly initialise theta
thetaParam = 0.005 * random.normal(size=numClasses * inputSize)

options = {
    'maxiter': 100,
    'disp': True,
}

result = optimize.minimize(softmaxCostCallback,
                           thetaParam,
                           method='L-BFGS-B',
                           jac=True,
                           options=options)

optTheta = result.x[0:numClasses * inputSize].reshape(numClasses, inputSize)

# Evaluating performance of the softmax classifier
testData = loadMNISTImages('mnist/t10k-images-idx3-ubyte')
testLabels = loadMNISTLabels('mnist/t10k-labels-idx1-ubyte')

pred = softmax.predict(optTheta, testData)

acc = mean(testLabels == pred)
print('Accuracy: %0.3f%%\n' % (acc * 100))
Beispiel #12
0
inputSize = 28 * 28		# Size of input vector (MNIST images are 28x28)
numClasses = 10			# Number of classes (MNIST images fall into 10 classes)
lambdaParam = 1e-4		# Weight decay parameter

trainData = loadMNISTImages('mnist/train-images-idx3-ubyte')
trainLabels = loadMNISTLabels('mnist/train-labels-idx1-ubyte')

def softmaxCostCallback(x):
	return softmax.cost(x, numClasses, inputSize, lambdaParam, trainData, trainLabels) 

# Randomly initialise theta
thetaParam = 0.005 * random.normal(size=numClasses * inputSize)

options = {
		'maxiter': 100,
		'disp': True,
	}

result = optimize.minimize(softmaxCostCallback, thetaParam, method='L-BFGS-B', jac=True, options=options)

optTheta = result.x[0:numClasses*inputSize].reshape(numClasses, inputSize)

# Evaluating performance of the softmax classifier
testData = loadMNISTImages('mnist/t10k-images-idx3-ubyte')
testLabels = loadMNISTLabels('mnist/t10k-labels-idx1-ubyte')

pred = softmax.predict(optTheta, testData)

acc = mean(testLabels==pred)
print('Accuracy: %0.3f%%\n' % (acc * 100))
Beispiel #13
0
            featureStart:featureEnd, :, :, :] = pooledFeaturesThis

    cnnPooledFeatures = {}
    cnnPooledFeatures['pooledFeaturesTrain'] = pooledFeaturesTrain
    cnnPooledFeatures['pooledFeaturesTest'] = pooledFeaturesTest
    sio.savemat('cnnPooledFeatures.mat', cnnPooledFeatures)

    #step7 用卷积特征来进行softmax预测,这个就很快了,十几秒, 正确率为80%左右
    #Mat1 = sio.loadmat('cnnPooledFeatures.mat')
    #pooledFeaturesTrain = Mat1['pooledFeaturesTrain']
    #pooledFeaturesTest = Mat1['pooledFeaturesTest']
    softmaxLambda = 1e-4
    numClasses = 4
    inputSize = int(pooledFeaturesTrain.size / numTrainImages)
    print inputSize
    softmaxX = np.transpose(pooledFeaturesTrain, (0, 2, 3, 1))
    softmaxX = softmaxX.reshape(inputSize, numTrainImages)
    softmaxY = trainLabels
    theta = softmax.initiallize(numClasses, inputSize)
    [X, cost, d] = sop.fmin_l_bfgs_b(lambda (x): softmax.SoftmaxCost(
        softmaxX, softmaxY, x, softmaxLambda, inputSize, numClasses),
                                     x0=theta,
                                     maxiter=200,
                                     disp=1)

    softmaxX = np.transpose(pooledFeaturesTest, (0, 2, 3, 1))
    softmaxX = softmaxX.reshape(inputSize, numTestImages)
    softmaxY = testLabels
    accuracy = softmax.predict(X, softmaxX, softmaxY, inputSize, numClasses)
    print accuracy