adding matrix factorization

Author: webeng

.gitignore

@@ -8,7 +8,11 @@ data/mnist.pkl.gz
 data/mnist_py3k.pkl.gz
 data/Nottingham.zip
 data/Nottingham
+data/cnn-furniture
 data/midi.zip
+data/test_set.pkl
+data/train_set.pkl
+data/valid_set.pkl
 html
 *.pyc
 *~

code/convolutional_mlp_test.py

@@ -32,7 +32,7 @@
 from theano.tensor.signal import downsample
 from theano.tensor.nnet import conv
 
-from logistic_sgd import LogisticRegression, load_data
+from logistic_sgd_test import LogisticRegression, load_data
 from mlp import HiddenLayer
 
 
@@ -136,9 +136,8 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     rng = numpy.random.RandomState(23455)
 
     datasets = load_data(dataset)
-    print datasets
 
-    """train_set_x, train_set_y = datasets[0]
+    train_set_x, train_set_y = datasets[0]
     valid_set_x, valid_set_y = datasets[1]
     test_set_x, test_set_y = datasets[2]
 
@@ -166,7 +165,8 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)
     # to a 4D tensor, compatible with our LeNetConvPoolLayer
     # (28, 28) is the size of MNIST images.
-    layer0_input = x.reshape((batch_size, 1, 28, 28))
+    #layer0_input = x.reshape((batch_size, 1, 28, 28))
+    layer0_input = x.reshape((batch_size, 1, 256, 256))
 
     # Construct the first convolutional pooling layer:
     # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24)
@@ -175,10 +175,17 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     layer0 = LeNetConvPoolLayer(
         rng,
         input=layer0_input,
-        image_shape=(batch_size, 1, 28, 28),
+        image_shape=(batch_size, 1, 256, 256),
         filter_shape=(nkerns[0], 1, 5, 5),
         poolsize=(2, 2)
     )
+    # layer0 = LeNetConvPoolLayer(
+    #     rng,
+    #     input=layer0_input,
+    #     image_shape=(batch_size, 1, 28, 28),
+    #     filter_shape=(nkerns[0], 1, 5, 5),
+    #     poolsize=(2, 2)
+    # )
 
     # Construct the second convolutional pooling layer
     # filtering reduces the image size to (12-5+1, 12-5+1) = (8, 8)
@@ -187,10 +194,25 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     layer1 = LeNetConvPoolLayer(
         rng,
         input=layer0.output,
-        image_shape=(batch_size, nkerns[0], 12, 12),
+        image_shape=(batch_size, nkerns[0], 126, 126),
         filter_shape=(nkerns[1], nkerns[0], 5, 5),
         poolsize=(2, 2)
     )
+    # layer1 = LeNetConvPoolLayer(
+    #     rng,
+    #     input=layer0.output,
+    #     image_shape=(batch_size, nkerns[0], 12, 12),
+    #     filter_shape=(nkerns[1], nkerns[0], 5, 5),
+    #     poolsize=(2, 2)
+    # )
+
+    # layer1 = LeNetConvPoolLayer(
+    #     rng,
+    #     input=layer0.output,
+    #     image_shape=(batch_size, nkerns[0], 126, 126),
+    #     filter_shape=(nkerns[1], nkerns[0], 5, 5),
+    #     poolsize=(2, 2)
+    # )
 
     # the HiddenLayer being fully-connected, it operates on 2D matrices of
     # shape (batch_size, num_pixels) (i.e matrix of rasterized images).
@@ -202,13 +224,22 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     layer2 = HiddenLayer(
         rng,
         input=layer2_input,
-        n_in=nkerns[1] * 4 * 4,
+        n_in=nkerns[1] * 61 * 61,
         n_out=500,
         activation=T.tanh
     )
 
+    # layer2 = HiddenLayer(
+    #     rng,
+    #     input=layer2_input,
+    #     n_in=nkerns[1] * 4 * 4,
+    #     n_out=500,
+    #     activation=T.tanh
+    # )
+
     # classify the values of the fully-connected sigmoidal layer
-    layer3 = LogisticRegression(input=layer2.output, n_in=500, n_out=10)
+    #layer3 = LogisticRegression(input=layer2.output, n_in=500, n_out=10)
+    layer3 = LogisticRegression(input=layer2.output, n_in=500, n_out=2)
 
     # the cost we minimize during training is the NLL of the model
     cost = layer3.negative_log_likelihood(y)
@@ -338,7 +369,6 @@ def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
     print >> sys.stderr, ('The code for file ' +
                           os.path.split(__file__)[1] +
                           ' ran for %.2fm' % ((end_time - start_time) / 60.))
-    """
 if __name__ == '__main__':
     evaluate_lenet5()
 

