Uploaded 7 py files

Author: ngjingheng95

Diff for: L1 Tensorflow Basic Functions.py

@@ -0,0 +1,22 @@
+import theano
+from theano import tensor
+import tensorflow as tf
+
+a = tensor.dscalar()
+b = tensor.dscalar()
+
+c = a + b
+
+f = theano.function([a,b], c)
+
+print("theano: ", f(55, 10))
+
+###
+
+a = tf.placeholder(tf.float32)
+b = tf.placeholder(tf.float32)
+add = tf.add(a, b)
+sess = tf.Session()
+binding = {a: 1.5, b: 2.5}
+c = sess.run(add, feed_dict=binding)
+print(c)

Diff for: L2 Pima Indian Diabetes.py

@@ -0,0 +1,36 @@
+import numpy
+from keras.models import Sequential
+from keras.layers import Dense
+
+#fix random seed
+seed = 7
+numpy.random.seed(seed)
+
+#load pima indians dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+
+#split into inputs (X) and outputs (Y)
+X = dataset[:,0:8]
+Y = dataset[:,8]
+
+#create model (8 input neurons, 12 neurons in hidden layer 1,
+#8 neurons in hidden layer 2, 1 output neuron with sigmoid function)
+model = Sequential()
+model.add(Dense(12, input_dim=8, init='uniform', activation='relu'))
+model.add(Dense(8, init='uniform', activation='relu'))
+model.add(Dense(1, init='uniform', activation='sigmoid'))
+
+#Compile model. 'loss' to evaluate set of weights,
+#'optimizer' search through different weights for the network
+#'metrics' used to report the classification accuracy
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+
+#Fit the model
+#'nb_epoch' for number of epochs to run
+#batch size => number of instances that are evaluated before a weight
+# update in the network
+model.fit(X, Y, validation_split=0.33, nb_epoch=150, batch_size=10)
+
+# evaluate the model
+scores = model.evaluate(X, Y)
+print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))

Diff for: L3 PID w StratifiedKFold.py

@@ -0,0 +1,50 @@
+## using StratifiedKFold for validation
+
+#load libraries
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.cross_validation import StratifiedKFold
+import numpy
+
+#fix random seed
+seed = 7
+numpy.random.seed(seed)
+
+#load dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+
+#split into input (X) and output (Y)
+#array[<rows>,<columns>]
+#X takes the first 8 columns as input and
+#Y takes the last column as output
+X = dataset[:,0:8]
+Y = dataset[:,8]
+
+# create a 10-fold cross validation test
+kfold = StratifiedKFold(y=Y, n_folds=10, shuffle=True, random_state = seed)
+#create an array to store the scores for each fold
+cvscores = []
+
+#creates 10 models for each fold
+for i, (train, test) in enumerate(kfold):
+    #create model
+    model = Sequential()
+    #use Dense() to create fully connected layers
+    model.add(Dense(12, input_dim=8, init='uniform', activation = 'relu'))
+    model.add(Dense(8, init = 'uniform', activation = 'relu'))
+    model.add(Dense(1, init = 'uniform', activation = 'sigmoid'))
+
+    #compile model
+    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+
+    #fit the model
+    #verbose = 0 to turn off verbose output for each epoch
+    model.fit(X[train], Y[train], nb_epoch = 150, batch_size = 10, verbose = 0)
+
+    # evaluate the model
+    scores = model.evaluate(X[test], Y[test], verbose = 0)
+    print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
+    #add the score for each model into cvscores to determine mean score and std dev
+    cvscores.append(scores[1] * 100)
+
+print("%.2f%% (+/- %.2f%%)" % (numpy.mean(cvscores), numpy.std(cvscores)))

Diff for: L4 PID w Keras Wrappers.py

