changes for python3.6

.gitignore

@@ -0,0 +1 @@
+__pycache__

cifar.py

@@ -0,0 +1,31 @@
+import keras
+from keras.datasets import cifar10
+import numpy as np
+
+def load():
+	num_classes = 10	    # number of classes
+	(x_train, y_train), (x_test, y_test) = cifar10.load_data()
+
+	# print(x_train.shape[0], 'train samples')
+	# print(x_test.shape[0], 'test samples')
+	# print(type(x_train))
+
+	x_train = x_train.reshape((x_train.shape[0],-1))
+	x_test = x_test.reshape((x_test.shape[0],-1))
+	# print('x_train shape:', x_train.shape)
+	# print(x_train[0],x_train.dtype)
+	n, D = x_train.shape    # (n_sample, n_feature)
+	x_train = np.divide(x_train,255.0)
+	x_test = np.divide(x_test,255.0)
+
+	print("Load CIFAR10 dataset.")
+	print(x_train.shape[0], 'train samples')
+	print(x_test.shape[0], 'test samples')
+
+	d = np.int32(n / 2) * 2 # number of random features
+
+	# convert class vectors to binary class matrices
+	y_train = keras.utils.to_categorical(y_train, num_classes)
+	y_test = keras.utils.to_categorical(y_test, num_classes)
+	R = np.max(np.linalg.norm(x_train,2,axis=1))**2
+	return num_classes,x_train,x_test,y_train,y_test,n,D,R,d

dnn.py

@@ -0,0 +1,103 @@
+'''Train a simple deep CNN on the CIFAR10 small images dataset.
+GPU run command with Theano backend (with TensorFlow, the GPU is automatically used):
+		THEANO_FLAGS=mode=FAST_RUN,device=gpu,floatx=float32 python cifar10_cnn.py
+It gets down to 0.65 test logloss in 25 epochs, and down to 0.55 after 50 epochs.
+(it's still underfitting at that point, though).
+'''
+
+from __future__ import print_function
+import keras
+from keras.datasets import cifar10
+from keras.preprocessing.image import ImageDataGenerator
+from keras.models import Sequential
+from keras.layers import Dense, Dropout, Activation, Flatten
+from keras.layers import Conv2D, MaxPooling2D
+import numpy.linalg
+from numpy.linalg import svd
+import mnist
+import cifar
+import imdb
+batch_size = 16
+epochs = 50
+data_augmentation = False
+
+# The data, shuffled and split between train and test sets:
+num_classes,x_train,x_test,y_train,y_test,n,D,R,d = imdb.load()
+
+model = Sequential()
+#model.add(Flatten(input_shape=x_train.shape[1:]))
+layer1 = Dense(256,input_shape=(x_train.shape[1],))#
+#Conv2D(32, (3, 3),strides=(3,3),padding='same',
+#					)
+model.add(layer1)
+# model.add(Activation('relu'))
+# model.add(Dropout(0.5))
+# layer2 = Dense(128)
+#Conv2D(32, (3, 3))
+# model.add(layer2)
+# model.add(Activation('relu'))
+# model.add(Dropout(0.5))
+#model.add(MaxPooling2D(pool_size=(2, 2)))
+#model.add(Dropout(0.25))
+# layer3 = Dense(64)#Conv2D(64, (3, 3), padding='same')
+# model.add(layer3)
+# model.add(Activation('relu'))
+#model.add(Dropout(0.5))
+#model.add(Dense(100))
+#model.add(Activation('relu'))
+layer5 = Dense(num_classes)
+model.add(layer5)
+model.add(Activation('softmax'))
+model.summary()
+# initiate RMSprop optimizer
+opt = keras.optimizers.sgd(lr=0.01)
+
+# Let's train the model using RMSprop
+model.compile(loss='categorical_crossentropy',
+							optimizer=opt,
+							metrics=['accuracy'])
+
+
+num_classes,x_train,x_test,y_train,y_test,n,D,R,d = imdb.load()
+from numpy.random import shuffle
+
+
+model.fit(x_train, y_train,
+		batch_size=batch_size,
+		epochs=epochs,
+		validation_data=(x_test, y_test),
+		shuffle=True,
+		verbose=2)
+
+
+# spectrum1 = svd(layer1.get_weights()[0],compute_uv=False)
+# spectrum2 = svd(layer2.get_weights()[0],compute_uv=False)
+# spectrum3 = svd(layer3.get_weights()[0],compute_uv=False)
+# #spectrum4 = svd(numpy.reshape(layer4.get_weights()[0],(64*9,64)),compute_uv=False)
+# spectrum5 = svd(layer5.get_weights()[0],compute_uv=False)
+
+# numpy.set_printoptions(threshold=numpy.nan)
+# #print(layer1.get_weights()[0].dot(layer1.get_weights()[0].transpose()))
+# W = layer1.get_weights()[0].transpose()
+# print(W.shape)
+# print(W.dot(W.transpose()).shape)
+# W = W/(numpy.linalg.norm(W,axis=1,ord=2).reshape(W.shape[0],1))
+# print(-numpy.sort(-(W.dot(W.transpose())).flatten())[W.shape[0]:W.shape[0]*3:2])
+# W = layer2.get_weights()[0].transpose()
+# W = W/(numpy.linalg.norm(W,axis=1,ord=2).reshape(W.shape[0],1))
+# print(-numpy.sort(-(W.dot(W.transpose())).flatten())[W.shape[0]:W.shape[0]*3:2])
+# W = layer3.get_weights()[0].transpose()
+# W = W/(numpy.linalg.norm(W,axis=1,ord=2).reshape(W.shape[0],1))
+# print(-numpy.sort(-(W.dot(W.transpose())).flatten())[W.shape[0]:W.shape[0]*3:2])
+# #print(spectrum4)
+# W = layer5.get_weights()[0].transpose()
+# W = W/(numpy.linalg.norm(W,axis=1,ord=2).reshape(W.shape[0],1))
+# print(-numpy.sort(-(W.dot(W.transpose())).flatten())[W.shape[0]:W.shape[0]*3:2])
+
+# print(spectrum1)
+# print(spectrum2)
+# print(spectrum3)
+# print(spectrum5)
+
+#preds = model.predict_on_batch(x_test)
+#print("done",preds[0])