code/logistic_sgd_test.py

@@ -222,9 +222,7 @@ def load_data(dataset):
 
     pkl_file = open( '../data/test_set.pkl', 'rb')
     test_set = cPickle.load(pkl_file)
-
-    #print dataset
-    #print train_set[0]
+    
     #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

code/mf.py

@@ -0,0 +1,125 @@
+import theano.tensor as T
+from theano import function
+from theano.ifelse import ifelse
+import theano, time, numpy
+from theano import shared
+rng = numpy.random
+
+state = shared(float(0))
+
+x = T.dscalar('x')
+y = T.dscalar('y')
+#x = T.scalar(dtype= state.type)
+#y = T.scalar(dtype= state.type)
+z = x + y
+
+
+#state = 1
+
+#f = function([x, y], z)
+f_updates = function([x, y], z , updates=[(state, state + x + y)])
+
+# print f_updates(1,2)
+# z_switch = T.switch(T.lt(x,y) , T.pow(x,2) + y , x + y)
+# f_switch = function([x,y],z_switch)
+# print f_switch(4,3)
+
+# for i in xrange(1,10):
+# 	f_updates(1,0)
+
+# print state.get_value()
+
+R = [
+     [5,3,0,1],
+     [4,0,0,1],
+     [1,1,0,5],
+     [1,0,0,4],
+     [0,1,5,4],
+    ]
+
+R = numpy.array(R).astype(theano.config.floatX)
+tR = theano.shared(R.astype(theano.config.floatX),name="R")
+print type(tR)
+ncols = len(R[0])
+nrows = len(R)
+#print 
+#theano.printing.debugprint(tR.shape) 
+#print
+row_values = T.dvector('row_values')
+column_values = T.dvector('column_values')
+row = T.dscalar('row')
+
+total_squared_sum = shared(float(0))
+#sq_sum = pow(row_values.sum(),2) + 
+dot_product = row + T.dot(row_values,row_values)
+f_test = function([row,row_values], dot_product , updates=[(total_squared_sum, total_squared_sum + dot_product)])
+
+for row in xrange(0,nrows):
+    f_test(row,R[row,:])
+
+print total_squared_sum.get_value()
+
+
+def matrix_factorization(R, P, Q, K, steps=5000, alpha=0.0002, beta=0.02):
+    Q = Q.T
+
+    # p_row = theano.shared(rng.random((1,4)).astype(theano.config.floatX))
+    # q_col = theano.shared(rng.random((1,5)).astype(theano.config.floatX))
+
+    for step in xrange(steps):
+        for i in xrange(len(R)):
+            for j in xrange(len(R[i])):
+                if R[i][j] > 0:
+                    eij = R[i][j] - numpy.dot(P[i,:],Q[:,j])
+                    for k in xrange(K):
+                        P[i][k] = P[i][k] + alpha * (2 * eij * Q[k][j] - beta * P[i][k])
+                        Q[k][j] = Q[k][j] + alpha * (2 * eij * P[i][k] - beta * Q[k][j])
+        eR = numpy.dot(P,Q)
+        e = 0
+        for i in xrange(len(R)):
+            for j in xrange(len(R[i])):
+                if R[i][j] > 0:
+                    e = e + pow(R[i][j] - numpy.dot(P[i,:],Q[:,j]), 2)
+                    for k in xrange(K):
+                        e = e + (beta/2) * (pow(P[i][k],2) + pow(Q[k][j],2))
+        if e < 0.001:
+            break
+    return P, Q.T
+
+R = [
+     [5,3,0,1],
+     [4,0,0,1],
+     [1,1,0,5],
+     [1,0,0,4],
+     [0,1,5,4],
+    ]
+
+R = numpy.array(R)
+
+N = len(R)
+M = len(R[0])
+K = 2
+
+# P = theano.shared(
+#     numpy.asarray(
+#         numpy.random.rand(N,K),
+#         dtype=theano.config.floatX
+#     ),
+#     borrow=True
+# )
+
+# Q = theano.shared(
+#     numpy.asarray(
+#         numpy.random.rand(M,K),
+#         dtype=theano.config.floatX
+#     ),
+#     borrow=True
+# )
+
+#print Q
+
+# P = numpy.random.rand(N,K)
+# Q = numpy.random.rand(M,K)
+
+# nP, nQ = matrix_factorization(R, P, Q, K)
+# nR = numpy.dot(nP, nQ.T)