@@ -0,0 +1,42 @@
+## using KerasClassifier to wrap deep learning models
+
+#import libraries
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+from sklearn.cross_validation import StratifiedKFold
+from sklearn.cross_validation import cross_val_score
+import numpy
+import pandas
+
+#define a function which creates a model.
+#KerasClassifier requires this function to be passed in as argument
+def create_model():
+    #create model
+    model = Sequential()
+    # 8 input - 12 neurons hidden layer 1 - 8 neurons in hidden layer 2 - 1 output
+    model.add(Dense(12, input_dim = 8, init = 'uniform', activation = 'relu'))
+    model.add(Dense(8, init = 'uniform', activation = 'relu'))
+    model.add(Dense(1, init = 'uniform', activation = 'sigmoid'))
+    #compile model
+    model.compile(loss='binary_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
+    return model
+
+#fix seed
+seed = 7
+numpy.random.seed(seed)
+#load pima indians dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+#split into input (X) and output (Y) variables
+X = dataset[:,0:8]
+Y = dataset[:,8]
+
+#create model
+model = KerasClassifier(build_fn=create_model, nb_epoch = 150, batch_size = 10)
+
+#evaluate using 10-fold cross validation
+kfold = StratifiedKFold(y=Y, n_folds=10, shuffle=True, random_state=seed)
+results = cross_val_score(model, X, Y ,cv = kfold)
+print(results.mean())
+
+

Diff for: L5 PID w Grid Search.py

@@ -0,0 +1,55 @@
+## Testing different configurations of optimizer, init, epoch and batchsize
+## using GridSearchCV()
+
+# load libraries
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+from sklearn.grid_search import GridSearchCV
+import numpy
+import pandas
+
+# define create_model function for KerasClassifier wrapper
+# include default values for grid search, in this case, optimizer = 'rmsprop', init = 'glorot_uniform'
+def create_model(optimizer = 'rmsprop', init = 'glorot_uniform'):
+    # create model
+    model = Sequential()
+    # 8 -> 12 -> 8 -> 1
+    model.add(Dense(12, input_dim=8, init = init, activation = 'relu'))
+    model.add(Dense(8, init = init, activation = 'relu'))
+    model.add(Dense(1, init = init, activation = 'sigmoid'))
+    #compile model
+    model.compile(loss='binary_crossentropy', optimizer = optimizer, metrics=['accuracy'])
+    return model
+
+# fix seed
+seed = 7
+numpy.random.seed(seed)
+
+# load dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+
+# split into input (X) and output (Y) variables
+X = dataset[:, 0:8]
+Y = dataset[:,8]
+
+# create model using KerasClassifier class
+model = KerasClassifier(build_fn=create_model)
+
+# create arrays of optimizer, init, epoch and batchsize for grid search
+optimizers = ['rmsprop', 'adam']
+init = ['glorot_uniform', 'normal', 'uniform']
+epochs = numpy.array([50,100,150])
+batches = numpy.array([5,10,20])
+
+# create a dict for grid search
+param_grid = dict(optimizer = optimizers, nb_epoch = epochs, batch_size = batches, init = init)
+grid = GridSearchCV(estimator = model, param_grid=param_grid)
+grid_result = grid.fit(X, Y)
+
+# summarize results
+#gives the best result
+print("best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+#gives all the results
+for params, mean_score, scores in grid_result.grid_scores_:
+    print("%f (%f) with: %r" % (scores.mean(), scores.std(), params))

Diff for: L6 Iris Multiclass Classification.py

@@ -0,0 +1,52 @@
+# import libraries
+import numpy
+import pandas
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+from keras.utils import np_utils
+from sklearn.cross_validation import cross_val_score
+from sklearn.cross_validation import KFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.pipeline import Pipeline
+
+# fix seed
+seed = 7
+numpy.random.seed(seed)
+
+# load dataset
+## it is easier to use 'pandas' to load dataset instead of 'numpy' if output variable contains strings
+dataframe = pandas.read_csv("Iris.csv", header = 0)
+dataset = dataframe.values
+X = dataset[:,1:5].astype(float)
+Y = dataset[:,5]
+
+#encode class values as integers
+encoder = LabelEncoder()
+encoder.fit(Y)
+#encoder.transform() does the conversion into integer
+encoded_Y = encoder.transform(Y)
+#convert integers to dummy variables (ie one hot encoding)
+dummy_y = np_utils.to_categorical(encoded_Y)
+
+# define baseline model
+## fully connected network with 4 inputs -> [4 hidden nodes] -> 3 outputs
+## 3 outputs as we did one hot encoding, so 1 output for each class
+def baseline_model():
+    model = Sequential()
+    model.add(Dense(4, input_dim = 4, init = 'normal', activation = 'relu'))
+    ## output uses sigmoid activation function to ensure output values are in the range of 0 and 1
+    model.add(Dense(3, init = 'normal', activation = 'sigmoid'))
+    #compile model
+    ## model uses ADAM gradient descent optimization algo
+    ## and uses a logarithmic loss function, called categorical_crossentropy in keras
+    model.compile(loss='categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
+    return model
+
+estimator = KerasClassifier(build_fn=baseline_model, nb_epoch = 100, batch_size = 5, verbose = 0)
+
+#using k-fold validation
+kfold = KFold(n=len(X), n_folds=10, shuffle= True, random_state = seed)
+
+results = cross_val_score(estimator, X, dummy_y, cv = kfold)
+print("Accuracy: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

Diff for: L7 Sonar Object Classification.py

@@ -0,0 +1,43 @@
+#import libraries
+import numpy
+import pandas
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+from sklearn.cross_validation import cross_val_score
+from sklearn.preprocessing import LabelEncoder
+from sklearn.cross_validation import StratifiedKFold
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import Pipeline
+
+seed = 7
+numpy.random.seed(seed)
+
+#load data
+dataframe = pandas.read_csv("sonar.csv", header = None)
+dataset = dataframe.values
+# split into input (X) and output (Y)
+X = dataset[:,0:60].astype(float)
+Y = dataset[:,60]
+
+# one hot encoding
+encoder = LabelEncoder()
+encoder.fit(Y)
+encoded_Y = encoder.transform(Y)
+
+#baseline model
+def create_baseline():
+    #create model
+    #we start with same number of neurons as input in hidden layer as a starting point
+    model = Sequential()
+    model.add(Dense(60, input_dim = 60, init = 'normal', activation = 'relu'))
+    model.add(Dense(1, init = 'normal', activation= 'sigmoid'))
+    #compile model
+    model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics=['accuracy'])
+    return model
+
+estimator = KerasClassifier(build_fn = create_baseline, nb_epoch = 100, batch_size = 5, verbose = 0)
+kfold = StratifiedKFold(y = encoded_Y, n_folds = 10, shuffle = True, random_state=seed)
+results = cross_val_score(estimator, X, encoded_Y, cv = kfold)
+print("Results: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+