Output = Test.iloc[:, 2].values # Setting up dataframes for 10 - cross validation from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(NN_Data, Output, test_size = 0.1,random_state = 0) # feature scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) # NEURAL NETWORK TIME! import keras from keras.model import Sequential from keras.layers import Dense NN = Sequential() # Input and 1st hidden layer NN.add(Dense(output_dim = 2, init = 'uniform', activation = 'relu', input_dim = 3)) # Second hidden layer NN.add(Dense(output_dim = 1, init = 'uniform', activation = 'relu')) # training the NN NN.compile(optimizer = 'adam', loss = 'mean_squared_error', metrics = ['accuracy']) NN.fit(X_train, y_train, batch_size = 10, nb_epoch = 100)
################### part eleven -- define optimizer ###############################
RMSprop = optimizers.RMSprop(lr=0.001) # can tune learning rate here
################## part twelve -- compile model #################################
classifier.compile(optimizer = RMSprop, loss = 'mean_squared_error', metrics = ['accuracy']) # can add more metrics, can change loss based on purpose
################# part thirteen -- set up early stoppping and prepare for history recording ##################################
from keras.callbacks import EarlyStopping, TensorBoard
early_stopping = EarlyStopping(monitor='val_loss', patience = 100)
tensorBoard = TensorBoard(log_dir={path to store log file}, histogram_freq=0, batch_size=128)
'''
Do we need to keep the batch_size of tensorBoard and the training classifier part SAME?
'''
#################### part fourteen -- fitting the model to training data set ################################################
hist = classifier.fit(X_train, y_train, batch_size=512, epochs=5000, validation_split=0.05)
# keep track of ending time
end = datetime.now()
################## part fifteen -- evaluation ###########################################
y_pred = classifier.predict(X_test)
y_pred_df = pd.DataFrame(y_pred)
################## part sixteen -- editing history file ############################
text_file = open({path of txt file you want to store}, 'w')
text_file.write("Processing time is " + str(end-start) + "\n")
text_file.write(str(hist.history))
text_file.close()
################## part seventeen -- store weight/output to a .h5 file ####################
# binary classes
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])
# mean square root
model.compile(optimizer='rmsprop', loss='mse')
# user defined metrics
def mean_pred(y_true, y_pred)
return K.mean(y_pred)
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy', mean_pred])
# train
# generate dataset
# binary
import numpy as np
data = np.random.random((1000, 100))
labels = np.random.randint(2, size=(1000, 1))
model = Squential()
model.add(Dense(32, activation='relu', input_dim=100))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss = 'binary_crossentropy', metrics=['accuracy'])
model.fit(data, labels, epochs=10, batch_size=32)
# multiple
labels = np.random.randint(10, size=(1000, 1))
one_hot_labels = keras.utils.to_categorical(label, num_classes=10)
model.fit(data, one_hot_labels, epoches=10, batch_size=32)
x = trainDataset[:-1, :]
y = trainDataset[1:, :]
from keras.model import Sequential
from keras.layers import Dense
from keras.layers import LSTM
model = Sequential()
model.add(LSTM(units=32, activation='sigmoid', input_shape=(None, 1)))
model.add(Dense(units=1))
model.compile(optimizer='adam', loss='mean_squared_error')
model.fit(x, y, epochs=100, batch_size=32)
realStock = pd.read_csv('Google_Stock_Price_Test.csv')
realStock = realStock.iloc[:, 4:5].values
plt.plot(realStock, 'r')
from keras.model import Sequential
from keras.layers import Dense
model = Sequential()
model.add(Dense(100, input_dim=128, init='uniform', activation='relu'))
model.add(Dense(100, init='uniform', activation='relu'))
model.add(Dense(1, init='uniform', activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(X_train,
Y_train,
validation_data=(X_test, Y_test),
nb_epoch=500,
batch_size=10,
verbose=2)
#training accuracy
scores = model.evaluate(X_train, Y_train)
print("Accuracy: %.2f%%" % (scores[1] * 100))
#testing accuracy
scores2 = model.evaluate(X_test, Y_test)
print("Accuracy: %.2f%%" % (scores2[1] * 100))
# In[ ]:
# all the pixels will be devided by 255
new_train_data = train_data/255
new_test_data = test_data/255
# this converts the pixels which has the range of 0-255 into 0-1
# In[ ]:
model.fit(new_train_data,new_test_data,epochs=20)
# In[ ]:
import matplotlib.pyplot as plt
plt.plot(model.history.history['loss'])
plt.xlabel('# epochs')
plt.ylabel('loss')
plt.show()
# In[ ]:
from keras.layers import Dense
from keras.optimizers import Adam,SGD
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
df = pd.read_csv('../data/weight-height.csv')
X = df[['Height']].values
y_true = df[['Weight']].values
model = Sequential()
#model.add(Dense(1,input_shape(1,))
model.add(Dense(4,input_shape(1,))
model.add(Dense(4,input_shape(4,))
model.add(Dense(1,input_shape(4,))
model.compile(Adam(lr=0.8),'mean_squared_error')
model.fit(X,y_true,epochs=40)
''' performance of model
Classification
Linear Regression'''
loss='hinge')
siamese.set_weight(siamese_theano)
get_feature100 = theano.function(siamese.layers[0].input,
siamese.layers[-2].output)
feat_x = get_feature100(train_x)
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(feat_x)
feat_neighbor = np.empty((n_samples, 6, feat_x.shape[1]))
for sample in xrange(n_samples):
neighbor_x = knn.kneighbors(feat_x[sample])
feat_neighbor[sample, :5, :] = neighbor_x
feat_neighbor[sample, 5, :] = feat_x[sample]
rnn = Sequential()
rnn.add(LSTM(100, input_shape=(5, 100), activation='tanh'))
rnn.add(Dense(n_labels, activation='softmax'))
rnn.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
rnn.fit(feat_neighbor, train_y,
batch_size=5,
nb_epoch=10,
verbose=1)
x_train = np.array(images) y_train = np.array(measurements) from keras.model import Sequential from keras.layers import Flatten, dense, Lambda model = Sequential() # lambda layer for normalization model.add(Lambda(Lambda x: x / 255.0, input_shape = (160, 320, 3))) model.add(Flatten()) model.add(Dense(1)) model.compile(loss="mse", optimizer="adam") model.fit(x_train, y_train, validation_split=0.2, shuffle=True, nb_epoch=5)
from keras.model import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import SGD
model = Sequential()
model.add(Dense(64, input_dim=20, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=20, batch_size=128)
score = model.evaluate(x_test, y_test, batch_size=128)
'''
model = Sequential()
# Dense(64) is a fully-connected layer with 64 hidden units.
# in the first layer, you must specify the expected input data shape:
# here, 20-dimensional vectors.
model.add(Dense(64, activation='relu', input_dim=20))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer=sgd,
#Making sure that the values are float so that we can get decimal points after division
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
#Normalizing the RGB codes by dividing it to the max RGB values
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print('NUmber of images in x_train', x_train.shape[0])
print('Number of images in x_test', x_test.shape[0])
#Import the required Keras modules containing model and layers
from keras.model import Sequential
from keras.layers import Dense, Conv2D, Dropout, Flatten, MaxPooling2D
#Creating a sequential model and adding the layers
model = Sequential()
model.add(Conv2d(28, kernel_size=(3, 3), input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten()) #Flatten the 2D arrays for the fully connected layers
model.add(Dense(128, activation=tf.nn.relu))
model.add(Dropout(0.2))
model.add(Dense(10, activation=tf.nn.softmax))
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x=x_train, y=y_train, epochs=10)
model.evauate(x_test, y_test)