imdb.py

@@ -0,0 +1,47 @@
+import keras
+import numpy as np
+from keras.datasets import imdb
+from scipy.sparse import csr_matrix
+def load():
+	(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=10000,
+													  skip_top=30,
+													  maxlen=None)
+	indptr = [0]
+	indices = []
+	data = []
+	vocabulary = {}
+	for d in x_train:
+		for index in d:
+			indices.append(index)
+			data.append(1.0/len(d))
+		indptr.append(len(indices))
+	x_train = csr_matrix((data, indices, indptr), dtype=float).toarray()
+
+	indptr = [0]
+	indices = []
+	data = []
+	vocabulary = {}
+	for d in x_test:
+		for index in d:
+			indices.append(index)
+			data.append(1.0/len(d))
+		indptr.append(len(indices))
+	x_test = csr_matrix((data, indices, indptr), dtype=float).toarray()
+	print("Load IMDB dataset.")
+	print(x_train.shape[0], 'train samples')
+	print(x_test.shape[0], 'test samples')
+	print(x_train.shape[1],"features")
+	#x_train = keras.preprocessing.text.one_hot(x_train,10000)
+	print(x_train[0])
+	#x_test = keras.preprocessing.text.one_hot(x_test,10000)
+	n, D = x_train.shape    # (n_sample, n_feature)
+	d = np.int32(n / 2) * 2 # number of random features
+	num_classes = 2
+	# convert class vectors to binary class matrices
+	y_train = keras.utils.to_categorical(y_train, num_classes)
+	y_test = keras.utils.to_categorical(y_test, num_classes)
+	R = np.max(np.linalg.norm(x_train,2,axis=1))**2
+	# x_train/=R
+	# x_test/=R
+	# R = 1.0
+	return num_classes,x_train,x_test,y_train,y_test,n,D,R,d