def load_data(dataset):
''' Loads the dataset
:type dataset: string
:param dataset: the path to the dataset (here MNIST)
'''
#############
# LOAD DATA #
#############
print '... loading data'
#train_set, valid_set, test_set format: tuple(input, target)
#input is an numpy.ndarray of 2 dimensions (a matrix)
#witch row's correspond to an example. target is a
#numpy.ndarray of 1 dimensions (vector)) that have the same length as
#the number of rows in the input. It should give the target
#target to the example with the same index in the input.
test_set = tdtf.read_test_data_xy_to_ndarray(dataset +
"test.csv",limit=28)
valid_set = tdtf.read_data_to_ndarray(dataset + "valid.csv",limit=280)
train_set = tdtf.read_data_to_ndarray(dataset + "train.csv",limit=280)
def shared_dataset(data_xy, borrow=True):
""" Function that loads the dataset into shared variables
The reason we store our dataset in shared variables is to allow
Theano to copy it into the GPU memory (when code is run on GPU).
Since copying data into the GPU is slow, copying a minibatch everytime
is needed (the default behaviour if the data is not in a shared
variable) would lead to a large decrease in performance.
"""
data_x, data_y = data_xy
shared_x = theano.shared(numpy.asarray(data_x,
dtype=theano.config.floatX),
borrow=borrow)
shared_y = theano.shared(numpy.asarray(data_y,
dtype=theano.config.floatX),
borrow=borrow)
# When storing data on the GPU it has to be stored as floats
# therefore we will store the labels as ``floatX`` as well
# (``shared_y`` does exactly that). But during our computations
# we need them as ints (we use labels as index, and if they are
# floats it doesn't make sense) therefore instead of returning
# ``shared_y`` we will have to cast it to int. This little hack
# lets ous get around this issue
return shared_x, T.cast(shared_y, 'int32')
test_set_x, test_set_y = shared_dataset(test_set)
valid_set_x, valid_set_y = shared_dataset(valid_set)
train_set_x, train_set_y = shared_dataset(train_set)
rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),
(test_set_x, test_set_y)]
return rval
def load_data(dataset):
''' Loads the dataset
:type dataset: string
:param dataset: the path to the dataset (here MNIST)
'''
#############
# LOAD DATA #
#############
print '... loading data'
#train_set, valid_set, test_set format: tuple(input, target)
#input is an numpy.ndarray of 2 dimensions (a matrix)
#witch row's correspond to an example. target is a
#numpy.ndarray of 1 dimensions (vector)) that have the same length as
#the number of rows in the input. It should give the target
#target to the example with the same index in the input.
test_set = tdtf.read_test_data_xy_to_ndarray(dataset + "test.csv",
limit=28)
valid_set = tdtf.read_data_to_ndarray(dataset + "valid.csv", limit=280)
train_set = tdtf.read_data_to_ndarray(dataset + "train.csv", limit=280)
def shared_dataset(data_xy, borrow=True):
""" Function that loads the dataset into shared variables
The reason we store our dataset in shared variables is to allow
Theano to copy it into the GPU memory (when code is run on GPU).
Since copying data into the GPU is slow, copying a minibatch everytime
is needed (the default behaviour if the data is not in a shared
variable) would lead to a large decrease in performance.
"""
data_x, data_y = data_xy
shared_x = theano.shared(numpy.asarray(data_x,
dtype=theano.config.floatX),
borrow=borrow)
shared_y = theano.shared(numpy.asarray(data_y,
dtype=theano.config.floatX),
borrow=borrow)
# When storing data on the GPU it has to be stored as floats
# therefore we will store the labels as ``floatX`` as well
# (``shared_y`` does exactly that). But during our computations
# we need them as ints (we use labels as index, and if they are
# floats it doesn't make sense) therefore instead of returning
# ``shared_y`` we will have to cast it to int. This little hack
# lets ous get around this issue
return shared_x, T.cast(shared_y, 'int32')
test_set_x, test_set_y = shared_dataset(test_set)
valid_set_x, valid_set_y = shared_dataset(valid_set)
train_set_x, train_set_y = shared_dataset(train_set)
rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),
(test_set_x, test_set_y)]
return rval
#!/usr/bin/python
"""
developed by hp_carrot
2013-11-01
only pca traindata to get more simple datas.
precision of valid data : 90% , and only with 2000 train samples.
"""
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
import transform_data_to_format as tdtf
from sklearn import decomposition
import numpy
ori_train_x, train_y = tdtf.read_data_to_ndarray("../data/train.csv", 2000)
temp_x = []
print "starting decomposition"
pca_component = decomposition.PCA(n_components=100).fit(ori_train_x)
for otx_ele in ori_train_x:
transformed = pca_component.transform(otx_ele)
reconstructed = pca_component.inverse_transform(transformed)
temp_x.append(reconstructed[0])
train_x = numpy.asarray(temp_x)
# test_x = tdtf.read_test_data_to_ndarray("../data/test.csv",280)
valid_x, valid_y = tdtf.read_data_to_ndarray("../data/valid.csv", 2000)
clf = KNeighborsClassifier(n_neighbors=5)
clf.fit(train_x, train_y)
pred_train_y = clf.predict(train_x)
#!/usr/bin/python
'''
developed by hp_carrot
2013-10-31
a method that comes better than NearestNeighborsCentroid method
with about 90% precision , and with 90.18% test precision on Kaggle
'''
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
import transform_data_to_format as tdtf
train_x , train_y = tdtf.read_data_to_ndarray("../data/train.csv",2000)
test_x = tdtf.read_test_data_to_ndarray("../data/test.csv",28000)
#valid_x , valid_y = tdtf.read_data_to_ndarray("../data/valid.csv",10000)
clf = KNeighborsClassifier(n_neighbors=5)
clf.fit(train_x,train_y)
#pred_train_y = clf.predict(train_x)
#pred_valid_y = clf.predict(valid_x)
pred_test_y = clf.predict(test_x)
'''
print("Classification report for classifier %s:\n%s\n"
% (clf , metrics.classification_report(train_y , pred_train_y )))
print("Confusion matrix:\n%s" % metrics.confusion_matrix(train_y , pred_train_y ))
print("Classification report for classifier %s:\n%s\n"
% (clf , metrics.classification_report(valid_y , pred_valid_y )))
print("Confusion matrix:\n%s" % metrics.confusion_matrix(valid_y , pred_valid_y ))
'''
tdtf.write_to_csv(pred_test_y,"../data/MNIST_KNearestNeighbors.out")
def load_data(dataset):
''' Loads the dataset
:type dataset: string
:param dataset: the path to the dataset (here MNIST)
'''
#############
# LOAD DATA #
#############
# Download the MNIST dataset if it is not present
'''
data_dir, data_file = os.path.split(dataset)
if (not os.path.isfile(dataset)) and data_file == 'mnist.pkl.gz':
import urllib
origin = 'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz'
print 'Downloading data from %s' % origin
urllib.urlretrieve(origin, dataset)
'''
#print '... loading data'
# Load the dataset
'''
f = gzip.open(dataset, 'rb')
train_set, valid_set, test_set = cPickle.load(f)
f.close()
'''
#train_set, valid_set, test_set format: tuple(input, target)
#input is an numpy.ndarray of 2 dimensions (a matrix)
#witch row's correspond to an example. target is a
#numpy.ndarray of 1 dimensions (vector)) that have the same length as
#the number of rows in the input. It should give the target
#target to the example with the same index in the input.
test_set = tdtf.read_test_data_xy_to_ndarray("../data/test.csv", limit=100)
valid_set = tdtf.read_data_to_ndarray("../data/valid.csv", limit=100)
train_set = tdtf.read_data_to_ndarray("../data/train.csv", limit=21000)
pca_component_train = decomposition.PCA(n_components=100).fit(train_set[0])
pca_train_set_x = pca_component_train.transform(train_set[0])
pca_component_valid = decomposition.PCA(n_components=100).fit(valid_set[0])
pca_valid_set_x = pca_component_valid.transform(valid_set[0])
train_set = (pca_train_set_x, train_set[1])
valid_set = (pca_valid_set_x, valid_set[1])
print type(train_set), len(train_set), type(
train_set[0]), train_set[0].shape
def shared_dataset(data_xy, borrow=True):
""" Function that loads the dataset into shared variables
The reason we store our dataset in shared variables is to allow
Theano to copy it into the GPU memory (when code is run on GPU).
Since copying data into the GPU is slow, copying a minibatch everytime
is needed (the default behaviour if the data is not in a shared
variable) would lead to a large decrease in performance.
"""
data_x, data_y = data_xy
shared_x = theano.shared(numpy.asarray(data_x,
dtype=theano.config.floatX),
borrow=borrow)
shared_y = theano.shared(numpy.asarray(data_y,
dtype=theano.config.floatX),
borrow=borrow)
# When storing data on the GPU it has to be stored as floats
# therefore we will store the labels as ``floatX`` as well
# (``shared_y`` does exactly that). But during our computations
# we need them as ints (we use labels as index, and if they are
# floats it doesn't make sense) therefore instead of returning
# ``shared_y`` we will have to cast it to int. This little hack
# lets ous get around this issue
return shared_x, T.cast(shared_y, 'int32')
test_set_x, test_set_y = shared_dataset(test_set)
valid_set_x, valid_set_y = shared_dataset(valid_set)
train_set_x, train_set_y = shared_dataset(train_set)
rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),
(test_set_x, test_set_y)]
return rval
#!/usr/bin/python
'''
developed by hp_carrot
2013-11-01
only pca traindata to get more simple datas.
precision of valid data : 90% , and only with 2000 train samples.
'''
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
import transform_data_to_format as tdtf
from sklearn import decomposition
import numpy
ori_train_x, train_y = tdtf.read_data_to_ndarray("../data/train.csv", 2000)
temp_x = []
print "starting decomposition"
pca_component = decomposition.PCA(n_components=100).fit(ori_train_x)
for otx_ele in ori_train_x:
transformed = pca_component.transform(otx_ele)
reconstructed = pca_component.inverse_transform(transformed)
temp_x.append(reconstructed[0])
train_x = numpy.asarray(temp_x)
#test_x = tdtf.read_test_data_to_ndarray("../data/test.csv",280)
valid_x, valid_y = tdtf.read_data_to_ndarray("../data/valid.csv", 2000)
clf = KNeighborsClassifier(n_neighbors=5)
clf.fit(train_x, train_y)
pred_train_y = clf.predict(train_x)
pred_valid_y = clf.predict(valid_x)
#!/usr/bin/python
'''
developed by hp_carrot
2013-10-31
a method that comes better than NearestNeighborsCentroid method
with about 90% precision , and using 2000 training data , we get with 90.18% test precision on Kaggle
modified by hp_carrot
2013-11-03
with 40000 training we get 96.514% score , which is good !!!!
'''
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
import transform_data_to_format as tdtf
train_x, train_y = tdtf.read_data_to_ndarray("../data/train.csv", 40000)
test_x = tdtf.read_test_data_to_ndarray("../data/test.csv", 28000)
#valid_x , valid_y = tdtf.read_data_to_ndarray("../data/valid.csv",10000)
clf = KNeighborsClassifier(n_neighbors=10)
print "fitting"
clf.fit(train_x, train_y)
#pred_train_y = clf.predict(train_x)
#pred_valid_y = clf.predict(valid_x)
print "predicting"
pred_test_y = clf.predict(test_x)
'''
print("Classification report for classifier %s:\n%s\n"
% (clf , metrics.classification_report(train_y , pred_train_y )))
print("Confusion matrix:\n%s" % metrics.confusion_matrix(train_y , pred_train_y ))
print("Classification report for classifier %s:\n%s\n"
% (clf , metrics.classification_report(valid_y , pred_valid_y )))
def load_data(dataset):
''' Loads the dataset
:type dataset: string
:param dataset: the path to the dataset (here MNIST)
'''
#############
# LOAD DATA #
#############
# Download the MNIST dataset if it is not present
'''
data_dir, data_file = os.path.split(dataset)
if (not os.path.isfile(dataset)) and data_file == 'mnist.pkl.gz':
import urllib
origin = 'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz'
print 'Downloading data from %s' % origin
urllib.urlretrieve(origin, dataset)
'''
#print '... loading data'
# Load the dataset
'''
f = gzip.open(dataset, 'rb')
train_set, valid_set, test_set = cPickle.load(f)
f.close()
'''
#train_set, valid_set, test_set format: tuple(input, target)
#input is an numpy.ndarray of 2 dimensions (a matrix)
#witch row's correspond to an example. target is a
#numpy.ndarray of 1 dimensions (vector)) that have the same length as
#the number of rows in the input. It should give the target
#target to the example with the same index in the input.
test_set = tdtf.read_test_data_xy_to_ndarray("../data/test.csv",limit=100)
valid_set = tdtf.read_data_to_ndarray("../data/valid.csv",limit=100)
train_set = tdtf.read_data_to_ndarray("../data/train.csv",limit=21000)
pca_component_train = decomposition.PCA(n_components=100).fit(train_set[0])
pca_train_set_x = pca_component_train.transform(train_set[0])
pca_component_valid = decomposition.PCA(n_components=100).fit(valid_set[0])
pca_valid_set_x = pca_component_valid.transform(valid_set[0])
train_set = (pca_train_set_x,train_set[1])
valid_set = (pca_valid_set_x,valid_set[1])
print type(train_set),len(train_set),type(train_set[0]),train_set[0].shape
def shared_dataset(data_xy, borrow=True):
""" Function that loads the dataset into shared variables
The reason we store our dataset in shared variables is to allow
Theano to copy it into the GPU memory (when code is run on GPU).
Since copying data into the GPU is slow, copying a minibatch everytime
is needed (the default behaviour if the data is not in a shared
variable) would lead to a large decrease in performance.
"""
data_x, data_y = data_xy
shared_x = theano.shared(numpy.asarray(data_x,
dtype=theano.config.floatX),
borrow=borrow)
shared_y = theano.shared(numpy.asarray(data_y,
dtype=theano.config.floatX),
borrow=borrow)
# When storing data on the GPU it has to be stored as floats
# therefore we will store the labels as ``floatX`` as well
# (``shared_y`` does exactly that). But during our computations
# we need them as ints (we use labels as index, and if they are
# floats it doesn't make sense) therefore instead of returning
# ``shared_y`` we will have to cast it to int. This little hack
# lets ous get around this issue
return shared_x, T.cast(shared_y, 'int32')
test_set_x, test_set_y = shared_dataset(test_set)
valid_set_x, valid_set_y = shared_dataset(valid_set)
train_set_x, train_set_y = shared_dataset(train_set)
rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),
(test_set_x, test_set_y)]
return rval
def evaluate_lenet5(dataset_route=DataHome+"DogVsCat_test_feature_2500.csv", \
nkerns=[20, 50], batch_size=5):
""" Demonstrates lenet on MNIST dataset
:type learning_rate: float
:param learning_rate: learning rate used (factor for the stochastic
gradient)
:type n_epochs: int
:param n_epochs: maximal number of epochs to run the optimizer
:type dataset: string
:param dataset: path to the dataset used for training /testing (MNIST here)
:type nkerns: list of ints
:param nkerns: number of kernels on each layer
"""
rng = numpy.random.RandomState(23455)
trained_model_pkl = open(ModelHome + train_model_route, 'r')
trained_model_state_list = cPickle.load(trained_model_pkl)
trained_model_state_array = numpy.load(trained_model_pkl)
layer0_state, layer1_state, layer2_state, layer3_state = trained_model_state_array
test_set = tdtf.read_data_to_ndarray(dataset_route, limit=None, header_n=0)
test_set_x, id_arr = test_set
datasets = load_data.shared_dataset(test_set)
test_set_x, test_set_y = datasets
print test_set_x.shape, test_set_y.shape
# compute number of minibatches for training, validation and testing
n_test_batches = test_set_x.get_value(borrow=True).shape[0]
n_test_batches /= batch_size
# allocate symbolic variables for the data
index = T.lscalar() # index to a [mini]batch
x = T.matrix('x') # the data is presented as rasterized images
y = T.ivector('y') # the labels are presented as 1D vector of
# [int] labels
ishape = (50, 50) # this is the size of MNIST images
######################
# BUILD ACTUAL MODEL #
######################
print '... building the model'
# Reshape matrix of rasterized images of shape (batch_size,28*28)
# to a 4D tensor, compatible with our LeNetConvPoolLayer
layer0_input = x.reshape((batch_size, 1, 50, 50))
# Construct the first convolutional pooling layer:
# filtering reduces the image size to (28-5+1,28-5+1)=(24,24)
# maxpooling reduces this further to (24/2,24/2) = (12,12)
# 4D output tensor is thus of shape (batch_size,nkerns[0],12,12)
layer0 = LeNetConvPoolLayer(rng, input=layer0_input, \
image_shape=(batch_size, 1, 50, 50), \
filter_shape=(nkerns[0], 1, 10, 10), poolsize=(2, 2), \
W=layer0_state[0], b=layer0_state[1] \
)
# Construct the second convolutional pooling layer
# filtering reduces the image size to (12-5+1,12-5+1)=(8,8)
# maxpooling reduces this further to (8/2,8/2) = (4,4)
# 4D output tensor is thus of shape (nkerns[0],nkerns[1],4,4)
layer1 = LeNetConvPoolLayer(rng, input=layer0.output,
image_shape=(batch_size, nkerns[0], 20, 20),
filter_shape=(nkerns[1], nkerns[0], 5, 5), poolsize=(2, 2), \
W=layer1_state[0], b=layer1_state[1] \
)
# the TanhLayer being fully-connected, it operates on 2D matrices of
# shape (batch_size,num_pixels) (i.e matrix of rasterized images).
# This will generate a matrix of shape (20,32*4*4) = (20,512)
layer2_input = layer1.output.flatten(2)
# construct a fully-connected sigmoidal layer
layer2 = HiddenLayer(rng, input=layer2_input, n_in=nkerns[1] * 8 * 8,
n_out=100, activation=T.tanh,\
W=layer2_state[0], b=layer2_state[1] \
)
# classify the values of the fully-connected sigmoidal layer
layer3 = LogisticRegression(input=layer2.output, n_in=100, n_out=2, \
W=layer3_state[0], b=layer3_state[1] \
)
print "predicting"
start_time = time.clock()
# create a function to compute the mistakes that are made by the model
test_results = theano.function(
inputs=[index],
outputs=layer3.y_pred,
givens={x: test_set_x[index * batch_size:(index + 1) * batch_size]})
test_res = [test_results(i) for i in xrange(n_test_batches)]
print test_res
id_l = []
label_l = []
index = 0
for arr in test_res:
for label in arr:
label_l.append(label)
id_l.append(id_arr[index])
index += 1
tdtf.wr_to_csv(header=['id', 'label'],
id_list=id_l,
pred_list=label_l,
filename=test_label_route)
end_time = time.clock()
print >> sys.stderr, ('The code for file ' + os.path.split(__file__)[1] +
' ran for %.2fm' % ((end_time - start_time) / 60.))
def evaluate_lenet5(dataset_route=DataHome+"DogVsCat_test_feature_2500.csv", \
nkerns=[20, 50], batch_size=5):
""" Demonstrates lenet on MNIST dataset
:type learning_rate: float
:param learning_rate: learning rate used (factor for the stochastic
gradient)
:type n_epochs: int
:param n_epochs: maximal number of epochs to run the optimizer
:type dataset: string
:param dataset: path to the dataset used for training /testing (MNIST here)
:type nkerns: list of ints
:param nkerns: number of kernels on each layer
"""
rng = numpy.random.RandomState(23455)
trained_model_pkl = open(ModelHome + train_model_route, 'r')
trained_model_state_list = cPickle.load(trained_model_pkl)
trained_model_state_array = numpy.load(trained_model_pkl)
layer0_state, layer1_state, layer2_state, layer3_state = trained_model_state_array
test_set = tdtf.read_data_to_ndarray(dataset_route, limit=None, header_n=0)
test_set_x, id_arr = test_set
datasets = load_data.shared_dataset(test_set)
test_set_x, test_set_y = datasets
print test_set_x.shape, test_set_y.shape
# compute number of minibatches for training, validation and testing
n_test_batches = test_set_x.get_value(borrow=True).shape[0]
n_test_batches /= batch_size
# allocate symbolic variables for the data
index = T.lscalar() # index to a [mini]batch
x = T.matrix('x') # the data is presented as rasterized images
y = T.ivector('y') # the labels are presented as 1D vector of
# [int] labels
ishape = (50, 50) # this is the size of MNIST images
######################
# BUILD ACTUAL MODEL #
######################
print '... building the model'
# Reshape matrix of rasterized images of shape (batch_size,28*28)
# to a 4D tensor, compatible with our LeNetConvPoolLayer
layer0_input = x.reshape((batch_size, 1, 50, 50))
# Construct the first convolutional pooling layer:
# filtering reduces the image size to (28-5+1,28-5+1)=(24,24)
# maxpooling reduces this further to (24/2,24/2) = (12,12)
# 4D output tensor is thus of shape (batch_size,nkerns[0],12,12)
layer0 = LeNetConvPoolLayer(rng, input=layer0_input, \
image_shape=(batch_size, 1, 50, 50), \
filter_shape=(nkerns[0], 1, 10, 10), poolsize=(2, 2), \
W=layer0_state[0], b=layer0_state[1] \
)
# Construct the second convolutional pooling layer
# filtering reduces the image size to (12-5+1,12-5+1)=(8,8)
# maxpooling reduces this further to (8/2,8/2) = (4,4)
# 4D output tensor is thus of shape (nkerns[0],nkerns[1],4,4)
layer1 = LeNetConvPoolLayer(rng, input=layer0.output,
image_shape=(batch_size, nkerns[0], 20, 20),
filter_shape=(nkerns[1], nkerns[0], 5, 5), poolsize=(2, 2), \
W=layer1_state[0], b=layer1_state[1] \
)
# the TanhLayer being fully-connected, it operates on 2D matrices of
# shape (batch_size,num_pixels) (i.e matrix of rasterized images).
# This will generate a matrix of shape (20,32*4*4) = (20,512)
layer2_input = layer1.output.flatten(2)
# construct a fully-connected sigmoidal layer
layer2 = HiddenLayer(rng, input=layer2_input, n_in=nkerns[1] * 8 * 8,
n_out=100, activation=T.tanh,\
W=layer2_state[0], b=layer2_state[1] \
)
# classify the values of the fully-connected sigmoidal layer
layer3 = LogisticRegression(input=layer2.output, n_in=100, n_out=2, \
W=layer3_state[0], b=layer3_state[1] \
)
print "predicting"
start_time = time.clock()
# create a function to compute the mistakes that are made by the model
test_results = theano.function(inputs=[index],
outputs= layer3.y_pred,
givens={
x: test_set_x[index * batch_size: (index + 1) * batch_size]})
test_res = [test_results(i)
for i in xrange(n_test_batches)]
print test_res
id_l = []
label_l = []
index = 0
for arr in test_res:
for label in arr:
label_l.append(label)
id_l.append(id_arr[index])
index += 1
tdtf.wr_to_csv(header=['id','label'], id_list=id_l, pred_list=label_l, filename=test_label_route)
end_time = time.clock()
print >> sys.stderr, ('The code for file ' +
os.path.split(__file__)[1] +
' ran for %.2fm' % ((end_time - start_time) / 60.))
